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         ALC260_FAVORIT100,
  82 #ifdef CONFIG_SND_DEBUG
  83         ALC260_TEST,
  84 #endif
  85         ALC260_AUTO,
  86         ALC260_MODEL_LAST /* last tag */
  87 };
  88
  89 /* ALC262 models */
  90 enum {
  91         ALC262_BASIC,
  92         ALC262_HIPPO,
  93         ALC262_HIPPO_1,
  94         ALC262_FUJITSU,
  95         ALC262_HP_BPC,
  96         ALC262_HP_BPC_D7000_WL,
  97         ALC262_HP_BPC_D7000_WF,
  98         ALC262_HP_TC_T5735,
  99         ALC262_HP_RP5700,
 100         ALC262_BENQ_ED8,
 101         ALC262_SONY_ASSAMD,
 102         ALC262_BENQ_T31,
 103         ALC262_ULTRA,
 104         ALC262_LENOVO_3000,
 105         ALC262_NEC,
 106         ALC262_TOSHIBA_S06,
 107         ALC262_TOSHIBA_RX1,
 108         ALC262_TYAN,
 109         ALC262_AUTO,
 110         ALC262_MODEL_LAST /* last tag */
 111 };
 112
 113 /* ALC268 models */
 114 enum {
 115         ALC267_QUANTA_IL1,
 116         ALC268_3ST,
 117         ALC268_TOSHIBA,
 118         ALC268_ACER,
 119         ALC268_ACER_DMIC,
 120         ALC268_ACER_ASPIRE_ONE,
 121         ALC268_DELL,
 122         ALC268_ZEPTO,
 123 #ifdef CONFIG_SND_DEBUG
 124         ALC268_TEST,
 125 #endif
 126         ALC268_AUTO,
 127         ALC268_MODEL_LAST /* last tag */
 128 };
 129
 130 /* ALC269 models */
 131 enum {
 132         ALC269_BASIC,
 133         ALC269_QUANTA_FL1,
 134         ALC269_ASUS_EEEPC_P703,
 135         ALC269_ASUS_EEEPC_P901,
 136         ALC269_FUJITSU,
 137         ALC269_LIFEBOOK,
 138         ALC269_AUTO,
 139         ALC269_MODEL_LAST /* last tag */
 140 };
 141
 142 /* ALC861 models */
 143 enum {
 144         ALC861_3ST,
 145         ALC660_3ST,
 146         ALC861_3ST_DIG,
 147         ALC861_6ST_DIG,
 148         ALC861_UNIWILL_M31,
 149         ALC861_TOSHIBA,
 150         ALC861_ASUS,
 151         ALC861_ASUS_LAPTOP,
 152         ALC861_AUTO,
 153         ALC861_MODEL_LAST,
 154 };
 155
 156 /* ALC861-VD models */
 157 enum {
 158         ALC660VD_3ST,
 159         ALC660VD_3ST_DIG,
 160         ALC660VD_ASUS_V1S,
 161         ALC861VD_3ST,
 162         ALC861VD_3ST_DIG,
 163         ALC861VD_6ST_DIG,
 164         ALC861VD_LENOVO,
 165         ALC861VD_DALLAS,
 166         ALC861VD_HP,
 167         ALC861VD_AUTO,
 168         ALC861VD_MODEL_LAST,
 169 };
 170
 171 /* ALC662 models */
 172 enum {
 173         ALC662_3ST_2ch_DIG,
 174         ALC662_3ST_6ch_DIG,
 175         ALC662_3ST_6ch,
 176         ALC662_5ST_DIG,
 177         ALC662_LENOVO_101E,
 178         ALC662_ASUS_EEEPC_P701,
 179         ALC662_ASUS_EEEPC_EP20,
 180         ALC663_ASUS_M51VA,
 181         ALC663_ASUS_G71V,
 182         ALC663_ASUS_H13,
 183         ALC663_ASUS_G50V,
 184         ALC662_ECS,
 185         ALC663_ASUS_MODE1,
 186         ALC662_ASUS_MODE2,
 187         ALC663_ASUS_MODE3,
 188         ALC663_ASUS_MODE4,
 189         ALC663_ASUS_MODE5,
 190         ALC663_ASUS_MODE6,
 191         ALC662_AUTO,
 192         ALC662_MODEL_LAST,
 193 };
 194
 195 /* ALC882 models */
 196 enum {
 197         ALC882_3ST_DIG,
 198         ALC882_6ST_DIG,
 199         ALC882_ARIMA,
 200         ALC882_W2JC,
 201         ALC882_TARGA,
 202         ALC882_ASUS_A7J,
 203         ALC882_ASUS_A7M,
 204         ALC885_MACPRO,
 205         ALC885_MBP3,
 206         ALC885_IMAC24,
 207         ALC882_AUTO,
 208         ALC882_MODEL_LAST,
 209 };
 210
 211 /* ALC883 models */
 212 enum {
 213         ALC883_3ST_2ch_DIG,
 214         ALC883_3ST_6ch_DIG,
 215         ALC883_3ST_6ch,
 216         ALC883_6ST_DIG,
 217         ALC883_TARGA_DIG,
 218         ALC883_TARGA_2ch_DIG,
 219         ALC883_ACER,
 220         ALC883_ACER_ASPIRE,
 221         ALC888_ACER_ASPIRE_4930G,
 222         ALC883_MEDION,
 223         ALC883_MEDION_MD2,
 224         ALC883_LAPTOP_EAPD,
 225         ALC883_LENOVO_101E_2ch,
 226         ALC883_LENOVO_NB0763,
 227         ALC888_LENOVO_MS7195_DIG,
 228         ALC888_LENOVO_SKY,
 229         ALC883_HAIER_W66,
 230         ALC888_3ST_HP,
 231         ALC888_6ST_DELL,
 232         ALC883_MITAC,
 233         ALC883_CLEVO_M720,
 234         ALC883_FUJITSU_PI2515,
 235         ALC888_FUJITSU_XA3530,
 236         ALC883_3ST_6ch_INTEL,
 237         ALC888_ASUS_M90V,
 238         ALC888_ASUS_EEE1601,
 239         ALC1200_ASUS_P5Q,
 240         ALC883_AUTO,
 241         ALC883_MODEL_LAST,
 242 };
 243
 244 /* styles of capture selection */
 245 enum {
 246         CAPT_MUX = 0,   /* only mux based */
 247         CAPT_MIX,       /* only mixer based */
 248         CAPT_1MUX_MIX,  /* first mux and other mixers */
 249 };
 250
 251 /* for GPIO Poll */
 252 #define GPIO_MASK       0x03
 253
 254 struct alc_spec {
 255         /* codec parameterization */
 256         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 257         unsigned int num_mixers;
 258         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 259         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 260
 261         const struct hda_verb *init_verbs[5];   /* initialization verbs
 262                                                  * don't forget NULL
 263                                                  * termination!
 264                                                  */
 265         unsigned int num_init_verbs;
 266
 267         char *stream_name_analog;       /* analog PCM stream */
 268         struct hda_pcm_stream *stream_analog_playback;
 269         struct hda_pcm_stream *stream_analog_capture;
 270         struct hda_pcm_stream *stream_analog_alt_playback;
 271         struct hda_pcm_stream *stream_analog_alt_capture;
 272
 273         char *stream_name_digital;      /* digital PCM stream */
 274         struct hda_pcm_stream *stream_digital_playback;
 275         struct hda_pcm_stream *stream_digital_capture;
 276
 277         /* playback */
 278         struct hda_multi_out multiout;  /* playback set-up
 279                                          * max_channels, dacs must be set
 280                                          * dig_out_nid and hp_nid are optional
 281                                          */
 282         hda_nid_t alt_dac_nid;
 283         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 284         int dig_out_type;
 285
 286         /* capture */
 287         unsigned int num_adc_nids;
 288         hda_nid_t *adc_nids;
 289         hda_nid_t *capsrc_nids;
 290         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 291         int capture_style;              /* capture style (CAPT_*) */
 292
 293         /* capture source */
 294         unsigned int num_mux_defs;
 295         const struct hda_input_mux *input_mux;
 296         unsigned int cur_mux[3];
 297
 298         /* channel model */
 299         const struct hda_channel_mode *channel_mode;
 300         int num_channel_mode;
 301         int need_dac_fix;
 302
 303         /* PCM information */
 304         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 305
 306         /* dynamic controls, init_verbs and input_mux */
 307         struct auto_pin_cfg autocfg;
 308         struct snd_array kctls;
 309         struct hda_input_mux private_imux[3];
 310         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 311
 312         /* hooks */
 313         void (*init_hook)(struct hda_codec *codec);
 314         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 315
 316         /* for pin sensing */
 317         unsigned int sense_updated: 1;
 318         unsigned int jack_present: 1;
 319         unsigned int master_sw: 1;
 320
 321         /* other flags */
 322         unsigned int no_analog :1; /* digital I/O only */
 323
 324         /* for virtual master */
 325         hda_nid_t vmaster_nid;
 326 #ifdef CONFIG_SND_HDA_POWER_SAVE
 327         struct hda_loopback_check loopback;
 328 #endif
 329
 330         /* for PLL fix */
 331         hda_nid_t pll_nid;
 332         unsigned int pll_coef_idx, pll_coef_bit;
 333 };
 334
 335 /*
 336  * configuration template - to be copied to the spec instance
 337  */
 338 struct alc_config_preset {
 339         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 340                                              * with spec
 341                                              */
 342         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 343         const struct hda_verb *init_verbs[5];
 344         unsigned int num_dacs;
 345         hda_nid_t *dac_nids;
 346         hda_nid_t dig_out_nid;          /* optional */
 347         hda_nid_t hp_nid;               /* optional */
 348         hda_nid_t *slave_dig_outs;
 349         unsigned int num_adc_nids;
 350         hda_nid_t *adc_nids;
 351         hda_nid_t *capsrc_nids;
 352         hda_nid_t dig_in_nid;
 353         unsigned int num_channel_mode;
 354         const struct hda_channel_mode *channel_mode;
 355         int need_dac_fix;
 356         unsigned int num_mux_defs;
 357         const struct hda_input_mux *input_mux;
 358         void (*unsol_event)(struct hda_codec *, unsigned int);
 359         void (*init_hook)(struct hda_codec *);
 360 #ifdef CONFIG_SND_HDA_POWER_SAVE
 361         struct hda_amp_list *loopbacks;
 362 #endif
 363 };
 364
 365
 366 /*
 367  * input MUX handling
 368  */
 369 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 370                              struct snd_ctl_elem_info *uinfo)
 371 {
 372         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 373         struct alc_spec *spec = codec->spec;
 374         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 375         if (mux_idx >= spec->num_mux_defs)
 376                 mux_idx = 0;
 377         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 378 }
 379
 380 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 381                             struct snd_ctl_elem_value *ucontrol)
 382 {
 383         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 384         struct alc_spec *spec = codec->spec;
 385         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 386
 387         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 388         return 0;
 389 }
 390
 391 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 392                             struct snd_ctl_elem_value *ucontrol)
 393 {
 394         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 395         struct alc_spec *spec = codec->spec;
 396         const struct hda_input_mux *imux;
 397         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 398         unsigned int mux_idx;
 399         hda_nid_t nid = spec->capsrc_nids ?
 400                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 401
 402         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 403         imux = &spec->input_mux[mux_idx];
 404
 405         if (spec->capture_style &&
 406             !(spec->capture_style == CAPT_1MUX_MIX && !adc_idx)) {
 407                 /* Matrix-mixer style (e.g. ALC882) */
 408                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 409                 unsigned int i, idx;
 410
 411                 idx = ucontrol->value.enumerated.item[0];
 412                 if (idx >= imux->num_items)
 413                         idx = imux->num_items - 1;
 414                 if (*cur_val == idx)
 415                         return 0;
 416                 for (i = 0; i < imux->num_items; i++) {
 417                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 418                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 419                                                  imux->items[i].index,
 420                                                  HDA_AMP_MUTE, v);
 421                 }
 422                 *cur_val = idx;
 423                 return 1;
 424         } else {
 425                 /* MUX style (e.g. ALC880) */
 426                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 427                                              &spec->cur_mux[adc_idx]);
 428         }
 429 }
 430
 431 /*
 432  * channel mode setting
 433  */
 434 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 435                             struct snd_ctl_elem_info *uinfo)
 436 {
 437         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 438         struct alc_spec *spec = codec->spec;
 439         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 440                                     spec->num_channel_mode);
 441 }
 442
 443 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 444                            struct snd_ctl_elem_value *ucontrol)
 445 {
 446         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 447         struct alc_spec *spec = codec->spec;
 448         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 449                                    spec->num_channel_mode,
 450                                    spec->multiout.max_channels);
 451 }
 452
 453 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 454                            struct snd_ctl_elem_value *ucontrol)
 455 {
 456         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 457         struct alc_spec *spec = codec->spec;
 458         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 459                                       spec->num_channel_mode,
 460                                       &spec->multiout.max_channels);
 461         if (err >= 0 && spec->need_dac_fix)
 462                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 463         return err;
 464 }
 465
 466 /*
 467  * Control the mode of pin widget settings via the mixer.  "pc" is used
 468  * instead of "%" to avoid consequences of accidently treating the % as
 469  * being part of a format specifier.  Maximum allowed length of a value is
 470  * 63 characters plus NULL terminator.
 471  *
 472  * Note: some retasking pin complexes seem to ignore requests for input
 473  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 474  * are requested.  Therefore order this list so that this behaviour will not
 475  * cause problems when mixer clients move through the enum sequentially.
 476  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 477  * March 2006.
 478  */
 479 static char *alc_pin_mode_names[] = {
 480         "Mic 50pc bias", "Mic 80pc bias",
 481         "Line in", "Line out", "Headphone out",
 482 };
 483 static unsigned char alc_pin_mode_values[] = {
 484         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 485 };
 486 /* The control can present all 5 options, or it can limit the options based
 487  * in the pin being assumed to be exclusively an input or an output pin.  In
 488  * addition, "input" pins may or may not process the mic bias option
 489  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 490  * accept requests for bias as of chip versions up to March 2006) and/or
 491  * wiring in the computer.
 492  */
 493 #define ALC_PIN_DIR_IN              0x00
 494 #define ALC_PIN_DIR_OUT             0x01
 495 #define ALC_PIN_DIR_INOUT           0x02
 496 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 497 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 498
 499 /* Info about the pin modes supported by the different pin direction modes.
 500  * For each direction the minimum and maximum values are given.
 501  */
 502 static signed char alc_pin_mode_dir_info[5][2] = {
 503         { 0, 2 },    /* ALC_PIN_DIR_IN */
 504         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 505         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 506         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 507         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 508 };
 509 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 510 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 511 #define alc_pin_mode_n_items(_dir) \
 512         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 513
 514 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 515                              struct snd_ctl_elem_info *uinfo)
 516 {
 517         unsigned int item_num = uinfo->value.enumerated.item;
 518         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 519
 520         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 521         uinfo->count = 1;
 522         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 523
 524         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 525                 item_num = alc_pin_mode_min(dir);
 526         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 527         return 0;
 528 }
 529
 530 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 531                             struct snd_ctl_elem_value *ucontrol)
 532 {
 533         unsigned int i;
 534         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 535         hda_nid_t nid = kcontrol->private_value & 0xffff;
 536         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 537         long *valp = ucontrol->value.integer.value;
 538         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 539                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 540                                                  0x00);
 541
 542         /* Find enumerated value for current pinctl setting */
 543         i = alc_pin_mode_min(dir);
 544         while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
 545                 i++;
 546         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 547         return 0;
 548 }
 549
 550 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 551                             struct snd_ctl_elem_value *ucontrol)
 552 {
 553         signed int change;
 554         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 555         hda_nid_t nid = kcontrol->private_value & 0xffff;
 556         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 557         long val = *ucontrol->value.integer.value;
 558         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 559                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 560                                                  0x00);
 561
 562         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 563                 val = alc_pin_mode_min(dir);
 564
 565         change = pinctl != alc_pin_mode_values[val];
 566         if (change) {
 567                 /* Set pin mode to that requested */
 568                 snd_hda_codec_write_cache(codec, nid, 0,
 569                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 570                                           alc_pin_mode_values[val]);
 571
 572                 /* Also enable the retasking pin's input/output as required
 573                  * for the requested pin mode.  Enum values of 2 or less are
 574                  * input modes.
 575                  *
 576                  * Dynamically switching the input/output buffers probably
 577                  * reduces noise slightly (particularly on input) so we'll
 578                  * do it.  However, having both input and output buffers
 579                  * enabled simultaneously doesn't seem to be problematic if
 580                  * this turns out to be necessary in the future.
 581                  */
 582                 if (val <= 2) {
 583                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 584                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 585                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 586                                                  HDA_AMP_MUTE, 0);
 587                 } else {
 588                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 589                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 590                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 591                                                  HDA_AMP_MUTE, 0);
 592                 }
 593         }
 594         return change;
 595 }
 596
 597 #define ALC_PIN_MODE(xname, nid, dir) \
 598         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 599           .info = alc_pin_mode_info, \
 600           .get = alc_pin_mode_get, \
 601           .put = alc_pin_mode_put, \
 602           .private_value = nid | (dir<<16) }
 603
 604 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 605  * together using a mask with more than one bit set.  This control is
 606  * currently used only by the ALC260 test model.  At this stage they are not
 607  * needed for any "production" models.
 608  */
 609 #ifdef CONFIG_SND_DEBUG
 610 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 611
 612 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 613                              struct snd_ctl_elem_value *ucontrol)
 614 {
 615         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 616         hda_nid_t nid = kcontrol->private_value & 0xffff;
 617         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 618         long *valp = ucontrol->value.integer.value;
 619         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 620                                               AC_VERB_GET_GPIO_DATA, 0x00);
 621
 622         *valp = (val & mask) != 0;
 623         return 0;
 624 }
 625 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 626                              struct snd_ctl_elem_value *ucontrol)
 627 {
 628         signed int change;
 629         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 630         hda_nid_t nid = kcontrol->private_value & 0xffff;
 631         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 632         long val = *ucontrol->value.integer.value;
 633         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 634                                                     AC_VERB_GET_GPIO_DATA,
 635                                                     0x00);
 636
 637         /* Set/unset the masked GPIO bit(s) as needed */
 638         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 639         if (val == 0)
 640                 gpio_data &= ~mask;
 641         else
 642                 gpio_data |= mask;
 643         snd_hda_codec_write_cache(codec, nid, 0,
 644                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 645
 646         return change;
 647 }
 648 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 649         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 650           .info = alc_gpio_data_info, \
 651           .get = alc_gpio_data_get, \
 652           .put = alc_gpio_data_put, \
 653           .private_value = nid | (mask<<16) }
 654 #endif   /* CONFIG_SND_DEBUG */
 655
 656 /* A switch control to allow the enabling of the digital IO pins on the
 657  * ALC260.  This is incredibly simplistic; the intention of this control is
 658  * to provide something in the test model allowing digital outputs to be
 659  * identified if present.  If models are found which can utilise these
 660  * outputs a more complete mixer control can be devised for those models if
 661  * necessary.
 662  */
 663 #ifdef CONFIG_SND_DEBUG
 664 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 665
 666 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 667                               struct snd_ctl_elem_value *ucontrol)
 668 {
 669         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 670         hda_nid_t nid = kcontrol->private_value & 0xffff;
 671         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 672         long *valp = ucontrol->value.integer.value;
 673         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 674                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 675
 676         *valp = (val & mask) != 0;
 677         return 0;
 678 }
 679 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 680                               struct snd_ctl_elem_value *ucontrol)
 681 {
 682         signed int change;
 683         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 684         hda_nid_t nid = kcontrol->private_value & 0xffff;
 685         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 686         long val = *ucontrol->value.integer.value;
 687         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 688                                                     AC_VERB_GET_DIGI_CONVERT_1,
 689                                                     0x00);
 690
 691         /* Set/unset the masked control bit(s) as needed */
 692         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 693         if (val==0)
 694                 ctrl_data &= ~mask;
 695         else
 696                 ctrl_data |= mask;
 697         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 698                                   ctrl_data);
 699
 700         return change;
 701 }
 702 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 703         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 704           .info = alc_spdif_ctrl_info, \
 705           .get = alc_spdif_ctrl_get, \
 706           .put = alc_spdif_ctrl_put, \
 707           .private_value = nid | (mask<<16) }
 708 #endif   /* CONFIG_SND_DEBUG */
 709
 710 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 711  * Again, this is only used in the ALC26x test models to help identify when
 712  * the EAPD line must be asserted for features to work.
 713  */
 714 #ifdef CONFIG_SND_DEBUG
 715 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 716
 717 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 718                               struct snd_ctl_elem_value *ucontrol)
 719 {
 720         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 721         hda_nid_t nid = kcontrol->private_value & 0xffff;
 722         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 723         long *valp = ucontrol->value.integer.value;
 724         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 725                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 726
 727         *valp = (val & mask) != 0;
 728         return 0;
 729 }
 730
 731 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 732                               struct snd_ctl_elem_value *ucontrol)
 733 {
 734         int change;
 735         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 736         hda_nid_t nid = kcontrol->private_value & 0xffff;
 737         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 738         long val = *ucontrol->value.integer.value;
 739         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 740                                                     AC_VERB_GET_EAPD_BTLENABLE,
 741                                                     0x00);
 742
 743         /* Set/unset the masked control bit(s) as needed */
 744         change = (!val ? 0 : mask) != (ctrl_data & mask);
 745         if (!val)
 746                 ctrl_data &= ~mask;
 747         else
 748                 ctrl_data |= mask;
 749         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 750                                   ctrl_data);
 751
 752         return change;
 753 }
 754
 755 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 756         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 757           .info = alc_eapd_ctrl_info, \
 758           .get = alc_eapd_ctrl_get, \
 759           .put = alc_eapd_ctrl_put, \
 760           .private_value = nid | (mask<<16) }
 761 #endif   /* CONFIG_SND_DEBUG */
 762
 763 /*
 764  * set up the input pin config (depending on the given auto-pin type)
 765  */
 766 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 767                               int auto_pin_type)
 768 {
 769         unsigned int val = PIN_IN;
 770
 771         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 772                 unsigned int pincap;
 773                 pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
 774                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 775                 if (pincap & AC_PINCAP_VREF_80)
 776                         val = PIN_VREF80;
 777         }
 778         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 779 }
 780
 781 /*
 782  */
 783 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 784 {
 785         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 786                 return;
 787         spec->mixers[spec->num_mixers++] = mix;
 788 }
 789
 790 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 791 {
 792         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 793                 return;
 794         spec->init_verbs[spec->num_init_verbs++] = verb;
 795 }
 796
 797 #ifdef CONFIG_PROC_FS
 798 /*
 799  * hook for proc
 800  */
 801 static void print_realtek_coef(struct snd_info_buffer *buffer,
 802                                struct hda_codec *codec, hda_nid_t nid)
 803 {
 804         int coeff;
 805
 806         if (nid != 0x20)
 807                 return;
 808         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 809         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 810         coeff = snd_hda_codec_read(codec, nid, 0,
 811                                    AC_VERB_GET_COEF_INDEX, 0);
 812         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 813 }
 814 #else
 815 #define print_realtek_coef      NULL
 816 #endif
 817
 818 /*
 819  * set up from the preset table
 820  */
 821 static void setup_preset(struct alc_spec *spec,
 822                          const struct alc_config_preset *preset)
 823 {
 824         int i;
 825
 826         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 827                 add_mixer(spec, preset->mixers[i]);
 828         spec->cap_mixer = preset->cap_mixer;
 829         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 830              i++)
 831                 add_verb(spec, preset->init_verbs[i]);
 832
 833         spec->channel_mode = preset->channel_mode;
 834         spec->num_channel_mode = preset->num_channel_mode;
 835         spec->need_dac_fix = preset->need_dac_fix;
 836
 837         spec->multiout.max_channels = spec->channel_mode[0].channels;
 838
 839         spec->multiout.num_dacs = preset->num_dacs;
 840         spec->multiout.dac_nids = preset->dac_nids;
 841         spec->multiout.dig_out_nid = preset->dig_out_nid;
 842         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 843         spec->multiout.hp_nid = preset->hp_nid;
 844
 845         spec->num_mux_defs = preset->num_mux_defs;
 846         if (!spec->num_mux_defs)
 847                 spec->num_mux_defs = 1;
 848         spec->input_mux = preset->input_mux;
 849
 850         spec->num_adc_nids = preset->num_adc_nids;
 851         spec->adc_nids = preset->adc_nids;
 852         spec->capsrc_nids = preset->capsrc_nids;
 853         spec->dig_in_nid = preset->dig_in_nid;
 854
 855         spec->unsol_event = preset->unsol_event;
 856         spec->init_hook = preset->init_hook;
 857 #ifdef CONFIG_SND_HDA_POWER_SAVE
 858         spec->loopback.amplist = preset->loopbacks;
 859 #endif
 860 }
 861
 862 /* Enable GPIO mask and set output */
 863 static struct hda_verb alc_gpio1_init_verbs[] = {
 864         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 865         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 866         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 867         { }
 868 };
 869
 870 static struct hda_verb alc_gpio2_init_verbs[] = {
 871         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 872         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 873         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 874         { }
 875 };
 876
 877 static struct hda_verb alc_gpio3_init_verbs[] = {
 878         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 879         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 880         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 881         { }
 882 };
 883
 884 /*
 885  * Fix hardware PLL issue
 886  * On some codecs, the analog PLL gating control must be off while
 887  * the default value is 1.
 888  */
 889 static void alc_fix_pll(struct hda_codec *codec)
 890 {
 891         struct alc_spec *spec = codec->spec;
 892         unsigned int val;
 893
 894         if (!spec->pll_nid)
 895                 return;
 896         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 897                             spec->pll_coef_idx);
 898         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 899                                  AC_VERB_GET_PROC_COEF, 0);
 900         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 901                             spec->pll_coef_idx);
 902         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 903                             val & ~(1 << spec->pll_coef_bit));
 904 }
 905
 906 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 907                              unsigned int coef_idx, unsigned int coef_bit)
 908 {
 909         struct alc_spec *spec = codec->spec;
 910         spec->pll_nid = nid;
 911         spec->pll_coef_idx = coef_idx;
 912         spec->pll_coef_bit = coef_bit;
 913         alc_fix_pll(codec);
 914 }
 915
 916 static void alc_sku_automute(struct hda_codec *codec)
 917 {
 918         struct alc_spec *spec = codec->spec;
 919         unsigned int present;
 920         unsigned int hp_nid = spec->autocfg.hp_pins[0];
 921         unsigned int sp_nid = spec->autocfg.speaker_pins[0];
 922
 923         /* need to execute and sync at first */
 924         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 925         present = snd_hda_codec_read(codec, hp_nid, 0,
 926                                      AC_VERB_GET_PIN_SENSE, 0);
 927         spec->jack_present = (present & 0x80000000) != 0;
 928         snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 929                             spec->jack_present ? 0 : PIN_OUT);
 930 }
 931
 932 #if 0 /* it's broken in some acses -- temporarily disabled */
 933 static void alc_mic_automute(struct hda_codec *codec)
 934 {
 935         struct alc_spec *spec = codec->spec;
 936         unsigned int present;
 937         unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
 938         unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
 939         unsigned int mix_nid = spec->capsrc_nids[0];
 940         unsigned int capsrc_idx_mic, capsrc_idx_fmic;
 941
 942         capsrc_idx_mic = mic_nid - 0x18;
 943         capsrc_idx_fmic = fmic_nid - 0x18;
 944         present = snd_hda_codec_read(codec, mic_nid, 0,
 945                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 946         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 947                     0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
 948         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 949                     0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
 950         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
 951                          HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 952 }
 953 #else
 954 #define alc_mic_automute(codec) do {} while(0) /* NOP */
 955 #endif /* disabled */
 956
 957 /* unsolicited event for HP jack sensing */
 958 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 959 {
 960         if (codec->vendor_id == 0x10ec0880)
 961                 res >>= 28;
 962         else
 963                 res >>= 26;
 964         if (res == ALC880_HP_EVENT)
 965                 alc_sku_automute(codec);
 966
 967         if (res == ALC880_MIC_EVENT)
 968                 alc_mic_automute(codec);
 969 }
 970
 971 static void alc_inithook(struct hda_codec *codec)
 972 {
 973         alc_sku_automute(codec);
 974         alc_mic_automute(codec);
 975 }
 976
 977 /* additional initialization for ALC888 variants */
 978 static void alc888_coef_init(struct hda_codec *codec)
 979 {
 980         unsigned int tmp;
 981
 982         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
 983         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 984         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 985         if ((tmp & 0xf0) == 2)
 986                 /* alc888S-VC */
 987                 snd_hda_codec_read(codec, 0x20, 0,
 988                                    AC_VERB_SET_PROC_COEF, 0x830);
 989          else
 990                  /* alc888-VB */
 991                  snd_hda_codec_read(codec, 0x20, 0,
 992                                     AC_VERB_SET_PROC_COEF, 0x3030);
 993 }
 994
 995 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 996  *      31 ~ 16 :       Manufacture ID
 997  *      15 ~ 8  :       SKU ID
 998  *      7  ~ 0  :       Assembly ID
 999  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1000  */
1001 static void alc_subsystem_id(struct hda_codec *codec,
1002                              unsigned int porta, unsigned int porte,
1003                              unsigned int portd)
1004 {
1005         unsigned int ass, tmp, i;
1006         unsigned nid;
1007         struct alc_spec *spec = codec->spec;
1008
1009         ass = codec->subsystem_id & 0xffff;
1010         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1011                 goto do_sku;
1012
1013         /*
1014          * 31~30        : port conetcivity
1015          * 29~21        : reserve
1016          * 20           : PCBEEP input
1017          * 19~16        : Check sum (15:1)
1018          * 15~1         : Custom
1019          * 0            : override
1020         */
1021         nid = 0x1d;
1022         if (codec->vendor_id == 0x10ec0260)
1023                 nid = 0x17;
1024         ass = snd_hda_codec_get_pincfg(codec, nid);
1025         if (!(ass & 1) && !(ass & 0x100000))
1026                 return;
1027         if ((ass >> 30) != 1)   /* no physical connection */
1028                 return;
1029
1030         /* check sum */
1031         tmp = 0;
1032         for (i = 1; i < 16; i++) {
1033                 if ((ass >> i) & 1)
1034                         tmp++;
1035         }
1036         if (((ass >> 16) & 0xf) != tmp)
1037                 return;
1038 do_sku:
1039         /*
1040          * 0 : override
1041          * 1 :  Swap Jack
1042          * 2 : 0 --> Desktop, 1 --> Laptop
1043          * 3~5 : External Amplifier control
1044          * 7~6 : Reserved
1045         */
1046         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1047         switch (tmp) {
1048         case 1:
1049                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1050                 break;
1051         case 3:
1052                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1053                 break;
1054         case 7:
1055                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1056                 break;
1057         case 5: /* set EAPD output high */
1058                 switch (codec->vendor_id) {
1059                 case 0x10ec0260:
1060                         snd_hda_codec_write(codec, 0x0f, 0,
1061                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1062                         snd_hda_codec_write(codec, 0x10, 0,
1063                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1064                         break;
1065                 case 0x10ec0262:
1066                 case 0x10ec0267:
1067                 case 0x10ec0268:
1068                 case 0x10ec0269:
1069                 case 0x10ec0272:
1070                 case 0x10ec0660:
1071                 case 0x10ec0662:
1072                 case 0x10ec0663:
1073                 case 0x10ec0862:
1074                 case 0x10ec0889:
1075                         snd_hda_codec_write(codec, 0x14, 0,
1076                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1077                         snd_hda_codec_write(codec, 0x15, 0,
1078                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1079                         break;
1080                 }
1081                 switch (codec->vendor_id) {
1082                 case 0x10ec0260:
1083                         snd_hda_codec_write(codec, 0x1a, 0,
1084                                             AC_VERB_SET_COEF_INDEX, 7);
1085                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1086                                                  AC_VERB_GET_PROC_COEF, 0);
1087                         snd_hda_codec_write(codec, 0x1a, 0,
1088                                             AC_VERB_SET_COEF_INDEX, 7);
1089                         snd_hda_codec_write(codec, 0x1a, 0,
1090                                             AC_VERB_SET_PROC_COEF,
1091                                             tmp | 0x2010);
1092                         break;
1093                 case 0x10ec0262:
1094                 case 0x10ec0880:
1095                 case 0x10ec0882:
1096                 case 0x10ec0883:
1097                 case 0x10ec0885:
1098                 case 0x10ec0887:
1099                 case 0x10ec0889:
1100                         snd_hda_codec_write(codec, 0x20, 0,
1101                                             AC_VERB_SET_COEF_INDEX, 7);
1102                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1103                                                  AC_VERB_GET_PROC_COEF, 0);
1104                         snd_hda_codec_write(codec, 0x20, 0,
1105                                             AC_VERB_SET_COEF_INDEX, 7);
1106                         snd_hda_codec_write(codec, 0x20, 0,
1107                                             AC_VERB_SET_PROC_COEF,
1108                                             tmp | 0x2010);
1109                         break;
1110                 case 0x10ec0888:
1111                         /*alc888_coef_init(codec);*/ /* called in alc_init() */
1112                         break;
1113                 case 0x10ec0267:
1114                 case 0x10ec0268:
1115                         snd_hda_codec_write(codec, 0x20, 0,
1116                                             AC_VERB_SET_COEF_INDEX, 7);
1117                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1118                                                  AC_VERB_GET_PROC_COEF, 0);
1119                         snd_hda_codec_write(codec, 0x20, 0,
1120                                             AC_VERB_SET_COEF_INDEX, 7);
1121                         snd_hda_codec_write(codec, 0x20, 0,
1122                                             AC_VERB_SET_PROC_COEF,
1123                                             tmp | 0x3000);
1124                         break;
1125                 }
1126         default:
1127                 break;
1128         }
1129
1130         /* is laptop or Desktop and enable the function "Mute internal speaker
1131          * when the external headphone out jack is plugged"
1132          */
1133         if (!(ass & 0x8000))
1134                 return;
1135         /*
1136          * 10~8 : Jack location
1137          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1138          * 14~13: Resvered
1139          * 15   : 1 --> enable the function "Mute internal speaker
1140          *              when the external headphone out jack is plugged"
1141          */
1142         if (!spec->autocfg.speaker_pins[0]) {
1143                 if (spec->autocfg.line_out_pins[0])
1144                         spec->autocfg.speaker_pins[0] =
1145                                 spec->autocfg.line_out_pins[0];
1146                 else
1147                         return;
1148         }
1149
1150         if (!spec->autocfg.hp_pins[0]) {
1151                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1152                 if (tmp == 0)
1153                         spec->autocfg.hp_pins[0] = porta;
1154                 else if (tmp == 1)
1155                         spec->autocfg.hp_pins[0] = porte;
1156                 else if (tmp == 2)
1157                         spec->autocfg.hp_pins[0] = portd;
1158                 else
1159                         return;
1160         }
1161         if (spec->autocfg.hp_pins[0])
1162                 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
1163                         AC_VERB_SET_UNSOLICITED_ENABLE,
1164                         AC_USRSP_EN | ALC880_HP_EVENT);
1165
1166 #if 0 /* it's broken in some acses -- temporarily disabled */
1167         if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
1168                 spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
1169                 snd_hda_codec_write(codec,
1170                         spec->autocfg.input_pins[AUTO_PIN_MIC], 0,
1171                         AC_VERB_SET_UNSOLICITED_ENABLE,
1172                         AC_USRSP_EN | ALC880_MIC_EVENT);
1173 #endif /* disabled */
1174
1175         spec->unsol_event = alc_sku_unsol_event;
1176 }
1177
1178 /*
1179  * Fix-up pin default configurations
1180  */
1181
1182 struct alc_pincfg {
1183         hda_nid_t nid;
1184         u32 val;
1185 };
1186
1187 static void alc_fix_pincfg(struct hda_codec *codec,
1188                            const struct snd_pci_quirk *quirk,
1189                            const struct alc_pincfg **pinfix)
1190 {
1191         const struct alc_pincfg *cfg;
1192
1193         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1194         if (!quirk)
1195                 return;
1196
1197         cfg = pinfix[quirk->value];
1198         for (; cfg->nid; cfg++)
1199                 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1200 }
1201
1202 /*
1203  * ALC888
1204  */
1205
1206 /*
1207  * 2ch mode
1208  */
1209 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1210 /* Mic-in jack as mic in */
1211         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1212         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1213 /* Line-in jack as Line in */
1214         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1215         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1216 /* Line-Out as Front */
1217         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1218         { } /* end */
1219 };
1220
1221 /*
1222  * 4ch mode
1223  */
1224 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1225 /* Mic-in jack as mic in */
1226         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1227         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1228 /* Line-in jack as Surround */
1229         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1230         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1231 /* Line-Out as Front */
1232         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1233         { } /* end */
1234 };
1235
1236 /*
1237  * 6ch mode
1238  */
1239 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1240 /* Mic-in jack as CLFE */
1241         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1242         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1243 /* Line-in jack as Surround */
1244         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1245         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1246 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1247         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1248         { } /* end */
1249 };
1250
1251 /*
1252  * 8ch mode
1253  */
1254 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1255 /* Mic-in jack as CLFE */
1256         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1257         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1258 /* Line-in jack as Surround */
1259         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1260         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1261 /* Line-Out as Side */
1262         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1263         { } /* end */
1264 };
1265
1266 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1267         { 2, alc888_4ST_ch2_intel_init },
1268         { 4, alc888_4ST_ch4_intel_init },
1269         { 6, alc888_4ST_ch6_intel_init },
1270         { 8, alc888_4ST_ch8_intel_init },
1271 };
1272
1273 /*
1274  * ALC888 Fujitsu Siemens Amillo xa3530
1275  */
1276
1277 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1278 /* Front Mic: set to PIN_IN (empty by default) */
1279         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1280 /* Connect Internal HP to Front */
1281         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1282         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1283         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1284 /* Connect Bass HP to Front */
1285         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1286         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1287         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1288 /* Connect Line-Out side jack (SPDIF) to Side */
1289         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1290         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1291         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1292 /* Connect Mic jack to CLFE */
1293         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1294         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1295         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1296 /* Connect Line-in jack to Surround */
1297         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1298         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1299         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1300 /* Connect HP out jack to Front */
1301         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1302         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1303         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1304 /* Enable unsolicited event for HP jack and Line-out jack */
1305         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1306         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1307         {}
1308 };
1309
1310 static void alc888_fujitsu_xa3530_automute(struct hda_codec *codec)
1311 {
1312         unsigned int present;
1313         unsigned int bits;
1314         /* Line out presence */
1315         present = snd_hda_codec_read(codec, 0x17, 0,
1316                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1317         /* HP out presence */
1318         present = present || snd_hda_codec_read(codec, 0x1b, 0,
1319                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1320         bits = present ? HDA_AMP_MUTE : 0;
1321         /* Toggle internal speakers muting */
1322         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1323                                  HDA_AMP_MUTE, bits);
1324         /* Toggle internal bass muting */
1325         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1326                                  HDA_AMP_MUTE, bits);
1327 }
1328
1329 static void alc888_fujitsu_xa3530_unsol_event(struct hda_codec *codec,
1330                 unsigned int res)
1331 {
1332         if (res >> 26 == ALC880_HP_EVENT)
1333                 alc888_fujitsu_xa3530_automute(codec);
1334 }
1335
1336
1337 /*
1338  * ALC888 Acer Aspire 4930G model
1339  */
1340
1341 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1342 /* Front Mic: set to PIN_IN (empty by default) */
1343         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1344 /* Unselect Front Mic by default in input mixer 3 */
1345         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1346 /* Enable unsolicited event for HP jack */
1347         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1348 /* Connect Internal HP to front */
1349         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1350         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1351         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1352 /* Connect HP out to front */
1353         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1354         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1355         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1356         { }
1357 };
1358
1359 static struct hda_input_mux alc888_2_capture_sources[2] = {
1360         /* Front mic only available on one ADC */
1361         {
1362                 .num_items = 4,
1363                 .items = {
1364                         { "Mic", 0x0 },
1365                         { "Line", 0x2 },
1366                         { "CD", 0x4 },
1367                         { "Front Mic", 0xb },
1368                 },
1369         },
1370         {
1371                 .num_items = 3,
1372                 .items = {
1373                         { "Mic", 0x0 },
1374                         { "Line", 0x2 },
1375                         { "CD", 0x4 },
1376                 },
1377         }
1378 };
1379
1380 static struct snd_kcontrol_new alc888_base_mixer[] = {
1381         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1382         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1383         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1384         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1385         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1386                 HDA_OUTPUT),
1387         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1388         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1389         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1390         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1391         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1392         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1393         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1394         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1395         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1396         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1397         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1398         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1399         { } /* end */
1400 };
1401
1402 static void alc888_acer_aspire_4930g_automute(struct hda_codec *codec)
1403 {
1404         unsigned int present;
1405         unsigned int bits;
1406         present = snd_hda_codec_read(codec, 0x15, 0,
1407                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1408         bits = present ? HDA_AMP_MUTE : 0;
1409         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1410                                  HDA_AMP_MUTE, bits);
1411 }
1412
1413 static void alc888_acer_aspire_4930g_unsol_event(struct hda_codec *codec,
1414                 unsigned int res)
1415 {
1416         if (res >> 26 == ALC880_HP_EVENT)
1417                 alc888_acer_aspire_4930g_automute(codec);
1418 }
1419
1420 /*
1421  * ALC880 3-stack model
1422  *
1423  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1424  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1425  *                 F-Mic = 0x1b, HP = 0x19
1426  */
1427
1428 static hda_nid_t alc880_dac_nids[4] = {
1429         /* front, rear, clfe, rear_surr */
1430         0x02, 0x05, 0x04, 0x03
1431 };
1432
1433 static hda_nid_t alc880_adc_nids[3] = {
1434         /* ADC0-2 */
1435         0x07, 0x08, 0x09,
1436 };
1437
1438 /* The datasheet says the node 0x07 is connected from inputs,
1439  * but it shows zero connection in the real implementation on some devices.
1440  * Note: this is a 915GAV bug, fixed on 915GLV
1441  */
1442 static hda_nid_t alc880_adc_nids_alt[2] = {
1443         /* ADC1-2 */
1444         0x08, 0x09,
1445 };
1446
1447 #define ALC880_DIGOUT_NID       0x06
1448 #define ALC880_DIGIN_NID        0x0a
1449
1450 static struct hda_input_mux alc880_capture_source = {
1451         .num_items = 4,
1452         .items = {
1453                 { "Mic", 0x0 },
1454                 { "Front Mic", 0x3 },
1455                 { "Line", 0x2 },
1456                 { "CD", 0x4 },
1457         },
1458 };
1459
1460 /* channel source setting (2/6 channel selection for 3-stack) */
1461 /* 2ch mode */
1462 static struct hda_verb alc880_threestack_ch2_init[] = {
1463         /* set line-in to input, mute it */
1464         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1465         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1466         /* set mic-in to input vref 80%, mute it */
1467         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1468         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1469         { } /* end */
1470 };
1471
1472 /* 6ch mode */
1473 static struct hda_verb alc880_threestack_ch6_init[] = {
1474         /* set line-in to output, unmute it */
1475         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1476         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1477         /* set mic-in to output, unmute it */
1478         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1479         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1480         { } /* end */
1481 };
1482
1483 static struct hda_channel_mode alc880_threestack_modes[2] = {
1484         { 2, alc880_threestack_ch2_init },
1485         { 6, alc880_threestack_ch6_init },
1486 };
1487
1488 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1489         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1490         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1491         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1492         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1493         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1494         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1495         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1496         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1497         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1498         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1499         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1500         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1501         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1502         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1503         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1504         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1505         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1506         {
1507                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1508                 .name = "Channel Mode",
1509                 .info = alc_ch_mode_info,
1510                 .get = alc_ch_mode_get,
1511                 .put = alc_ch_mode_put,
1512         },
1513         { } /* end */
1514 };
1515
1516 /* capture mixer elements */
1517 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1518                             struct snd_ctl_elem_info *uinfo)
1519 {
1520         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1521         struct alc_spec *spec = codec->spec;
1522         int err;
1523
1524         mutex_lock(&codec->control_mutex);
1525         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1526                                                       HDA_INPUT);
1527         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1528         mutex_unlock(&codec->control_mutex);
1529         return err;
1530 }
1531
1532 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1533                            unsigned int size, unsigned int __user *tlv)
1534 {
1535         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1536         struct alc_spec *spec = codec->spec;
1537         int err;
1538
1539         mutex_lock(&codec->control_mutex);
1540         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1541                                                       HDA_INPUT);
1542         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1543         mutex_unlock(&codec->control_mutex);
1544         return err;
1545 }
1546
1547 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1548                              struct snd_ctl_elem_value *ucontrol);
1549
1550 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1551                                  struct snd_ctl_elem_value *ucontrol,
1552                                  getput_call_t func)
1553 {
1554         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1555         struct alc_spec *spec = codec->spec;
1556         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1557         int err;
1558
1559         mutex_lock(&codec->control_mutex);
1560         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1561                                                       3, 0, HDA_INPUT);
1562         err = func(kcontrol, ucontrol);
1563         mutex_unlock(&codec->control_mutex);
1564         return err;
1565 }
1566
1567 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1568                            struct snd_ctl_elem_value *ucontrol)
1569 {
1570         return alc_cap_getput_caller(kcontrol, ucontrol,
1571                                      snd_hda_mixer_amp_volume_get);
1572 }
1573
1574 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1575                            struct snd_ctl_elem_value *ucontrol)
1576 {
1577         return alc_cap_getput_caller(kcontrol, ucontrol,
1578                                      snd_hda_mixer_amp_volume_put);
1579 }
1580
1581 /* capture mixer elements */
1582 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1583
1584 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1585                           struct snd_ctl_elem_value *ucontrol)
1586 {
1587         return alc_cap_getput_caller(kcontrol, ucontrol,
1588                                      snd_hda_mixer_amp_switch_get);
1589 }
1590
1591 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1592                           struct snd_ctl_elem_value *ucontrol)
1593 {
1594         return alc_cap_getput_caller(kcontrol, ucontrol,
1595                                      snd_hda_mixer_amp_switch_put);
1596 }
1597
1598 #define DEFINE_CAPMIX(num) \
1599 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1600         { \
1601                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1602                 .name = "Capture Switch", \
1603                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1604                 .count = num, \
1605                 .info = alc_cap_sw_info, \
1606                 .get = alc_cap_sw_get, \
1607                 .put = alc_cap_sw_put, \
1608         }, \
1609         { \
1610                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1611                 .name = "Capture Volume", \
1612                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1613                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1614                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1615                 .count = num, \
1616                 .info = alc_cap_vol_info, \
1617                 .get = alc_cap_vol_get, \
1618                 .put = alc_cap_vol_put, \
1619                 .tlv = { .c = alc_cap_vol_tlv }, \
1620         }, \
1621         { \
1622                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1623                 /* .name = "Capture Source", */ \
1624                 .name = "Input Source", \
1625                 .count = num, \
1626                 .info = alc_mux_enum_info, \
1627                 .get = alc_mux_enum_get, \
1628                 .put = alc_mux_enum_put, \
1629         }, \
1630         { } /* end */ \
1631 }
1632
1633 /* up to three ADCs */
1634 DEFINE_CAPMIX(1);
1635 DEFINE_CAPMIX(2);
1636 DEFINE_CAPMIX(3);
1637
1638
1639 /*
1640  * ALC880 5-stack model
1641  *
1642  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1643  *      Side = 0x02 (0xd)
1644  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1645  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1646  */
1647
1648 /* additional mixers to alc880_three_stack_mixer */
1649 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1650         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1651         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1652         { } /* end */
1653 };
1654
1655 /* channel source setting (6/8 channel selection for 5-stack) */
1656 /* 6ch mode */
1657 static struct hda_verb alc880_fivestack_ch6_init[] = {
1658         /* set line-in to input, mute it */
1659         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1660         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1661         { } /* end */
1662 };
1663
1664 /* 8ch mode */
1665 static struct hda_verb alc880_fivestack_ch8_init[] = {
1666         /* set line-in to output, unmute it */
1667         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1668         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1669         { } /* end */
1670 };
1671
1672 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1673         { 6, alc880_fivestack_ch6_init },
1674         { 8, alc880_fivestack_ch8_init },
1675 };
1676
1677
1678 /*
1679  * ALC880 6-stack model
1680  *
1681  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1682  *      Side = 0x05 (0x0f)
1683  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1684  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1685  */
1686
1687 static hda_nid_t alc880_6st_dac_nids[4] = {
1688         /* front, rear, clfe, rear_surr */
1689         0x02, 0x03, 0x04, 0x05
1690 };
1691
1692 static struct hda_input_mux alc880_6stack_capture_source = {
1693         .num_items = 4,
1694         .items = {
1695                 { "Mic", 0x0 },
1696                 { "Front Mic", 0x1 },
1697                 { "Line", 0x2 },
1698                 { "CD", 0x4 },
1699         },
1700 };
1701
1702 /* fixed 8-channels */
1703 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1704         { 8, NULL },
1705 };
1706
1707 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1708         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1709         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1710         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1711         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1712         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1713         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1714         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1715         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1716         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1717         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1718         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1719         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1720         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1721         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1722         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1723         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1724         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1725         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1726         {
1727                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1728                 .name = "Channel Mode",
1729                 .info = alc_ch_mode_info,
1730                 .get = alc_ch_mode_get,
1731                 .put = alc_ch_mode_put,
1732         },
1733         { } /* end */
1734 };
1735
1736
1737 /*
1738  * ALC880 W810 model
1739  *
1740  * W810 has rear IO for:
1741  * Front (DAC 02)
1742  * Surround (DAC 03)
1743  * Center/LFE (DAC 04)
1744  * Digital out (06)
1745  *
1746  * The system also has a pair of internal speakers, and a headphone jack.
1747  * These are both connected to Line2 on the codec, hence to DAC 02.
1748  *
1749  * There is a variable resistor to control the speaker or headphone
1750  * volume. This is a hardware-only device without a software API.
1751  *
1752  * Plugging headphones in will disable the internal speakers. This is
1753  * implemented in hardware, not via the driver using jack sense. In
1754  * a similar fashion, plugging into the rear socket marked "front" will
1755  * disable both the speakers and headphones.
1756  *
1757  * For input, there's a microphone jack, and an "audio in" jack.
1758  * These may not do anything useful with this driver yet, because I
1759  * haven't setup any initialization verbs for these yet...
1760  */
1761
1762 static hda_nid_t alc880_w810_dac_nids[3] = {
1763         /* front, rear/surround, clfe */
1764         0x02, 0x03, 0x04
1765 };
1766
1767 /* fixed 6 channels */
1768 static struct hda_channel_mode alc880_w810_modes[1] = {
1769         { 6, NULL }
1770 };
1771
1772 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1773 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1774         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1775         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1776         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1777         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1778         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1779         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1780         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1781         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1782         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1783         { } /* end */
1784 };
1785
1786
1787 /*
1788  * Z710V model
1789  *
1790  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1791  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1792  *                 Line = 0x1a
1793  */
1794
1795 static hda_nid_t alc880_z71v_dac_nids[1] = {
1796         0x02
1797 };
1798 #define ALC880_Z71V_HP_DAC      0x03
1799
1800 /* fixed 2 channels */
1801 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1802         { 2, NULL }
1803 };
1804
1805 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1806         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1807         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1808         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1809         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1810         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1811         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1812         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1813         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1814         { } /* end */
1815 };
1816
1817
1818 /*
1819  * ALC880 F1734 model
1820  *
1821  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1822  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1823  */
1824
1825 static hda_nid_t alc880_f1734_dac_nids[1] = {
1826         0x03
1827 };
1828 #define ALC880_F1734_HP_DAC     0x02
1829
1830 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1831         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1832         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1833         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1834         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1835         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1836         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1837         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1838         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1839         { } /* end */
1840 };
1841
1842 static struct hda_input_mux alc880_f1734_capture_source = {
1843         .num_items = 2,
1844         .items = {
1845                 { "Mic", 0x1 },
1846                 { "CD", 0x4 },
1847         },
1848 };
1849
1850
1851 /*
1852  * ALC880 ASUS model
1853  *
1854  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1855  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1856  *  Mic = 0x18, Line = 0x1a
1857  */
1858
1859 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
1860 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
1861
1862 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1863         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1864         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1865         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1866         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1867         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1868         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1869         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1870         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1871         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1872         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1873         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1874         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1875         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1876         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1877         {
1878                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1879                 .name = "Channel Mode",
1880                 .info = alc_ch_mode_info,
1881                 .get = alc_ch_mode_get,
1882                 .put = alc_ch_mode_put,
1883         },
1884         { } /* end */
1885 };
1886
1887 /*
1888  * ALC880 ASUS W1V model
1889  *
1890  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1891  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1892  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1893  */
1894
1895 /* additional mixers to alc880_asus_mixer */
1896 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1897         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1898         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1899         { } /* end */
1900 };
1901
1902 /* TCL S700 */
1903 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1904         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1905         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1906         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
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("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1910         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1911         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1912         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1913         { } /* end */
1914 };
1915
1916 /* Uniwill */
1917 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1918         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1919         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1920         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1921         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1922         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1923         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1924         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1925         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1926         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1927         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1928         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1929         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1930         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1931         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1932         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1933         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1934         {
1935                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1936                 .name = "Channel Mode",
1937                 .info = alc_ch_mode_info,
1938                 .get = alc_ch_mode_get,
1939                 .put = alc_ch_mode_put,
1940         },
1941         { } /* end */
1942 };
1943
1944 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1945         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1946         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1947         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1948         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1949         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1950         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1951         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1952         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1953         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1954         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1955         { } /* end */
1956 };
1957
1958 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1959         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1960         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1961         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1962         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1963         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1964         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1965         { } /* end */
1966 };
1967
1968 /*
1969  * virtual master controls
1970  */
1971
1972 /*
1973  * slave controls for virtual master
1974  */
1975 static const char *alc_slave_vols[] = {
1976         "Front Playback Volume",
1977         "Surround Playback Volume",
1978         "Center Playback Volume",
1979         "LFE Playback Volume",
1980         "Side Playback Volume",
1981         "Headphone Playback Volume",
1982         "Speaker Playback Volume",
1983         "Mono Playback Volume",
1984         "Line-Out Playback Volume",
1985         "PCM Playback Volume",
1986         NULL,
1987 };
1988
1989 static const char *alc_slave_sws[] = {
1990         "Front Playback Switch",
1991         "Surround Playback Switch",
1992         "Center Playback Switch",
1993         "LFE Playback Switch",
1994         "Side Playback Switch",
1995         "Headphone Playback Switch",
1996         "Speaker Playback Switch",
1997         "Mono Playback Switch",
1998         "IEC958 Playback Switch",
1999         NULL,
2000 };
2001
2002 /*
2003  * build control elements
2004  */
2005
2006 static void alc_free_kctls(struct hda_codec *codec);
2007
2008 /* additional beep mixers; the actual parameters are overwritten at build */
2009 static struct snd_kcontrol_new alc_beep_mixer[] = {
2010         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2011         HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
2012         { } /* end */
2013 };
2014
2015 static int alc_build_controls(struct hda_codec *codec)
2016 {
2017         struct alc_spec *spec = codec->spec;
2018         int err;
2019         int i;
2020
2021         for (i = 0; i < spec->num_mixers; i++) {
2022                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2023                 if (err < 0)
2024                         return err;
2025         }
2026         if (spec->cap_mixer) {
2027                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2028                 if (err < 0)
2029                         return err;
2030         }
2031         if (spec->multiout.dig_out_nid) {
2032                 err = snd_hda_create_spdif_out_ctls(codec,
2033                                                     spec->multiout.dig_out_nid);
2034                 if (err < 0)
2035                         return err;
2036                 if (!spec->no_analog) {
2037                         err = snd_hda_create_spdif_share_sw(codec,
2038                                                             &spec->multiout);
2039                         if (err < 0)
2040                                 return err;
2041                         spec->multiout.share_spdif = 1;
2042                 }
2043         }
2044         if (spec->dig_in_nid) {
2045                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2046                 if (err < 0)
2047                         return err;
2048         }
2049
2050         /* create beep controls if needed */
2051         if (spec->beep_amp) {
2052                 struct snd_kcontrol_new *knew;
2053                 for (knew = alc_beep_mixer; knew->name; knew++) {
2054                         struct snd_kcontrol *kctl;
2055                         kctl = snd_ctl_new1(knew, codec);
2056                         if (!kctl)
2057                                 return -ENOMEM;
2058                         kctl->private_value = spec->beep_amp;
2059                         err = snd_hda_ctl_add(codec, kctl);
2060                         if (err < 0)
2061                                 return err;
2062                 }
2063         }
2064
2065         /* if we have no master control, let's create it */
2066         if (!spec->no_analog &&
2067             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2068                 unsigned int vmaster_tlv[4];
2069                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2070                                         HDA_OUTPUT, vmaster_tlv);
2071                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2072                                           vmaster_tlv, alc_slave_vols);
2073                 if (err < 0)
2074                         return err;
2075         }
2076         if (!spec->no_analog &&
2077             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2078                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2079                                           NULL, alc_slave_sws);
2080                 if (err < 0)
2081                         return err;
2082         }
2083
2084         alc_free_kctls(codec); /* no longer needed */
2085         return 0;
2086 }
2087
2088
2089 /*
2090  * initialize the codec volumes, etc
2091  */
2092
2093 /*
2094  * generic initialization of ADC, input mixers and output mixers
2095  */
2096 static struct hda_verb alc880_volume_init_verbs[] = {
2097         /*
2098          * Unmute ADC0-2 and set the default input to mic-in
2099          */
2100         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2101         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2102         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2103         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2104         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2105         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2106
2107         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2108          * mixer widget
2109          * Note: PASD motherboards uses the Line In 2 as the input for front
2110          * panel mic (mic 2)
2111          */
2112         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2113         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2114         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2115         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2116         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2117         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2118         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2119         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2120
2121         /*
2122          * Set up output mixers (0x0c - 0x0f)
2123          */
2124         /* set vol=0 to output mixers */
2125         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2126         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2127         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2128         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2129         /* set up input amps for analog loopback */
2130         /* Amp Indices: DAC = 0, mixer = 1 */
2131         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2132         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2133         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2134         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2135         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2136         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2137         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2138         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2139
2140         { }
2141 };
2142
2143 /*
2144  * 3-stack pin configuration:
2145  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2146  */
2147 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2148         /*
2149          * preset connection lists of input pins
2150          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2151          */
2152         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2153         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2154         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2155
2156         /*
2157          * Set pin mode and muting
2158          */
2159         /* set front pin widgets 0x14 for output */
2160         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2161         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2162         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2163         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2164         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2165         /* Mic2 (as headphone out) for HP output */
2166         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2167         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2168         /* Line In pin widget for input */
2169         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2170         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2171         /* Line2 (as front mic) pin widget for input and vref at 80% */
2172         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2173         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2174         /* CD pin widget for input */
2175         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2176
2177         { }
2178 };
2179
2180 /*
2181  * 5-stack pin configuration:
2182  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2183  * line-in/side = 0x1a, f-mic = 0x1b
2184  */
2185 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2186         /*
2187          * preset connection lists of input pins
2188          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2189          */
2190         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2191         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2192
2193         /*
2194          * Set pin mode and muting
2195          */
2196         /* set pin widgets 0x14-0x17 for output */
2197         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2198         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2199         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2200         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2201         /* unmute pins for output (no gain on this amp) */
2202         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2203         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2204         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2205         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2206
2207         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2208         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2209         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2210         /* Mic2 (as headphone out) for HP output */
2211         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2212         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2213         /* Line In pin widget for input */
2214         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2215         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2216         /* Line2 (as front mic) pin widget for input and vref at 80% */
2217         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2218         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2219         /* CD pin widget for input */
2220         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2221
2222         { }
2223 };
2224
2225 /*
2226  * W810 pin configuration:
2227  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2228  */
2229 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2230         /* hphone/speaker input selector: front DAC */
2231         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2232
2233         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2234         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2235         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2236         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2237         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2238         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2239
2240         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2241         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2242
2243         { }
2244 };
2245
2246 /*
2247  * Z71V pin configuration:
2248  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2249  */
2250 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2251         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2252         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2253         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2254         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2255
2256         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2257         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2258         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2259         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2260
2261         { }
2262 };
2263
2264 /*
2265  * 6-stack pin configuration:
2266  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2267  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2268  */
2269 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2270         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2271
2272         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2273         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2274         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2275         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2276         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2277         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2278         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2279         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2280
2281         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2282         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2283         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2284         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2285         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2286         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2287         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2288         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2289         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2290
2291         { }
2292 };
2293
2294 /*
2295  * Uniwill pin configuration:
2296  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2297  * line = 0x1a
2298  */
2299 static struct hda_verb alc880_uniwill_init_verbs[] = {
2300         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2301
2302         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2303         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2304         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2305         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2306         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2307         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2308         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2309         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2310         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2311         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2312         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2313         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2314         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2315         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2316
2317         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2318         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2319         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2320         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2321         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2322         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2323         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2324         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2325         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2326
2327         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2328         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2329
2330         { }
2331 };
2332
2333 /*
2334 * Uniwill P53
2335 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2336  */
2337 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2338         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2339
2340         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2341         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2342         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2343         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2344         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2345         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2346         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2347         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2348         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2349         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2350         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2351         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2352
2353         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2354         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2355         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2356         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2357         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2358         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2359
2360         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2361         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2362
2363         { }
2364 };
2365
2366 static struct hda_verb alc880_beep_init_verbs[] = {
2367         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2368         { }
2369 };
2370
2371 /* toggle speaker-output according to the hp-jack state */
2372 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
2373 {
2374         unsigned int present;
2375         unsigned char bits;
2376
2377         present = snd_hda_codec_read(codec, 0x14, 0,
2378                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2379         bits = present ? HDA_AMP_MUTE : 0;
2380         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
2381                                  HDA_AMP_MUTE, bits);
2382         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
2383                                  HDA_AMP_MUTE, bits);
2384 }
2385
2386 /* auto-toggle front mic */
2387 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2388 {
2389         unsigned int present;
2390         unsigned char bits;
2391
2392         present = snd_hda_codec_read(codec, 0x18, 0,
2393                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2394         bits = present ? HDA_AMP_MUTE : 0;
2395         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2396 }
2397
2398 static void alc880_uniwill_automute(struct hda_codec *codec)
2399 {
2400         alc880_uniwill_hp_automute(codec);
2401         alc880_uniwill_mic_automute(codec);
2402 }
2403
2404 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2405                                        unsigned int res)
2406 {
2407         /* Looks like the unsol event is incompatible with the standard
2408          * definition.  4bit tag is placed at 28 bit!
2409          */
2410         switch (res >> 28) {
2411         case ALC880_HP_EVENT:
2412                 alc880_uniwill_hp_automute(codec);
2413                 break;
2414         case ALC880_MIC_EVENT:
2415                 alc880_uniwill_mic_automute(codec);
2416                 break;
2417         }
2418 }
2419
2420 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
2421 {
2422         unsigned int present;
2423         unsigned char bits;
2424
2425         present = snd_hda_codec_read(codec, 0x14, 0,
2426                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2427         bits = present ? HDA_AMP_MUTE : 0;
2428         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
2429 }
2430
2431 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2432 {
2433         unsigned int present;
2434
2435         present = snd_hda_codec_read(codec, 0x21, 0,
2436                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2437         present &= HDA_AMP_VOLMASK;
2438         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2439                                  HDA_AMP_VOLMASK, present);
2440         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2441                                  HDA_AMP_VOLMASK, present);
2442 }
2443
2444 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2445                                            unsigned int res)
2446 {
2447         /* Looks like the unsol event is incompatible with the standard
2448          * definition.  4bit tag is placed at 28 bit!
2449          */
2450         if ((res >> 28) == ALC880_HP_EVENT)
2451                 alc880_uniwill_p53_hp_automute(codec);
2452         if ((res >> 28) == ALC880_DCVOL_EVENT)
2453                 alc880_uniwill_p53_dcvol_automute(codec);
2454 }
2455
2456 /*
2457  * F1734 pin configuration:
2458  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2459  */
2460 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2461         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2462         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2463         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2464         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2465         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2466
2467         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2468         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2469         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2470         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2471
2472         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2473         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2474         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2475         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2476         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2477         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2478         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2479         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2480         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2481
2482         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2483         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2484
2485         { }
2486 };
2487
2488 /*
2489  * ASUS pin configuration:
2490  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2491  */
2492 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2493         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2494         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2495         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2496         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2497
2498         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2499         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2500         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2501         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2502         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2503         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2504         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2505         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2506
2507         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2508         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2509         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2510         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2511         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2512         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2513         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2514         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2515         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2516
2517         { }
2518 };
2519
2520 /* Enable GPIO mask and set output */
2521 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2522 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2523
2524 /* Clevo m520g init */
2525 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2526         /* headphone output */
2527         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2528         /* line-out */
2529         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2530         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2531         /* Line-in */
2532         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2533         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2534         /* CD */
2535         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2536         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2537         /* Mic1 (rear panel) */
2538         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2539         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2540         /* Mic2 (front panel) */
2541         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2542         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2543         /* headphone */
2544         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2545         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2546         /* change to EAPD mode */
2547         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2548         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2549
2550         { }
2551 };
2552
2553 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2554         /* change to EAPD mode */
2555         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2556         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2557
2558         /* Headphone output */
2559         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2560         /* Front output*/
2561         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2562         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2563
2564         /* Line In pin widget for input */
2565         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2566         /* CD pin widget for input */
2567         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2568         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2569         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2570
2571         /* change to EAPD mode */
2572         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2573         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2574
2575         { }
2576 };
2577
2578 /*
2579  * LG m1 express dual
2580  *
2581  * Pin assignment:
2582  *   Rear Line-In/Out (blue): 0x14
2583  *   Build-in Mic-In: 0x15
2584  *   Speaker-out: 0x17
2585  *   HP-Out (green): 0x1b
2586  *   Mic-In/Out (red): 0x19
2587  *   SPDIF-Out: 0x1e
2588  */
2589
2590 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2591 static hda_nid_t alc880_lg_dac_nids[3] = {
2592         0x05, 0x02, 0x03
2593 };
2594
2595 /* seems analog CD is not working */
2596 static struct hda_input_mux alc880_lg_capture_source = {
2597         .num_items = 3,
2598         .items = {
2599                 { "Mic", 0x1 },
2600                 { "Line", 0x5 },
2601                 { "Internal Mic", 0x6 },
2602         },
2603 };
2604
2605 /* 2,4,6 channel modes */
2606 static struct hda_verb alc880_lg_ch2_init[] = {
2607         /* set line-in and mic-in to input */
2608         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2609         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2610         { }
2611 };
2612
2613 static struct hda_verb alc880_lg_ch4_init[] = {
2614         /* set line-in to out and mic-in to input */
2615         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2616         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2617         { }
2618 };
2619
2620 static struct hda_verb alc880_lg_ch6_init[] = {
2621         /* set line-in and mic-in to output */
2622         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2623         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2624         { }
2625 };
2626
2627 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2628         { 2, alc880_lg_ch2_init },
2629         { 4, alc880_lg_ch4_init },
2630         { 6, alc880_lg_ch6_init },
2631 };
2632
2633 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2634         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2635         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2636         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2637         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2638         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2639         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2640         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2641         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2642         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2643         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2644         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2645         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2646         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2647         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2648         {
2649                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2650                 .name = "Channel Mode",
2651                 .info = alc_ch_mode_info,
2652                 .get = alc_ch_mode_get,
2653                 .put = alc_ch_mode_put,
2654         },
2655         { } /* end */
2656 };
2657
2658 static struct hda_verb alc880_lg_init_verbs[] = {
2659         /* set capture source to mic-in */
2660         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2661         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2662         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2663         /* mute all amp mixer inputs */
2664         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2665         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2666         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2667         /* line-in to input */
2668         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2669         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2670         /* built-in mic */
2671         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2672         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2673         /* speaker-out */
2674         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2675         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2676         /* mic-in to input */
2677         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2678         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2679         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2680         /* HP-out */
2681         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2682         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2683         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2684         /* jack sense */
2685         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2686         { }
2687 };
2688
2689 /* toggle speaker-output according to the hp-jack state */
2690 static void alc880_lg_automute(struct hda_codec *codec)
2691 {
2692         unsigned int present;
2693         unsigned char bits;
2694
2695         present = snd_hda_codec_read(codec, 0x1b, 0,
2696                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2697         bits = present ? HDA_AMP_MUTE : 0;
2698         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2699                                  HDA_AMP_MUTE, bits);
2700 }
2701
2702 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2703 {
2704         /* Looks like the unsol event is incompatible with the standard
2705          * definition.  4bit tag is placed at 28 bit!
2706          */
2707         if ((res >> 28) == 0x01)
2708                 alc880_lg_automute(codec);
2709 }
2710
2711 /*
2712  * LG LW20
2713  *
2714  * Pin assignment:
2715  *   Speaker-out: 0x14
2716  *   Mic-In: 0x18
2717  *   Built-in Mic-In: 0x19
2718  *   Line-In: 0x1b
2719  *   HP-Out: 0x1a
2720  *   SPDIF-Out: 0x1e
2721  */
2722
2723 static struct hda_input_mux alc880_lg_lw_capture_source = {
2724         .num_items = 3,
2725         .items = {
2726                 { "Mic", 0x0 },
2727                 { "Internal Mic", 0x1 },
2728                 { "Line In", 0x2 },
2729         },
2730 };
2731
2732 #define alc880_lg_lw_modes alc880_threestack_modes
2733
2734 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2735         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2736         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2737         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2738         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2739         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2740         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2741         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2742         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2743         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2744         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2745         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2746         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2747         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2748         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2749         {
2750                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2751                 .name = "Channel Mode",
2752                 .info = alc_ch_mode_info,
2753                 .get = alc_ch_mode_get,
2754                 .put = alc_ch_mode_put,
2755         },
2756         { } /* end */
2757 };
2758
2759 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2760         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2761         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2762         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2763
2764         /* set capture source to mic-in */
2765         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2766         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2767         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2768         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2769         /* speaker-out */
2770         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2771         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2772         /* HP-out */
2773         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2774         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2775         /* mic-in to input */
2776         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2777         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2778         /* built-in mic */
2779         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2780         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2781         /* jack sense */
2782         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2783         { }
2784 };
2785
2786 /* toggle speaker-output according to the hp-jack state */
2787 static void alc880_lg_lw_automute(struct hda_codec *codec)
2788 {
2789         unsigned int present;
2790         unsigned char bits;
2791
2792         present = snd_hda_codec_read(codec, 0x1b, 0,
2793                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2794         bits = present ? HDA_AMP_MUTE : 0;
2795         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2796                                  HDA_AMP_MUTE, bits);
2797 }
2798
2799 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2800 {
2801         /* Looks like the unsol event is incompatible with the standard
2802          * definition.  4bit tag is placed at 28 bit!
2803          */
2804         if ((res >> 28) == 0x01)
2805                 alc880_lg_lw_automute(codec);
2806 }
2807
2808 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2809         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2810         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2811         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2812         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2813         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2814         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2815         { } /* end */
2816 };
2817
2818 static struct hda_input_mux alc880_medion_rim_capture_source = {
2819         .num_items = 2,
2820         .items = {
2821                 { "Mic", 0x0 },
2822                 { "Internal Mic", 0x1 },
2823         },
2824 };
2825
2826 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2827         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2828
2829         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2830         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2831
2832         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2833         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2834         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2835         /* Mic2 (as headphone out) for HP output */
2836         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2837         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2838         /* Internal Speaker */
2839         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2840         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2841
2842         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2843         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2844
2845         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2846         { }
2847 };
2848
2849 /* toggle speaker-output according to the hp-jack state */
2850 static void alc880_medion_rim_automute(struct hda_codec *codec)
2851 {
2852         unsigned int present;
2853         unsigned char bits;
2854
2855         present = snd_hda_codec_read(codec, 0x14, 0,
2856                                      AC_VERB_GET_PIN_SENSE, 0)
2857                 & AC_PINSENSE_PRESENCE;
2858         bits = present ? HDA_AMP_MUTE : 0;
2859         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
2860                                  HDA_AMP_MUTE, bits);
2861         if (present)
2862                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2863         else
2864                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2865 }
2866
2867 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2868                                           unsigned int res)
2869 {
2870         /* Looks like the unsol event is incompatible with the standard
2871          * definition.  4bit tag is placed at 28 bit!
2872          */
2873         if ((res >> 28) == ALC880_HP_EVENT)
2874                 alc880_medion_rim_automute(codec);
2875 }
2876
2877 #ifdef CONFIG_SND_HDA_POWER_SAVE
2878 static struct hda_amp_list alc880_loopbacks[] = {
2879         { 0x0b, HDA_INPUT, 0 },
2880         { 0x0b, HDA_INPUT, 1 },
2881         { 0x0b, HDA_INPUT, 2 },
2882         { 0x0b, HDA_INPUT, 3 },
2883         { 0x0b, HDA_INPUT, 4 },
2884         { } /* end */
2885 };
2886
2887 static struct hda_amp_list alc880_lg_loopbacks[] = {
2888         { 0x0b, HDA_INPUT, 1 },
2889         { 0x0b, HDA_INPUT, 6 },
2890         { 0x0b, HDA_INPUT, 7 },
2891         { } /* end */
2892 };
2893 #endif
2894
2895 /*
2896  * Common callbacks
2897  */
2898
2899 static int alc_init(struct hda_codec *codec)
2900 {
2901         struct alc_spec *spec = codec->spec;
2902         unsigned int i;
2903
2904         alc_fix_pll(codec);
2905         if (codec->vendor_id == 0x10ec0888)
2906                 alc888_coef_init(codec);
2907
2908         for (i = 0; i < spec->num_init_verbs; i++)
2909                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2910
2911         if (spec->init_hook)
2912                 spec->init_hook(codec);
2913
2914         return 0;
2915 }
2916
2917 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2918 {
2919         struct alc_spec *spec = codec->spec;
2920
2921         if (spec->unsol_event)
2922                 spec->unsol_event(codec, res);
2923 }
2924
2925 #ifdef CONFIG_SND_HDA_POWER_SAVE
2926 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2927 {
2928         struct alc_spec *spec = codec->spec;
2929         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2930 }
2931 #endif
2932
2933 /*
2934  * Analog playback callbacks
2935  */
2936 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2937                                     struct hda_codec *codec,
2938                                     struct snd_pcm_substream *substream)
2939 {
2940         struct alc_spec *spec = codec->spec;
2941         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2942                                              hinfo);
2943 }
2944
2945 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2946                                        struct hda_codec *codec,
2947                                        unsigned int stream_tag,
2948                                        unsigned int format,
2949                                        struct snd_pcm_substream *substream)
2950 {
2951         struct alc_spec *spec = codec->spec;
2952         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2953                                                 stream_tag, format, substream);
2954 }
2955
2956 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2957                                        struct hda_codec *codec,
2958                                        struct snd_pcm_substream *substream)
2959 {
2960         struct alc_spec *spec = codec->spec;
2961         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2962 }
2963
2964 /*
2965  * Digital out
2966  */
2967 static int alc880_dig_playback_pcm_open(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_open(codec, &spec->multiout);
2973 }
2974
2975 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2976                                            struct hda_codec *codec,
2977                                            unsigned int stream_tag,
2978                                            unsigned int format,
2979                                            struct snd_pcm_substream *substream)
2980 {
2981         struct alc_spec *spec = codec->spec;
2982         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2983                                              stream_tag, format, substream);
2984 }
2985
2986 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2987                                            struct hda_codec *codec,
2988                                            struct snd_pcm_substream *substream)
2989 {
2990         struct alc_spec *spec = codec->spec;
2991         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2992 }
2993
2994 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2995                                          struct hda_codec *codec,
2996                                          struct snd_pcm_substream *substream)
2997 {
2998         struct alc_spec *spec = codec->spec;
2999         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3000 }
3001
3002 /*
3003  * Analog capture
3004  */
3005 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3006                                       struct hda_codec *codec,
3007                                       unsigned int stream_tag,
3008                                       unsigned int format,
3009                                       struct snd_pcm_substream *substream)
3010 {
3011         struct alc_spec *spec = codec->spec;
3012
3013         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3014                                    stream_tag, 0, format);
3015         return 0;
3016 }
3017
3018 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3019                                       struct hda_codec *codec,
3020                                       struct snd_pcm_substream *substream)
3021 {
3022         struct alc_spec *spec = codec->spec;
3023
3024         snd_hda_codec_cleanup_stream(codec,
3025                                      spec->adc_nids[substream->number + 1]);
3026         return 0;
3027 }
3028
3029
3030 /*
3031  */
3032 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3033         .substreams = 1,
3034         .channels_min = 2,
3035         .channels_max = 8,
3036         /* NID is set in alc_build_pcms */
3037         .ops = {
3038                 .open = alc880_playback_pcm_open,
3039                 .prepare = alc880_playback_pcm_prepare,
3040                 .cleanup = alc880_playback_pcm_cleanup
3041         },
3042 };
3043
3044 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3045         .substreams = 1,
3046         .channels_min = 2,
3047         .channels_max = 2,
3048         /* NID is set in alc_build_pcms */
3049 };
3050
3051 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3052         .substreams = 1,
3053         .channels_min = 2,
3054         .channels_max = 2,
3055         /* NID is set in alc_build_pcms */
3056 };
3057
3058 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3059         .substreams = 2, /* can be overridden */
3060         .channels_min = 2,
3061         .channels_max = 2,
3062         /* NID is set in alc_build_pcms */
3063         .ops = {
3064                 .prepare = alc880_alt_capture_pcm_prepare,
3065                 .cleanup = alc880_alt_capture_pcm_cleanup
3066         },
3067 };
3068
3069 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3070         .substreams = 1,
3071         .channels_min = 2,
3072         .channels_max = 2,
3073         /* NID is set in alc_build_pcms */
3074         .ops = {
3075                 .open = alc880_dig_playback_pcm_open,
3076                 .close = alc880_dig_playback_pcm_close,
3077                 .prepare = alc880_dig_playback_pcm_prepare,
3078                 .cleanup = alc880_dig_playback_pcm_cleanup
3079         },
3080 };
3081
3082 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3083         .substreams = 1,
3084         .channels_min = 2,
3085         .channels_max = 2,
3086         /* NID is set in alc_build_pcms */
3087 };
3088
3089 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3090 static struct hda_pcm_stream alc_pcm_null_stream = {
3091         .substreams = 0,
3092         .channels_min = 0,
3093         .channels_max = 0,
3094 };
3095
3096 static int alc_build_pcms(struct hda_codec *codec)
3097 {
3098         struct alc_spec *spec = codec->spec;
3099         struct hda_pcm *info = spec->pcm_rec;
3100         int i;
3101
3102         codec->num_pcms = 1;
3103         codec->pcm_info = info;
3104
3105         if (spec->no_analog)
3106                 goto skip_analog;
3107
3108         info->name = spec->stream_name_analog;
3109         if (spec->stream_analog_playback) {
3110                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3111                         return -EINVAL;
3112                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3113                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3114         }
3115         if (spec->stream_analog_capture) {
3116                 if (snd_BUG_ON(!spec->adc_nids))
3117                         return -EINVAL;
3118                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3119                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3120         }
3121
3122         if (spec->channel_mode) {
3123                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3124                 for (i = 0; i < spec->num_channel_mode; i++) {
3125                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3126                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3127                         }
3128                 }
3129         }
3130
3131  skip_analog:
3132         /* SPDIF for stream index #1 */
3133         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3134                 codec->num_pcms = 2;
3135                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3136                 info = spec->pcm_rec + 1;
3137                 info->name = spec->stream_name_digital;
3138                 if (spec->dig_out_type)
3139                         info->pcm_type = spec->dig_out_type;
3140                 else
3141                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3142                 if (spec->multiout.dig_out_nid &&
3143                     spec->stream_digital_playback) {
3144                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3145                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3146                 }
3147                 if (spec->dig_in_nid &&
3148                     spec->stream_digital_capture) {
3149                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3150                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3151                 }
3152                 /* FIXME: do we need this for all Realtek codec models? */
3153                 codec->spdif_status_reset = 1;
3154         }
3155
3156         if (spec->no_analog)
3157                 return 0;
3158
3159         /* If the use of more than one ADC is requested for the current
3160          * model, configure a second analog capture-only PCM.
3161          */
3162         /* Additional Analaog capture for index #2 */
3163         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3164             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3165                 codec->num_pcms = 3;
3166                 info = spec->pcm_rec + 2;
3167                 info->name = spec->stream_name_analog;
3168                 if (spec->alt_dac_nid) {
3169                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3170                                 *spec->stream_analog_alt_playback;
3171                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3172                                 spec->alt_dac_nid;
3173                 } else {
3174                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3175                                 alc_pcm_null_stream;
3176                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3177                 }
3178                 if (spec->num_adc_nids > 1) {
3179                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3180                                 *spec->stream_analog_alt_capture;
3181                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3182                                 spec->adc_nids[1];
3183                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3184                                 spec->num_adc_nids - 1;
3185                 } else {
3186                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3187                                 alc_pcm_null_stream;
3188                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3189                 }
3190         }
3191
3192         return 0;
3193 }
3194
3195 static void alc_free_kctls(struct hda_codec *codec)
3196 {
3197         struct alc_spec *spec = codec->spec;
3198
3199         if (spec->kctls.list) {
3200                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3201                 int i;
3202                 for (i = 0; i < spec->kctls.used; i++)
3203                         kfree(kctl[i].name);
3204         }
3205         snd_array_free(&spec->kctls);
3206 }
3207
3208 static void alc_free(struct hda_codec *codec)
3209 {
3210         struct alc_spec *spec = codec->spec;
3211
3212         if (!spec)
3213                 return;
3214
3215         alc_free_kctls(codec);
3216         kfree(spec);
3217         snd_hda_detach_beep_device(codec);
3218 }
3219
3220 #ifdef SND_HDA_NEEDS_RESUME
3221 static int alc_resume(struct hda_codec *codec)
3222 {
3223         codec->patch_ops.init(codec);
3224         snd_hda_codec_resume_amp(codec);
3225         snd_hda_codec_resume_cache(codec);
3226         return 0;
3227 }
3228 #endif
3229
3230 /*
3231  */
3232 static struct hda_codec_ops alc_patch_ops = {
3233         .build_controls = alc_build_controls,
3234         .build_pcms = alc_build_pcms,
3235         .init = alc_init,
3236         .free = alc_free,
3237         .unsol_event = alc_unsol_event,
3238 #ifdef SND_HDA_NEEDS_RESUME
3239         .resume = alc_resume,
3240 #endif
3241 #ifdef CONFIG_SND_HDA_POWER_SAVE
3242         .check_power_status = alc_check_power_status,
3243 #endif
3244 };
3245
3246
3247 /*
3248  * Test configuration for debugging
3249  *
3250  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3251  * enum controls.
3252  */
3253 #ifdef CONFIG_SND_DEBUG
3254 static hda_nid_t alc880_test_dac_nids[4] = {
3255         0x02, 0x03, 0x04, 0x05
3256 };
3257
3258 static struct hda_input_mux alc880_test_capture_source = {
3259         .num_items = 7,
3260         .items = {
3261                 { "In-1", 0x0 },
3262                 { "In-2", 0x1 },
3263                 { "In-3", 0x2 },
3264                 { "In-4", 0x3 },
3265                 { "CD", 0x4 },
3266                 { "Front", 0x5 },
3267                 { "Surround", 0x6 },
3268         },
3269 };
3270
3271 static struct hda_channel_mode alc880_test_modes[4] = {
3272         { 2, NULL },
3273         { 4, NULL },
3274         { 6, NULL },
3275         { 8, NULL },
3276 };
3277
3278 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3279                                  struct snd_ctl_elem_info *uinfo)
3280 {
3281         static char *texts[] = {
3282                 "N/A", "Line Out", "HP Out",
3283                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3284         };
3285         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3286         uinfo->count = 1;
3287         uinfo->value.enumerated.items = 8;
3288         if (uinfo->value.enumerated.item >= 8)
3289                 uinfo->value.enumerated.item = 7;
3290         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3291         return 0;
3292 }
3293
3294 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3295                                 struct snd_ctl_elem_value *ucontrol)
3296 {
3297         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3298         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3299         unsigned int pin_ctl, item = 0;
3300
3301         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3302                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3303         if (pin_ctl & AC_PINCTL_OUT_EN) {
3304                 if (pin_ctl & AC_PINCTL_HP_EN)
3305                         item = 2;
3306                 else
3307                         item = 1;
3308         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3309                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3310                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3311                 case AC_PINCTL_VREF_50:  item = 4; break;
3312                 case AC_PINCTL_VREF_GRD: item = 5; break;
3313                 case AC_PINCTL_VREF_80:  item = 6; break;
3314                 case AC_PINCTL_VREF_100: item = 7; break;
3315                 }
3316         }
3317         ucontrol->value.enumerated.item[0] = item;
3318         return 0;
3319 }
3320
3321 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3322                                 struct snd_ctl_elem_value *ucontrol)
3323 {
3324         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3325         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3326         static unsigned int ctls[] = {
3327                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3328                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3329                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3330                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3331                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3332                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3333         };
3334         unsigned int old_ctl, new_ctl;
3335
3336         old_ctl = snd_hda_codec_read(codec, nid, 0,
3337                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3338         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3339         if (old_ctl != new_ctl) {
3340                 int val;
3341                 snd_hda_codec_write_cache(codec, nid, 0,
3342                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3343                                           new_ctl);
3344                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3345                         HDA_AMP_MUTE : 0;
3346                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3347                                          HDA_AMP_MUTE, val);
3348                 return 1;
3349         }
3350         return 0;
3351 }
3352
3353 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3354                                  struct snd_ctl_elem_info *uinfo)
3355 {
3356         static char *texts[] = {
3357                 "Front", "Surround", "CLFE", "Side"
3358         };
3359         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3360         uinfo->count = 1;
3361         uinfo->value.enumerated.items = 4;
3362         if (uinfo->value.enumerated.item >= 4)
3363                 uinfo->value.enumerated.item = 3;
3364         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3365         return 0;
3366 }
3367
3368 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3369                                 struct snd_ctl_elem_value *ucontrol)
3370 {
3371         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3372         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3373         unsigned int sel;
3374
3375         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3376         ucontrol->value.enumerated.item[0] = sel & 3;
3377         return 0;
3378 }
3379
3380 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3381                                 struct snd_ctl_elem_value *ucontrol)
3382 {
3383         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3384         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3385         unsigned int sel;
3386
3387         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3388         if (ucontrol->value.enumerated.item[0] != sel) {
3389                 sel = ucontrol->value.enumerated.item[0] & 3;
3390                 snd_hda_codec_write_cache(codec, nid, 0,
3391                                           AC_VERB_SET_CONNECT_SEL, sel);
3392                 return 1;
3393         }
3394         return 0;
3395 }
3396
3397 #define PIN_CTL_TEST(xname,nid) {                       \
3398                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3399                         .name = xname,                 \
3400                         .info = alc_test_pin_ctl_info, \
3401                         .get = alc_test_pin_ctl_get,   \
3402                         .put = alc_test_pin_ctl_put,   \
3403                         .private_value = nid           \
3404                         }
3405
3406 #define PIN_SRC_TEST(xname,nid) {                       \
3407                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3408                         .name = xname,                 \
3409                         .info = alc_test_pin_src_info, \
3410                         .get = alc_test_pin_src_get,   \
3411                         .put = alc_test_pin_src_put,   \
3412                         .private_value = nid           \
3413                         }
3414
3415 static struct snd_kcontrol_new alc880_test_mixer[] = {
3416         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3417         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3418         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3419         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3420         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3421         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3422         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3423         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3424         PIN_CTL_TEST("Front Pin Mode", 0x14),
3425         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3426         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3427         PIN_CTL_TEST("Side Pin Mode", 0x17),
3428         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3429         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3430         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3431         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3432         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3433         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3434         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3435         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3436         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3437         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3438         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3439         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3440         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3441         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3442         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3443         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3444         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3445         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3446         {
3447                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3448                 .name = "Channel Mode",
3449                 .info = alc_ch_mode_info,
3450                 .get = alc_ch_mode_get,
3451                 .put = alc_ch_mode_put,
3452         },
3453         { } /* end */
3454 };
3455
3456 static struct hda_verb alc880_test_init_verbs[] = {
3457         /* Unmute inputs of 0x0c - 0x0f */
3458         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3459         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3460         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3461         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3462         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3463         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3464         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3465         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3466         /* Vol output for 0x0c-0x0f */
3467         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3468         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3469         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3470         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3471         /* Set output pins 0x14-0x17 */
3472         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3473         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3474         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3475         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3476         /* Unmute output pins 0x14-0x17 */
3477         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3478         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3479         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3480         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3481         /* Set input pins 0x18-0x1c */
3482         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3483         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3484         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3485         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3486         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3487         /* Mute input pins 0x18-0x1b */
3488         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3489         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3490         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3491         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3492         /* ADC set up */
3493         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3494         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3495         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3496         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3497         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3498         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3499         /* Analog input/passthru */
3500         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3501         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3502         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3503         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3504         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3505         { }
3506 };
3507 #endif
3508
3509 /*
3510  */
3511
3512 static const char *alc880_models[ALC880_MODEL_LAST] = {
3513         [ALC880_3ST]            = "3stack",
3514         [ALC880_TCL_S700]       = "tcl",
3515         [ALC880_3ST_DIG]        = "3stack-digout",
3516         [ALC880_CLEVO]          = "clevo",
3517         [ALC880_5ST]            = "5stack",
3518         [ALC880_5ST_DIG]        = "5stack-digout",
3519         [ALC880_W810]           = "w810",
3520         [ALC880_Z71V]           = "z71v",
3521         [ALC880_6ST]            = "6stack",
3522         [ALC880_6ST_DIG]        = "6stack-digout",
3523         [ALC880_ASUS]           = "asus",
3524         [ALC880_ASUS_W1V]       = "asus-w1v",
3525         [ALC880_ASUS_DIG]       = "asus-dig",
3526         [ALC880_ASUS_DIG2]      = "asus-dig2",
3527         [ALC880_UNIWILL_DIG]    = "uniwill",
3528         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3529         [ALC880_FUJITSU]        = "fujitsu",
3530         [ALC880_F1734]          = "F1734",
3531         [ALC880_LG]             = "lg",
3532         [ALC880_LG_LW]          = "lg-lw",
3533         [ALC880_MEDION_RIM]     = "medion",
3534 #ifdef CONFIG_SND_DEBUG
3535         [ALC880_TEST]           = "test",
3536 #endif
3537         [ALC880_AUTO]           = "auto",
3538 };
3539
3540 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3541         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3542         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3543         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3544         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3545         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3546         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3547         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3548         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3549         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3550         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3551         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3552         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3553         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3554         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3555         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3556         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3557         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3558         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3559         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3560         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3561         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3562         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3563         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3564         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3565         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3566         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
3567         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3568         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3569         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3570         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3571         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3572         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3573         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3574         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3575         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3576         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3577         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3578         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3579         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3580         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3581         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3582         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3583         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3584         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3585         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3586         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3587         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3588         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3589         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3590         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3591         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3592         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3593         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3594         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3595         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3596         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3597         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3598         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3599         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3600         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3601         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3602         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3603         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3604         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3605         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3606         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3607         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3608         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3609         /* default Intel */
3610         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
3611         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3612         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3613         {}
3614 };
3615
3616 /*
3617  * ALC880 codec presets
3618  */
3619 static struct alc_config_preset alc880_presets[] = {
3620         [ALC880_3ST] = {
3621                 .mixers = { alc880_three_stack_mixer },
3622                 .init_verbs = { alc880_volume_init_verbs,
3623                                 alc880_pin_3stack_init_verbs },
3624                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3625                 .dac_nids = alc880_dac_nids,
3626                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3627                 .channel_mode = alc880_threestack_modes,
3628                 .need_dac_fix = 1,
3629                 .input_mux = &alc880_capture_source,
3630         },
3631         [ALC880_3ST_DIG] = {
3632                 .mixers = { alc880_three_stack_mixer },
3633                 .init_verbs = { alc880_volume_init_verbs,
3634                                 alc880_pin_3stack_init_verbs },
3635                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3636                 .dac_nids = alc880_dac_nids,
3637                 .dig_out_nid = ALC880_DIGOUT_NID,
3638                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3639                 .channel_mode = alc880_threestack_modes,
3640                 .need_dac_fix = 1,
3641                 .input_mux = &alc880_capture_source,
3642         },
3643         [ALC880_TCL_S700] = {
3644                 .mixers = { alc880_tcl_s700_mixer },
3645                 .init_verbs = { alc880_volume_init_verbs,
3646                                 alc880_pin_tcl_S700_init_verbs,
3647                                 alc880_gpio2_init_verbs },
3648                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3649                 .dac_nids = alc880_dac_nids,
3650                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
3651                 .num_adc_nids = 1, /* single ADC */
3652                 .hp_nid = 0x03,
3653                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3654                 .channel_mode = alc880_2_jack_modes,
3655                 .input_mux = &alc880_capture_source,
3656         },
3657         [ALC880_5ST] = {
3658                 .mixers = { alc880_three_stack_mixer,
3659                             alc880_five_stack_mixer},
3660                 .init_verbs = { alc880_volume_init_verbs,
3661                                 alc880_pin_5stack_init_verbs },
3662                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3663                 .dac_nids = alc880_dac_nids,
3664                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3665                 .channel_mode = alc880_fivestack_modes,
3666                 .input_mux = &alc880_capture_source,
3667         },
3668         [ALC880_5ST_DIG] = {
3669                 .mixers = { alc880_three_stack_mixer,
3670                             alc880_five_stack_mixer },
3671                 .init_verbs = { alc880_volume_init_verbs,
3672                                 alc880_pin_5stack_init_verbs },
3673                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3674                 .dac_nids = alc880_dac_nids,
3675                 .dig_out_nid = ALC880_DIGOUT_NID,
3676                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3677                 .channel_mode = alc880_fivestack_modes,
3678                 .input_mux = &alc880_capture_source,
3679         },
3680         [ALC880_6ST] = {
3681                 .mixers = { alc880_six_stack_mixer },
3682                 .init_verbs = { alc880_volume_init_verbs,
3683                                 alc880_pin_6stack_init_verbs },
3684                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3685                 .dac_nids = alc880_6st_dac_nids,
3686                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3687                 .channel_mode = alc880_sixstack_modes,
3688                 .input_mux = &alc880_6stack_capture_source,
3689         },
3690         [ALC880_6ST_DIG] = {
3691                 .mixers = { alc880_six_stack_mixer },
3692                 .init_verbs = { alc880_volume_init_verbs,
3693                                 alc880_pin_6stack_init_verbs },
3694                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3695                 .dac_nids = alc880_6st_dac_nids,
3696                 .dig_out_nid = ALC880_DIGOUT_NID,
3697                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3698                 .channel_mode = alc880_sixstack_modes,
3699                 .input_mux = &alc880_6stack_capture_source,
3700         },
3701         [ALC880_W810] = {
3702                 .mixers = { alc880_w810_base_mixer },
3703                 .init_verbs = { alc880_volume_init_verbs,
3704                                 alc880_pin_w810_init_verbs,
3705                                 alc880_gpio2_init_verbs },
3706                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3707                 .dac_nids = alc880_w810_dac_nids,
3708                 .dig_out_nid = ALC880_DIGOUT_NID,
3709                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3710                 .channel_mode = alc880_w810_modes,
3711                 .input_mux = &alc880_capture_source,
3712         },
3713         [ALC880_Z71V] = {
3714                 .mixers = { alc880_z71v_mixer },
3715                 .init_verbs = { alc880_volume_init_verbs,
3716                                 alc880_pin_z71v_init_verbs },
3717                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3718                 .dac_nids = alc880_z71v_dac_nids,
3719                 .dig_out_nid = ALC880_DIGOUT_NID,
3720                 .hp_nid = 0x03,
3721                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3722                 .channel_mode = alc880_2_jack_modes,
3723                 .input_mux = &alc880_capture_source,
3724         },
3725         [ALC880_F1734] = {
3726                 .mixers = { alc880_f1734_mixer },
3727                 .init_verbs = { alc880_volume_init_verbs,
3728                                 alc880_pin_f1734_init_verbs },
3729                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3730                 .dac_nids = alc880_f1734_dac_nids,
3731                 .hp_nid = 0x02,
3732                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3733                 .channel_mode = alc880_2_jack_modes,
3734                 .input_mux = &alc880_f1734_capture_source,
3735                 .unsol_event = alc880_uniwill_p53_unsol_event,
3736                 .init_hook = alc880_uniwill_p53_hp_automute,
3737         },
3738         [ALC880_ASUS] = {
3739                 .mixers = { alc880_asus_mixer },
3740                 .init_verbs = { alc880_volume_init_verbs,
3741                                 alc880_pin_asus_init_verbs,
3742                                 alc880_gpio1_init_verbs },
3743                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3744                 .dac_nids = alc880_asus_dac_nids,
3745                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3746                 .channel_mode = alc880_asus_modes,
3747                 .need_dac_fix = 1,
3748                 .input_mux = &alc880_capture_source,
3749         },
3750         [ALC880_ASUS_DIG] = {
3751                 .mixers = { alc880_asus_mixer },
3752                 .init_verbs = { alc880_volume_init_verbs,
3753                                 alc880_pin_asus_init_verbs,
3754                                 alc880_gpio1_init_verbs },
3755                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3756                 .dac_nids = alc880_asus_dac_nids,
3757                 .dig_out_nid = ALC880_DIGOUT_NID,
3758                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3759                 .channel_mode = alc880_asus_modes,
3760                 .need_dac_fix = 1,
3761                 .input_mux = &alc880_capture_source,
3762         },
3763         [ALC880_ASUS_DIG2] = {
3764                 .mixers = { alc880_asus_mixer },
3765                 .init_verbs = { alc880_volume_init_verbs,
3766                                 alc880_pin_asus_init_verbs,
3767                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
3768                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3769                 .dac_nids = alc880_asus_dac_nids,
3770                 .dig_out_nid = ALC880_DIGOUT_NID,
3771                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3772                 .channel_mode = alc880_asus_modes,
3773                 .need_dac_fix = 1,
3774                 .input_mux = &alc880_capture_source,
3775         },
3776         [ALC880_ASUS_W1V] = {
3777                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3778                 .init_verbs = { alc880_volume_init_verbs,
3779                                 alc880_pin_asus_init_verbs,
3780                                 alc880_gpio1_init_verbs },
3781                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3782                 .dac_nids = alc880_asus_dac_nids,
3783                 .dig_out_nid = ALC880_DIGOUT_NID,
3784                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3785                 .channel_mode = alc880_asus_modes,
3786                 .need_dac_fix = 1,
3787                 .input_mux = &alc880_capture_source,
3788         },
3789         [ALC880_UNIWILL_DIG] = {
3790                 .mixers = { alc880_asus_mixer },
3791                 .init_verbs = { alc880_volume_init_verbs,
3792                                 alc880_pin_asus_init_verbs },
3793                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3794                 .dac_nids = alc880_asus_dac_nids,
3795                 .dig_out_nid = ALC880_DIGOUT_NID,
3796                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3797                 .channel_mode = alc880_asus_modes,
3798                 .need_dac_fix = 1,
3799                 .input_mux = &alc880_capture_source,
3800         },
3801         [ALC880_UNIWILL] = {
3802                 .mixers = { alc880_uniwill_mixer },
3803                 .init_verbs = { alc880_volume_init_verbs,
3804                                 alc880_uniwill_init_verbs },
3805                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3806                 .dac_nids = alc880_asus_dac_nids,
3807                 .dig_out_nid = ALC880_DIGOUT_NID,
3808                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3809                 .channel_mode = alc880_threestack_modes,
3810                 .need_dac_fix = 1,
3811                 .input_mux = &alc880_capture_source,
3812                 .unsol_event = alc880_uniwill_unsol_event,
3813                 .init_hook = alc880_uniwill_automute,
3814         },
3815         [ALC880_UNIWILL_P53] = {
3816                 .mixers = { alc880_uniwill_p53_mixer },
3817                 .init_verbs = { alc880_volume_init_verbs,
3818                                 alc880_uniwill_p53_init_verbs },
3819                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3820                 .dac_nids = alc880_asus_dac_nids,
3821                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3822                 .channel_mode = alc880_threestack_modes,
3823                 .input_mux = &alc880_capture_source,
3824                 .unsol_event = alc880_uniwill_p53_unsol_event,
3825                 .init_hook = alc880_uniwill_p53_hp_automute,
3826         },
3827         [ALC880_FUJITSU] = {
3828                 .mixers = { alc880_fujitsu_mixer },
3829                 .init_verbs = { alc880_volume_init_verbs,
3830                                 alc880_uniwill_p53_init_verbs,
3831                                 alc880_beep_init_verbs },
3832                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3833                 .dac_nids = alc880_dac_nids,
3834                 .dig_out_nid = ALC880_DIGOUT_NID,
3835                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3836                 .channel_mode = alc880_2_jack_modes,
3837                 .input_mux = &alc880_capture_source,
3838                 .unsol_event = alc880_uniwill_p53_unsol_event,
3839                 .init_hook = alc880_uniwill_p53_hp_automute,
3840         },
3841         [ALC880_CLEVO] = {
3842                 .mixers = { alc880_three_stack_mixer },
3843                 .init_verbs = { alc880_volume_init_verbs,
3844                                 alc880_pin_clevo_init_verbs },
3845                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3846                 .dac_nids = alc880_dac_nids,
3847                 .hp_nid = 0x03,
3848                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3849                 .channel_mode = alc880_threestack_modes,
3850                 .need_dac_fix = 1,
3851                 .input_mux = &alc880_capture_source,
3852         },
3853         [ALC880_LG] = {
3854                 .mixers = { alc880_lg_mixer },
3855                 .init_verbs = { alc880_volume_init_verbs,
3856                                 alc880_lg_init_verbs },
3857                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3858                 .dac_nids = alc880_lg_dac_nids,
3859                 .dig_out_nid = ALC880_DIGOUT_NID,
3860                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3861                 .channel_mode = alc880_lg_ch_modes,
3862                 .need_dac_fix = 1,
3863                 .input_mux = &alc880_lg_capture_source,
3864                 .unsol_event = alc880_lg_unsol_event,
3865                 .init_hook = alc880_lg_automute,
3866 #ifdef CONFIG_SND_HDA_POWER_SAVE
3867                 .loopbacks = alc880_lg_loopbacks,
3868 #endif
3869         },
3870         [ALC880_LG_LW] = {
3871                 .mixers = { alc880_lg_lw_mixer },
3872                 .init_verbs = { alc880_volume_init_verbs,
3873                                 alc880_lg_lw_init_verbs },
3874                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3875                 .dac_nids = alc880_dac_nids,
3876                 .dig_out_nid = ALC880_DIGOUT_NID,
3877                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3878                 .channel_mode = alc880_lg_lw_modes,
3879                 .input_mux = &alc880_lg_lw_capture_source,
3880                 .unsol_event = alc880_lg_lw_unsol_event,
3881                 .init_hook = alc880_lg_lw_automute,
3882         },
3883         [ALC880_MEDION_RIM] = {
3884                 .mixers = { alc880_medion_rim_mixer },
3885                 .init_verbs = { alc880_volume_init_verbs,
3886                                 alc880_medion_rim_init_verbs,
3887                                 alc_gpio2_init_verbs },
3888                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3889                 .dac_nids = alc880_dac_nids,
3890                 .dig_out_nid = ALC880_DIGOUT_NID,
3891                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3892                 .channel_mode = alc880_2_jack_modes,
3893                 .input_mux = &alc880_medion_rim_capture_source,
3894                 .unsol_event = alc880_medion_rim_unsol_event,
3895                 .init_hook = alc880_medion_rim_automute,
3896         },
3897 #ifdef CONFIG_SND_DEBUG
3898         [ALC880_TEST] = {
3899                 .mixers = { alc880_test_mixer },
3900                 .init_verbs = { alc880_test_init_verbs },
3901                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3902                 .dac_nids = alc880_test_dac_nids,
3903                 .dig_out_nid = ALC880_DIGOUT_NID,
3904                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3905                 .channel_mode = alc880_test_modes,
3906                 .input_mux = &alc880_test_capture_source,
3907         },
3908 #endif
3909 };
3910
3911 /*
3912  * Automatic parse of I/O pins from the BIOS configuration
3913  */
3914
3915 enum {
3916         ALC_CTL_WIDGET_VOL,
3917         ALC_CTL_WIDGET_MUTE,
3918         ALC_CTL_BIND_MUTE,
3919 };
3920 static struct snd_kcontrol_new alc880_control_templates[] = {
3921         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3922         HDA_CODEC_MUTE(NULL, 0, 0, 0),
3923         HDA_BIND_MUTE(NULL, 0, 0, 0),
3924 };
3925
3926 /* add dynamic controls */
3927 static int add_control(struct alc_spec *spec, int type, const char *name,
3928                        unsigned long val)
3929 {
3930         struct snd_kcontrol_new *knew;
3931
3932         snd_array_init(&spec->kctls, sizeof(*knew), 32);
3933         knew = snd_array_new(&spec->kctls);
3934         if (!knew)
3935                 return -ENOMEM;
3936         *knew = alc880_control_templates[type];
3937         knew->name = kstrdup(name, GFP_KERNEL);
3938         if (!knew->name)
3939                 return -ENOMEM;
3940         knew->private_value = val;
3941         return 0;
3942 }
3943
3944 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
3945 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
3946 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
3947 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
3948 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
3949 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
3950 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
3951 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
3952 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
3953 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
3954 #define ALC880_PIN_CD_NID               0x1c
3955
3956 /* fill in the dac_nids table from the parsed pin configuration */
3957 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
3958                                      const struct auto_pin_cfg *cfg)
3959 {
3960         hda_nid_t nid;
3961         int assigned[4];
3962         int i, j;
3963
3964         memset(assigned, 0, sizeof(assigned));
3965         spec->multiout.dac_nids = spec->private_dac_nids;
3966
3967         /* check the pins hardwired to audio widget */
3968         for (i = 0; i < cfg->line_outs; i++) {
3969                 nid = cfg->line_out_pins[i];
3970                 if (alc880_is_fixed_pin(nid)) {
3971                         int idx = alc880_fixed_pin_idx(nid);
3972                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
3973                         assigned[idx] = 1;
3974                 }
3975         }
3976         /* left pins can be connect to any audio widget */
3977         for (i = 0; i < cfg->line_outs; i++) {
3978                 nid = cfg->line_out_pins[i];
3979                 if (alc880_is_fixed_pin(nid))
3980                         continue;
3981                 /* search for an empty channel */
3982                 for (j = 0; j < cfg->line_outs; j++) {
3983                         if (!assigned[j]) {
3984                                 spec->multiout.dac_nids[i] =
3985                                         alc880_idx_to_dac(j);
3986                                 assigned[j] = 1;
3987                                 break;
3988                         }
3989                 }
3990         }
3991         spec->multiout.num_dacs = cfg->line_outs;
3992         return 0;
3993 }
3994
3995 /* add playback controls from the parsed DAC table */
3996 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
3997                                              const struct auto_pin_cfg *cfg)
3998 {
3999         char name[32];
4000         static const char *chname[4] = {
4001                 "Front", "Surround", NULL /*CLFE*/, "Side"
4002         };
4003         hda_nid_t nid;
4004         int i, err;
4005
4006         for (i = 0; i < cfg->line_outs; i++) {
4007                 if (!spec->multiout.dac_nids[i])
4008                         continue;
4009                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4010                 if (i == 2) {
4011                         /* Center/LFE */
4012                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4013                                           "Center Playback Volume",
4014                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4015                                                               HDA_OUTPUT));
4016                         if (err < 0)
4017                                 return err;
4018                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4019                                           "LFE Playback Volume",
4020                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4021                                                               HDA_OUTPUT));
4022                         if (err < 0)
4023                                 return err;
4024                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4025                                           "Center Playback Switch",
4026                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4027                                                               HDA_INPUT));
4028                         if (err < 0)
4029                                 return err;
4030                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4031                                           "LFE Playback Switch",
4032                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4033                                                               HDA_INPUT));
4034                         if (err < 0)
4035                                 return err;
4036                 } else {
4037                         sprintf(name, "%s Playback Volume", chname[i]);
4038                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4039                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4040                                                               HDA_OUTPUT));
4041                         if (err < 0)
4042                                 return err;
4043                         sprintf(name, "%s Playback Switch", chname[i]);
4044                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4045                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4046                                                               HDA_INPUT));
4047                         if (err < 0)
4048                                 return err;
4049                 }
4050         }
4051         return 0;
4052 }
4053
4054 /* add playback controls for speaker and HP outputs */
4055 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4056                                         const char *pfx)
4057 {
4058         hda_nid_t nid;
4059         int err;
4060         char name[32];
4061
4062         if (!pin)
4063                 return 0;
4064
4065         if (alc880_is_fixed_pin(pin)) {
4066                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4067                 /* specify the DAC as the extra output */
4068                 if (!spec->multiout.hp_nid)
4069                         spec->multiout.hp_nid = nid;
4070                 else
4071                         spec->multiout.extra_out_nid[0] = nid;
4072                 /* control HP volume/switch on the output mixer amp */
4073                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4074                 sprintf(name, "%s Playback Volume", pfx);
4075                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4076                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4077                 if (err < 0)
4078                         return err;
4079                 sprintf(name, "%s Playback Switch", pfx);
4080                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4081                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4082                 if (err < 0)
4083                         return err;
4084         } else if (alc880_is_multi_pin(pin)) {
4085                 /* set manual connection */
4086                 /* we have only a switch on HP-out PIN */
4087                 sprintf(name, "%s Playback Switch", pfx);
4088                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4089                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4090                 if (err < 0)
4091                         return err;
4092         }
4093         return 0;
4094 }
4095
4096 /* create input playback/capture controls for the given pin */
4097 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4098                             const char *ctlname,
4099                             int idx, hda_nid_t mix_nid)
4100 {
4101         char name[32];
4102         int err;
4103
4104         sprintf(name, "%s Playback Volume", ctlname);
4105         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4106                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4107         if (err < 0)
4108                 return err;
4109         sprintf(name, "%s Playback Switch", ctlname);
4110         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4111                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4112         if (err < 0)
4113                 return err;
4114         return 0;
4115 }
4116
4117 /* create playback/capture controls for input pins */
4118 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
4119                                                 const struct auto_pin_cfg *cfg)
4120 {
4121         struct hda_input_mux *imux = &spec->private_imux[0];
4122         int i, err, idx;
4123
4124         for (i = 0; i < AUTO_PIN_LAST; i++) {
4125                 if (alc880_is_input_pin(cfg->input_pins[i])) {
4126                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
4127                         err = new_analog_input(spec, cfg->input_pins[i],
4128                                                auto_pin_cfg_labels[i],
4129                                                idx, 0x0b);
4130                         if (err < 0)
4131                                 return err;
4132                         imux->items[imux->num_items].label =
4133                                 auto_pin_cfg_labels[i];
4134                         imux->items[imux->num_items].index =
4135                                 alc880_input_pin_idx(cfg->input_pins[i]);
4136                         imux->num_items++;
4137                 }
4138         }
4139         return 0;
4140 }
4141
4142 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4143                                unsigned int pin_type)
4144 {
4145         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4146                             pin_type);
4147         /* unmute pin */
4148         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4149                             AMP_OUT_UNMUTE);
4150 }
4151
4152 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4153                                               hda_nid_t nid, int pin_type,
4154                                               int dac_idx)
4155 {
4156         alc_set_pin_output(codec, nid, pin_type);
4157         /* need the manual connection? */
4158         if (alc880_is_multi_pin(nid)) {
4159                 struct alc_spec *spec = codec->spec;
4160                 int idx = alc880_multi_pin_idx(nid);
4161                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4162                                     AC_VERB_SET_CONNECT_SEL,
4163                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4164         }
4165 }
4166
4167 static int get_pin_type(int line_out_type)
4168 {
4169         if (line_out_type == AUTO_PIN_HP_OUT)
4170                 return PIN_HP;
4171         else
4172                 return PIN_OUT;
4173 }
4174
4175 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4176 {
4177         struct alc_spec *spec = codec->spec;
4178         int i;
4179
4180         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
4181         for (i = 0; i < spec->autocfg.line_outs; i++) {
4182                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4183                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4184                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4185         }
4186 }
4187
4188 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4189 {
4190         struct alc_spec *spec = codec->spec;
4191         hda_nid_t pin;
4192
4193         pin = spec->autocfg.speaker_pins[0];
4194         if (pin) /* connect to front */
4195                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4196         pin = spec->autocfg.hp_pins[0];
4197         if (pin) /* connect to front */
4198                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4199 }
4200
4201 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4202 {
4203         struct alc_spec *spec = codec->spec;
4204         int i;
4205
4206         for (i = 0; i < AUTO_PIN_LAST; i++) {
4207                 hda_nid_t nid = spec->autocfg.input_pins[i];
4208                 if (alc880_is_input_pin(nid)) {
4209                         alc_set_input_pin(codec, nid, i);
4210                         if (nid != ALC880_PIN_CD_NID)
4211                                 snd_hda_codec_write(codec, nid, 0,
4212                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4213                                                     AMP_OUT_MUTE);
4214                 }
4215         }
4216 }
4217
4218 /* parse the BIOS configuration and set up the alc_spec */
4219 /* return 1 if successful, 0 if the proper config is not found,
4220  * or a negative error code
4221  */
4222 static int alc880_parse_auto_config(struct hda_codec *codec)
4223 {
4224         struct alc_spec *spec = codec->spec;
4225         int i, err;
4226         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4227
4228         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4229                                            alc880_ignore);
4230         if (err < 0)
4231                 return err;
4232         if (!spec->autocfg.line_outs)
4233                 return 0; /* can't find valid BIOS pin config */
4234
4235         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4236         if (err < 0)
4237                 return err;
4238         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4239         if (err < 0)
4240                 return err;
4241         err = alc880_auto_create_extra_out(spec,
4242                                            spec->autocfg.speaker_pins[0],
4243                                            "Speaker");
4244         if (err < 0)
4245                 return err;
4246         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4247                                            "Headphone");
4248         if (err < 0)
4249                 return err;
4250         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
4251         if (err < 0)
4252                 return err;
4253
4254         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4255
4256         /* check multiple SPDIF-out (for recent codecs) */
4257         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4258                 hda_nid_t dig_nid;
4259                 err = snd_hda_get_connections(codec,
4260                                               spec->autocfg.dig_out_pins[i],
4261                                               &dig_nid, 1);
4262                 if (err < 0)
4263                         continue;
4264                 if (!i)
4265                         spec->multiout.dig_out_nid = dig_nid;
4266                 else {
4267                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4268                         spec->slave_dig_outs[i - 1] = dig_nid;
4269                         if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
4270                                 break;
4271                 }
4272         }
4273         if (spec->autocfg.dig_in_pin)
4274                 spec->dig_in_nid = ALC880_DIGIN_NID;
4275
4276         if (spec->kctls.list)
4277                 add_mixer(spec, spec->kctls.list);
4278
4279         add_verb(spec, alc880_volume_init_verbs);
4280
4281         spec->num_mux_defs = 1;
4282         spec->input_mux = &spec->private_imux[0];
4283
4284         return 1;
4285 }
4286
4287 /* additional initialization for auto-configuration model */
4288 static void alc880_auto_init(struct hda_codec *codec)
4289 {
4290         struct alc_spec *spec = codec->spec;
4291         alc880_auto_init_multi_out(codec);
4292         alc880_auto_init_extra_out(codec);
4293         alc880_auto_init_analog_input(codec);
4294         if (spec->unsol_event)
4295                 alc_inithook(codec);
4296 }
4297
4298 static void set_capture_mixer(struct alc_spec *spec)
4299 {
4300         static struct snd_kcontrol_new *caps[3] = {
4301                 alc_capture_mixer1,
4302                 alc_capture_mixer2,
4303                 alc_capture_mixer3,
4304         };
4305         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3)
4306                 spec->cap_mixer = caps[spec->num_adc_nids - 1];
4307 }
4308
4309 #define set_beep_amp(spec, nid, idx, dir) \
4310         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4311
4312 /*
4313  * OK, here we have finally the patch for ALC880
4314  */
4315
4316 static int patch_alc880(struct hda_codec *codec)
4317 {
4318         struct alc_spec *spec;
4319         int board_config;
4320         int err;
4321
4322         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4323         if (spec == NULL)
4324                 return -ENOMEM;
4325
4326         codec->spec = spec;
4327
4328         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4329                                                   alc880_models,
4330                                                   alc880_cfg_tbl);
4331         if (board_config < 0) {
4332                 printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
4333                        "trying auto-probe from BIOS...\n");
4334                 board_config = ALC880_AUTO;
4335         }
4336
4337         if (board_config == ALC880_AUTO) {
4338                 /* automatic parse from the BIOS config */
4339                 err = alc880_parse_auto_config(codec);
4340                 if (err < 0) {
4341                         alc_free(codec);
4342                         return err;
4343                 } else if (!err) {
4344                         printk(KERN_INFO
4345                                "hda_codec: Cannot set up configuration "
4346                                "from BIOS.  Using 3-stack mode...\n");
4347                         board_config = ALC880_3ST;
4348                 }
4349         }
4350
4351         err = snd_hda_attach_beep_device(codec, 0x1);
4352         if (err < 0) {
4353                 alc_free(codec);
4354                 return err;
4355         }
4356
4357         if (board_config != ALC880_AUTO)
4358                 setup_preset(spec, &alc880_presets[board_config]);
4359
4360         spec->stream_name_analog = "ALC880 Analog";
4361         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4362         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4363         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4364
4365         spec->stream_name_digital = "ALC880 Digital";
4366         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4367         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4368
4369         if (!spec->adc_nids && spec->input_mux) {
4370                 /* check whether NID 0x07 is valid */
4371                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4372                 /* get type */
4373                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
4374                 if (wcap != AC_WID_AUD_IN) {
4375                         spec->adc_nids = alc880_adc_nids_alt;
4376                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4377                 } else {
4378                         spec->adc_nids = alc880_adc_nids;
4379                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4380                 }
4381         }
4382         set_capture_mixer(spec);
4383         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4384
4385         spec->vmaster_nid = 0x0c;
4386
4387         codec->patch_ops = alc_patch_ops;
4388         if (board_config == ALC880_AUTO)
4389                 spec->init_hook = alc880_auto_init;
4390 #ifdef CONFIG_SND_HDA_POWER_SAVE
4391         if (!spec->loopback.amplist)
4392                 spec->loopback.amplist = alc880_loopbacks;
4393 #endif
4394         codec->proc_widget_hook = print_realtek_coef;
4395
4396         return 0;
4397 }
4398
4399
4400 /*
4401  * ALC260 support
4402  */
4403
4404 static hda_nid_t alc260_dac_nids[1] = {
4405         /* front */
4406         0x02,
4407 };
4408
4409 static hda_nid_t alc260_adc_nids[1] = {
4410         /* ADC0 */
4411         0x04,
4412 };
4413
4414 static hda_nid_t alc260_adc_nids_alt[1] = {
4415         /* ADC1 */
4416         0x05,
4417 };
4418
4419 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4420  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4421  */
4422 static hda_nid_t alc260_dual_adc_nids[2] = {
4423         /* ADC0, ADC1 */
4424         0x04, 0x05
4425 };
4426
4427 #define ALC260_DIGOUT_NID       0x03
4428 #define ALC260_DIGIN_NID        0x06
4429
4430 static struct hda_input_mux alc260_capture_source = {
4431         .num_items = 4,
4432         .items = {
4433                 { "Mic", 0x0 },
4434                 { "Front Mic", 0x1 },
4435                 { "Line", 0x2 },
4436                 { "CD", 0x4 },
4437         },
4438 };
4439
4440 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4441  * headphone jack and the internal CD lines since these are the only pins at
4442  * which audio can appear.  For flexibility, also allow the option of
4443  * recording the mixer output on the second ADC (ADC0 doesn't have a
4444  * connection to the mixer output).
4445  */
4446 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4447         {
4448                 .num_items = 3,
4449                 .items = {
4450                         { "Mic/Line", 0x0 },
4451                         { "CD", 0x4 },
4452                         { "Headphone", 0x2 },
4453                 },
4454         },
4455         {
4456                 .num_items = 4,
4457                 .items = {
4458                         { "Mic/Line", 0x0 },
4459                         { "CD", 0x4 },
4460                         { "Headphone", 0x2 },
4461                         { "Mixer", 0x5 },
4462                 },
4463         },
4464
4465 };
4466
4467 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4468  * the Fujitsu S702x, but jacks are marked differently.
4469  */
4470 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4471         {
4472                 .num_items = 4,
4473                 .items = {
4474                         { "Mic", 0x0 },
4475                         { "Line", 0x2 },
4476                         { "CD", 0x4 },
4477                         { "Headphone", 0x5 },
4478                 },
4479         },
4480         {
4481                 .num_items = 5,
4482                 .items = {
4483                         { "Mic", 0x0 },
4484                         { "Line", 0x2 },
4485                         { "CD", 0x4 },
4486                         { "Headphone", 0x6 },
4487                         { "Mixer", 0x5 },
4488                 },
4489         },
4490 };
4491
4492 /* Maxdata Favorit 100XS */
4493 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
4494         {
4495                 .num_items = 2,
4496                 .items = {
4497                         { "Line/Mic", 0x0 },
4498                         { "CD", 0x4 },
4499                 },
4500         },
4501         {
4502                 .num_items = 3,
4503                 .items = {
4504                         { "Line/Mic", 0x0 },
4505                         { "CD", 0x4 },
4506                         { "Mixer", 0x5 },
4507                 },
4508         },
4509 };
4510
4511 /*
4512  * This is just place-holder, so there's something for alc_build_pcms to look
4513  * at when it calculates the maximum number of channels. ALC260 has no mixer
4514  * element which allows changing the channel mode, so the verb list is
4515  * never used.
4516  */
4517 static struct hda_channel_mode alc260_modes[1] = {
4518         { 2, NULL },
4519 };
4520
4521
4522 /* Mixer combinations
4523  *
4524  * basic: base_output + input + pc_beep + capture
4525  * HP: base_output + input + capture_alt
4526  * HP_3013: hp_3013 + input + capture
4527  * fujitsu: fujitsu + capture
4528  * acer: acer + capture
4529  */
4530
4531 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4532         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4533         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4534         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4535         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4536         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4537         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4538         { } /* end */
4539 };
4540
4541 static struct snd_kcontrol_new alc260_input_mixer[] = {
4542         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4543         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4544         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4545         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4546         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4547         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4548         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4549         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4550         { } /* end */
4551 };
4552
4553 /* update HP, line and mono out pins according to the master switch */
4554 static void alc260_hp_master_update(struct hda_codec *codec,
4555                                     hda_nid_t hp, hda_nid_t line,
4556                                     hda_nid_t mono)
4557 {
4558         struct alc_spec *spec = codec->spec;
4559         unsigned int val = spec->master_sw ? PIN_HP : 0;
4560         /* change HP and line-out pins */
4561         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4562                             val);
4563         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4564                             val);
4565         /* mono (speaker) depending on the HP jack sense */
4566         val = (val && !spec->jack_present) ? PIN_OUT : 0;
4567         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4568                             val);
4569 }
4570
4571 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4572                                    struct snd_ctl_elem_value *ucontrol)
4573 {
4574         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4575         struct alc_spec *spec = codec->spec;
4576         *ucontrol->value.integer.value = spec->master_sw;
4577         return 0;
4578 }
4579
4580 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4581                                    struct snd_ctl_elem_value *ucontrol)
4582 {
4583         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4584         struct alc_spec *spec = codec->spec;
4585         int val = !!*ucontrol->value.integer.value;
4586         hda_nid_t hp, line, mono;
4587
4588         if (val == spec->master_sw)
4589                 return 0;
4590         spec->master_sw = val;
4591         hp = (kcontrol->private_value >> 16) & 0xff;
4592         line = (kcontrol->private_value >> 8) & 0xff;
4593         mono = kcontrol->private_value & 0xff;
4594         alc260_hp_master_update(codec, hp, line, mono);
4595         return 1;
4596 }
4597
4598 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4599         {
4600                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4601                 .name = "Master Playback Switch",
4602                 .info = snd_ctl_boolean_mono_info,
4603                 .get = alc260_hp_master_sw_get,
4604                 .put = alc260_hp_master_sw_put,
4605                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4606         },
4607         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4608         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4609         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4610         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4611         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4612                               HDA_OUTPUT),
4613         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4614         { } /* end */
4615 };
4616
4617 static struct hda_verb alc260_hp_unsol_verbs[] = {
4618         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4619         {},
4620 };
4621
4622 static void alc260_hp_automute(struct hda_codec *codec)
4623 {
4624         struct alc_spec *spec = codec->spec;
4625         unsigned int present;
4626
4627         present = snd_hda_codec_read(codec, 0x10, 0,
4628                                      AC_VERB_GET_PIN_SENSE, 0);
4629         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4630         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4631 }
4632
4633 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4634 {
4635         if ((res >> 26) == ALC880_HP_EVENT)
4636                 alc260_hp_automute(codec);
4637 }
4638
4639 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4640         {
4641                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4642                 .name = "Master Playback Switch",
4643                 .info = snd_ctl_boolean_mono_info,
4644                 .get = alc260_hp_master_sw_get,
4645                 .put = alc260_hp_master_sw_put,
4646                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
4647         },
4648         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4649         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4650         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4651         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4652         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4653         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4654         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4655         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4656         { } /* end */
4657 };
4658
4659 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4660         .ops = &snd_hda_bind_vol,
4661         .values = {
4662                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4663                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4664                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4665                 0
4666         },
4667 };
4668
4669 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4670         .ops = &snd_hda_bind_sw,
4671         .values = {
4672                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4673                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4674                 0
4675         },
4676 };
4677
4678 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4679         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4680         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4681         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4682         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4683         { } /* end */
4684 };
4685
4686 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4687         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4688         {},
4689 };
4690
4691 static void alc260_hp_3013_automute(struct hda_codec *codec)
4692 {
4693         struct alc_spec *spec = codec->spec;
4694         unsigned int present;
4695
4696         present = snd_hda_codec_read(codec, 0x15, 0,
4697                                      AC_VERB_GET_PIN_SENSE, 0);
4698         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4699         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
4700 }
4701
4702 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4703                                        unsigned int res)
4704 {
4705         if ((res >> 26) == ALC880_HP_EVENT)
4706                 alc260_hp_3013_automute(codec);
4707 }
4708
4709 static void alc260_hp_3012_automute(struct hda_codec *codec)
4710 {
4711         unsigned int present, bits;
4712
4713         present = snd_hda_codec_read(codec, 0x10, 0,
4714                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4715
4716         bits = present ? 0 : PIN_OUT;
4717         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4718                             bits);
4719         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4720                             bits);
4721         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4722                             bits);
4723 }
4724
4725 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4726                                        unsigned int res)
4727 {
4728         if ((res >> 26) == ALC880_HP_EVENT)
4729                 alc260_hp_3012_automute(codec);
4730 }
4731
4732 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
4733  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
4734  */
4735 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4736         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4737         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4738         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4739         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4740         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4741         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4742         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4743         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4744         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4745         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4746         { } /* end */
4747 };
4748
4749 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
4750  * versions of the ALC260 don't act on requests to enable mic bias from NID
4751  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
4752  * datasheet doesn't mention this restriction.  At this stage it's not clear
4753  * whether this behaviour is intentional or is a hardware bug in chip
4754  * revisions available in early 2006.  Therefore for now allow the
4755  * "Headphone Jack Mode" control to span all choices, but if it turns out
4756  * that the lack of mic bias for this NID is intentional we could change the
4757  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4758  *
4759  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4760  * don't appear to make the mic bias available from the "line" jack, even
4761  * though the NID used for this jack (0x14) can supply it.  The theory is
4762  * that perhaps Acer have included blocking capacitors between the ALC260
4763  * and the output jack.  If this turns out to be the case for all such
4764  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4765  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4766  *
4767  * The C20x Tablet series have a mono internal speaker which is controlled
4768  * via the chip's Mono sum widget and pin complex, so include the necessary
4769  * controls for such models.  On models without a "mono speaker" the control
4770  * won't do anything.
4771  */
4772 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4773         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4774         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4775         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4776         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4777                               HDA_OUTPUT),
4778         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4779                            HDA_INPUT),
4780         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4781         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4782         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4783         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4784         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4785         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4786         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4787         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4788         { } /* end */
4789 };
4790
4791 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
4792  */
4793 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
4794         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4795         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4796         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4797         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4798         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4799         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4800         { } /* end */
4801 };
4802
4803 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4804  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
4805  */
4806 static struct snd_kcontrol_new alc260_will_mixer[] = {
4807         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4808         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4809         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4810         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4811         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4812         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4813         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4814         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4815         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4816         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4817         { } /* end */
4818 };
4819
4820 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4821  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4822  */
4823 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4824         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4825         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4826         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4827         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4828         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4829         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4830         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4831         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4832         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4833         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4834         { } /* end */
4835 };
4836
4837 /*
4838  * initialization verbs
4839  */
4840 static struct hda_verb alc260_init_verbs[] = {
4841         /* Line In pin widget for input */
4842         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4843         /* CD pin widget for input */
4844         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4845         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4846         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4847         /* Mic2 (front panel) pin widget for input and vref at 80% */
4848         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4849         /* LINE-2 is used for line-out in rear */
4850         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4851         /* select line-out */
4852         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4853         /* LINE-OUT pin */
4854         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4855         /* enable HP */
4856         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4857         /* enable Mono */
4858         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4859         /* mute capture amp left and right */
4860         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4861         /* set connection select to line in (default select for this ADC) */
4862         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4863         /* mute capture amp left and right */
4864         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4865         /* set connection select to line in (default select for this ADC) */
4866         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4867         /* set vol=0 Line-Out mixer amp left and right */
4868         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4869         /* unmute pin widget amp left and right (no gain on this amp) */
4870         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4871         /* set vol=0 HP mixer amp left and right */
4872         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4873         /* unmute pin widget amp left and right (no gain on this amp) */
4874         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4875         /* set vol=0 Mono mixer amp left and right */
4876         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4877         /* unmute pin widget amp left and right (no gain on this amp) */
4878         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4879         /* unmute LINE-2 out pin */
4880         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4881         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4882          * Line In 2 = 0x03
4883          */
4884         /* mute analog inputs */
4885         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4886         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4887         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4888         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4889         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4890         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4891         /* mute Front out path */
4892         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4893         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4894         /* mute Headphone out path */
4895         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4896         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4897         /* mute Mono out path */
4898         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4899         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4900         { }
4901 };
4902
4903 #if 0 /* should be identical with alc260_init_verbs? */
4904 static struct hda_verb alc260_hp_init_verbs[] = {
4905         /* Headphone and output */
4906         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4907         /* mono output */
4908         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4909         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4910         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4911         /* Mic2 (front panel) pin widget for input and vref at 80% */
4912         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4913         /* Line In pin widget for input */
4914         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4915         /* Line-2 pin widget for output */
4916         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4917         /* CD pin widget for input */
4918         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4919         /* unmute amp left and right */
4920         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4921         /* set connection select to line in (default select for this ADC) */
4922         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4923         /* unmute Line-Out mixer amp left and right (volume = 0) */
4924         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4925         /* mute pin widget amp left and right (no gain on this amp) */
4926         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4927         /* unmute HP mixer amp left and right (volume = 0) */
4928         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4929         /* mute pin widget amp left and right (no gain on this amp) */
4930         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4931         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4932          * Line In 2 = 0x03
4933          */
4934         /* mute analog inputs */
4935         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4936         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4937         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4938         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4939         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4940         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4941         /* Unmute Front out path */
4942         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4943         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4944         /* Unmute Headphone out path */
4945         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4946         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4947         /* Unmute Mono out path */
4948         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4949         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4950         { }
4951 };
4952 #endif
4953
4954 static struct hda_verb alc260_hp_3013_init_verbs[] = {
4955         /* Line out and output */
4956         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4957         /* mono output */
4958         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4959         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4960         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4961         /* Mic2 (front panel) pin widget for input and vref at 80% */
4962         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4963         /* Line In pin widget for input */
4964         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4965         /* Headphone pin widget for output */
4966         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4967         /* CD pin widget for input */
4968         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4969         /* unmute amp left and right */
4970         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4971         /* set connection select to line in (default select for this ADC) */
4972         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4973         /* unmute Line-Out mixer amp left and right (volume = 0) */
4974         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4975         /* mute pin widget amp left and right (no gain on this amp) */
4976         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4977         /* unmute HP mixer amp left and right (volume = 0) */
4978         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4979         /* mute pin widget amp left and right (no gain on this amp) */
4980         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4981         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4982          * Line In 2 = 0x03
4983          */
4984         /* mute analog inputs */
4985         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4986         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4987         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4988         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4989         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4990         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4991         /* Unmute Front out path */
4992         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4993         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4994         /* Unmute Headphone out path */
4995         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4996         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4997         /* Unmute Mono out path */
4998         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4999         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5000         { }
5001 };
5002
5003 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5004  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5005  * audio = 0x16, internal speaker = 0x10.
5006  */
5007 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5008         /* Disable all GPIOs */
5009         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5010         /* Internal speaker is connected to headphone pin */
5011         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5012         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5013         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5014         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5015         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5016         /* Ensure all other unused pins are disabled and muted. */
5017         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5018         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5019         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5020         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5021         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5022         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5023         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5024         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5025
5026         /* Disable digital (SPDIF) pins */
5027         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5028         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5029
5030         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5031          * when acting as an output.
5032          */
5033         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5034
5035         /* Start with output sum widgets muted and their output gains at min */
5036         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5037         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5038         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5039         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5040         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5041         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5042         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5043         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5044         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5045
5046         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5047         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5048         /* Unmute Line1 pin widget output buffer since it starts as an output.
5049          * If the pin mode is changed by the user the pin mode control will
5050          * take care of enabling the pin's input/output buffers as needed.
5051          * Therefore there's no need to enable the input buffer at this
5052          * stage.
5053          */
5054         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5055         /* Unmute input buffer of pin widget used for Line-in (no equiv
5056          * mixer ctrl)
5057          */
5058         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5059
5060         /* Mute capture amp left and right */
5061         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5062         /* Set ADC connection select to match default mixer setting - line
5063          * in (on mic1 pin)
5064          */
5065         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5066
5067         /* Do the same for the second ADC: mute capture input amp and
5068          * set ADC connection to line in (on mic1 pin)
5069          */
5070         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5071         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5072
5073         /* Mute all inputs to mixer widget (even unconnected ones) */
5074         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5075         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5076         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5077         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5078         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5079         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5080         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5081         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5082
5083         { }
5084 };
5085
5086 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5087  * similar laptops (adapted from Fujitsu init verbs).
5088  */
5089 static struct hda_verb alc260_acer_init_verbs[] = {
5090         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5091          * the headphone jack.  Turn this on and rely on the standard mute
5092          * methods whenever the user wants to turn these outputs off.
5093          */
5094         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5095         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5096         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5097         /* Internal speaker/Headphone jack is connected to Line-out pin */
5098         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5099         /* Internal microphone/Mic jack is connected to Mic1 pin */
5100         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5101         /* Line In jack is connected to Line1 pin */
5102         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5103         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5104         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5105         /* Ensure all other unused pins are disabled and muted. */
5106         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5107         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5108         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5109         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5110         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5111         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5112         /* Disable digital (SPDIF) pins */
5113         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5114         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5115
5116         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5117          * bus when acting as outputs.
5118          */
5119         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5120         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5121
5122         /* Start with output sum widgets muted and their output gains at min */
5123         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5124         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5125         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5126         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5127         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5128         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5129         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5130         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5131         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5132
5133         /* Unmute Line-out pin widget amp left and right
5134          * (no equiv mixer ctrl)
5135          */
5136         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5137         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5138         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5139         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5140          * inputs. If the pin mode is changed by the user the pin mode control
5141          * will take care of enabling the pin's input/output buffers as needed.
5142          * Therefore there's no need to enable the input buffer at this
5143          * stage.
5144          */
5145         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5146         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5147
5148         /* Mute capture amp left and right */
5149         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5150         /* Set ADC connection select to match default mixer setting - mic
5151          * (on mic1 pin)
5152          */
5153         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5154
5155         /* Do similar with the second ADC: mute capture input amp and
5156          * set ADC connection to mic to match ALSA's default state.
5157          */
5158         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5159         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5160
5161         /* Mute all inputs to mixer widget (even unconnected ones) */
5162         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5163         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5164         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5165         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5166         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5167         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5168         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5169         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5170
5171         { }
5172 };
5173
5174 /* Initialisation sequence for Maxdata Favorit 100XS
5175  * (adapted from Acer init verbs).
5176  */
5177 static struct hda_verb alc260_favorit100_init_verbs[] = {
5178         /* GPIO 0 enables the output jack.
5179          * Turn this on and rely on the standard mute
5180          * methods whenever the user wants to turn these outputs off.
5181          */
5182         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5183         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5184         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5185         /* Line/Mic input jack is connected to Mic1 pin */
5186         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5187         /* Ensure all other unused pins are disabled and muted. */
5188         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5189         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5190         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5191         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5192         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5193         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5194         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5195         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5196         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5197         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5198         /* Disable digital (SPDIF) pins */
5199         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5200         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5201
5202         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5203          * bus when acting as outputs.
5204          */
5205         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5206         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5207
5208         /* Start with output sum widgets muted and their output gains at min */
5209         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5210         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5211         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5212         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5213         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5214         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5215         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5216         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5217         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5218
5219         /* Unmute Line-out pin widget amp left and right
5220          * (no equiv mixer ctrl)
5221          */
5222         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5223         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5224          * inputs. If the pin mode is changed by the user the pin mode control
5225          * will take care of enabling the pin's input/output buffers as needed.
5226          * Therefore there's no need to enable the input buffer at this
5227          * stage.
5228          */
5229         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5230
5231         /* Mute capture amp left and right */
5232         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5233         /* Set ADC connection select to match default mixer setting - mic
5234          * (on mic1 pin)
5235          */
5236         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5237
5238         /* Do similar with the second ADC: mute capture input amp and
5239          * set ADC connection to mic to match ALSA's default state.
5240          */
5241         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5242         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5243
5244         /* Mute all inputs to mixer widget (even unconnected ones) */
5245         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5246         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5247         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5248         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5249         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5250         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5251         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5252         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5253
5254         { }
5255 };
5256
5257 static struct hda_verb alc260_will_verbs[] = {
5258         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5259         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5260         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5261         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5262         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5263         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5264         {}
5265 };
5266
5267 static struct hda_verb alc260_replacer_672v_verbs[] = {
5268         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5269         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5270         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5271
5272         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5273         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5274         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5275
5276         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5277         {}
5278 };
5279
5280 /* toggle speaker-output according to the hp-jack state */
5281 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5282 {
5283         unsigned int present;
5284
5285         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5286         present = snd_hda_codec_read(codec, 0x0f, 0,
5287                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5288         if (present) {
5289                 snd_hda_codec_write_cache(codec, 0x01, 0,
5290                                           AC_VERB_SET_GPIO_DATA, 1);
5291                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5292                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5293                                           PIN_HP);
5294         } else {
5295                 snd_hda_codec_write_cache(codec, 0x01, 0,
5296                                           AC_VERB_SET_GPIO_DATA, 0);
5297                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5298                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5299                                           PIN_OUT);
5300         }
5301 }
5302
5303 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5304                                        unsigned int res)
5305 {
5306         if ((res >> 26) == ALC880_HP_EVENT)
5307                 alc260_replacer_672v_automute(codec);
5308 }
5309
5310 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5311         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5312         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5313         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5314         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5315         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5316         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5317         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5318         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5319         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5320         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5321         {}
5322 };
5323
5324 /* Test configuration for debugging, modelled after the ALC880 test
5325  * configuration.
5326  */
5327 #ifdef CONFIG_SND_DEBUG
5328 static hda_nid_t alc260_test_dac_nids[1] = {
5329         0x02,
5330 };
5331 static hda_nid_t alc260_test_adc_nids[2] = {
5332         0x04, 0x05,
5333 };
5334 /* For testing the ALC260, each input MUX needs its own definition since
5335  * the signal assignments are different.  This assumes that the first ADC
5336  * is NID 0x04.
5337  */
5338 static struct hda_input_mux alc260_test_capture_sources[2] = {
5339         {
5340                 .num_items = 7,
5341                 .items = {
5342                         { "MIC1 pin", 0x0 },
5343                         { "MIC2 pin", 0x1 },
5344                         { "LINE1 pin", 0x2 },
5345                         { "LINE2 pin", 0x3 },
5346                         { "CD pin", 0x4 },
5347                         { "LINE-OUT pin", 0x5 },
5348                         { "HP-OUT pin", 0x6 },
5349                 },
5350         },
5351         {
5352                 .num_items = 8,
5353                 .items = {
5354                         { "MIC1 pin", 0x0 },
5355                         { "MIC2 pin", 0x1 },
5356                         { "LINE1 pin", 0x2 },
5357                         { "LINE2 pin", 0x3 },
5358                         { "CD pin", 0x4 },
5359                         { "Mixer", 0x5 },
5360                         { "LINE-OUT pin", 0x6 },
5361                         { "HP-OUT pin", 0x7 },
5362                 },
5363         },
5364 };
5365 static struct snd_kcontrol_new alc260_test_mixer[] = {
5366         /* Output driver widgets */
5367         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5368         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5369         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5370         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5371         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5372         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5373
5374         /* Modes for retasking pin widgets
5375          * Note: the ALC260 doesn't seem to act on requests to enable mic
5376          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5377          * mention this restriction.  At this stage it's not clear whether
5378          * this behaviour is intentional or is a hardware bug in chip
5379          * revisions available at least up until early 2006.  Therefore for
5380          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5381          * choices, but if it turns out that the lack of mic bias for these
5382          * NIDs is intentional we could change their modes from
5383          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5384          */
5385         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5386         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5387         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5388         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5389         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5390         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5391
5392         /* Loopback mixer controls */
5393         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5394         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5395         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5396         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5397         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5398         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5399         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5400         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5401         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5402         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5403         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5404         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5405         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5406         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5407
5408         /* Controls for GPIO pins, assuming they are configured as outputs */
5409         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5410         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5411         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5412         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5413
5414         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5415          * is ambigious as to which NID is which; testing on laptops which
5416          * make this output available should provide clarification.
5417          */
5418         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5419         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5420
5421         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5422          * this output to turn on an external amplifier.
5423          */
5424         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5425         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5426
5427         { } /* end */
5428 };
5429 static struct hda_verb alc260_test_init_verbs[] = {
5430         /* Enable all GPIOs as outputs with an initial value of 0 */
5431         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5432         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5433         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5434
5435         /* Enable retasking pins as output, initially without power amp */
5436         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5437         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5438         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5439         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5440         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5441         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5442
5443         /* Disable digital (SPDIF) pins initially, but users can enable
5444          * them via a mixer switch.  In the case of SPDIF-out, this initverb
5445          * payload also sets the generation to 0, output to be in "consumer"
5446          * PCM format, copyright asserted, no pre-emphasis and no validity
5447          * control.
5448          */
5449         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5450         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5451
5452         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5453          * OUT1 sum bus when acting as an output.
5454          */
5455         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5456         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5457         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5458         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5459
5460         /* Start with output sum widgets muted and their output gains at min */
5461         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5462         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5463         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5464         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5465         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5466         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5467         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5468         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5469         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5470
5471         /* Unmute retasking pin widget output buffers since the default
5472          * state appears to be output.  As the pin mode is changed by the
5473          * user the pin mode control will take care of enabling the pin's
5474          * input/output buffers as needed.
5475          */
5476         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5477         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5478         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5479         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5480         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5481         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5482         /* Also unmute the mono-out pin widget */
5483         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5484
5485         /* Mute capture amp left and right */
5486         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5487         /* Set ADC connection select to match default mixer setting (mic1
5488          * pin)
5489          */
5490         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5491
5492         /* Do the same for the second ADC: mute capture input amp and
5493          * set ADC connection to mic1 pin
5494          */
5495         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5496         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5497
5498         /* Mute all inputs to mixer widget (even unconnected ones) */
5499         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5500         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5501         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5502         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5503         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5504         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5505         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5506         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5507
5508         { }
5509 };
5510 #endif
5511
5512 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
5513 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
5514
5515 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
5516 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
5517
5518 /*
5519  * for BIOS auto-configuration
5520  */
5521
5522 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5523                                         const char *pfx, int *vol_bits)
5524 {
5525         hda_nid_t nid_vol;
5526         unsigned long vol_val, sw_val;
5527         char name[32];
5528         int err;
5529
5530         if (nid >= 0x0f && nid < 0x11) {
5531                 nid_vol = nid - 0x7;
5532                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5533                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5534         } else if (nid == 0x11) {
5535                 nid_vol = nid - 0x7;
5536                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5537                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5538         } else if (nid >= 0x12 && nid <= 0x15) {
5539                 nid_vol = 0x08;
5540                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5541                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5542         } else
5543                 return 0; /* N/A */
5544
5545         if (!(*vol_bits & (1 << nid_vol))) {
5546                 /* first control for the volume widget */
5547                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5548                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5549                 if (err < 0)
5550                         return err;
5551                 *vol_bits |= (1 << nid_vol);
5552         }
5553         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5554         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5555         if (err < 0)
5556                 return err;
5557         return 1;
5558 }
5559
5560 /* add playback controls from the parsed DAC table */
5561 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5562                                              const struct auto_pin_cfg *cfg)
5563 {
5564         hda_nid_t nid;
5565         int err;
5566         int vols = 0;
5567
5568         spec->multiout.num_dacs = 1;
5569         spec->multiout.dac_nids = spec->private_dac_nids;
5570         spec->multiout.dac_nids[0] = 0x02;
5571
5572         nid = cfg->line_out_pins[0];
5573         if (nid) {
5574                 err = alc260_add_playback_controls(spec, nid, "Front", &vols);
5575                 if (err < 0)
5576                         return err;
5577         }
5578
5579         nid = cfg->speaker_pins[0];
5580         if (nid) {
5581                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
5582                 if (err < 0)
5583                         return err;
5584         }
5585
5586         nid = cfg->hp_pins[0];
5587         if (nid) {
5588                 err = alc260_add_playback_controls(spec, nid, "Headphone",
5589                                                    &vols);
5590                 if (err < 0)
5591                         return err;
5592         }
5593         return 0;
5594 }
5595
5596 /* create playback/capture controls for input pins */
5597 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5598                                                 const struct auto_pin_cfg *cfg)
5599 {
5600         struct hda_input_mux *imux = &spec->private_imux[0];
5601         int i, err, idx;
5602
5603         for (i = 0; i < AUTO_PIN_LAST; i++) {
5604                 if (cfg->input_pins[i] >= 0x12) {
5605                         idx = cfg->input_pins[i] - 0x12;
5606                         err = new_analog_input(spec, cfg->input_pins[i],
5607                                                auto_pin_cfg_labels[i], idx,
5608                                                0x07);
5609                         if (err < 0)
5610                                 return err;
5611                         imux->items[imux->num_items].label =
5612                                 auto_pin_cfg_labels[i];
5613                         imux->items[imux->num_items].index = idx;
5614                         imux->num_items++;
5615                 }
5616                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5617                         idx = cfg->input_pins[i] - 0x09;
5618                         err = new_analog_input(spec, cfg->input_pins[i],
5619                                                auto_pin_cfg_labels[i], idx,
5620                                                0x07);
5621                         if (err < 0)
5622                                 return err;
5623                         imux->items[imux->num_items].label =
5624                                 auto_pin_cfg_labels[i];
5625                         imux->items[imux->num_items].index = idx;
5626                         imux->num_items++;
5627                 }
5628         }
5629         return 0;
5630 }
5631
5632 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5633                                               hda_nid_t nid, int pin_type,
5634                                               int sel_idx)
5635 {
5636         alc_set_pin_output(codec, nid, pin_type);
5637         /* need the manual connection? */
5638         if (nid >= 0x12) {
5639                 int idx = nid - 0x12;
5640                 snd_hda_codec_write(codec, idx + 0x0b, 0,
5641                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
5642         }
5643 }
5644
5645 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5646 {
5647         struct alc_spec *spec = codec->spec;
5648         hda_nid_t nid;
5649
5650         alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
5651         nid = spec->autocfg.line_out_pins[0];
5652         if (nid) {
5653                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5654                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5655         }
5656
5657         nid = spec->autocfg.speaker_pins[0];
5658         if (nid)
5659                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5660
5661         nid = spec->autocfg.hp_pins[0];
5662         if (nid)
5663                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5664 }
5665
5666 #define ALC260_PIN_CD_NID               0x16
5667 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5668 {
5669         struct alc_spec *spec = codec->spec;
5670         int i;
5671
5672         for (i = 0; i < AUTO_PIN_LAST; i++) {
5673                 hda_nid_t nid = spec->autocfg.input_pins[i];
5674                 if (nid >= 0x12) {
5675                         alc_set_input_pin(codec, nid, i);
5676                         if (nid != ALC260_PIN_CD_NID)
5677                                 snd_hda_codec_write(codec, nid, 0,
5678                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5679                                                     AMP_OUT_MUTE);
5680                 }
5681         }
5682 }
5683
5684 /*
5685  * generic initialization of ADC, input mixers and output mixers
5686  */
5687 static struct hda_verb alc260_volume_init_verbs[] = {
5688         /*
5689          * Unmute ADC0-1 and set the default input to mic-in
5690          */
5691         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5692         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5693         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5694         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5695
5696         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5697          * mixer widget
5698          * Note: PASD motherboards uses the Line In 2 as the input for
5699          * front panel mic (mic 2)
5700          */
5701         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5702         /* mute analog inputs */
5703         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5704         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5705         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5706         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5707         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5708
5709         /*
5710          * Set up output mixers (0x08 - 0x0a)
5711          */
5712         /* set vol=0 to output mixers */
5713         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5714         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5715         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5716         /* set up input amps for analog loopback */
5717         /* Amp Indices: DAC = 0, mixer = 1 */
5718         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5719         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5720         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5721         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5722         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5723         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5724
5725         { }
5726 };
5727
5728 static int alc260_parse_auto_config(struct hda_codec *codec)
5729 {
5730         struct alc_spec *spec = codec->spec;
5731         int err;
5732         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5733
5734         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5735                                            alc260_ignore);
5736         if (err < 0)
5737                 return err;
5738         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5739         if (err < 0)
5740                 return err;
5741         if (!spec->kctls.list)
5742                 return 0; /* can't find valid BIOS pin config */
5743         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5744         if (err < 0)
5745                 return err;
5746
5747         spec->multiout.max_channels = 2;
5748
5749         if (spec->autocfg.dig_outs)
5750                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5751         if (spec->kctls.list)
5752                 add_mixer(spec, spec->kctls.list);
5753
5754         add_verb(spec, alc260_volume_init_verbs);
5755
5756         spec->num_mux_defs = 1;
5757         spec->input_mux = &spec->private_imux[0];
5758
5759         return 1;
5760 }
5761
5762 /* additional initialization for auto-configuration model */
5763 static void alc260_auto_init(struct hda_codec *codec)
5764 {
5765         struct alc_spec *spec = codec->spec;
5766         alc260_auto_init_multi_out(codec);
5767         alc260_auto_init_analog_input(codec);
5768         if (spec->unsol_event)
5769                 alc_inithook(codec);
5770 }
5771
5772 #ifdef CONFIG_SND_HDA_POWER_SAVE
5773 static struct hda_amp_list alc260_loopbacks[] = {
5774         { 0x07, HDA_INPUT, 0 },
5775         { 0x07, HDA_INPUT, 1 },
5776         { 0x07, HDA_INPUT, 2 },
5777         { 0x07, HDA_INPUT, 3 },
5778         { 0x07, HDA_INPUT, 4 },
5779         { } /* end */
5780 };
5781 #endif
5782
5783 /*
5784  * ALC260 configurations
5785  */
5786 static const char *alc260_models[ALC260_MODEL_LAST] = {
5787         [ALC260_BASIC]          = "basic",
5788         [ALC260_HP]             = "hp",
5789         [ALC260_HP_3013]        = "hp-3013",
5790         [ALC260_HP_DC7600]      = "hp-dc7600",
5791         [ALC260_FUJITSU_S702X]  = "fujitsu",
5792         [ALC260_ACER]           = "acer",
5793         [ALC260_WILL]           = "will",
5794         [ALC260_REPLACER_672V]  = "replacer",
5795         [ALC260_FAVORIT100]     = "favorit100",
5796 #ifdef CONFIG_SND_DEBUG
5797         [ALC260_TEST]           = "test",
5798 #endif
5799         [ALC260_AUTO]           = "auto",
5800 };
5801
5802 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5803         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5804         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5805         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
5806         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5807         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5808         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5809         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
5810         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
5811         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5812         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5813         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5814         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5815         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5816         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5817         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5818         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5819         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5820         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5821         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5822         {}
5823 };
5824
5825 static struct alc_config_preset alc260_presets[] = {
5826         [ALC260_BASIC] = {
5827                 .mixers = { alc260_base_output_mixer,
5828                             alc260_input_mixer },
5829                 .init_verbs = { alc260_init_verbs },
5830                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5831                 .dac_nids = alc260_dac_nids,
5832                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5833                 .adc_nids = alc260_adc_nids,
5834                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5835                 .channel_mode = alc260_modes,
5836                 .input_mux = &alc260_capture_source,
5837         },
5838         [ALC260_HP] = {
5839                 .mixers = { alc260_hp_output_mixer,
5840                             alc260_input_mixer },
5841                 .init_verbs = { alc260_init_verbs,
5842                                 alc260_hp_unsol_verbs },
5843                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5844                 .dac_nids = alc260_dac_nids,
5845                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5846                 .adc_nids = alc260_adc_nids_alt,
5847                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5848                 .channel_mode = alc260_modes,
5849                 .input_mux = &alc260_capture_source,
5850                 .unsol_event = alc260_hp_unsol_event,
5851                 .init_hook = alc260_hp_automute,
5852         },
5853         [ALC260_HP_DC7600] = {
5854                 .mixers = { alc260_hp_dc7600_mixer,
5855                             alc260_input_mixer },
5856                 .init_verbs = { alc260_init_verbs,
5857                                 alc260_hp_dc7600_verbs },
5858                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5859                 .dac_nids = alc260_dac_nids,
5860                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5861                 .adc_nids = alc260_adc_nids_alt,
5862                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5863                 .channel_mode = alc260_modes,
5864                 .input_mux = &alc260_capture_source,
5865                 .unsol_event = alc260_hp_3012_unsol_event,
5866                 .init_hook = alc260_hp_3012_automute,
5867         },
5868         [ALC260_HP_3013] = {
5869                 .mixers = { alc260_hp_3013_mixer,
5870                             alc260_input_mixer },
5871                 .init_verbs = { alc260_hp_3013_init_verbs,
5872                                 alc260_hp_3013_unsol_verbs },
5873                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5874                 .dac_nids = alc260_dac_nids,
5875                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5876                 .adc_nids = alc260_adc_nids_alt,
5877                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5878                 .channel_mode = alc260_modes,
5879                 .input_mux = &alc260_capture_source,
5880                 .unsol_event = alc260_hp_3013_unsol_event,
5881                 .init_hook = alc260_hp_3013_automute,
5882         },
5883         [ALC260_FUJITSU_S702X] = {
5884                 .mixers = { alc260_fujitsu_mixer },
5885                 .init_verbs = { alc260_fujitsu_init_verbs },
5886                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5887                 .dac_nids = alc260_dac_nids,
5888                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5889                 .adc_nids = alc260_dual_adc_nids,
5890                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5891                 .channel_mode = alc260_modes,
5892                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5893                 .input_mux = alc260_fujitsu_capture_sources,
5894         },
5895         [ALC260_ACER] = {
5896                 .mixers = { alc260_acer_mixer },
5897                 .init_verbs = { alc260_acer_init_verbs },
5898                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5899                 .dac_nids = alc260_dac_nids,
5900                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5901                 .adc_nids = alc260_dual_adc_nids,
5902                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5903                 .channel_mode = alc260_modes,
5904                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5905                 .input_mux = alc260_acer_capture_sources,
5906         },
5907         [ALC260_FAVORIT100] = {
5908                 .mixers = { alc260_favorit100_mixer },
5909                 .init_verbs = { alc260_favorit100_init_verbs },
5910                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5911                 .dac_nids = alc260_dac_nids,
5912                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5913                 .adc_nids = alc260_dual_adc_nids,
5914                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5915                 .channel_mode = alc260_modes,
5916                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
5917                 .input_mux = alc260_favorit100_capture_sources,
5918         },
5919         [ALC260_WILL] = {
5920                 .mixers = { alc260_will_mixer },
5921                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
5922                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5923                 .dac_nids = alc260_dac_nids,
5924                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5925                 .adc_nids = alc260_adc_nids,
5926                 .dig_out_nid = ALC260_DIGOUT_NID,
5927                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5928                 .channel_mode = alc260_modes,
5929                 .input_mux = &alc260_capture_source,
5930         },
5931         [ALC260_REPLACER_672V] = {
5932                 .mixers = { alc260_replacer_672v_mixer },
5933                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
5934                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5935                 .dac_nids = alc260_dac_nids,
5936                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5937                 .adc_nids = alc260_adc_nids,
5938                 .dig_out_nid = ALC260_DIGOUT_NID,
5939                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5940                 .channel_mode = alc260_modes,
5941                 .input_mux = &alc260_capture_source,
5942                 .unsol_event = alc260_replacer_672v_unsol_event,
5943                 .init_hook = alc260_replacer_672v_automute,
5944         },
5945 #ifdef CONFIG_SND_DEBUG
5946         [ALC260_TEST] = {
5947                 .mixers = { alc260_test_mixer },
5948                 .init_verbs = { alc260_test_init_verbs },
5949                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
5950                 .dac_nids = alc260_test_dac_nids,
5951                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
5952                 .adc_nids = alc260_test_adc_nids,
5953                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5954                 .channel_mode = alc260_modes,
5955                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
5956                 .input_mux = alc260_test_capture_sources,
5957         },
5958 #endif
5959 };
5960
5961 static int patch_alc260(struct hda_codec *codec)
5962 {
5963         struct alc_spec *spec;
5964         int err, board_config;
5965
5966         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5967         if (spec == NULL)
5968                 return -ENOMEM;
5969
5970         codec->spec = spec;
5971
5972         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
5973                                                   alc260_models,
5974                                                   alc260_cfg_tbl);
5975         if (board_config < 0) {
5976                 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
5977                            "trying auto-probe from BIOS...\n");
5978                 board_config = ALC260_AUTO;
5979         }
5980
5981         if (board_config == ALC260_AUTO) {
5982                 /* automatic parse from the BIOS config */
5983                 err = alc260_parse_auto_config(codec);
5984                 if (err < 0) {
5985                         alc_free(codec);
5986                         return err;
5987                 } else if (!err) {
5988                         printk(KERN_INFO
5989                                "hda_codec: Cannot set up configuration "
5990                                "from BIOS.  Using base mode...\n");
5991                         board_config = ALC260_BASIC;
5992                 }
5993         }
5994
5995         err = snd_hda_attach_beep_device(codec, 0x1);
5996         if (err < 0) {
5997                 alc_free(codec);
5998                 return err;
5999         }
6000
6001         if (board_config != ALC260_AUTO)
6002                 setup_preset(spec, &alc260_presets[board_config]);
6003
6004         spec->stream_name_analog = "ALC260 Analog";
6005         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6006         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6007
6008         spec->stream_name_digital = "ALC260 Digital";
6009         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6010         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6011
6012         if (!spec->adc_nids && spec->input_mux) {
6013                 /* check whether NID 0x04 is valid */
6014                 unsigned int wcap = get_wcaps(codec, 0x04);
6015                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6016                 /* get type */
6017                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6018                         spec->adc_nids = alc260_adc_nids_alt;
6019                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6020                 } else {
6021                         spec->adc_nids = alc260_adc_nids;
6022                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6023                 }
6024         }
6025         set_capture_mixer(spec);
6026         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6027
6028         spec->vmaster_nid = 0x08;
6029
6030         codec->patch_ops = alc_patch_ops;
6031         if (board_config == ALC260_AUTO)
6032                 spec->init_hook = alc260_auto_init;
6033 #ifdef CONFIG_SND_HDA_POWER_SAVE
6034         if (!spec->loopback.amplist)
6035                 spec->loopback.amplist = alc260_loopbacks;
6036 #endif
6037         codec->proc_widget_hook = print_realtek_coef;
6038
6039         return 0;
6040 }
6041
6042
6043 /*
6044  * ALC882 support
6045  *
6046  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6047  * configuration.  Each pin widget can choose any input DACs and a mixer.
6048  * Each ADC is connected from a mixer of all inputs.  This makes possible
6049  * 6-channel independent captures.
6050  *
6051  * In addition, an independent DAC for the multi-playback (not used in this
6052  * driver yet).
6053  */
6054 #define ALC882_DIGOUT_NID       0x06
6055 #define ALC882_DIGIN_NID        0x0a
6056
6057 static struct hda_channel_mode alc882_ch_modes[1] = {
6058         { 8, NULL }
6059 };
6060
6061 static hda_nid_t alc882_dac_nids[4] = {
6062         /* front, rear, clfe, rear_surr */
6063         0x02, 0x03, 0x04, 0x05
6064 };
6065
6066 /* identical with ALC880 */
6067 #define alc882_adc_nids         alc880_adc_nids
6068 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6069
6070 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6071 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6072
6073 /* input MUX */
6074 /* FIXME: should be a matrix-type input source selection */
6075
6076 static struct hda_input_mux alc882_capture_source = {
6077         .num_items = 4,
6078         .items = {
6079                 { "Mic", 0x0 },
6080                 { "Front Mic", 0x1 },
6081                 { "Line", 0x2 },
6082                 { "CD", 0x4 },
6083         },
6084 };
6085 /*
6086  * 2ch mode
6087  */
6088 static struct hda_verb alc882_3ST_ch2_init[] = {
6089         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6090         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6091         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6092         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6093         { } /* end */
6094 };
6095
6096 /*
6097  * 6ch mode
6098  */
6099 static struct hda_verb alc882_3ST_ch6_init[] = {
6100         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6101         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6102         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6103         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6104         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6105         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6106         { } /* end */
6107 };
6108
6109 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
6110         { 2, alc882_3ST_ch2_init },
6111         { 6, alc882_3ST_ch6_init },
6112 };
6113
6114 /*
6115  * 6ch mode
6116  */
6117 static struct hda_verb alc882_sixstack_ch6_init[] = {
6118         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6119         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6120         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6121         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6122         { } /* end */
6123 };
6124
6125 /*
6126  * 8ch mode
6127  */
6128 static struct hda_verb alc882_sixstack_ch8_init[] = {
6129         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6130         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6131         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6132         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6133         { } /* end */
6134 };
6135
6136 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6137         { 6, alc882_sixstack_ch6_init },
6138         { 8, alc882_sixstack_ch8_init },
6139 };
6140
6141 /*
6142  * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
6143  */
6144
6145 /*
6146  * 2ch mode
6147  */
6148 static struct hda_verb alc885_mbp_ch2_init[] = {
6149         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6150         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6151         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6152         { } /* end */
6153 };
6154
6155 /*
6156  * 6ch mode
6157  */
6158 static struct hda_verb alc885_mbp_ch6_init[] = {
6159         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6160         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6161         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6162         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6163         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6164         { } /* end */
6165 };
6166
6167 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
6168         { 2, alc885_mbp_ch2_init },
6169         { 6, alc885_mbp_ch6_init },
6170 };
6171
6172
6173 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6174  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6175  */
6176 static struct snd_kcontrol_new alc882_base_mixer[] = {
6177         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6178         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6179         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6180         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6181         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6182         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6183         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6184         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6185         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6186         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6187         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6188         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6189         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6190         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6191         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6192         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6193         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6194         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6195         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6196         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6197         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6198         { } /* end */
6199 };
6200
6201 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
6202         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6203         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6204         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
6205         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6206         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6207         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6208         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
6209         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
6210         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
6211         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
6212         { } /* end */
6213 };
6214 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
6215         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6216         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6217         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6218         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6219         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6220         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6221         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6222         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6223         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6224         { } /* end */
6225 };
6226
6227 static struct snd_kcontrol_new alc882_targa_mixer[] = {
6228         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6229         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6230         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6231         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6232         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6233         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6234         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6235         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6236         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6237         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6238         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6239         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6240         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6241         { } /* end */
6242 };
6243
6244 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
6245  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
6246  */
6247 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
6248         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6249         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6250         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6251         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
6252         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6253         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6254         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6255         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6256         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
6257         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
6258         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6259         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6260         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6261         { } /* end */
6262 };
6263
6264 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
6265         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6266         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6267         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6268         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6269         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6270         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6271         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6272         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6273         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6274         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6275         { } /* end */
6276 };
6277
6278 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
6279         {
6280                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6281                 .name = "Channel Mode",
6282                 .info = alc_ch_mode_info,
6283                 .get = alc_ch_mode_get,
6284                 .put = alc_ch_mode_put,
6285         },
6286         { } /* end */
6287 };
6288
6289 static struct hda_verb alc882_init_verbs[] = {
6290         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6291         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6292         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6293         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6294         /* Rear mixer */
6295         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6296         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6297         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6298         /* CLFE mixer */
6299         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6300         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6301         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6302         /* Side mixer */
6303         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6304         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6305         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6306
6307         /* Front Pin: output 0 (0x0c) */
6308         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6309         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6310         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6311         /* Rear Pin: output 1 (0x0d) */
6312         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6313         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6314         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6315         /* CLFE Pin: output 2 (0x0e) */
6316         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6317         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6318         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
6319         /* Side Pin: output 3 (0x0f) */
6320         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6321         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6322         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
6323         /* Mic (rear) pin: input vref at 80% */
6324         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6325         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6326         /* Front Mic pin: input vref at 80% */
6327         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6328         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6329         /* Line In pin: input */
6330         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6331         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6332         /* Line-2 In: Headphone output (output 0 - 0x0c) */
6333         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6334         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6335         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
6336         /* CD pin widget for input */
6337         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6338
6339         /* FIXME: use matrix-type input source selection */
6340         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6341         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6342         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6343         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6344         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6345         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6346         /* Input mixer2 */
6347         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6348         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6349         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6350         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6351         /* Input mixer3 */
6352         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6353         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6354         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6355         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6356         /* ADC1: mute amp left and right */
6357         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6358         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6359         /* ADC2: mute amp left and right */
6360         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6361         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6362         /* ADC3: mute amp left and right */
6363         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6364         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6365
6366         { }
6367 };
6368
6369 static struct hda_verb alc882_eapd_verbs[] = {
6370         /* change to EAPD mode */
6371         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6372         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
6373         { }
6374 };
6375
6376 /* Mac Pro test */
6377 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
6378         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6379         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6380         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
6381         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
6382         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
6383         /* FIXME: this looks suspicious...
6384         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
6385         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
6386         */
6387         { } /* end */
6388 };
6389
6390 static struct hda_verb alc882_macpro_init_verbs[] = {
6391         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6392         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6393         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6394         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6395         /* Front Pin: output 0 (0x0c) */
6396         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6397         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6398         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6399         /* Front Mic pin: input vref at 80% */
6400         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6401         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6402         /* Speaker:  output */
6403         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6404         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6405         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
6406         /* Headphone output (output 0 - 0x0c) */
6407         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6408         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6409         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6410
6411         /* FIXME: use matrix-type input source selection */
6412         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6413         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6414         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6415         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6416         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6417         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6418         /* Input mixer2 */
6419         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6420         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6421         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6422         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6423         /* Input mixer3 */
6424         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6425         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6426         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6427         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6428         /* ADC1: mute amp left and right */
6429         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6430         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6431         /* ADC2: mute amp left and right */
6432         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6433         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6434         /* ADC3: mute amp left and right */
6435         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6436         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6437
6438         { }
6439 };
6440
6441 /* Macbook Pro rev3 */
6442 static struct hda_verb alc885_mbp3_init_verbs[] = {
6443         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6444         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6445         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6446         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6447         /* Rear mixer */
6448         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6449         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6450         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6451         /* Front Pin: output 0 (0x0c) */
6452         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6453         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6454         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6455         /* HP Pin: output 0 (0x0d) */
6456         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
6457         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6458         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6459         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6460         /* Mic (rear) pin: input vref at 80% */
6461         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6462         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6463         /* Front Mic pin: input vref at 80% */
6464         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6465         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6466         /* Line In pin: use output 1 when in LineOut mode */
6467         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6468         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6469         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
6470
6471         /* FIXME: use matrix-type input source selection */
6472         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6473         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6474         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6475         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6476         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6477         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6478         /* Input mixer2 */
6479         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6480         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6481         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6482         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6483         /* Input mixer3 */
6484         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6485         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6486         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6487         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6488         /* ADC1: mute amp left and right */
6489         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6490         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6491         /* ADC2: mute amp left and right */
6492         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6493         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6494         /* ADC3: mute amp left and right */
6495         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6496         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6497
6498         { }
6499 };
6500
6501 /* iMac 24 mixer. */
6502 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
6503         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6504         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
6505         { } /* end */
6506 };
6507
6508 /* iMac 24 init verbs. */
6509 static struct hda_verb alc885_imac24_init_verbs[] = {
6510         /* Internal speakers: output 0 (0x0c) */
6511         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6512         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6513         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6514         /* Internal speakers: output 0 (0x0c) */
6515         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6516         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6517         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
6518         /* Headphone: output 0 (0x0c) */
6519         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6520         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6521         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6522         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6523         /* Front Mic: input vref at 80% */
6524         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6525         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6526         { }
6527 };
6528
6529 /* Toggle speaker-output according to the hp-jack state */
6530 static void alc885_imac24_automute(struct hda_codec *codec)
6531 {
6532         unsigned int present;
6533
6534         present = snd_hda_codec_read(codec, 0x14, 0,
6535                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6536         snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
6537                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6538         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
6539                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6540 }
6541
6542 /* Processes unsolicited events. */
6543 static void alc885_imac24_unsol_event(struct hda_codec *codec,
6544                                       unsigned int res)
6545 {
6546         /* Headphone insertion or removal. */
6547         if ((res >> 26) == ALC880_HP_EVENT)
6548                 alc885_imac24_automute(codec);
6549 }
6550
6551 static void alc885_mbp3_automute(struct hda_codec *codec)
6552 {
6553         unsigned int present;
6554
6555         present = snd_hda_codec_read(codec, 0x15, 0,
6556                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6557         snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
6558                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6559         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
6560                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
6561
6562 }
6563 static void alc885_mbp3_unsol_event(struct hda_codec *codec,
6564                                     unsigned int res)
6565 {
6566         /* Headphone insertion or removal. */
6567         if ((res >> 26) == ALC880_HP_EVENT)
6568                 alc885_mbp3_automute(codec);
6569 }
6570
6571
6572 static struct hda_verb alc882_targa_verbs[] = {
6573         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6574         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6575
6576         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6577         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6578
6579         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6580         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6581         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6582
6583         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6584         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6585         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
6586         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
6587         { } /* end */
6588 };
6589
6590 /* toggle speaker-output according to the hp-jack state */
6591 static void alc882_targa_automute(struct hda_codec *codec)
6592 {
6593         unsigned int present;
6594
6595         present = snd_hda_codec_read(codec, 0x14, 0,
6596                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6597         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
6598                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6599         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
6600                                   present ? 1 : 3);
6601 }
6602
6603 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
6604 {
6605         /* Looks like the unsol event is incompatible with the standard
6606          * definition.  4bit tag is placed at 26 bit!
6607          */
6608         if (((res >> 26) == ALC880_HP_EVENT)) {
6609                 alc882_targa_automute(codec);
6610         }
6611 }
6612
6613 static struct hda_verb alc882_asus_a7j_verbs[] = {
6614         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6615         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6616
6617         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6618         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6619         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6620
6621         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6622         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6623         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6624
6625         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6626         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6627         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6628         { } /* end */
6629 };
6630
6631 static struct hda_verb alc882_asus_a7m_verbs[] = {
6632         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6633         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6634
6635         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6636         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6637         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6638
6639         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6640         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6641         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6642
6643         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6644         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6645         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6646         { } /* end */
6647 };
6648
6649 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
6650 {
6651         unsigned int gpiostate, gpiomask, gpiodir;
6652
6653         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
6654                                        AC_VERB_GET_GPIO_DATA, 0);
6655
6656         if (!muted)
6657                 gpiostate |= (1 << pin);
6658         else
6659                 gpiostate &= ~(1 << pin);
6660
6661         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
6662                                       AC_VERB_GET_GPIO_MASK, 0);
6663         gpiomask |= (1 << pin);
6664
6665         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
6666                                      AC_VERB_GET_GPIO_DIRECTION, 0);
6667         gpiodir |= (1 << pin);
6668
6669
6670         snd_hda_codec_write(codec, codec->afg, 0,
6671                             AC_VERB_SET_GPIO_MASK, gpiomask);
6672         snd_hda_codec_write(codec, codec->afg, 0,
6673                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
6674
6675         msleep(1);
6676
6677         snd_hda_codec_write(codec, codec->afg, 0,
6678                             AC_VERB_SET_GPIO_DATA, gpiostate);
6679 }
6680
6681 /* set up GPIO at initialization */
6682 static void alc885_macpro_init_hook(struct hda_codec *codec)
6683 {
6684         alc882_gpio_mute(codec, 0, 0);
6685         alc882_gpio_mute(codec, 1, 0);
6686 }
6687
6688 /* set up GPIO and update auto-muting at initialization */
6689 static void alc885_imac24_init_hook(struct hda_codec *codec)
6690 {
6691         alc885_macpro_init_hook(codec);
6692         alc885_imac24_automute(codec);
6693 }
6694
6695 /*
6696  * generic initialization of ADC, input mixers and output mixers
6697  */
6698 static struct hda_verb alc882_auto_init_verbs[] = {
6699         /*
6700          * Unmute ADC0-2 and set the default input to mic-in
6701          */
6702         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6703         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6704         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6705         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6706         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6707         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6708
6709         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6710          * mixer widget
6711          * Note: PASD motherboards uses the Line In 2 as the input for
6712          * front panel mic (mic 2)
6713          */
6714         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6715         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6716         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6717         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6718         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6719         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6720
6721         /*
6722          * Set up output mixers (0x0c - 0x0f)
6723          */
6724         /* set vol=0 to output mixers */
6725         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6726         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6727         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6728         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6729         /* set up input amps for analog loopback */
6730         /* Amp Indices: DAC = 0, mixer = 1 */
6731         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6732         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6733         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6734         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6735         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6736         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6737         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6738         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6739         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6740         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6741
6742         /* FIXME: use matrix-type input source selection */
6743         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6744         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6745         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6746         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6747         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6748         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6749         /* Input mixer2 */
6750         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6751         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6752         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6753         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6754         /* Input mixer3 */
6755         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6756         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6757         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6758         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6759
6760         { }
6761 };
6762
6763 #ifdef CONFIG_SND_HDA_POWER_SAVE
6764 #define alc882_loopbacks        alc880_loopbacks
6765 #endif
6766
6767 /* pcm configuration: identiacal with ALC880 */
6768 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
6769 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
6770 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
6771 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
6772
6773 /*
6774  * configuration and preset
6775  */
6776 static const char *alc882_models[ALC882_MODEL_LAST] = {
6777         [ALC882_3ST_DIG]        = "3stack-dig",
6778         [ALC882_6ST_DIG]        = "6stack-dig",
6779         [ALC882_ARIMA]          = "arima",
6780         [ALC882_W2JC]           = "w2jc",
6781         [ALC882_TARGA]          = "targa",
6782         [ALC882_ASUS_A7J]       = "asus-a7j",
6783         [ALC882_ASUS_A7M]       = "asus-a7m",
6784         [ALC885_MACPRO]         = "macpro",
6785         [ALC885_MBP3]           = "mbp3",
6786         [ALC885_IMAC24]         = "imac24",
6787         [ALC882_AUTO]           = "auto",
6788 };
6789
6790 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6791         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6792         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6793         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6794         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6795         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6796         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6797         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6798         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6799         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6800         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
6801         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6802         SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6803         {}
6804 };
6805
6806 static struct alc_config_preset alc882_presets[] = {
6807         [ALC882_3ST_DIG] = {
6808                 .mixers = { alc882_base_mixer },
6809                 .init_verbs = { alc882_init_verbs },
6810                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6811                 .dac_nids = alc882_dac_nids,
6812                 .dig_out_nid = ALC882_DIGOUT_NID,
6813                 .dig_in_nid = ALC882_DIGIN_NID,
6814                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6815                 .channel_mode = alc882_ch_modes,
6816                 .need_dac_fix = 1,
6817                 .input_mux = &alc882_capture_source,
6818         },
6819         [ALC882_6ST_DIG] = {
6820                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6821                 .init_verbs = { alc882_init_verbs },
6822                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6823                 .dac_nids = alc882_dac_nids,
6824                 .dig_out_nid = ALC882_DIGOUT_NID,
6825                 .dig_in_nid = ALC882_DIGIN_NID,
6826                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6827                 .channel_mode = alc882_sixstack_modes,
6828                 .input_mux = &alc882_capture_source,
6829         },
6830         [ALC882_ARIMA] = {
6831                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6832                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
6833                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6834                 .dac_nids = alc882_dac_nids,
6835                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6836                 .channel_mode = alc882_sixstack_modes,
6837                 .input_mux = &alc882_capture_source,
6838         },
6839         [ALC882_W2JC] = {
6840                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
6841                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6842                                 alc880_gpio1_init_verbs },
6843                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6844                 .dac_nids = alc882_dac_nids,
6845                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6846                 .channel_mode = alc880_threestack_modes,
6847                 .need_dac_fix = 1,
6848                 .input_mux = &alc882_capture_source,
6849                 .dig_out_nid = ALC882_DIGOUT_NID,
6850         },
6851         [ALC885_MBP3] = {
6852                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
6853                 .init_verbs = { alc885_mbp3_init_verbs,
6854                                 alc880_gpio1_init_verbs },
6855                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6856                 .dac_nids = alc882_dac_nids,
6857                 .channel_mode = alc885_mbp_6ch_modes,
6858                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6859                 .input_mux = &alc882_capture_source,
6860                 .dig_out_nid = ALC882_DIGOUT_NID,
6861                 .dig_in_nid = ALC882_DIGIN_NID,
6862                 .unsol_event = alc885_mbp3_unsol_event,
6863                 .init_hook = alc885_mbp3_automute,
6864         },
6865         [ALC885_MACPRO] = {
6866                 .mixers = { alc882_macpro_mixer },
6867                 .init_verbs = { alc882_macpro_init_verbs },
6868                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6869                 .dac_nids = alc882_dac_nids,
6870                 .dig_out_nid = ALC882_DIGOUT_NID,
6871                 .dig_in_nid = ALC882_DIGIN_NID,
6872                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6873                 .channel_mode = alc882_ch_modes,
6874                 .input_mux = &alc882_capture_source,
6875                 .init_hook = alc885_macpro_init_hook,
6876         },
6877         [ALC885_IMAC24] = {
6878                 .mixers = { alc885_imac24_mixer },
6879                 .init_verbs = { alc885_imac24_init_verbs },
6880                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6881                 .dac_nids = alc882_dac_nids,
6882                 .dig_out_nid = ALC882_DIGOUT_NID,
6883                 .dig_in_nid = ALC882_DIGIN_NID,
6884                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6885                 .channel_mode = alc882_ch_modes,
6886                 .input_mux = &alc882_capture_source,
6887                 .unsol_event = alc885_imac24_unsol_event,
6888                 .init_hook = alc885_imac24_init_hook,
6889         },
6890         [ALC882_TARGA] = {
6891                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
6892                 .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
6893                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6894                 .dac_nids = alc882_dac_nids,
6895                 .dig_out_nid = ALC882_DIGOUT_NID,
6896                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6897                 .adc_nids = alc882_adc_nids,
6898                 .capsrc_nids = alc882_capsrc_nids,
6899                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6900                 .channel_mode = alc882_3ST_6ch_modes,
6901                 .need_dac_fix = 1,
6902                 .input_mux = &alc882_capture_source,
6903                 .unsol_event = alc882_targa_unsol_event,
6904                 .init_hook = alc882_targa_automute,
6905         },
6906         [ALC882_ASUS_A7J] = {
6907                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
6908                 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
6909                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6910                 .dac_nids = alc882_dac_nids,
6911                 .dig_out_nid = ALC882_DIGOUT_NID,
6912                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6913                 .adc_nids = alc882_adc_nids,
6914                 .capsrc_nids = alc882_capsrc_nids,
6915                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6916                 .channel_mode = alc882_3ST_6ch_modes,
6917                 .need_dac_fix = 1,
6918                 .input_mux = &alc882_capture_source,
6919         },
6920         [ALC882_ASUS_A7M] = {
6921                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
6922                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6923                                 alc880_gpio1_init_verbs,
6924                                 alc882_asus_a7m_verbs },
6925                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6926                 .dac_nids = alc882_dac_nids,
6927                 .dig_out_nid = ALC882_DIGOUT_NID,
6928                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6929                 .channel_mode = alc880_threestack_modes,
6930                 .need_dac_fix = 1,
6931                 .input_mux = &alc882_capture_source,
6932         },
6933 };
6934
6935
6936 /*
6937  * Pin config fixes
6938  */
6939 enum {
6940         PINFIX_ABIT_AW9D_MAX
6941 };
6942
6943 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
6944         { 0x15, 0x01080104 }, /* side */
6945         { 0x16, 0x01011012 }, /* rear */
6946         { 0x17, 0x01016011 }, /* clfe */
6947         { }
6948 };
6949
6950 static const struct alc_pincfg *alc882_pin_fixes[] = {
6951         [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
6952 };
6953
6954 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
6955         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
6956         {}
6957 };
6958
6959 /*
6960  * BIOS auto configuration
6961  */
6962 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
6963                                               hda_nid_t nid, int pin_type,
6964                                               int dac_idx)
6965 {
6966         /* set as output */
6967         struct alc_spec *spec = codec->spec;
6968         int idx;
6969
6970         alc_set_pin_output(codec, nid, pin_type);
6971         if (spec->multiout.dac_nids[dac_idx] == 0x25)
6972                 idx = 4;
6973         else
6974                 idx = spec->multiout.dac_nids[dac_idx] - 2;
6975         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
6976
6977 }
6978
6979 static void alc882_auto_init_multi_out(struct hda_codec *codec)
6980 {
6981         struct alc_spec *spec = codec->spec;
6982         int i;
6983
6984         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
6985         for (i = 0; i <= HDA_SIDE; i++) {
6986                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
6987                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6988                 if (nid)
6989                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
6990                                                           i);
6991         }
6992 }
6993
6994 static void alc882_auto_init_hp_out(struct hda_codec *codec)
6995 {
6996         struct alc_spec *spec = codec->spec;
6997         hda_nid_t pin;
6998
6999         pin = spec->autocfg.hp_pins[0];
7000         if (pin) /* connect to front */
7001                 /* use dac 0 */
7002                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
7003         pin = spec->autocfg.speaker_pins[0];
7004         if (pin)
7005                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
7006 }
7007
7008 #define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
7009 #define ALC882_PIN_CD_NID               ALC880_PIN_CD_NID
7010
7011 static void alc882_auto_init_analog_input(struct hda_codec *codec)
7012 {
7013         struct alc_spec *spec = codec->spec;
7014         int i;
7015
7016         for (i = 0; i < AUTO_PIN_LAST; i++) {
7017                 hda_nid_t nid = spec->autocfg.input_pins[i];
7018                 if (!nid)
7019                         continue;
7020                 alc_set_input_pin(codec, nid, AUTO_PIN_FRONT_MIC /*i*/);
7021                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
7022                         snd_hda_codec_write(codec, nid, 0,
7023                                             AC_VERB_SET_AMP_GAIN_MUTE,
7024                                             AMP_OUT_MUTE);
7025         }
7026 }
7027
7028 static void alc882_auto_init_input_src(struct hda_codec *codec)
7029 {
7030         struct alc_spec *spec = codec->spec;
7031         int c;
7032
7033         for (c = 0; c < spec->num_adc_nids; c++) {
7034                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
7035                 hda_nid_t nid = spec->capsrc_nids[c];
7036                 unsigned int mux_idx;
7037                 const struct hda_input_mux *imux;
7038                 int conns, mute, idx, item;
7039
7040                 conns = snd_hda_get_connections(codec, nid, conn_list,
7041                                                 ARRAY_SIZE(conn_list));
7042                 if (conns < 0)
7043                         continue;
7044                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
7045                 imux = &spec->input_mux[mux_idx];
7046                 for (idx = 0; idx < conns; idx++) {
7047                         /* if the current connection is the selected one,
7048                          * unmute it as default - otherwise mute it
7049                          */
7050                         mute = AMP_IN_MUTE(idx);
7051                         for (item = 0; item < imux->num_items; item++) {
7052                                 if (imux->items[item].index == idx) {
7053                                         if (spec->cur_mux[c] == item)
7054                                                 mute = AMP_IN_UNMUTE(idx);
7055                                         break;
7056                                 }
7057                         }
7058                         /* check if we have a selector or mixer
7059                          * we could check for the widget type instead, but
7060                          * just check for Amp-In presence (in case of mixer
7061                          * without amp-in there is something wrong, this
7062                          * function shouldn't be used or capsrc nid is wrong)
7063                          */
7064                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
7065                                 snd_hda_codec_write(codec, nid, 0,
7066                                                     AC_VERB_SET_AMP_GAIN_MUTE,
7067                                                     mute);
7068                         else if (mute != AMP_IN_MUTE(idx))
7069                                 snd_hda_codec_write(codec, nid, 0,
7070                                                     AC_VERB_SET_CONNECT_SEL,
7071                                                     idx);
7072                 }
7073         }
7074 }
7075
7076 /* add mic boosts if needed */
7077 static int alc_auto_add_mic_boost(struct hda_codec *codec)
7078 {
7079         struct alc_spec *spec = codec->spec;
7080         int err;
7081         hda_nid_t nid;
7082
7083         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
7084         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
7085                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
7086                                   "Mic Boost",
7087                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
7088                 if (err < 0)
7089                         return err;
7090         }
7091         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
7092         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
7093                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
7094                                   "Front Mic Boost",
7095                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
7096                 if (err < 0)
7097                         return err;
7098         }
7099         return 0;
7100 }
7101
7102 /* almost identical with ALC880 parser... */
7103 static int alc882_parse_auto_config(struct hda_codec *codec)
7104 {
7105         struct alc_spec *spec = codec->spec;
7106         int err = alc880_parse_auto_config(codec);
7107
7108         if (err < 0)
7109                 return err;
7110         else if (!err)
7111                 return 0; /* no config found */
7112
7113         err = alc_auto_add_mic_boost(codec);
7114         if (err < 0)
7115                 return err;
7116
7117         /* hack - override the init verbs */
7118         spec->init_verbs[0] = alc882_auto_init_verbs;
7119
7120         return 1; /* config found */
7121 }
7122
7123 /* additional initialization for auto-configuration model */
7124 static void alc882_auto_init(struct hda_codec *codec)
7125 {
7126         struct alc_spec *spec = codec->spec;
7127         alc882_auto_init_multi_out(codec);
7128         alc882_auto_init_hp_out(codec);
7129         alc882_auto_init_analog_input(codec);
7130         alc882_auto_init_input_src(codec);
7131         if (spec->unsol_event)
7132                 alc_inithook(codec);
7133 }
7134
7135 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
7136
7137 static int patch_alc882(struct hda_codec *codec)
7138 {
7139         struct alc_spec *spec;
7140         int err, board_config;
7141
7142         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7143         if (spec == NULL)
7144                 return -ENOMEM;
7145
7146         codec->spec = spec;
7147
7148         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
7149                                                   alc882_models,
7150                                                   alc882_cfg_tbl);
7151
7152         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
7153                 /* Pick up systems that don't supply PCI SSID */
7154                 switch (codec->subsystem_id) {
7155                 case 0x106b0c00: /* Mac Pro */
7156                         board_config = ALC885_MACPRO;
7157                         break;
7158                 case 0x106b1000: /* iMac 24 */
7159                 case 0x106b2800: /* AppleTV */
7160                 case 0x106b3e00: /* iMac 24 Aluminium */
7161                         board_config = ALC885_IMAC24;
7162                         break;
7163                 case 0x106b00a0: /* MacBookPro3,1 - Another revision */
7164                 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
7165                 case 0x106b00a4: /* MacbookPro4,1 */
7166                 case 0x106b2c00: /* Macbook Pro rev3 */
7167                 case 0x106b3600: /* Macbook 3.1 */
7168                 case 0x106b3800: /* MacbookPro4,1 - latter revision */
7169                         board_config = ALC885_MBP3;
7170                         break;
7171                 default:
7172                         /* ALC889A is handled better as ALC888-compatible */
7173                         if (codec->revision_id == 0x100101 ||
7174                             codec->revision_id == 0x100103) {
7175                                 alc_free(codec);
7176                                 return patch_alc883(codec);
7177                         }
7178                         printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
7179                                          "trying auto-probe from BIOS...\n");
7180                         board_config = ALC882_AUTO;
7181                 }
7182         }
7183
7184         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
7185
7186         if (board_config == ALC882_AUTO) {
7187                 /* automatic parse from the BIOS config */
7188                 err = alc882_parse_auto_config(codec);
7189                 if (err < 0) {
7190                         alc_free(codec);
7191                         return err;
7192                 } else if (!err) {
7193                         printk(KERN_INFO
7194                                "hda_codec: Cannot set up configuration "
7195                                "from BIOS.  Using base mode...\n");
7196                         board_config = ALC882_3ST_DIG;
7197                 }
7198         }
7199
7200         err = snd_hda_attach_beep_device(codec, 0x1);
7201         if (err < 0) {
7202                 alc_free(codec);
7203                 return err;
7204         }
7205
7206         if (board_config != ALC882_AUTO)
7207                 setup_preset(spec, &alc882_presets[board_config]);
7208
7209         if (codec->vendor_id == 0x10ec0885) {
7210                 spec->stream_name_analog = "ALC885 Analog";
7211                 spec->stream_name_digital = "ALC885 Digital";
7212         } else {
7213                 spec->stream_name_analog = "ALC882 Analog";
7214                 spec->stream_name_digital = "ALC882 Digital";
7215         }
7216
7217         spec->stream_analog_playback = &alc882_pcm_analog_playback;
7218         spec->stream_analog_capture = &alc882_pcm_analog_capture;
7219         /* FIXME: setup DAC5 */
7220         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
7221         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
7222
7223         spec->stream_digital_playback = &alc882_pcm_digital_playback;
7224         spec->stream_digital_capture = &alc882_pcm_digital_capture;
7225
7226         spec->capture_style = CAPT_MIX; /* matrix-style capture */
7227         if (!spec->adc_nids && spec->input_mux) {
7228                 /* check whether NID 0x07 is valid */
7229                 unsigned int wcap = get_wcaps(codec, 0x07);
7230                 /* get type */
7231                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
7232                 if (wcap != AC_WID_AUD_IN) {
7233                         spec->adc_nids = alc882_adc_nids_alt;
7234                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
7235                         spec->capsrc_nids = alc882_capsrc_nids_alt;
7236                 } else {
7237                         spec->adc_nids = alc882_adc_nids;
7238                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
7239                         spec->capsrc_nids = alc882_capsrc_nids;
7240                 }
7241         }
7242         set_capture_mixer(spec);
7243         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
7244
7245         spec->vmaster_nid = 0x0c;
7246
7247         codec->patch_ops = alc_patch_ops;
7248         if (board_config == ALC882_AUTO)
7249                 spec->init_hook = alc882_auto_init;
7250 #ifdef CONFIG_SND_HDA_POWER_SAVE
7251         if (!spec->loopback.amplist)
7252                 spec->loopback.amplist = alc882_loopbacks;
7253 #endif
7254         codec->proc_widget_hook = print_realtek_coef;
7255
7256         return 0;
7257 }
7258
7259 /*
7260  * ALC883 support
7261  *
7262  * ALC883 is almost identical with ALC880 but has cleaner and more flexible
7263  * configuration.  Each pin widget can choose any input DACs and a mixer.
7264  * Each ADC is connected from a mixer of all inputs.  This makes possible
7265  * 6-channel independent captures.
7266  *
7267  * In addition, an independent DAC for the multi-playback (not used in this
7268  * driver yet).
7269  */
7270 #define ALC883_DIGOUT_NID       0x06
7271 #define ALC883_DIGIN_NID        0x0a
7272
7273 #define ALC1200_DIGOUT_NID      0x10
7274
7275 static hda_nid_t alc883_dac_nids[4] = {
7276         /* front, rear, clfe, rear_surr */
7277         0x02, 0x03, 0x04, 0x05
7278 };
7279
7280 static hda_nid_t alc883_adc_nids[2] = {
7281         /* ADC1-2 */
7282         0x08, 0x09,
7283 };
7284
7285 static hda_nid_t alc883_adc_nids_alt[1] = {
7286         /* ADC1 */
7287         0x08,
7288 };
7289
7290 static hda_nid_t alc883_adc_nids_rev[2] = {
7291         /* ADC2-1 */
7292         0x09, 0x08
7293 };
7294
7295 #define alc889_adc_nids         alc880_adc_nids
7296
7297 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
7298
7299 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7300
7301 #define alc889_capsrc_nids      alc882_capsrc_nids
7302
7303 /* input MUX */
7304 /* FIXME: should be a matrix-type input source selection */
7305
7306 static struct hda_input_mux alc883_capture_source = {
7307         .num_items = 4,
7308         .items = {
7309                 { "Mic", 0x0 },
7310                 { "Front Mic", 0x1 },
7311                 { "Line", 0x2 },
7312                 { "CD", 0x4 },
7313         },
7314 };
7315
7316 static struct hda_input_mux alc883_3stack_6ch_intel = {
7317         .num_items = 4,
7318         .items = {
7319                 { "Mic", 0x1 },
7320                 { "Front Mic", 0x0 },
7321                 { "Line", 0x2 },
7322                 { "CD", 0x4 },
7323         },
7324 };
7325
7326 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7327         .num_items = 2,
7328         .items = {
7329                 { "Mic", 0x1 },
7330                 { "Line", 0x2 },
7331         },
7332 };
7333
7334 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7335         .num_items = 4,
7336         .items = {
7337                 { "Mic", 0x0 },
7338                 { "iMic", 0x1 },
7339                 { "Line", 0x2 },
7340                 { "CD", 0x4 },
7341         },
7342 };
7343
7344 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7345         .num_items = 2,
7346         .items = {
7347                 { "Mic", 0x0 },
7348                 { "Int Mic", 0x1 },
7349         },
7350 };
7351
7352 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7353         .num_items = 3,
7354         .items = {
7355                 { "Mic", 0x0 },
7356                 { "Front Mic", 0x1 },
7357                 { "Line", 0x4 },
7358         },
7359 };
7360
7361 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7362         .num_items = 2,
7363         .items = {
7364                 { "Mic", 0x0 },
7365                 { "Line", 0x2 },
7366         },
7367 };
7368
7369 /*
7370  * 2ch mode
7371  */
7372 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7373         { 2, NULL }
7374 };
7375
7376 /*
7377  * 2ch mode
7378  */
7379 static struct hda_verb alc883_3ST_ch2_init[] = {
7380         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7381         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7382         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7383         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7384         { } /* end */
7385 };
7386
7387 /*
7388  * 4ch mode
7389  */
7390 static struct hda_verb alc883_3ST_ch4_init[] = {
7391         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7392         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7393         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7394         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7395         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7396         { } /* end */
7397 };
7398
7399 /*
7400  * 6ch mode
7401  */
7402 static struct hda_verb alc883_3ST_ch6_init[] = {
7403         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7404         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7405         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7406         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7407         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7408         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7409         { } /* end */
7410 };
7411
7412 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
7413         { 2, alc883_3ST_ch2_init },
7414         { 4, alc883_3ST_ch4_init },
7415         { 6, alc883_3ST_ch6_init },
7416 };
7417
7418 /*
7419  * 2ch mode
7420  */
7421 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7422         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7423         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7424         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7425         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7426         { } /* end */
7427 };
7428
7429 /*
7430  * 4ch mode
7431  */
7432 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7433         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7434         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7435         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7436         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7437         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7438         { } /* end */
7439 };
7440
7441 /*
7442  * 6ch mode
7443  */
7444 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7445         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7446         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7447         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7448         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7449         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7450         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7451         { } /* end */
7452 };
7453
7454 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7455         { 2, alc883_3ST_ch2_intel_init },
7456         { 4, alc883_3ST_ch4_intel_init },
7457         { 6, alc883_3ST_ch6_intel_init },
7458 };
7459
7460 /*
7461  * 6ch mode
7462  */
7463 static struct hda_verb alc883_sixstack_ch6_init[] = {
7464         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7465         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7466         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7467         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7468         { } /* end */
7469 };
7470
7471 /*
7472  * 8ch mode
7473  */
7474 static struct hda_verb alc883_sixstack_ch8_init[] = {
7475         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7476         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7477         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7478         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7479         { } /* end */
7480 };
7481
7482 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7483         { 6, alc883_sixstack_ch6_init },
7484         { 8, alc883_sixstack_ch8_init },
7485 };
7486
7487 static struct hda_verb alc883_medion_eapd_verbs[] = {
7488         /* eanable EAPD on medion laptop */
7489         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7490         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7491         { }
7492 };
7493
7494 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7495  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7496  */
7497
7498 static struct snd_kcontrol_new alc883_base_mixer[] = {
7499         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7500         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7501         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7502         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7503         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7504         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7505         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7506         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7507         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7508         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7509         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7510         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7511         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7512         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7513         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7514         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7515         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7516         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7517         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7518         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7519         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7520         { } /* end */
7521 };
7522
7523 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7524         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7525         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7526         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7527         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7528         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7529         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7530         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7531         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7532         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7533         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7534         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7535         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7536         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7537         { } /* end */
7538 };
7539
7540 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7541         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7542         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7543         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7544         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7545         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7546         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7547         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7548         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7549         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7550         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7551         { } /* end */
7552 };
7553
7554 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7555         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7556         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7557         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7558         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7559         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7560         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7561         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7562         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7563         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7564         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7565         { } /* end */
7566 };
7567
7568 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7569         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7570         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7571         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7572         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7573         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7574         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7575         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7576         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7577         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7578         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7579         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7580         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7581         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7582         { } /* end */
7583 };
7584
7585 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7586         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7587         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7588         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7589         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7590         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7591         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7592         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7593         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7594         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7595         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7596         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7597         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7598         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7599         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7600         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7601         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7602         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7603         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7604         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7605         { } /* end */
7606 };
7607
7608 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7609         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7610         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7611         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7612         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7613         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7614                               HDA_OUTPUT),
7615         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7616         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7617         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7618         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7619         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7620         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7621         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7622         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7623         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7624         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7625         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7626         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7627         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7628         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7629         { } /* end */
7630 };
7631
7632 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7633         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7634         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7635         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7636         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7637         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7638         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7639         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7640         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7641         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7642         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7643         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7644         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7645         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7646         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7647         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7648         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7649         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7650         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7651         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7652         { } /* end */
7653 };
7654
7655 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7656         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7657         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7658         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7659         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7660         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7661         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7662         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7663         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7664         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7665         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7666         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7667         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7668         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7669         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7670         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7671         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7672         { } /* end */
7673 };
7674
7675 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7676         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7677         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7678         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7679         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7680         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7681         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7682         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7683         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7684         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7685         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7686         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7687         { } /* end */
7688 };
7689
7690 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7691         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7692         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7693         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7694         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7695         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7696         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7697         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7698         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7699         { } /* end */
7700 };
7701
7702 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7703         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7704         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7705         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7706         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7707         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7708         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7709         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7710         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7711         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7712         { } /* end */
7713 };
7714
7715 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7716         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7717         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7718         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7719         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7720         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7721         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7722         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7723         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7724         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7725         { } /* end */
7726 };
7727
7728 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7729         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7730         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7731         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7732         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7733         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7734         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7735         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7736         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7737         { } /* end */
7738 };
7739
7740 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7741         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7742         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7743         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7744         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7745         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7746                                                 0x0d, 1, 0x0, HDA_OUTPUT),
7747         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7748         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7749         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7750         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7751         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7752         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7753         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
7754         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7755         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7756         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7757         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7758         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7759         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7760         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7761         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7762         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7763         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7764         { } /* end */
7765 };
7766
7767 static struct hda_bind_ctls alc883_bind_cap_vol = {
7768         .ops = &snd_hda_bind_vol,
7769         .values = {
7770                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7771                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7772                 0
7773         },
7774 };
7775
7776 static struct hda_bind_ctls alc883_bind_cap_switch = {
7777         .ops = &snd_hda_bind_sw,
7778         .values = {
7779                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7780                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7781                 0
7782         },
7783 };
7784
7785 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
7786         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7787         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7788         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7789         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7790         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7791         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7792         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7793         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7794         { } /* end */
7795 };
7796
7797 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
7798         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
7799         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
7800         {
7801                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7802                 /* .name = "Capture Source", */
7803                 .name = "Input Source",
7804                 .count = 1,
7805                 .info = alc_mux_enum_info,
7806                 .get = alc_mux_enum_get,
7807                 .put = alc_mux_enum_put,
7808         },
7809         { } /* end */
7810 };
7811
7812 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7813         {
7814                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7815                 .name = "Channel Mode",
7816                 .info = alc_ch_mode_info,
7817                 .get = alc_ch_mode_get,
7818                 .put = alc_ch_mode_put,
7819         },
7820         { } /* end */
7821 };
7822
7823 static struct hda_verb alc883_init_verbs[] = {
7824         /* ADC1: mute amp left and right */
7825         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7826         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7827         /* ADC2: mute amp left and right */
7828         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7829         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7830         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7831         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7832         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7833         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7834         /* Rear mixer */
7835         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7836         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7837         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7838         /* CLFE mixer */
7839         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7840         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7841         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7842         /* Side mixer */
7843         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7844         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7845         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7846
7847         /* mute analog input loopbacks */
7848         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7849         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7850         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7851         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7852         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7853
7854         /* Front Pin: output 0 (0x0c) */
7855         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7856         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7857         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7858         /* Rear Pin: output 1 (0x0d) */
7859         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7860         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7861         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7862         /* CLFE Pin: output 2 (0x0e) */
7863         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7864         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7865         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7866         /* Side Pin: output 3 (0x0f) */
7867         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7868         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7869         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7870         /* Mic (rear) pin: input vref at 80% */
7871         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7872         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7873         /* Front Mic pin: input vref at 80% */
7874         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7875         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7876         /* Line In pin: input */
7877         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7878         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7879         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7880         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7881         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7882         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7883         /* CD pin widget for input */
7884         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7885
7886         /* FIXME: use matrix-type input source selection */
7887         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7888         /* Input mixer2 */
7889         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7890         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7891         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7892         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7893         /* Input mixer3 */
7894         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7895         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7896         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7897         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7898         { }
7899 };
7900
7901 /* toggle speaker-output according to the hp-jack state */
7902 static void alc883_mitac_hp_automute(struct hda_codec *codec)
7903 {
7904         unsigned int present;
7905
7906         present = snd_hda_codec_read(codec, 0x15, 0,
7907                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7908         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7909                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7910         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7911                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7912 }
7913
7914 /* auto-toggle front mic */
7915 /*
7916 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7917 {
7918         unsigned int present;
7919         unsigned char bits;
7920
7921         present = snd_hda_codec_read(codec, 0x18, 0,
7922                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7923         bits = present ? HDA_AMP_MUTE : 0;
7924         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7925 }
7926 */
7927
7928 static void alc883_mitac_automute(struct hda_codec *codec)
7929 {
7930         alc883_mitac_hp_automute(codec);
7931         /* alc883_mitac_mic_automute(codec); */
7932 }
7933
7934 static void alc883_mitac_unsol_event(struct hda_codec *codec,
7935                                            unsigned int res)
7936 {
7937         switch (res >> 26) {
7938         case ALC880_HP_EVENT:
7939                 alc883_mitac_hp_automute(codec);
7940                 break;
7941         case ALC880_MIC_EVENT:
7942                 /* alc883_mitac_mic_automute(codec); */
7943                 break;
7944         }
7945 }
7946
7947 static struct hda_verb alc883_mitac_verbs[] = {
7948         /* HP */
7949         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7950         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7951         /* Subwoofer */
7952         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7953         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7954
7955         /* enable unsolicited event */
7956         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7957         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7958
7959         { } /* end */
7960 };
7961
7962 static struct hda_verb alc883_clevo_m720_verbs[] = {
7963         /* HP */
7964         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7965         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7966         /* Int speaker */
7967         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
7968         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7969
7970         /* enable unsolicited event */
7971         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7972         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
7973
7974         { } /* end */
7975 };
7976
7977 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
7978         /* HP */
7979         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7980         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7981         /* Subwoofer */
7982         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7983         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7984
7985         /* enable unsolicited event */
7986         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7987
7988         { } /* end */
7989 };
7990
7991 static struct hda_verb alc883_tagra_verbs[] = {
7992         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7993         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7994
7995         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7996         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7997
7998         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7999         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8000         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8001
8002         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8003         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
8004         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
8005         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
8006
8007         { } /* end */
8008 };
8009
8010 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8011         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8012         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8013         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8014         { } /* end */
8015 };
8016
8017 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8018         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8019         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8020         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8021         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8022         { } /* end */
8023 };
8024
8025 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8026         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8027         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8028         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8029         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8030         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8031         { } /* end */
8032 };
8033
8034 static struct hda_verb alc883_haier_w66_verbs[] = {
8035         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8036         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8037
8038         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8039
8040         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8041         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8042         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8043         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8044         { } /* end */
8045 };
8046
8047 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8048         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8049         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8050         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8051         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8052         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8053         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8054         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8055         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8056         { } /* end */
8057 };
8058
8059 static struct hda_verb alc888_3st_hp_verbs[] = {
8060         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8061         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8062         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8063         { }
8064 };
8065
8066 static struct hda_verb alc888_6st_dell_verbs[] = {
8067         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8068         { }
8069 };
8070
8071 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8072         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8073         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8074         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8075         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8076         { }
8077 };
8078
8079 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8080         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8081         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8082         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8083         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8084         { }
8085 };
8086
8087 static struct hda_channel_mode alc888_3st_hp_modes[2] = {
8088         { 2, alc888_3st_hp_2ch_init },
8089         { 6, alc888_3st_hp_6ch_init },
8090 };
8091
8092 /* toggle front-jack and RCA according to the hp-jack state */
8093 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8094 {
8095         unsigned int present;
8096
8097         present = snd_hda_codec_read(codec, 0x1b, 0,
8098                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8099         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8100                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8101         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8102                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8103 }
8104
8105 /* toggle RCA according to the front-jack state */
8106 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8107 {
8108         unsigned int present;
8109
8110         present = snd_hda_codec_read(codec, 0x14, 0,
8111                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8112         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8113                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8114 }
8115
8116 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8117                                              unsigned int res)
8118 {
8119         if ((res >> 26) == ALC880_HP_EVENT)
8120                 alc888_lenovo_ms7195_front_automute(codec);
8121         if ((res >> 26) == ALC880_FRONT_EVENT)
8122                 alc888_lenovo_ms7195_rca_automute(codec);
8123 }
8124
8125 static struct hda_verb alc883_medion_md2_verbs[] = {
8126         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8127         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8128
8129         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8130
8131         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8132         { } /* end */
8133 };
8134
8135 /* toggle speaker-output according to the hp-jack state */
8136 static void alc883_medion_md2_automute(struct hda_codec *codec)
8137 {
8138         unsigned int present;
8139
8140         present = snd_hda_codec_read(codec, 0x14, 0,
8141                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8142         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8143                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8144 }
8145
8146 static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
8147                                           unsigned int res)
8148 {
8149         if ((res >> 26) == ALC880_HP_EVENT)
8150                 alc883_medion_md2_automute(codec);
8151 }
8152
8153 /* toggle speaker-output according to the hp-jack state */
8154 static void alc883_tagra_automute(struct hda_codec *codec)
8155 {
8156         unsigned int present;
8157         unsigned char bits;
8158
8159         present = snd_hda_codec_read(codec, 0x14, 0,
8160                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8161         bits = present ? HDA_AMP_MUTE : 0;
8162         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
8163                                  HDA_AMP_MUTE, bits);
8164         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8165                                   present ? 1 : 3);
8166 }
8167
8168 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
8169 {
8170         if ((res >> 26) == ALC880_HP_EVENT)
8171                 alc883_tagra_automute(codec);
8172 }
8173
8174 /* toggle speaker-output according to the hp-jack state */
8175 static void alc883_clevo_m720_hp_automute(struct hda_codec *codec)
8176 {
8177         unsigned int present;
8178         unsigned char bits;
8179
8180         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
8181                 & AC_PINSENSE_PRESENCE;
8182         bits = present ? HDA_AMP_MUTE : 0;
8183         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8184                                  HDA_AMP_MUTE, bits);
8185 }
8186
8187 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8188 {
8189         unsigned int present;
8190
8191         present = snd_hda_codec_read(codec, 0x18, 0,
8192                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8193         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8194                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8195 }
8196
8197 static void alc883_clevo_m720_automute(struct hda_codec *codec)
8198 {
8199         alc883_clevo_m720_hp_automute(codec);
8200         alc883_clevo_m720_mic_automute(codec);
8201 }
8202
8203 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8204                                            unsigned int res)
8205 {
8206         switch (res >> 26) {
8207         case ALC880_HP_EVENT:
8208                 alc883_clevo_m720_hp_automute(codec);
8209                 break;
8210         case ALC880_MIC_EVENT:
8211                 alc883_clevo_m720_mic_automute(codec);
8212                 break;
8213         }
8214 }
8215
8216 /* toggle speaker-output according to the hp-jack state */
8217 static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec)
8218 {
8219         unsigned int present;
8220         unsigned char bits;
8221
8222         present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
8223                 & AC_PINSENSE_PRESENCE;
8224         bits = present ? HDA_AMP_MUTE : 0;
8225         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8226                                  HDA_AMP_MUTE, bits);
8227 }
8228
8229 static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec,
8230                                                   unsigned int res)
8231 {
8232         if ((res >> 26) == ALC880_HP_EVENT)
8233                 alc883_2ch_fujitsu_pi2515_automute(codec);
8234 }
8235
8236 static void alc883_haier_w66_automute(struct hda_codec *codec)
8237 {
8238         unsigned int present;
8239         unsigned char bits;
8240
8241         present = snd_hda_codec_read(codec, 0x1b, 0,
8242                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8243         bits = present ? 0x80 : 0;
8244         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8245                                  0x80, bits);
8246 }
8247
8248 static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
8249                                          unsigned int res)
8250 {
8251         if ((res >> 26) == ALC880_HP_EVENT)
8252                 alc883_haier_w66_automute(codec);
8253 }
8254
8255 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8256 {
8257         unsigned int present;
8258         unsigned char bits;
8259
8260         present = snd_hda_codec_read(codec, 0x14, 0,
8261                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8262         bits = present ? HDA_AMP_MUTE : 0;
8263         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8264                                  HDA_AMP_MUTE, bits);
8265 }
8266
8267 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8268 {
8269         unsigned int present;
8270         unsigned char bits;
8271
8272         present = snd_hda_codec_read(codec, 0x1b, 0,
8273                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8274         bits = present ? HDA_AMP_MUTE : 0;
8275         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8276                                  HDA_AMP_MUTE, bits);
8277         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8278                                  HDA_AMP_MUTE, bits);
8279 }
8280
8281 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8282                                            unsigned int res)
8283 {
8284         if ((res >> 26) == ALC880_HP_EVENT)
8285                 alc883_lenovo_101e_all_automute(codec);
8286         if ((res >> 26) == ALC880_FRONT_EVENT)
8287                 alc883_lenovo_101e_ispeaker_automute(codec);
8288 }
8289
8290 /* toggle speaker-output according to the hp-jack state */
8291 static void alc883_acer_aspire_automute(struct hda_codec *codec)
8292 {
8293         unsigned int present;
8294
8295         present = snd_hda_codec_read(codec, 0x14, 0,
8296                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8297         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8298                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8299         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8300                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8301 }
8302
8303 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
8304                                            unsigned int res)
8305 {
8306         if ((res >> 26) == ALC880_HP_EVENT)
8307                 alc883_acer_aspire_automute(codec);
8308 }
8309
8310 static struct hda_verb alc883_acer_eapd_verbs[] = {
8311         /* HP Pin: output 0 (0x0c) */
8312         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8313         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8314         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8315         /* Front Pin: output 0 (0x0c) */
8316         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8317         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8318         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8319         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8320         /* eanable EAPD on medion laptop */
8321         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8322         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8323         /* enable unsolicited event */
8324         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8325         { }
8326 };
8327
8328 static void alc888_6st_dell_front_automute(struct hda_codec *codec)
8329 {
8330         unsigned int present;
8331
8332         present = snd_hda_codec_read(codec, 0x1b, 0,
8333                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8334         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8335                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8336         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8337                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8338         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8339                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8340         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8341                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8342 }
8343
8344 static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
8345                                              unsigned int res)
8346 {
8347         switch (res >> 26) {
8348         case ALC880_HP_EVENT:
8349                 /* printk(KERN_DEBUG "hp_event\n"); */
8350                 alc888_6st_dell_front_automute(codec);
8351                 break;
8352         }
8353 }
8354
8355 static void alc888_lenovo_sky_front_automute(struct hda_codec *codec)
8356 {
8357         unsigned int mute;
8358         unsigned int present;
8359
8360         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8361         present = snd_hda_codec_read(codec, 0x1b, 0,
8362                                      AC_VERB_GET_PIN_SENSE, 0);
8363         present = (present & 0x80000000) != 0;
8364         if (present) {
8365                 /* mute internal speaker */
8366                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8367                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8368                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8369                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8370                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8371                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8372                 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8373                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8374                 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8375                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8376         } else {
8377                 /* unmute internal speaker if necessary */
8378                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
8379                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8380                                          HDA_AMP_MUTE, mute);
8381                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8382                                          HDA_AMP_MUTE, mute);
8383                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8384                                          HDA_AMP_MUTE, mute);
8385                 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8386                                          HDA_AMP_MUTE, mute);
8387                 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8388                                          HDA_AMP_MUTE, mute);
8389         }
8390 }
8391
8392 static void alc883_lenovo_sky_unsol_event(struct hda_codec *codec,
8393                                              unsigned int res)
8394 {
8395         if ((res >> 26) == ALC880_HP_EVENT)
8396                 alc888_lenovo_sky_front_automute(codec);
8397 }
8398
8399 /*
8400  * generic initialization of ADC, input mixers and output mixers
8401  */
8402 static struct hda_verb alc883_auto_init_verbs[] = {
8403         /*
8404          * Unmute ADC0-2 and set the default input to mic-in
8405          */
8406         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8407         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8408         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8409         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8410
8411         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8412          * mixer widget
8413          * Note: PASD motherboards uses the Line In 2 as the input for
8414          * front panel mic (mic 2)
8415          */
8416         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8417         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8418         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8419         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8420         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8421         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8422
8423         /*
8424          * Set up output mixers (0x0c - 0x0f)
8425          */
8426         /* set vol=0 to output mixers */
8427         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8428         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8429         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8430         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8431         /* set up input amps for analog loopback */
8432         /* Amp Indices: DAC = 0, mixer = 1 */
8433         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8434         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8435         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8436         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8437         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8438         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8439         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8440         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8441         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8442         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8443
8444         /* FIXME: use matrix-type input source selection */
8445         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8446         /* Input mixer1 */
8447         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8448         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8449         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8450         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8451         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8452         /* Input mixer2 */
8453         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8454         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8455         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8456         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8457         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8458
8459         { }
8460 };
8461
8462 static struct hda_verb alc888_asus_m90v_verbs[] = {
8463         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8464         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8465         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8466         /* enable unsolicited event */
8467         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8468         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8469         { } /* end */
8470 };
8471
8472 static void alc883_nb_mic_automute(struct hda_codec *codec)
8473 {
8474         unsigned int present;
8475
8476         present = snd_hda_codec_read(codec, 0x18, 0,
8477                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8478         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8479                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8480         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8481                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8482 }
8483
8484 static void alc883_M90V_speaker_automute(struct hda_codec *codec)
8485 {
8486         unsigned int present;
8487         unsigned char bits;
8488
8489         present = snd_hda_codec_read(codec, 0x1b, 0,
8490                                      AC_VERB_GET_PIN_SENSE, 0)
8491                 & AC_PINSENSE_PRESENCE;
8492         bits = present ? 0 : PIN_OUT;
8493         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8494                             bits);
8495         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8496                             bits);
8497         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8498                             bits);
8499 }
8500
8501 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8502                                            unsigned int res)
8503 {
8504         switch (res >> 26) {
8505         case ALC880_HP_EVENT:
8506                 alc883_M90V_speaker_automute(codec);
8507                 break;
8508         case ALC880_MIC_EVENT:
8509                 alc883_nb_mic_automute(codec);
8510                 break;
8511         }
8512 }
8513
8514 static void alc883_mode2_inithook(struct hda_codec *codec)
8515 {
8516         alc883_M90V_speaker_automute(codec);
8517         alc883_nb_mic_automute(codec);
8518 }
8519
8520 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8521         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8522         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8523         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8524         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8525         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8526         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8527         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8528         /* enable unsolicited event */
8529         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8530         { } /* end */
8531 };
8532
8533 static void alc883_eee1601_speaker_automute(struct hda_codec *codec)
8534 {
8535         unsigned int present;
8536         unsigned char bits;
8537
8538         present = snd_hda_codec_read(codec, 0x14, 0,
8539                                      AC_VERB_GET_PIN_SENSE, 0)
8540                 & AC_PINSENSE_PRESENCE;
8541         bits = present ? 0 : PIN_OUT;
8542         snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8543                             bits);
8544 }
8545
8546 static void alc883_eee1601_unsol_event(struct hda_codec *codec,
8547                                            unsigned int res)
8548 {
8549         switch (res >> 26) {
8550         case ALC880_HP_EVENT:
8551                 alc883_eee1601_speaker_automute(codec);
8552                 break;
8553         }
8554 }
8555
8556 static void alc883_eee1601_inithook(struct hda_codec *codec)
8557 {
8558         alc883_eee1601_speaker_automute(codec);
8559 }
8560
8561 #ifdef CONFIG_SND_HDA_POWER_SAVE
8562 #define alc883_loopbacks        alc880_loopbacks
8563 #endif
8564
8565 /* pcm configuration: identiacal with ALC880 */
8566 #define alc883_pcm_analog_playback      alc880_pcm_analog_playback
8567 #define alc883_pcm_analog_capture       alc880_pcm_analog_capture
8568 #define alc883_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
8569 #define alc883_pcm_digital_playback     alc880_pcm_digital_playback
8570 #define alc883_pcm_digital_capture      alc880_pcm_digital_capture
8571
8572 /*
8573  * configuration and preset
8574  */
8575 static const char *alc883_models[ALC883_MODEL_LAST] = {
8576         [ALC883_3ST_2ch_DIG]    = "3stack-dig",
8577         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8578         [ALC883_3ST_6ch]        = "3stack-6ch",
8579         [ALC883_6ST_DIG]        = "6stack-dig",
8580         [ALC883_TARGA_DIG]      = "targa-dig",
8581         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8582         [ALC883_ACER]           = "acer",
8583         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8584         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8585         [ALC883_MEDION]         = "medion",
8586         [ALC883_MEDION_MD2]     = "medion-md2",
8587         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8588         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8589         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8590         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8591         [ALC888_LENOVO_SKY] = "lenovo-sky",
8592         [ALC883_HAIER_W66]      = "haier-w66",
8593         [ALC888_3ST_HP]         = "3stack-hp",
8594         [ALC888_6ST_DELL]       = "6stack-dell",
8595         [ALC883_MITAC]          = "mitac",
8596         [ALC883_CLEVO_M720]     = "clevo-m720",
8597         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8598         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8599         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8600         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8601         [ALC883_AUTO]           = "auto",
8602 };
8603
8604 static struct snd_pci_quirk alc883_cfg_tbl[] = {
8605         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
8606         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8607         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8608         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8609         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8610         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8611         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8612                 ALC888_ACER_ASPIRE_4930G),
8613         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8614                 ALC888_ACER_ASPIRE_4930G),
8615         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC883_AUTO),
8616         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC883_AUTO),
8617         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8618                 ALC888_ACER_ASPIRE_4930G),
8619         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8620                 ALC888_ACER_ASPIRE_4930G),
8621         /* default Acer */
8622         SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER),
8623         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8624         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8625         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8626         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8627         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8628         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8629         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8630         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8631         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8632         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8633         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8634         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8635         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
8636         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8637         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8638         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8639         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8640         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8641         SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
8642         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8643         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8644         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8645         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8646         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8647         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8648         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8649         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8650         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8651         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8652         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8653         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8654         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8655         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8656         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8657         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8658         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8659         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8660         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8661         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8662         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8663         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8664         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8665         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8666         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8667         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8668         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
8669         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8670         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8671         SND_PCI_QUIRK(0x1734, 0x1107, "FSC AMILO Xi2550",
8672                       ALC883_FUJITSU_PI2515),
8673         SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515),
8674         SND_PCI_QUIRK(0x1734, 0x113d, "Fujitsu AMILO Xa3530",
8675                 ALC888_FUJITSU_XA3530),
8676         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8677         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8678         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8679         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8680         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8681         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8682         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
8683         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8684         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8685         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8686         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8687         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
8688         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL),
8689         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8690         {}
8691 };
8692
8693 static hda_nid_t alc1200_slave_dig_outs[] = {
8694         ALC883_DIGOUT_NID, 0,
8695 };
8696
8697 static struct alc_config_preset alc883_presets[] = {
8698         [ALC883_3ST_2ch_DIG] = {
8699                 .mixers = { alc883_3ST_2ch_mixer },
8700                 .init_verbs = { alc883_init_verbs },
8701                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8702                 .dac_nids = alc883_dac_nids,
8703                 .dig_out_nid = ALC883_DIGOUT_NID,
8704                 .dig_in_nid = ALC883_DIGIN_NID,
8705                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8706                 .channel_mode = alc883_3ST_2ch_modes,
8707                 .input_mux = &alc883_capture_source,
8708         },
8709         [ALC883_3ST_6ch_DIG] = {
8710                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8711                 .init_verbs = { alc883_init_verbs },
8712                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8713                 .dac_nids = alc883_dac_nids,
8714                 .dig_out_nid = ALC883_DIGOUT_NID,
8715                 .dig_in_nid = ALC883_DIGIN_NID,
8716                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8717                 .channel_mode = alc883_3ST_6ch_modes,
8718                 .need_dac_fix = 1,
8719                 .input_mux = &alc883_capture_source,
8720         },
8721         [ALC883_3ST_6ch] = {
8722                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8723                 .init_verbs = { alc883_init_verbs },
8724                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8725                 .dac_nids = alc883_dac_nids,
8726                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8727                 .channel_mode = alc883_3ST_6ch_modes,
8728                 .need_dac_fix = 1,
8729                 .input_mux = &alc883_capture_source,
8730         },
8731         [ALC883_3ST_6ch_INTEL] = {
8732                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8733                 .init_verbs = { alc883_init_verbs },
8734                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8735                 .dac_nids = alc883_dac_nids,
8736                 .dig_out_nid = ALC883_DIGOUT_NID,
8737                 .dig_in_nid = ALC883_DIGIN_NID,
8738                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8739                 .channel_mode = alc883_3ST_6ch_intel_modes,
8740                 .need_dac_fix = 1,
8741                 .input_mux = &alc883_3stack_6ch_intel,
8742         },
8743         [ALC883_6ST_DIG] = {
8744                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8745                 .init_verbs = { alc883_init_verbs },
8746                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8747                 .dac_nids = alc883_dac_nids,
8748                 .dig_out_nid = ALC883_DIGOUT_NID,
8749                 .dig_in_nid = ALC883_DIGIN_NID,
8750                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8751                 .channel_mode = alc883_sixstack_modes,
8752                 .input_mux = &alc883_capture_source,
8753         },
8754         [ALC883_TARGA_DIG] = {
8755                 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8756                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8757                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8758                 .dac_nids = alc883_dac_nids,
8759                 .dig_out_nid = ALC883_DIGOUT_NID,
8760                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8761                 .channel_mode = alc883_3ST_6ch_modes,
8762                 .need_dac_fix = 1,
8763                 .input_mux = &alc883_capture_source,
8764                 .unsol_event = alc883_tagra_unsol_event,
8765                 .init_hook = alc883_tagra_automute,
8766         },
8767         [ALC883_TARGA_2ch_DIG] = {
8768                 .mixers = { alc883_tagra_2ch_mixer},
8769                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8770                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8771                 .dac_nids = alc883_dac_nids,
8772                 .adc_nids = alc883_adc_nids_alt,
8773                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8774                 .dig_out_nid = ALC883_DIGOUT_NID,
8775                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8776                 .channel_mode = alc883_3ST_2ch_modes,
8777                 .input_mux = &alc883_capture_source,
8778                 .unsol_event = alc883_tagra_unsol_event,
8779                 .init_hook = alc883_tagra_automute,
8780         },
8781         [ALC883_ACER] = {
8782                 .mixers = { alc883_base_mixer },
8783                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8784                  * and the headphone jack.  Turn this on and rely on the
8785                  * standard mute methods whenever the user wants to turn
8786                  * these outputs off.
8787                  */
8788                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8789                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8790                 .dac_nids = alc883_dac_nids,
8791                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8792                 .channel_mode = alc883_3ST_2ch_modes,
8793                 .input_mux = &alc883_capture_source,
8794         },
8795         [ALC883_ACER_ASPIRE] = {
8796                 .mixers = { alc883_acer_aspire_mixer },
8797                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8798                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8799                 .dac_nids = alc883_dac_nids,
8800                 .dig_out_nid = ALC883_DIGOUT_NID,
8801                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8802                 .channel_mode = alc883_3ST_2ch_modes,
8803                 .input_mux = &alc883_capture_source,
8804                 .unsol_event = alc883_acer_aspire_unsol_event,
8805                 .init_hook = alc883_acer_aspire_automute,
8806         },
8807         [ALC888_ACER_ASPIRE_4930G] = {
8808                 .mixers = { alc888_base_mixer,
8809                                 alc883_chmode_mixer },
8810                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
8811                                 alc888_acer_aspire_4930g_verbs },
8812                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8813                 .dac_nids = alc883_dac_nids,
8814                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8815                 .adc_nids = alc883_adc_nids_rev,
8816                 .capsrc_nids = alc883_capsrc_nids_rev,
8817                 .dig_out_nid = ALC883_DIGOUT_NID,
8818                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8819                 .channel_mode = alc883_3ST_6ch_modes,
8820                 .need_dac_fix = 1,
8821                 .num_mux_defs =
8822                         ARRAY_SIZE(alc888_2_capture_sources),
8823                 .input_mux = alc888_2_capture_sources,
8824                 .unsol_event = alc888_acer_aspire_4930g_unsol_event,
8825                 .init_hook = alc888_acer_aspire_4930g_automute,
8826         },
8827         [ALC883_MEDION] = {
8828                 .mixers = { alc883_fivestack_mixer,
8829                             alc883_chmode_mixer },
8830                 .init_verbs = { alc883_init_verbs,
8831                                 alc883_medion_eapd_verbs },
8832                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8833                 .dac_nids = alc883_dac_nids,
8834                 .adc_nids = alc883_adc_nids_alt,
8835                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8836                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8837                 .channel_mode = alc883_sixstack_modes,
8838                 .input_mux = &alc883_capture_source,
8839         },
8840         [ALC883_MEDION_MD2] = {
8841                 .mixers = { alc883_medion_md2_mixer},
8842                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8843                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8844                 .dac_nids = alc883_dac_nids,
8845                 .dig_out_nid = ALC883_DIGOUT_NID,
8846                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8847                 .channel_mode = alc883_3ST_2ch_modes,
8848                 .input_mux = &alc883_capture_source,
8849                 .unsol_event = alc883_medion_md2_unsol_event,
8850                 .init_hook = alc883_medion_md2_automute,
8851         },
8852         [ALC883_LAPTOP_EAPD] = {
8853                 .mixers = { alc883_base_mixer },
8854                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8855                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8856                 .dac_nids = alc883_dac_nids,
8857                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8858                 .channel_mode = alc883_3ST_2ch_modes,
8859                 .input_mux = &alc883_capture_source,
8860         },
8861         [ALC883_CLEVO_M720] = {
8862                 .mixers = { alc883_clevo_m720_mixer },
8863                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8864                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8865                 .dac_nids = alc883_dac_nids,
8866                 .dig_out_nid = ALC883_DIGOUT_NID,
8867                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8868                 .channel_mode = alc883_3ST_2ch_modes,
8869                 .input_mux = &alc883_capture_source,
8870                 .unsol_event = alc883_clevo_m720_unsol_event,
8871                 .init_hook = alc883_clevo_m720_automute,
8872         },
8873         [ALC883_LENOVO_101E_2ch] = {
8874                 .mixers = { alc883_lenovo_101e_2ch_mixer},
8875                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8876                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8877                 .dac_nids = alc883_dac_nids,
8878                 .adc_nids = alc883_adc_nids_alt,
8879                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8880                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8881                 .channel_mode = alc883_3ST_2ch_modes,
8882                 .input_mux = &alc883_lenovo_101e_capture_source,
8883                 .unsol_event = alc883_lenovo_101e_unsol_event,
8884                 .init_hook = alc883_lenovo_101e_all_automute,
8885         },
8886         [ALC883_LENOVO_NB0763] = {
8887                 .mixers = { alc883_lenovo_nb0763_mixer },
8888                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8889                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8890                 .dac_nids = alc883_dac_nids,
8891                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8892                 .channel_mode = alc883_3ST_2ch_modes,
8893                 .need_dac_fix = 1,
8894                 .input_mux = &alc883_lenovo_nb0763_capture_source,
8895                 .unsol_event = alc883_medion_md2_unsol_event,
8896                 .init_hook = alc883_medion_md2_automute,
8897         },
8898         [ALC888_LENOVO_MS7195_DIG] = {
8899                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8900                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8901                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8902                 .dac_nids = alc883_dac_nids,
8903                 .dig_out_nid = ALC883_DIGOUT_NID,
8904                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8905                 .channel_mode = alc883_3ST_6ch_modes,
8906                 .need_dac_fix = 1,
8907                 .input_mux = &alc883_capture_source,
8908                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
8909                 .init_hook = alc888_lenovo_ms7195_front_automute,
8910         },
8911         [ALC883_HAIER_W66] = {
8912                 .mixers = { alc883_tagra_2ch_mixer},
8913                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8914                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8915                 .dac_nids = alc883_dac_nids,
8916                 .dig_out_nid = ALC883_DIGOUT_NID,
8917                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8918                 .channel_mode = alc883_3ST_2ch_modes,
8919                 .input_mux = &alc883_capture_source,
8920                 .unsol_event = alc883_haier_w66_unsol_event,
8921                 .init_hook = alc883_haier_w66_automute,
8922         },
8923         [ALC888_3ST_HP] = {
8924                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8925                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
8926                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8927                 .dac_nids = alc883_dac_nids,
8928                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
8929                 .channel_mode = alc888_3st_hp_modes,
8930                 .need_dac_fix = 1,
8931                 .input_mux = &alc883_capture_source,
8932         },
8933         [ALC888_6ST_DELL] = {
8934                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8935                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
8936                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8937                 .dac_nids = alc883_dac_nids,
8938                 .dig_out_nid = ALC883_DIGOUT_NID,
8939                 .dig_in_nid = ALC883_DIGIN_NID,
8940                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8941                 .channel_mode = alc883_sixstack_modes,
8942                 .input_mux = &alc883_capture_source,
8943                 .unsol_event = alc888_6st_dell_unsol_event,
8944                 .init_hook = alc888_6st_dell_front_automute,
8945         },
8946         [ALC883_MITAC] = {
8947                 .mixers = { alc883_mitac_mixer },
8948                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
8949                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8950                 .dac_nids = alc883_dac_nids,
8951                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8952                 .channel_mode = alc883_3ST_2ch_modes,
8953                 .input_mux = &alc883_capture_source,
8954                 .unsol_event = alc883_mitac_unsol_event,
8955                 .init_hook = alc883_mitac_automute,
8956         },
8957         [ALC883_FUJITSU_PI2515] = {
8958                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
8959                 .init_verbs = { alc883_init_verbs,
8960                                 alc883_2ch_fujitsu_pi2515_verbs},
8961                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8962                 .dac_nids = alc883_dac_nids,
8963                 .dig_out_nid = ALC883_DIGOUT_NID,
8964                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8965                 .channel_mode = alc883_3ST_2ch_modes,
8966                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8967                 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
8968                 .init_hook = alc883_2ch_fujitsu_pi2515_automute,
8969         },
8970         [ALC888_FUJITSU_XA3530] = {
8971                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
8972                 .init_verbs = { alc883_init_verbs,
8973                         alc888_fujitsu_xa3530_verbs },
8974                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8975                 .dac_nids = alc883_dac_nids,
8976                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8977                 .adc_nids = alc883_adc_nids_rev,
8978                 .capsrc_nids = alc883_capsrc_nids_rev,
8979                 .dig_out_nid = ALC883_DIGOUT_NID,
8980                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
8981                 .channel_mode = alc888_4ST_8ch_intel_modes,
8982                 .num_mux_defs =
8983                         ARRAY_SIZE(alc888_2_capture_sources),
8984                 .input_mux = alc888_2_capture_sources,
8985                 .unsol_event = alc888_fujitsu_xa3530_unsol_event,
8986                 .init_hook = alc888_fujitsu_xa3530_automute,
8987         },
8988         [ALC888_LENOVO_SKY] = {
8989                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
8990                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
8991                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8992                 .dac_nids = alc883_dac_nids,
8993                 .dig_out_nid = ALC883_DIGOUT_NID,
8994                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8995                 .channel_mode = alc883_sixstack_modes,
8996                 .need_dac_fix = 1,
8997                 .input_mux = &alc883_lenovo_sky_capture_source,
8998                 .unsol_event = alc883_lenovo_sky_unsol_event,
8999                 .init_hook = alc888_lenovo_sky_front_automute,
9000         },
9001         [ALC888_ASUS_M90V] = {
9002                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9003                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9004                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9005                 .dac_nids = alc883_dac_nids,
9006                 .dig_out_nid = ALC883_DIGOUT_NID,
9007                 .dig_in_nid = ALC883_DIGIN_NID,
9008                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9009                 .channel_mode = alc883_3ST_6ch_modes,
9010                 .need_dac_fix = 1,
9011                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9012                 .unsol_event = alc883_mode2_unsol_event,
9013                 .init_hook = alc883_mode2_inithook,
9014         },
9015         [ALC888_ASUS_EEE1601] = {
9016                 .mixers = { alc883_asus_eee1601_mixer },
9017                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
9018                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9019                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9020                 .dac_nids = alc883_dac_nids,
9021                 .dig_out_nid = ALC883_DIGOUT_NID,
9022                 .dig_in_nid = ALC883_DIGIN_NID,
9023                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9024                 .channel_mode = alc883_3ST_2ch_modes,
9025                 .need_dac_fix = 1,
9026                 .input_mux = &alc883_asus_eee1601_capture_source,
9027                 .unsol_event = alc883_eee1601_unsol_event,
9028                 .init_hook = alc883_eee1601_inithook,
9029         },
9030         [ALC1200_ASUS_P5Q] = {
9031                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9032                 .init_verbs = { alc883_init_verbs },
9033                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9034                 .dac_nids = alc883_dac_nids,
9035                 .dig_out_nid = ALC1200_DIGOUT_NID,
9036                 .dig_in_nid = ALC883_DIGIN_NID,
9037                 .slave_dig_outs = alc1200_slave_dig_outs,
9038                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9039                 .channel_mode = alc883_sixstack_modes,
9040                 .input_mux = &alc883_capture_source,
9041         },
9042 };
9043
9044
9045 /*
9046  * BIOS auto configuration
9047  */
9048 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
9049                                               hda_nid_t nid, int pin_type,
9050                                               int dac_idx)
9051 {
9052         /* set as output */
9053         struct alc_spec *spec = codec->spec;
9054         int idx;
9055
9056         alc_set_pin_output(codec, nid, pin_type);
9057         if (spec->multiout.dac_nids[dac_idx] == 0x25)
9058                 idx = 4;
9059         else
9060                 idx = spec->multiout.dac_nids[dac_idx] - 2;
9061         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9062
9063 }
9064
9065 static void alc883_auto_init_multi_out(struct hda_codec *codec)
9066 {
9067         struct alc_spec *spec = codec->spec;
9068         int i;
9069
9070         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
9071         for (i = 0; i <= HDA_SIDE; i++) {
9072                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9073                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
9074                 if (nid)
9075                         alc883_auto_set_output_and_unmute(codec, nid, pin_type,
9076                                                           i);
9077         }
9078 }
9079
9080 static void alc883_auto_init_hp_out(struct hda_codec *codec)
9081 {
9082         struct alc_spec *spec = codec->spec;
9083         hda_nid_t pin;
9084
9085         pin = spec->autocfg.hp_pins[0];
9086         if (pin) /* connect to front */
9087                 /* use dac 0 */
9088                 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9089         pin = spec->autocfg.speaker_pins[0];
9090         if (pin)
9091                 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9092 }
9093
9094 #define alc883_is_input_pin(nid)        alc880_is_input_pin(nid)
9095 #define ALC883_PIN_CD_NID               ALC880_PIN_CD_NID
9096
9097 static void alc883_auto_init_analog_input(struct hda_codec *codec)
9098 {
9099         struct alc_spec *spec = codec->spec;
9100         int i;
9101
9102         for (i = 0; i < AUTO_PIN_LAST; i++) {
9103                 hda_nid_t nid = spec->autocfg.input_pins[i];
9104                 if (alc883_is_input_pin(nid)) {
9105                         alc_set_input_pin(codec, nid, i);
9106                         if (nid != ALC883_PIN_CD_NID)
9107                                 snd_hda_codec_write(codec, nid, 0,
9108                                                     AC_VERB_SET_AMP_GAIN_MUTE,
9109                                                     AMP_OUT_MUTE);
9110                 }
9111         }
9112 }
9113
9114 #define alc883_auto_init_input_src      alc882_auto_init_input_src
9115
9116 /* almost identical with ALC880 parser... */
9117 static int alc883_parse_auto_config(struct hda_codec *codec)
9118 {
9119         struct alc_spec *spec = codec->spec;
9120         int err = alc880_parse_auto_config(codec);
9121         struct auto_pin_cfg *cfg = &spec->autocfg;
9122         int i;
9123
9124         if (err < 0)
9125                 return err;
9126         else if (!err)
9127                 return 0; /* no config found */
9128
9129         err = alc_auto_add_mic_boost(codec);
9130         if (err < 0)
9131                 return err;
9132
9133         /* hack - override the init verbs */
9134         spec->init_verbs[0] = alc883_auto_init_verbs;
9135
9136         /* setup input_mux for ALC889 */
9137         if (codec->vendor_id == 0x10ec0889) {
9138                 /* digital-mic input pin is excluded in alc880_auto_create..()
9139                  * because it's under 0x18
9140                  */
9141                 if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
9142                     cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
9143                         struct hda_input_mux *imux = &spec->private_imux[0];
9144                         for (i = 1; i < 3; i++)
9145                                 memcpy(&spec->private_imux[i],
9146                                        &spec->private_imux[0],
9147                                        sizeof(spec->private_imux[0]));
9148                         imux->items[imux->num_items].label = "Int DMic";
9149                         imux->items[imux->num_items].index = 0x0b;
9150                         imux->num_items++;
9151                         spec->num_mux_defs = 3;
9152                         spec->input_mux = spec->private_imux;
9153                 }
9154         }
9155
9156         return 1; /* config found */
9157 }
9158
9159 /* additional initialization for auto-configuration model */
9160 static void alc883_auto_init(struct hda_codec *codec)
9161 {
9162         struct alc_spec *spec = codec->spec;
9163         alc883_auto_init_multi_out(codec);
9164         alc883_auto_init_hp_out(codec);
9165         alc883_auto_init_analog_input(codec);
9166         alc883_auto_init_input_src(codec);
9167         if (spec->unsol_event)
9168                 alc_inithook(codec);
9169 }
9170
9171 static int patch_alc883(struct hda_codec *codec)
9172 {
9173         struct alc_spec *spec;
9174         int err, board_config;
9175
9176         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9177         if (spec == NULL)
9178                 return -ENOMEM;
9179
9180         codec->spec = spec;
9181
9182         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9183
9184         board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
9185                                                   alc883_models,
9186                                                   alc883_cfg_tbl);
9187         if (board_config < 0) {
9188                 printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
9189                        "trying auto-probe from BIOS...\n");
9190                 board_config = ALC883_AUTO;
9191         }
9192
9193         if (board_config == ALC883_AUTO) {
9194                 /* automatic parse from the BIOS config */
9195                 err = alc883_parse_auto_config(codec);
9196                 if (err < 0) {
9197                         alc_free(codec);
9198                         return err;
9199                 } else if (!err) {
9200                         printk(KERN_INFO
9201                                "hda_codec: Cannot set up configuration "
9202                                "from BIOS.  Using base mode...\n");
9203                         board_config = ALC883_3ST_2ch_DIG;
9204                 }
9205         }
9206
9207         err = snd_hda_attach_beep_device(codec, 0x1);
9208         if (err < 0) {
9209                 alc_free(codec);
9210                 return err;
9211         }
9212
9213         if (board_config != ALC883_AUTO)
9214                 setup_preset(spec, &alc883_presets[board_config]);
9215
9216         switch (codec->vendor_id) {
9217         case 0x10ec0888:
9218                 if (codec->revision_id == 0x100101) {
9219                         spec->stream_name_analog = "ALC1200 Analog";
9220                         spec->stream_name_digital = "ALC1200 Digital";
9221                 } else {
9222                         spec->stream_name_analog = "ALC888 Analog";
9223                         spec->stream_name_digital = "ALC888 Digital";
9224                 }
9225                 if (!spec->num_adc_nids) {
9226                         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9227                         spec->adc_nids = alc883_adc_nids;
9228                 }
9229                 if (!spec->capsrc_nids)
9230                         spec->capsrc_nids = alc883_capsrc_nids;
9231                 spec->capture_style = CAPT_MIX; /* matrix-style capture */
9232                 break;
9233         case 0x10ec0889:
9234                 spec->stream_name_analog = "ALC889 Analog";
9235                 spec->stream_name_digital = "ALC889 Digital";
9236                 if (!spec->num_adc_nids) {
9237                         spec->num_adc_nids = ARRAY_SIZE(alc889_adc_nids);
9238                         spec->adc_nids = alc889_adc_nids;
9239                 }
9240                 if (!spec->capsrc_nids)
9241                         spec->capsrc_nids = alc889_capsrc_nids;
9242                 spec->capture_style = CAPT_1MUX_MIX; /* 1mux/Nmix-style
9243                                                         capture */
9244                 break;
9245         default:
9246                 spec->stream_name_analog = "ALC883 Analog";
9247                 spec->stream_name_digital = "ALC883 Digital";
9248                 if (!spec->num_adc_nids) {
9249                         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9250                         spec->adc_nids = alc883_adc_nids;
9251                 }
9252                 if (!spec->capsrc_nids)
9253                         spec->capsrc_nids = alc883_capsrc_nids;
9254                 spec->capture_style = CAPT_MIX; /* matrix-style capture */
9255                 break;
9256         }
9257
9258         spec->stream_analog_playback = &alc883_pcm_analog_playback;
9259         spec->stream_analog_capture = &alc883_pcm_analog_capture;
9260         spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
9261
9262         spec->stream_digital_playback = &alc883_pcm_digital_playback;
9263         spec->stream_digital_capture = &alc883_pcm_digital_capture;
9264
9265         if (!spec->cap_mixer)
9266                 set_capture_mixer(spec);
9267         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9268
9269         spec->vmaster_nid = 0x0c;
9270
9271         codec->patch_ops = alc_patch_ops;
9272         if (board_config == ALC883_AUTO)
9273                 spec->init_hook = alc883_auto_init;
9274
9275 #ifdef CONFIG_SND_HDA_POWER_SAVE
9276         if (!spec->loopback.amplist)
9277                 spec->loopback.amplist = alc883_loopbacks;
9278 #endif
9279         codec->proc_widget_hook = print_realtek_coef;
9280
9281         return 0;
9282 }
9283
9284 /*
9285  * ALC262 support
9286  */
9287
9288 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
9289 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
9290
9291 #define alc262_dac_nids         alc260_dac_nids
9292 #define alc262_adc_nids         alc882_adc_nids
9293 #define alc262_adc_nids_alt     alc882_adc_nids_alt
9294 #define alc262_capsrc_nids      alc882_capsrc_nids
9295 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
9296
9297 #define alc262_modes            alc260_modes
9298 #define alc262_capture_source   alc882_capture_source
9299
9300 static hda_nid_t alc262_dmic_adc_nids[1] = {
9301         /* ADC0 */
9302         0x09
9303 };
9304
9305 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
9306
9307 static struct snd_kcontrol_new alc262_base_mixer[] = {
9308         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9309         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9310         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9311         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, 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("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9315         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9316         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9317         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9318         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9319         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9320         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
9321         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9322         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9323         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
9324         { } /* end */
9325 };
9326
9327 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
9328         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9329         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9330         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9331         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9332         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9333         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9334         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9335         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9336         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9337         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9338         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9339         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9340         /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
9341         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9342         { } /* end */
9343 };
9344
9345 /* update HP, line and mono-out pins according to the master switch */
9346 static void alc262_hp_master_update(struct hda_codec *codec)
9347 {
9348         struct alc_spec *spec = codec->spec;
9349         int val = spec->master_sw;
9350
9351         /* HP & line-out */
9352         snd_hda_codec_write_cache(codec, 0x1b, 0,
9353                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9354                                   val ? PIN_HP : 0);
9355         snd_hda_codec_write_cache(codec, 0x15, 0,
9356                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9357                                   val ? PIN_HP : 0);
9358         /* mono (speaker) depending on the HP jack sense */
9359         val = val && !spec->jack_present;
9360         snd_hda_codec_write_cache(codec, 0x16, 0,
9361                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9362                                   val ? PIN_OUT : 0);
9363 }
9364
9365 static void alc262_hp_bpc_automute(struct hda_codec *codec)
9366 {
9367         struct alc_spec *spec = codec->spec;
9368         unsigned int presence;
9369         presence = snd_hda_codec_read(codec, 0x1b, 0,
9370                                       AC_VERB_GET_PIN_SENSE, 0);
9371         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9372         alc262_hp_master_update(codec);
9373 }
9374
9375 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
9376 {
9377         if ((res >> 26) != ALC880_HP_EVENT)
9378                 return;
9379         alc262_hp_bpc_automute(codec);
9380 }
9381
9382 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
9383 {
9384         struct alc_spec *spec = codec->spec;
9385         unsigned int presence;
9386         presence = snd_hda_codec_read(codec, 0x15, 0,
9387                                       AC_VERB_GET_PIN_SENSE, 0);
9388         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9389         alc262_hp_master_update(codec);
9390 }
9391
9392 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
9393                                            unsigned int res)
9394 {
9395         if ((res >> 26) != ALC880_HP_EVENT)
9396                 return;
9397         alc262_hp_wildwest_automute(codec);
9398 }
9399
9400 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
9401                                    struct snd_ctl_elem_value *ucontrol)
9402 {
9403         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9404         struct alc_spec *spec = codec->spec;
9405         *ucontrol->value.integer.value = spec->master_sw;
9406         return 0;
9407 }
9408
9409 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9410                                    struct snd_ctl_elem_value *ucontrol)
9411 {
9412         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9413         struct alc_spec *spec = codec->spec;
9414         int val = !!*ucontrol->value.integer.value;
9415
9416         if (val == spec->master_sw)
9417                 return 0;
9418         spec->master_sw = val;
9419         alc262_hp_master_update(codec);
9420         return 1;
9421 }
9422
9423 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9424         {
9425                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9426                 .name = "Master Playback Switch",
9427                 .info = snd_ctl_boolean_mono_info,
9428                 .get = alc262_hp_master_sw_get,
9429                 .put = alc262_hp_master_sw_put,
9430         },
9431         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9432         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9433         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9434         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9435                               HDA_OUTPUT),
9436         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9437                             HDA_OUTPUT),
9438         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9439         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9440         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9441         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9442         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9443         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9444         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9445         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9446         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9447         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9448         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9449         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9450         { } /* end */
9451 };
9452
9453 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9454         {
9455                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9456                 .name = "Master Playback Switch",
9457                 .info = snd_ctl_boolean_mono_info,
9458                 .get = alc262_hp_master_sw_get,
9459                 .put = alc262_hp_master_sw_put,
9460         },
9461         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9462         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9463         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9464         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9465         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9466                               HDA_OUTPUT),
9467         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9468                             HDA_OUTPUT),
9469         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9470         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9471         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9472         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9473         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9474         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9475         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9476         { } /* end */
9477 };
9478
9479 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9480         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9481         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9482         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9483         { } /* end */
9484 };
9485
9486 /* mute/unmute internal speaker according to the hp jack and mute state */
9487 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
9488 {
9489         struct alc_spec *spec = codec->spec;
9490
9491         if (force || !spec->sense_updated) {
9492                 unsigned int present;
9493                 present = snd_hda_codec_read(codec, 0x15, 0,
9494                                              AC_VERB_GET_PIN_SENSE, 0);
9495                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9496                 spec->sense_updated = 1;
9497         }
9498         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
9499                                  spec->jack_present ? HDA_AMP_MUTE : 0);
9500 }
9501
9502 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
9503                                         unsigned int res)
9504 {
9505         if ((res >> 26) != ALC880_HP_EVENT)
9506                 return;
9507         alc262_hp_t5735_automute(codec, 1);
9508 }
9509
9510 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9511 {
9512         alc262_hp_t5735_automute(codec, 1);
9513 }
9514
9515 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9516         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9517         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9518         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9519         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9520         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9521         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9522         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9523         { } /* end */
9524 };
9525
9526 static struct hda_verb alc262_hp_t5735_verbs[] = {
9527         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9528         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9529
9530         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9531         { }
9532 };
9533
9534 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9535         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9536         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9537         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9538         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9539         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9540         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9541         { } /* end */
9542 };
9543
9544 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9545         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9546         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9547         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9548         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9549         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9550         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9551         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9552         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9553         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9554         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9555         {}
9556 };
9557
9558 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9559         .num_items = 1,
9560         .items = {
9561                 { "Line", 0x1 },
9562         },
9563 };
9564
9565 /* bind hp and internal speaker mute (with plug check) */
9566 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
9567                                      struct snd_ctl_elem_value *ucontrol)
9568 {
9569         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9570         long *valp = ucontrol->value.integer.value;
9571         int change;
9572
9573         /* change hp mute */
9574         change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
9575                                           HDA_AMP_MUTE,
9576                                           valp[0] ? 0 : HDA_AMP_MUTE);
9577         change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
9578                                            HDA_AMP_MUTE,
9579                                            valp[1] ? 0 : HDA_AMP_MUTE);
9580         if (change) {
9581                 /* change speaker according to HP jack state */
9582                 struct alc_spec *spec = codec->spec;
9583                 unsigned int mute;
9584                 if (spec->jack_present)
9585                         mute = HDA_AMP_MUTE;
9586                 else
9587                         mute = snd_hda_codec_amp_read(codec, 0x15, 0,
9588                                                       HDA_OUTPUT, 0);
9589                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9590                                          HDA_AMP_MUTE, mute);
9591         }
9592         return change;
9593 }
9594
9595 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9596         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9597         {
9598                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9599                 .name = "Master Playback Switch",
9600                 .info = snd_hda_mixer_amp_switch_info,
9601                 .get = snd_hda_mixer_amp_switch_get,
9602                 .put = alc262_sony_master_sw_put,
9603                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9604         },
9605         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9606         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9607         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9608         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9609         { } /* end */
9610 };
9611
9612 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9613         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9614         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9615         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9616         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9617         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9618         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9619         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9620         { } /* end */
9621 };
9622
9623 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
9624         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9625         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9626         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
9627         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
9628         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9629         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9630         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9631         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9632         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9633         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9634         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9635         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9636         { } /* end */
9637 };
9638
9639 static struct hda_verb alc262_tyan_verbs[] = {
9640         /* Headphone automute */
9641         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9642         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9643         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9644
9645         /* P11 AUX_IN, white 4-pin connector */
9646         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9647         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
9648         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
9649         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
9650
9651         {}
9652 };
9653
9654 /* unsolicited event for HP jack sensing */
9655 static void alc262_tyan_automute(struct hda_codec *codec)
9656 {
9657         unsigned int mute;
9658         unsigned int present;
9659
9660         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9661         present = snd_hda_codec_read(codec, 0x1b, 0,
9662                                      AC_VERB_GET_PIN_SENSE, 0);
9663         present = (present & 0x80000000) != 0;
9664         if (present) {
9665                 /* mute line output on ATX panel */
9666                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9667                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9668         } else {
9669                 /* unmute line output if necessary */
9670                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9671                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9672                                          HDA_AMP_MUTE, mute);
9673         }
9674 }
9675
9676 static void alc262_tyan_unsol_event(struct hda_codec *codec,
9677                                        unsigned int res)
9678 {
9679         if ((res >> 26) != ALC880_HP_EVENT)
9680                 return;
9681         alc262_tyan_automute(codec);
9682 }
9683
9684 #define alc262_capture_mixer            alc882_capture_mixer
9685 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
9686
9687 /*
9688  * generic initialization of ADC, input mixers and output mixers
9689  */
9690 static struct hda_verb alc262_init_verbs[] = {
9691         /*
9692          * Unmute ADC0-2 and set the default input to mic-in
9693          */
9694         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9695         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9696         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9697         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9698         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9699         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9700
9701         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9702          * mixer widget
9703          * Note: PASD motherboards uses the Line In 2 as the input for
9704          * front panel mic (mic 2)
9705          */
9706         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9707         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9708         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9709         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9710         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9711         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9712
9713         /*
9714          * Set up output mixers (0x0c - 0x0e)
9715          */
9716         /* set vol=0 to output mixers */
9717         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9718         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9719         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9720         /* set up input amps for analog loopback */
9721         /* Amp Indices: DAC = 0, mixer = 1 */
9722         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9723         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9724         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9725         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9726         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9727         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9728
9729         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9730         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9731         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9732         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9733         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9734         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9735
9736         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9737         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9738         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9739         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9740         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9741
9742         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9743         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9744
9745         /* FIXME: use matrix-type input source selection */
9746         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9747         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9748         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9749         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9750         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9751         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9752         /* Input mixer2 */
9753         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9754         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9755         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9756         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9757         /* Input mixer3 */
9758         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9759         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9760         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9761         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9762
9763         { }
9764 };
9765
9766 static struct hda_verb alc262_eapd_verbs[] = {
9767         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9768         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9769         { }
9770 };
9771
9772 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9773         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9774         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9775         {}
9776 };
9777
9778 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9779         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9780         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9781         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9782
9783         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9784         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9785         {}
9786 };
9787
9788 static struct hda_verb alc262_sony_unsol_verbs[] = {
9789         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9790         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9791         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
9792
9793         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9794         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9795         {}
9796 };
9797
9798 static struct hda_input_mux alc262_dmic_capture_source = {
9799         .num_items = 2,
9800         .items = {
9801                 { "Int DMic", 0x9 },
9802                 { "Mic", 0x0 },
9803         },
9804 };
9805
9806 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
9807         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9808         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9809         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9810         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9811         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9812         { } /* end */
9813 };
9814
9815 static struct hda_verb alc262_toshiba_s06_verbs[] = {
9816         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9817         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9818         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9819         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9820         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
9821         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9822         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
9823         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9824         {}
9825 };
9826
9827 static void alc262_dmic_automute(struct hda_codec *codec)
9828 {
9829         unsigned int present;
9830
9831         present = snd_hda_codec_read(codec, 0x18, 0,
9832                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9833         snd_hda_codec_write(codec, 0x22, 0,
9834                                 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
9835 }
9836
9837 /* toggle speaker-output according to the hp-jack state */
9838 static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec)
9839 {
9840         unsigned int present;
9841         unsigned char bits;
9842
9843         present = snd_hda_codec_read(codec, 0x15, 0,
9844                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9845         bits = present ? 0 : PIN_OUT;
9846         snd_hda_codec_write(codec, 0x14, 0,
9847                                         AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
9848 }
9849
9850
9851
9852 /* unsolicited event for HP jack sensing */
9853 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
9854                                        unsigned int res)
9855 {
9856         if ((res >> 26) == ALC880_HP_EVENT)
9857                 alc262_toshiba_s06_speaker_automute(codec);
9858         if ((res >> 26) == ALC880_MIC_EVENT)
9859                 alc262_dmic_automute(codec);
9860
9861 }
9862
9863 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
9864 {
9865         alc262_toshiba_s06_speaker_automute(codec);
9866         alc262_dmic_automute(codec);
9867 }
9868
9869 /* mute/unmute internal speaker according to the hp jack and mute state */
9870 static void alc262_hippo_automute(struct hda_codec *codec)
9871 {
9872         struct alc_spec *spec = codec->spec;
9873         unsigned int mute;
9874         unsigned int present;
9875
9876         /* need to execute and sync at first */
9877         snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9878         present = snd_hda_codec_read(codec, 0x15, 0,
9879                                      AC_VERB_GET_PIN_SENSE, 0);
9880         spec->jack_present = (present & 0x80000000) != 0;
9881         if (spec->jack_present) {
9882                 /* mute internal speaker */
9883                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9884                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9885         } else {
9886                 /* unmute internal speaker if necessary */
9887                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
9888                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9889                                          HDA_AMP_MUTE, mute);
9890         }
9891 }
9892
9893 /* unsolicited event for HP jack sensing */
9894 static void alc262_hippo_unsol_event(struct hda_codec *codec,
9895                                        unsigned int res)
9896 {
9897         if ((res >> 26) != ALC880_HP_EVENT)
9898                 return;
9899         alc262_hippo_automute(codec);
9900 }
9901
9902 static void alc262_hippo1_automute(struct hda_codec *codec)
9903 {
9904         unsigned int mute;
9905         unsigned int present;
9906
9907         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9908         present = snd_hda_codec_read(codec, 0x1b, 0,
9909                                      AC_VERB_GET_PIN_SENSE, 0);
9910         present = (present & 0x80000000) != 0;
9911         if (present) {
9912                 /* mute internal speaker */
9913                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9914                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9915         } else {
9916                 /* unmute internal speaker if necessary */
9917                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9918                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9919                                          HDA_AMP_MUTE, mute);
9920         }
9921 }
9922
9923 /* unsolicited event for HP jack sensing */
9924 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
9925                                        unsigned int res)
9926 {
9927         if ((res >> 26) != ALC880_HP_EVENT)
9928                 return;
9929         alc262_hippo1_automute(codec);
9930 }
9931
9932 /*
9933  * nec model
9934  *  0x15 = headphone
9935  *  0x16 = internal speaker
9936  *  0x18 = external mic
9937  */
9938
9939 static struct snd_kcontrol_new alc262_nec_mixer[] = {
9940         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9941         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
9942
9943         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9944         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9945         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9946
9947         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9948         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9949         { } /* end */
9950 };
9951
9952 static struct hda_verb alc262_nec_verbs[] = {
9953         /* Unmute Speaker */
9954         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9955
9956         /* Headphone */
9957         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9958         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9959
9960         /* External mic to headphone */
9961         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9962         /* External mic to speaker */
9963         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9964         {}
9965 };
9966
9967 /*
9968  * fujitsu model
9969  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
9970  *  0x1b = port replicator headphone out
9971  */
9972
9973 #define ALC_HP_EVENT    0x37
9974
9975 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
9976         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9977         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9978         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9979         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9980         {}
9981 };
9982
9983 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
9984         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9985         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9986         {}
9987 };
9988
9989 static struct hda_input_mux alc262_fujitsu_capture_source = {
9990         .num_items = 3,
9991         .items = {
9992                 { "Mic", 0x0 },
9993                 { "Int Mic", 0x1 },
9994                 { "CD", 0x4 },
9995         },
9996 };
9997
9998 static struct hda_input_mux alc262_HP_capture_source = {
9999         .num_items = 5,
10000         .items = {
10001                 { "Mic", 0x0 },
10002                 { "Front Mic", 0x1 },
10003                 { "Line", 0x2 },
10004                 { "CD", 0x4 },
10005                 { "AUX IN", 0x6 },
10006         },
10007 };
10008
10009 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10010         .num_items = 4,
10011         .items = {
10012                 { "Mic", 0x0 },
10013                 { "Front Mic", 0x2 },
10014                 { "Line", 0x1 },
10015                 { "CD", 0x4 },
10016         },
10017 };
10018
10019 /* mute/unmute internal speaker according to the hp jacks and mute state */
10020 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10021 {
10022         struct alc_spec *spec = codec->spec;
10023         unsigned int mute;
10024
10025         if (force || !spec->sense_updated) {
10026                 unsigned int present;
10027                 /* need to execute and sync at first */
10028                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
10029                 /* check laptop HP jack */
10030                 present = snd_hda_codec_read(codec, 0x14, 0,
10031                                              AC_VERB_GET_PIN_SENSE, 0);
10032                 /* need to execute and sync at first */
10033                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10034                 /* check docking HP jack */
10035                 present |= snd_hda_codec_read(codec, 0x1b, 0,
10036                                               AC_VERB_GET_PIN_SENSE, 0);
10037                 if (present & AC_PINSENSE_PRESENCE)
10038                         spec->jack_present = 1;
10039                 else
10040                         spec->jack_present = 0;
10041                 spec->sense_updated = 1;
10042         }
10043         /* unmute internal speaker only if both HPs are unplugged and
10044          * master switch is on
10045          */
10046         if (spec->jack_present)
10047                 mute = HDA_AMP_MUTE;
10048         else
10049                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10050         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10051                                  HDA_AMP_MUTE, mute);
10052 }
10053
10054 /* unsolicited event for HP jack sensing */
10055 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10056                                        unsigned int res)
10057 {
10058         if ((res >> 26) != ALC_HP_EVENT)
10059                 return;
10060         alc262_fujitsu_automute(codec, 1);
10061 }
10062
10063 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10064 {
10065         alc262_fujitsu_automute(codec, 1);
10066 }
10067
10068 /* bind volumes of both NID 0x0c and 0x0d */
10069 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10070         .ops = &snd_hda_bind_vol,
10071         .values = {
10072                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10073                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10074                 0
10075         },
10076 };
10077
10078 /* mute/unmute internal speaker according to the hp jack and mute state */
10079 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10080 {
10081         struct alc_spec *spec = codec->spec;
10082         unsigned int mute;
10083
10084         if (force || !spec->sense_updated) {
10085                 unsigned int present_int_hp;
10086                 /* need to execute and sync at first */
10087                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10088                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
10089                                         AC_VERB_GET_PIN_SENSE, 0);
10090                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
10091                 spec->sense_updated = 1;
10092         }
10093         if (spec->jack_present) {
10094                 /* mute internal speaker */
10095                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10096                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10097                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10098                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10099         } else {
10100                 /* unmute internal speaker if necessary */
10101                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10102                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10103                                          HDA_AMP_MUTE, mute);
10104                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10105                                          HDA_AMP_MUTE, mute);
10106         }
10107 }
10108
10109 /* unsolicited event for HP jack sensing */
10110 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10111                                        unsigned int res)
10112 {
10113         if ((res >> 26) != ALC_HP_EVENT)
10114                 return;
10115         alc262_lenovo_3000_automute(codec, 1);
10116 }
10117
10118 /* bind hp and internal speaker mute (with plug check) */
10119 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10120                                          struct snd_ctl_elem_value *ucontrol)
10121 {
10122         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10123         long *valp = ucontrol->value.integer.value;
10124         int change;
10125
10126         change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10127                                                  HDA_AMP_MUTE,
10128                                                  valp ? 0 : HDA_AMP_MUTE);
10129         change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10130                                                  HDA_AMP_MUTE,
10131                                                  valp ? 0 : HDA_AMP_MUTE);
10132
10133         if (change)
10134                 alc262_fujitsu_automute(codec, 0);
10135         return change;
10136 }
10137
10138 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10139         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10140         {
10141                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10142                 .name = "Master Playback Switch",
10143                 .info = snd_hda_mixer_amp_switch_info,
10144                 .get = snd_hda_mixer_amp_switch_get,
10145                 .put = alc262_fujitsu_master_sw_put,
10146                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10147         },
10148         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10149         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10150         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10151         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10152         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10153         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10154         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10155         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10156         { } /* end */
10157 };
10158
10159 /* bind hp and internal speaker mute (with plug check) */
10160 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10161                                          struct snd_ctl_elem_value *ucontrol)
10162 {
10163         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10164         long *valp = ucontrol->value.integer.value;
10165         int change;
10166
10167         change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10168                                                  HDA_AMP_MUTE,
10169                                                  valp ? 0 : HDA_AMP_MUTE);
10170
10171         if (change)
10172                 alc262_lenovo_3000_automute(codec, 0);
10173         return change;
10174 }
10175
10176 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10177         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10178         {
10179                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10180                 .name = "Master Playback Switch",
10181                 .info = snd_hda_mixer_amp_switch_info,
10182                 .get = snd_hda_mixer_amp_switch_get,
10183                 .put = alc262_lenovo_3000_master_sw_put,
10184                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10185         },
10186         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10187         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10188         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10189         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10190         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10191         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10192         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10193         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10194         { } /* end */
10195 };
10196
10197 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10198         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10199         {
10200                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10201                 .name = "Master Playback Switch",
10202                 .info = snd_hda_mixer_amp_switch_info,
10203                 .get = snd_hda_mixer_amp_switch_get,
10204                 .put = alc262_sony_master_sw_put,
10205                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
10206         },
10207         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10208         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10209         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10210         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10211         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10212         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10213         { } /* end */
10214 };
10215
10216 /* additional init verbs for Benq laptops */
10217 static struct hda_verb alc262_EAPD_verbs[] = {
10218         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10219         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10220         {}
10221 };
10222
10223 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10224         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10225         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10226
10227         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10228         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10229         {}
10230 };
10231
10232 /* Samsung Q1 Ultra Vista model setup */
10233 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10234         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10235         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10236         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10237         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10238         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10239         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10240         { } /* end */
10241 };
10242
10243 static struct hda_verb alc262_ultra_verbs[] = {
10244         /* output mixer */
10245         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10246         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10247         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10248         /* speaker */
10249         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10250         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10251         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10252         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10253         /* HP */
10254         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10255         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10256         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10257         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10258         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10259         /* internal mic */
10260         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10261         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10262         /* ADC, choose mic */
10263         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10264         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10265         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10266         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10267         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10268         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10269         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10270         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10271         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10272         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
10273         {}
10274 };
10275
10276 /* mute/unmute internal speaker according to the hp jack and mute state */
10277 static void alc262_ultra_automute(struct hda_codec *codec)
10278 {
10279         struct alc_spec *spec = codec->spec;
10280         unsigned int mute;
10281
10282         mute = 0;
10283         /* auto-mute only when HP is used as HP */
10284         if (!spec->cur_mux[0]) {
10285                 unsigned int present;
10286                 /* need to execute and sync at first */
10287                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
10288                 present = snd_hda_codec_read(codec, 0x15, 0,
10289                                              AC_VERB_GET_PIN_SENSE, 0);
10290                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
10291                 if (spec->jack_present)
10292                         mute = HDA_AMP_MUTE;
10293         }
10294         /* mute/unmute internal speaker */
10295         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10296                                  HDA_AMP_MUTE, mute);
10297         /* mute/unmute HP */
10298         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10299                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
10300 }
10301
10302 /* unsolicited event for HP jack sensing */
10303 static void alc262_ultra_unsol_event(struct hda_codec *codec,
10304                                        unsigned int res)
10305 {
10306         if ((res >> 26) != ALC880_HP_EVENT)
10307                 return;
10308         alc262_ultra_automute(codec);
10309 }
10310
10311 static struct hda_input_mux alc262_ultra_capture_source = {
10312         .num_items = 2,
10313         .items = {
10314                 { "Mic", 0x1 },
10315                 { "Headphone", 0x7 },
10316         },
10317 };
10318
10319 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
10320                                      struct snd_ctl_elem_value *ucontrol)
10321 {
10322         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10323         struct alc_spec *spec = codec->spec;
10324         int ret;
10325
10326         ret = alc_mux_enum_put(kcontrol, ucontrol);
10327         if (!ret)
10328                 return 0;
10329         /* reprogram the HP pin as mic or HP according to the input source */
10330         snd_hda_codec_write_cache(codec, 0x15, 0,
10331                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10332                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
10333         alc262_ultra_automute(codec); /* mute/unmute HP */
10334         return ret;
10335 }
10336
10337 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
10338         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10339         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10340         {
10341                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10342                 .name = "Capture Source",
10343                 .info = alc_mux_enum_info,
10344                 .get = alc_mux_enum_get,
10345                 .put = alc262_ultra_mux_enum_put,
10346         },
10347         { } /* end */
10348 };
10349
10350 /* add playback controls from the parsed DAC table */
10351 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
10352                                              const struct auto_pin_cfg *cfg)
10353 {
10354         hda_nid_t nid;
10355         int err;
10356
10357         spec->multiout.num_dacs = 1;    /* only use one dac */
10358         spec->multiout.dac_nids = spec->private_dac_nids;
10359         spec->multiout.dac_nids[0] = 2;
10360
10361         nid = cfg->line_out_pins[0];
10362         if (nid) {
10363                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10364                                   "Front Playback Volume",
10365                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
10366                 if (err < 0)
10367                         return err;
10368                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10369                                   "Front Playback Switch",
10370                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10371                 if (err < 0)
10372                         return err;
10373         }
10374
10375         nid = cfg->speaker_pins[0];
10376         if (nid) {
10377                 if (nid == 0x16) {
10378                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10379                                           "Speaker Playback Volume",
10380                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10381                                                               HDA_OUTPUT));
10382                         if (err < 0)
10383                                 return err;
10384                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10385                                           "Speaker Playback Switch",
10386                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10387                                                               HDA_OUTPUT));
10388                         if (err < 0)
10389                                 return err;
10390                 } else {
10391                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10392                                           "Speaker Playback Switch",
10393                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10394                                                               HDA_OUTPUT));
10395                         if (err < 0)
10396                                 return err;
10397                 }
10398         }
10399         nid = cfg->hp_pins[0];
10400         if (nid) {
10401                 /* spec->multiout.hp_nid = 2; */
10402                 if (nid == 0x16) {
10403                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10404                                           "Headphone Playback Volume",
10405                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10406                                                               HDA_OUTPUT));
10407                         if (err < 0)
10408                                 return err;
10409                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10410                                           "Headphone Playback Switch",
10411                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10412                                                               HDA_OUTPUT));
10413                         if (err < 0)
10414                                 return err;
10415                 } else {
10416                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10417                                           "Headphone Playback Switch",
10418                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10419                                                               HDA_OUTPUT));
10420                         if (err < 0)
10421                                 return err;
10422                 }
10423         }
10424         return 0;
10425 }
10426
10427 /* identical with ALC880 */
10428 #define alc262_auto_create_analog_input_ctls \
10429         alc880_auto_create_analog_input_ctls
10430
10431 /*
10432  * generic initialization of ADC, input mixers and output mixers
10433  */
10434 static struct hda_verb alc262_volume_init_verbs[] = {
10435         /*
10436          * Unmute ADC0-2 and set the default input to mic-in
10437          */
10438         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10439         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10440         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10441         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10442         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10443         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10444
10445         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10446          * mixer widget
10447          * Note: PASD motherboards uses the Line In 2 as the input for
10448          * front panel mic (mic 2)
10449          */
10450         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10451         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10452         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10453         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10454         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10455         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10456
10457         /*
10458          * Set up output mixers (0x0c - 0x0f)
10459          */
10460         /* set vol=0 to output mixers */
10461         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10462         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10463         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10464
10465         /* set up input amps for analog loopback */
10466         /* Amp Indices: DAC = 0, mixer = 1 */
10467         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10468         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10469         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10470         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10471         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10472         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10473
10474         /* FIXME: use matrix-type input source selection */
10475         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10476         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10477         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10478         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10479         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10480         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10481         /* Input mixer2 */
10482         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10483         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10484         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10485         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10486         /* Input mixer3 */
10487         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10488         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10489         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10490         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10491
10492         { }
10493 };
10494
10495 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10496         /*
10497          * Unmute ADC0-2 and set the default input to mic-in
10498          */
10499         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10500         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10501         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10502         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10503         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10504         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10505
10506         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10507          * mixer widget
10508          * Note: PASD motherboards uses the Line In 2 as the input for
10509          * front panel mic (mic 2)
10510          */
10511         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10512         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10513         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10514         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10515         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10516         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10517         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10518         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10519
10520         /*
10521          * Set up output mixers (0x0c - 0x0e)
10522          */
10523         /* set vol=0 to output mixers */
10524         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10525         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10526         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10527
10528         /* set up input amps for analog loopback */
10529         /* Amp Indices: DAC = 0, mixer = 1 */
10530         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10531         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10532         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10533         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10534         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10535         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10536
10537         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10538         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10539         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10540
10541         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10542         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10543
10544         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10545         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10546
10547         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10548         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10549         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10550         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10551         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10552
10553         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10554         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10555         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10556         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10557         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10558         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10559
10560
10561         /* FIXME: use matrix-type input source selection */
10562         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10563         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10564         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10565         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10566         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10567         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10568         /* Input mixer2 */
10569         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10570         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10571         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10572         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10573         /* Input mixer3 */
10574         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10575         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10576         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10577         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10578
10579         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10580
10581         { }
10582 };
10583
10584 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10585         /*
10586          * Unmute ADC0-2 and set the default input to mic-in
10587          */
10588         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10589         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10590         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10591         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10592         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10593         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10594
10595         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10596          * mixer widget
10597          * Note: PASD motherboards uses the Line In 2 as the input for front
10598          * panel mic (mic 2)
10599          */
10600         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10601         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10602         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10603         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10604         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10605         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10606         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10607         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10608         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10609         /*
10610          * Set up output mixers (0x0c - 0x0e)
10611          */
10612         /* set vol=0 to output mixers */
10613         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10614         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10615         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10616
10617         /* set up input amps for analog loopback */
10618         /* Amp Indices: DAC = 0, mixer = 1 */
10619         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10620         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10621         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10622         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10623         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10624         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10625
10626
10627         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
10628         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
10629         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
10630         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
10631         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10632         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
10633         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
10634
10635         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10636         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10637
10638         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10639         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10640
10641         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10642         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10643         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10644         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10645         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10646         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10647
10648         /* FIXME: use matrix-type input source selection */
10649         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10650         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10651         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10652         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10653         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10654         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10655         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10656         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
10657         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10658         /* Input mixer2 */
10659         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10660         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10661         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10662         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10663         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10664         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10665         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10666         /* Input mixer3 */
10667         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10668         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10669         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10670         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10671         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10672         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10673         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10674
10675         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10676
10677         { }
10678 };
10679
10680 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10681
10682         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
10683         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10684         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10685
10686         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
10687         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10688         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10689         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10690
10691         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
10692         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10693         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10694         {}
10695 };
10696
10697
10698 #ifdef CONFIG_SND_HDA_POWER_SAVE
10699 #define alc262_loopbacks        alc880_loopbacks
10700 #endif
10701
10702 /* pcm configuration: identiacal with ALC880 */
10703 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
10704 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
10705 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
10706 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
10707
10708 /*
10709  * BIOS auto configuration
10710  */
10711 static int alc262_parse_auto_config(struct hda_codec *codec)
10712 {
10713         struct alc_spec *spec = codec->spec;
10714         int err;
10715         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10716
10717         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10718                                            alc262_ignore);
10719         if (err < 0)
10720                 return err;
10721         if (!spec->autocfg.line_outs) {
10722                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
10723                         spec->multiout.max_channels = 2;
10724                         spec->no_analog = 1;
10725                         goto dig_only;
10726                 }
10727                 return 0; /* can't find valid BIOS pin config */
10728         }
10729         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10730         if (err < 0)
10731                 return err;
10732         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10733         if (err < 0)
10734                 return err;
10735
10736         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10737
10738  dig_only:
10739         if (spec->autocfg.dig_outs) {
10740                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10741                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
10742         }
10743         if (spec->autocfg.dig_in_pin)
10744                 spec->dig_in_nid = ALC262_DIGIN_NID;
10745
10746         if (spec->kctls.list)
10747                 add_mixer(spec, spec->kctls.list);
10748
10749         add_verb(spec, alc262_volume_init_verbs);
10750         spec->num_mux_defs = 1;
10751         spec->input_mux = &spec->private_imux[0];
10752
10753         err = alc_auto_add_mic_boost(codec);
10754         if (err < 0)
10755                 return err;
10756
10757         return 1;
10758 }
10759
10760 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
10761 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
10762 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
10763 #define alc262_auto_init_input_src      alc882_auto_init_input_src
10764
10765
10766 /* init callback for auto-configuration model -- overriding the default init */
10767 static void alc262_auto_init(struct hda_codec *codec)
10768 {
10769         struct alc_spec *spec = codec->spec;
10770         alc262_auto_init_multi_out(codec);
10771         alc262_auto_init_hp_out(codec);
10772         alc262_auto_init_analog_input(codec);
10773         alc262_auto_init_input_src(codec);
10774         if (spec->unsol_event)
10775                 alc_inithook(codec);
10776 }
10777
10778 /*
10779  * configuration and preset
10780  */
10781 static const char *alc262_models[ALC262_MODEL_LAST] = {
10782         [ALC262_BASIC]          = "basic",
10783         [ALC262_HIPPO]          = "hippo",
10784         [ALC262_HIPPO_1]        = "hippo_1",
10785         [ALC262_FUJITSU]        = "fujitsu",
10786         [ALC262_HP_BPC]         = "hp-bpc",
10787         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10788         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
10789         [ALC262_HP_RP5700]      = "hp-rp5700",
10790         [ALC262_BENQ_ED8]       = "benq",
10791         [ALC262_BENQ_T31]       = "benq-t31",
10792         [ALC262_SONY_ASSAMD]    = "sony-assamd",
10793         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
10794         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
10795         [ALC262_ULTRA]          = "ultra",
10796         [ALC262_LENOVO_3000]    = "lenovo-3000",
10797         [ALC262_NEC]            = "nec",
10798         [ALC262_TYAN]           = "tyan",
10799         [ALC262_AUTO]           = "auto",
10800 };
10801
10802 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10803         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10804         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10805         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
10806                            ALC262_HP_BPC),
10807         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
10808                            ALC262_HP_BPC),
10809         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
10810                            ALC262_HP_BPC),
10811         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10812         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10813         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10814         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10815         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10816         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10817         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10818         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10819         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10820         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10821         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10822         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10823                       ALC262_HP_TC_T5735),
10824         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10825         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10826         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10827         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10828         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
10829         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
10830                            ALC262_SONY_ASSAMD),
10831         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10832                       ALC262_TOSHIBA_RX1),
10833         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
10834         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10835         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10836         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
10837         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
10838                            ALC262_ULTRA),
10839         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
10840         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10841         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10842         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10843         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
10844         {}
10845 };
10846
10847 static struct alc_config_preset alc262_presets[] = {
10848         [ALC262_BASIC] = {
10849                 .mixers = { alc262_base_mixer },
10850                 .init_verbs = { alc262_init_verbs },
10851                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10852                 .dac_nids = alc262_dac_nids,
10853                 .hp_nid = 0x03,
10854                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10855                 .channel_mode = alc262_modes,
10856                 .input_mux = &alc262_capture_source,
10857         },
10858         [ALC262_HIPPO] = {
10859                 .mixers = { alc262_base_mixer },
10860                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
10861                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10862                 .dac_nids = alc262_dac_nids,
10863                 .hp_nid = 0x03,
10864                 .dig_out_nid = ALC262_DIGOUT_NID,
10865                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10866                 .channel_mode = alc262_modes,
10867                 .input_mux = &alc262_capture_source,
10868                 .unsol_event = alc262_hippo_unsol_event,
10869                 .init_hook = alc262_hippo_automute,
10870         },
10871         [ALC262_HIPPO_1] = {
10872                 .mixers = { alc262_hippo1_mixer },
10873                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
10874                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10875                 .dac_nids = alc262_dac_nids,
10876                 .hp_nid = 0x02,
10877                 .dig_out_nid = ALC262_DIGOUT_NID,
10878                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10879                 .channel_mode = alc262_modes,
10880                 .input_mux = &alc262_capture_source,
10881                 .unsol_event = alc262_hippo1_unsol_event,
10882                 .init_hook = alc262_hippo1_automute,
10883         },
10884         [ALC262_FUJITSU] = {
10885                 .mixers = { alc262_fujitsu_mixer },
10886                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10887                                 alc262_fujitsu_unsol_verbs },
10888                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10889                 .dac_nids = alc262_dac_nids,
10890                 .hp_nid = 0x03,
10891                 .dig_out_nid = ALC262_DIGOUT_NID,
10892                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10893                 .channel_mode = alc262_modes,
10894                 .input_mux = &alc262_fujitsu_capture_source,
10895                 .unsol_event = alc262_fujitsu_unsol_event,
10896                 .init_hook = alc262_fujitsu_init_hook,
10897         },
10898         [ALC262_HP_BPC] = {
10899                 .mixers = { alc262_HP_BPC_mixer },
10900                 .init_verbs = { alc262_HP_BPC_init_verbs },
10901                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10902                 .dac_nids = alc262_dac_nids,
10903                 .hp_nid = 0x03,
10904                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10905                 .channel_mode = alc262_modes,
10906                 .input_mux = &alc262_HP_capture_source,
10907                 .unsol_event = alc262_hp_bpc_unsol_event,
10908                 .init_hook = alc262_hp_bpc_automute,
10909         },
10910         [ALC262_HP_BPC_D7000_WF] = {
10911                 .mixers = { alc262_HP_BPC_WildWest_mixer },
10912                 .init_verbs = { alc262_HP_BPC_WildWest_init_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_HP_D7000_capture_source,
10919                 .unsol_event = alc262_hp_wildwest_unsol_event,
10920                 .init_hook = alc262_hp_wildwest_automute,
10921         },
10922         [ALC262_HP_BPC_D7000_WL] = {
10923                 .mixers = { alc262_HP_BPC_WildWest_mixer,
10924                             alc262_HP_BPC_WildWest_option_mixer },
10925                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10926                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10927                 .dac_nids = alc262_dac_nids,
10928                 .hp_nid = 0x03,
10929                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10930                 .channel_mode = alc262_modes,
10931                 .input_mux = &alc262_HP_D7000_capture_source,
10932                 .unsol_event = alc262_hp_wildwest_unsol_event,
10933                 .init_hook = alc262_hp_wildwest_automute,
10934         },
10935         [ALC262_HP_TC_T5735] = {
10936                 .mixers = { alc262_hp_t5735_mixer },
10937                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
10938                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10939                 .dac_nids = alc262_dac_nids,
10940                 .hp_nid = 0x03,
10941                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10942                 .channel_mode = alc262_modes,
10943                 .input_mux = &alc262_capture_source,
10944                 .unsol_event = alc262_hp_t5735_unsol_event,
10945                 .init_hook = alc262_hp_t5735_init_hook,
10946         },
10947         [ALC262_HP_RP5700] = {
10948                 .mixers = { alc262_hp_rp5700_mixer },
10949                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
10950                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10951                 .dac_nids = alc262_dac_nids,
10952                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10953                 .channel_mode = alc262_modes,
10954                 .input_mux = &alc262_hp_rp5700_capture_source,
10955         },
10956         [ALC262_BENQ_ED8] = {
10957                 .mixers = { alc262_base_mixer },
10958                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
10959                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10960                 .dac_nids = alc262_dac_nids,
10961                 .hp_nid = 0x03,
10962                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10963                 .channel_mode = alc262_modes,
10964                 .input_mux = &alc262_capture_source,
10965         },
10966         [ALC262_SONY_ASSAMD] = {
10967                 .mixers = { alc262_sony_mixer },
10968                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
10969                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10970                 .dac_nids = alc262_dac_nids,
10971                 .hp_nid = 0x02,
10972                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10973                 .channel_mode = alc262_modes,
10974                 .input_mux = &alc262_capture_source,
10975                 .unsol_event = alc262_hippo_unsol_event,
10976                 .init_hook = alc262_hippo_automute,
10977         },
10978         [ALC262_BENQ_T31] = {
10979                 .mixers = { alc262_benq_t31_mixer },
10980                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
10981                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10982                 .dac_nids = alc262_dac_nids,
10983                 .hp_nid = 0x03,
10984                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10985                 .channel_mode = alc262_modes,
10986                 .input_mux = &alc262_capture_source,
10987                 .unsol_event = alc262_hippo_unsol_event,
10988                 .init_hook = alc262_hippo_automute,
10989         },
10990         [ALC262_ULTRA] = {
10991                 .mixers = { alc262_ultra_mixer },
10992                 .cap_mixer = alc262_ultra_capture_mixer,
10993                 .init_verbs = { alc262_ultra_verbs },
10994                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10995                 .dac_nids = alc262_dac_nids,
10996                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10997                 .channel_mode = alc262_modes,
10998                 .input_mux = &alc262_ultra_capture_source,
10999                 .adc_nids = alc262_adc_nids, /* ADC0 */
11000                 .capsrc_nids = alc262_capsrc_nids,
11001                 .num_adc_nids = 1, /* single ADC */
11002                 .unsol_event = alc262_ultra_unsol_event,
11003                 .init_hook = alc262_ultra_automute,
11004         },
11005         [ALC262_LENOVO_3000] = {
11006                 .mixers = { alc262_lenovo_3000_mixer },
11007                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11008                                 alc262_lenovo_3000_unsol_verbs },
11009                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11010                 .dac_nids = alc262_dac_nids,
11011                 .hp_nid = 0x03,
11012                 .dig_out_nid = ALC262_DIGOUT_NID,
11013                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11014                 .channel_mode = alc262_modes,
11015                 .input_mux = &alc262_fujitsu_capture_source,
11016                 .unsol_event = alc262_lenovo_3000_unsol_event,
11017         },
11018         [ALC262_NEC] = {
11019                 .mixers = { alc262_nec_mixer },
11020                 .init_verbs = { alc262_nec_verbs },
11021                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11022                 .dac_nids = alc262_dac_nids,
11023                 .hp_nid = 0x03,
11024                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11025                 .channel_mode = alc262_modes,
11026                 .input_mux = &alc262_capture_source,
11027         },
11028         [ALC262_TOSHIBA_S06] = {
11029                 .mixers = { alc262_toshiba_s06_mixer },
11030                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11031                                                         alc262_eapd_verbs },
11032                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11033                 .capsrc_nids = alc262_dmic_capsrc_nids,
11034                 .dac_nids = alc262_dac_nids,
11035                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11036                 .dig_out_nid = ALC262_DIGOUT_NID,
11037                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11038                 .channel_mode = alc262_modes,
11039                 .input_mux = &alc262_dmic_capture_source,
11040                 .unsol_event = alc262_toshiba_s06_unsol_event,
11041                 .init_hook = alc262_toshiba_s06_init_hook,
11042         },
11043         [ALC262_TOSHIBA_RX1] = {
11044                 .mixers = { alc262_toshiba_rx1_mixer },
11045                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11046                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11047                 .dac_nids = alc262_dac_nids,
11048                 .hp_nid = 0x03,
11049                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11050                 .channel_mode = alc262_modes,
11051                 .input_mux = &alc262_capture_source,
11052                 .unsol_event = alc262_hippo_unsol_event,
11053                 .init_hook = alc262_hippo_automute,
11054         },
11055         [ALC262_TYAN] = {
11056                 .mixers = { alc262_tyan_mixer },
11057                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11058                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11059                 .dac_nids = alc262_dac_nids,
11060                 .hp_nid = 0x02,
11061                 .dig_out_nid = ALC262_DIGOUT_NID,
11062                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11063                 .channel_mode = alc262_modes,
11064                 .input_mux = &alc262_capture_source,
11065                 .unsol_event = alc262_tyan_unsol_event,
11066                 .init_hook = alc262_tyan_automute,
11067         },
11068 };
11069
11070 static int patch_alc262(struct hda_codec *codec)
11071 {
11072         struct alc_spec *spec;
11073         int board_config;
11074         int err;
11075
11076         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11077         if (spec == NULL)
11078                 return -ENOMEM;
11079
11080         codec->spec = spec;
11081 #if 0
11082         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11083          * under-run
11084          */
11085         {
11086         int tmp;
11087         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11088         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11089         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11090         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11091         }
11092 #endif
11093
11094         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11095
11096         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11097                                                   alc262_models,
11098                                                   alc262_cfg_tbl);
11099
11100         if (board_config < 0) {
11101                 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
11102                        "trying auto-probe from BIOS...\n");
11103                 board_config = ALC262_AUTO;
11104         }
11105
11106         if (board_config == ALC262_AUTO) {
11107                 /* automatic parse from the BIOS config */
11108                 err = alc262_parse_auto_config(codec);
11109                 if (err < 0) {
11110                         alc_free(codec);
11111                         return err;
11112                 } else if (!err) {
11113                         printk(KERN_INFO
11114                                "hda_codec: Cannot set up configuration "
11115                                "from BIOS.  Using base mode...\n");
11116                         board_config = ALC262_BASIC;
11117                 }
11118         }
11119
11120         if (!spec->no_analog) {
11121                 err = snd_hda_attach_beep_device(codec, 0x1);
11122                 if (err < 0) {
11123                         alc_free(codec);
11124                         return err;
11125                 }
11126         }
11127
11128         if (board_config != ALC262_AUTO)
11129                 setup_preset(spec, &alc262_presets[board_config]);
11130
11131         spec->stream_name_analog = "ALC262 Analog";
11132         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11133         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11134
11135         spec->stream_name_digital = "ALC262 Digital";
11136         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11137         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11138
11139         spec->capture_style = CAPT_MIX;
11140         if (!spec->adc_nids && spec->input_mux) {
11141                 /* check whether NID 0x07 is valid */
11142                 unsigned int wcap = get_wcaps(codec, 0x07);
11143
11144                 /* get type */
11145                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11146                 if (wcap != AC_WID_AUD_IN) {
11147                         spec->adc_nids = alc262_adc_nids_alt;
11148                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
11149                         spec->capsrc_nids = alc262_capsrc_nids_alt;
11150                 } else {
11151                         spec->adc_nids = alc262_adc_nids;
11152                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
11153                         spec->capsrc_nids = alc262_capsrc_nids;
11154                 }
11155         }
11156         if (!spec->cap_mixer && !spec->no_analog)
11157                 set_capture_mixer(spec);
11158         if (!spec->no_analog)
11159                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11160
11161         spec->vmaster_nid = 0x0c;
11162
11163         codec->patch_ops = alc_patch_ops;
11164         if (board_config == ALC262_AUTO)
11165                 spec->init_hook = alc262_auto_init;
11166 #ifdef CONFIG_SND_HDA_POWER_SAVE
11167         if (!spec->loopback.amplist)
11168                 spec->loopback.amplist = alc262_loopbacks;
11169 #endif
11170         codec->proc_widget_hook = print_realtek_coef;
11171
11172         return 0;
11173 }
11174
11175 /*
11176  *  ALC268 channel source setting (2 channel)
11177  */
11178 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
11179 #define alc268_modes            alc260_modes
11180
11181 static hda_nid_t alc268_dac_nids[2] = {
11182         /* front, hp */
11183         0x02, 0x03
11184 };
11185
11186 static hda_nid_t alc268_adc_nids[2] = {
11187         /* ADC0-1 */
11188         0x08, 0x07
11189 };
11190
11191 static hda_nid_t alc268_adc_nids_alt[1] = {
11192         /* ADC0 */
11193         0x08
11194 };
11195
11196 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11197
11198 static struct snd_kcontrol_new alc268_base_mixer[] = {
11199         /* output mixer control */
11200         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11201         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11202         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11203         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11204         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11205         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11206         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11207         { }
11208 };
11209
11210 /* bind Beep switches of both NID 0x0f and 0x10 */
11211 static struct hda_bind_ctls alc268_bind_beep_sw = {
11212         .ops = &snd_hda_bind_sw,
11213         .values = {
11214                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
11215                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
11216                 0
11217         },
11218 };
11219
11220 static struct snd_kcontrol_new alc268_beep_mixer[] = {
11221         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
11222         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
11223         { }
11224 };
11225
11226 static struct hda_verb alc268_eapd_verbs[] = {
11227         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11228         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11229         { }
11230 };
11231
11232 /* Toshiba specific */
11233 #define alc268_toshiba_automute alc262_hippo_automute
11234
11235 static struct hda_verb alc268_toshiba_verbs[] = {
11236         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11237         { } /* end */
11238 };
11239
11240 static struct hda_input_mux alc268_acer_lc_capture_source = {
11241         .num_items = 2,
11242         .items = {
11243                 { "i-Mic", 0x6 },
11244                 { "E-Mic", 0x0 },
11245         },
11246 };
11247
11248 /* Acer specific */
11249 /* bind volumes of both NID 0x02 and 0x03 */
11250 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
11251         .ops = &snd_hda_bind_vol,
11252         .values = {
11253                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11254                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11255                 0
11256         },
11257 };
11258
11259 /* mute/unmute internal speaker according to the hp jack and mute state */
11260 static void alc268_acer_automute(struct hda_codec *codec, int force)
11261 {
11262         struct alc_spec *spec = codec->spec;
11263         unsigned int mute;
11264
11265         if (force || !spec->sense_updated) {
11266                 unsigned int present;
11267                 present = snd_hda_codec_read(codec, 0x14, 0,
11268                                          AC_VERB_GET_PIN_SENSE, 0);
11269                 spec->jack_present = (present & 0x80000000) != 0;
11270                 spec->sense_updated = 1;
11271         }
11272         if (spec->jack_present)
11273                 mute = HDA_AMP_MUTE; /* mute internal speaker */
11274         else /* unmute internal speaker if necessary */
11275                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11276         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11277                                  HDA_AMP_MUTE, mute);
11278 }
11279
11280
11281 /* bind hp and internal speaker mute (with plug check) */
11282 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
11283                                      struct snd_ctl_elem_value *ucontrol)
11284 {
11285         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11286         long *valp = ucontrol->value.integer.value;
11287         int change;
11288
11289         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
11290                                           HDA_AMP_MUTE,
11291                                           valp[0] ? 0 : HDA_AMP_MUTE);
11292         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
11293                                            HDA_AMP_MUTE,
11294                                            valp[1] ? 0 : HDA_AMP_MUTE);
11295         if (change)
11296                 alc268_acer_automute(codec, 0);
11297         return change;
11298 }
11299
11300 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
11301         /* output mixer control */
11302         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11303         {
11304                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11305                 .name = "Master Playback Switch",
11306                 .info = snd_hda_mixer_amp_switch_info,
11307                 .get = snd_hda_mixer_amp_switch_get,
11308                 .put = alc268_acer_master_sw_put,
11309                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11310         },
11311         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
11312         { }
11313 };
11314
11315 static struct snd_kcontrol_new alc268_acer_mixer[] = {
11316         /* output mixer control */
11317         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11318         {
11319                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11320                 .name = "Master Playback Switch",
11321                 .info = snd_hda_mixer_amp_switch_info,
11322                 .get = snd_hda_mixer_amp_switch_get,
11323                 .put = alc268_acer_master_sw_put,
11324                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11325         },
11326         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11327         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11328         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11329         { }
11330 };
11331
11332 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
11333         /* output mixer control */
11334         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11335         {
11336                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11337                 .name = "Master Playback Switch",
11338                 .info = snd_hda_mixer_amp_switch_info,
11339                 .get = snd_hda_mixer_amp_switch_get,
11340                 .put = alc268_acer_master_sw_put,
11341                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11342         },
11343         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11344         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11345         { }
11346 };
11347
11348 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
11349         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11350         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11351         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11352         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11353         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
11354         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
11355         { }
11356 };
11357
11358 static struct hda_verb alc268_acer_verbs[] = {
11359         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
11360         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11361         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11362         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11363         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11364         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11365         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11366         { }
11367 };
11368
11369 /* unsolicited event for HP jack sensing */
11370 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
11371                                        unsigned int res)
11372 {
11373         if ((res >> 26) != ALC880_HP_EVENT)
11374                 return;
11375         alc268_toshiba_automute(codec);
11376 }
11377
11378 static void alc268_acer_unsol_event(struct hda_codec *codec,
11379                                        unsigned int res)
11380 {
11381         if ((res >> 26) != ALC880_HP_EVENT)
11382                 return;
11383         alc268_acer_automute(codec, 1);
11384 }
11385
11386 static void alc268_acer_init_hook(struct hda_codec *codec)
11387 {
11388         alc268_acer_automute(codec, 1);
11389 }
11390
11391 /* toggle speaker-output according to the hp-jack state */
11392 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
11393 {
11394         unsigned int present;
11395         unsigned char bits;
11396
11397         present = snd_hda_codec_read(codec, 0x15, 0,
11398                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11399         bits = present ? AMP_IN_MUTE(0) : 0;
11400         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
11401                                 AMP_IN_MUTE(0), bits);
11402         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
11403                                 AMP_IN_MUTE(0), bits);
11404 }
11405
11406
11407 static void alc268_acer_mic_automute(struct hda_codec *codec)
11408 {
11409         unsigned int present;
11410
11411         present = snd_hda_codec_read(codec, 0x18, 0,
11412                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11413         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11414                             present ? 0x0 : 0x6);
11415 }
11416
11417 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
11418                                     unsigned int res)
11419 {
11420         if ((res >> 26) == ALC880_HP_EVENT)
11421                 alc268_aspire_one_speaker_automute(codec);
11422         if ((res >> 26) == ALC880_MIC_EVENT)
11423                 alc268_acer_mic_automute(codec);
11424 }
11425
11426 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
11427 {
11428         alc268_aspire_one_speaker_automute(codec);
11429         alc268_acer_mic_automute(codec);
11430 }
11431
11432 static struct snd_kcontrol_new alc268_dell_mixer[] = {
11433         /* output mixer control */
11434         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11435         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11436         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11437         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11438         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11439         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11440         { }
11441 };
11442
11443 static struct hda_verb alc268_dell_verbs[] = {
11444         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11445         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11446         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11447         { }
11448 };
11449
11450 /* mute/unmute internal speaker according to the hp jack and mute state */
11451 static void alc268_dell_automute(struct hda_codec *codec)
11452 {
11453         unsigned int present;
11454         unsigned int mute;
11455
11456         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
11457         if (present & 0x80000000)
11458                 mute = HDA_AMP_MUTE;
11459         else
11460                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
11461         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11462                                  HDA_AMP_MUTE, mute);
11463 }
11464
11465 static void alc268_dell_unsol_event(struct hda_codec *codec,
11466                                     unsigned int res)
11467 {
11468         if ((res >> 26) != ALC880_HP_EVENT)
11469                 return;
11470         alc268_dell_automute(codec);
11471 }
11472
11473 #define alc268_dell_init_hook   alc268_dell_automute
11474
11475 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
11476         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11477         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11478         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11479         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11480         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11481         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
11482         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
11483         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11484         { }
11485 };
11486
11487 static struct hda_verb alc267_quanta_il1_verbs[] = {
11488         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11489         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11490         { }
11491 };
11492
11493 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
11494 {
11495         unsigned int present;
11496
11497         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
11498                 & AC_PINSENSE_PRESENCE;
11499         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11500                             present ? 0 : PIN_OUT);
11501 }
11502
11503 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11504 {
11505         unsigned int present;
11506
11507         present = snd_hda_codec_read(codec, 0x18, 0,
11508                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11509         snd_hda_codec_write(codec, 0x23, 0,
11510                             AC_VERB_SET_CONNECT_SEL,
11511                             present ? 0x00 : 0x01);
11512 }
11513
11514 static void alc267_quanta_il1_automute(struct hda_codec *codec)
11515 {
11516         alc267_quanta_il1_hp_automute(codec);
11517         alc267_quanta_il1_mic_automute(codec);
11518 }
11519
11520 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11521                                            unsigned int res)
11522 {
11523         switch (res >> 26) {
11524         case ALC880_HP_EVENT:
11525                 alc267_quanta_il1_hp_automute(codec);
11526                 break;
11527         case ALC880_MIC_EVENT:
11528                 alc267_quanta_il1_mic_automute(codec);
11529                 break;
11530         }
11531 }
11532
11533 /*
11534  * generic initialization of ADC, input mixers and output mixers
11535  */
11536 static struct hda_verb alc268_base_init_verbs[] = {
11537         /* Unmute DAC0-1 and set vol = 0 */
11538         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11539         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11540
11541         /*
11542          * Set up output mixers (0x0c - 0x0e)
11543          */
11544         /* set vol=0 to output mixers */
11545         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11546         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11547
11548         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11549         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11550
11551         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11552         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11553         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11554         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11555         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11556         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11557         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11558         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11559
11560         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11561         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11562         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11563         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11564         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11565
11566         /* set PCBEEP vol = 0, mute connections */
11567         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11568         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11569         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11570
11571         /* Unmute Selector 23h,24h and set the default input to mic-in */
11572
11573         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11574         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11575         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11576         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11577
11578         { }
11579 };
11580
11581 /*
11582  * generic initialization of ADC, input mixers and output mixers
11583  */
11584 static struct hda_verb alc268_volume_init_verbs[] = {
11585         /* set output DAC */
11586         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11587         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11588
11589         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11590         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11591         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11592         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11593         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11594
11595         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11596         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11597         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11598
11599         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11600         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11601
11602         /* set PCBEEP vol = 0, mute connections */
11603         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11604         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11605         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11606
11607         { }
11608 };
11609
11610 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11611         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11612         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11613         {
11614                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11615                 /* The multiple "Capture Source" controls confuse alsamixer
11616                  * So call somewhat different..
11617                  */
11618                 /* .name = "Capture Source", */
11619                 .name = "Input Source",
11620                 .count = 1,
11621                 .info = alc_mux_enum_info,
11622                 .get = alc_mux_enum_get,
11623                 .put = alc_mux_enum_put,
11624         },
11625         { } /* end */
11626 };
11627
11628 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11629         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11630         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11631         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11632         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11633         {
11634                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11635                 /* The multiple "Capture Source" controls confuse alsamixer
11636                  * So call somewhat different..
11637                  */
11638                 /* .name = "Capture Source", */
11639                 .name = "Input Source",
11640                 .count = 2,
11641                 .info = alc_mux_enum_info,
11642                 .get = alc_mux_enum_get,
11643                 .put = alc_mux_enum_put,
11644         },
11645         { } /* end */
11646 };
11647
11648 static struct hda_input_mux alc268_capture_source = {
11649         .num_items = 4,
11650         .items = {
11651                 { "Mic", 0x0 },
11652                 { "Front Mic", 0x1 },
11653                 { "Line", 0x2 },
11654                 { "CD", 0x3 },
11655         },
11656 };
11657
11658 static struct hda_input_mux alc268_acer_capture_source = {
11659         .num_items = 3,
11660         .items = {
11661                 { "Mic", 0x0 },
11662                 { "Internal Mic", 0x1 },
11663                 { "Line", 0x2 },
11664         },
11665 };
11666
11667 static struct hda_input_mux alc268_acer_dmic_capture_source = {
11668         .num_items = 3,
11669         .items = {
11670                 { "Mic", 0x0 },
11671                 { "Internal Mic", 0x6 },
11672                 { "Line", 0x2 },
11673         },
11674 };
11675
11676 #ifdef CONFIG_SND_DEBUG
11677 static struct snd_kcontrol_new alc268_test_mixer[] = {
11678         /* Volume widgets */
11679         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11680         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11681         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11682         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11683         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11684         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11685         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11686         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11687         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11688         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11689         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11690         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11691         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11692         /* The below appears problematic on some hardwares */
11693         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11694         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11695         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11696         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11697         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11698
11699         /* Modes for retasking pin widgets */
11700         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11701         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11702         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11703         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11704
11705         /* Controls for GPIO pins, assuming they are configured as outputs */
11706         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11707         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11708         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11709         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11710
11711         /* Switches to allow the digital SPDIF output pin to be enabled.
11712          * The ALC268 does not have an SPDIF input.
11713          */
11714         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11715
11716         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
11717          * this output to turn on an external amplifier.
11718          */
11719         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11720         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11721
11722         { } /* end */
11723 };
11724 #endif
11725
11726 /* create input playback/capture controls for the given pin */
11727 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11728                                     const char *ctlname, int idx)
11729 {
11730         char name[32];
11731         int err;
11732
11733         sprintf(name, "%s Playback Volume", ctlname);
11734         if (nid == 0x14) {
11735                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11736                                   HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
11737                                                       HDA_OUTPUT));
11738                 if (err < 0)
11739                         return err;
11740         } else if (nid == 0x15) {
11741                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11742                                   HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
11743                                                       HDA_OUTPUT));
11744                 if (err < 0)
11745                         return err;
11746         } else
11747                 return -1;
11748         sprintf(name, "%s Playback Switch", ctlname);
11749         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11750                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11751         if (err < 0)
11752                 return err;
11753         return 0;
11754 }
11755
11756 /* add playback controls from the parsed DAC table */
11757 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11758                                              const struct auto_pin_cfg *cfg)
11759 {
11760         hda_nid_t nid;
11761         int err;
11762
11763         spec->multiout.num_dacs = 2;    /* only use one dac */
11764         spec->multiout.dac_nids = spec->private_dac_nids;
11765         spec->multiout.dac_nids[0] = 2;
11766         spec->multiout.dac_nids[1] = 3;
11767
11768         nid = cfg->line_out_pins[0];
11769         if (nid)
11770                 alc268_new_analog_output(spec, nid, "Front", 0);
11771
11772         nid = cfg->speaker_pins[0];
11773         if (nid == 0x1d) {
11774                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11775                                   "Speaker Playback Volume",
11776                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11777                 if (err < 0)
11778                         return err;
11779         }
11780         nid = cfg->hp_pins[0];
11781         if (nid)
11782                 alc268_new_analog_output(spec, nid, "Headphone", 0);
11783
11784         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11785         if (nid == 0x16) {
11786                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11787                                   "Mono Playback Switch",
11788                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
11789                 if (err < 0)
11790                         return err;
11791         }
11792         return 0;
11793 }
11794
11795 /* create playback/capture controls for input pins */
11796 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11797                                                 const struct auto_pin_cfg *cfg)
11798 {
11799         struct hda_input_mux *imux = &spec->private_imux[0];
11800         int i, idx1;
11801
11802         for (i = 0; i < AUTO_PIN_LAST; i++) {
11803                 switch(cfg->input_pins[i]) {
11804                 case 0x18:
11805                         idx1 = 0;       /* Mic 1 */
11806                         break;
11807                 case 0x19:
11808                         idx1 = 1;       /* Mic 2 */
11809                         break;
11810                 case 0x1a:
11811                         idx1 = 2;       /* Line In */
11812                         break;
11813                 case 0x1c:
11814                         idx1 = 3;       /* CD */
11815                         break;
11816                 case 0x12:
11817                 case 0x13:
11818                         idx1 = 6;       /* digital mics */
11819                         break;
11820                 default:
11821                         continue;
11822                 }
11823                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11824                 imux->items[imux->num_items].index = idx1;
11825                 imux->num_items++;
11826         }
11827         return 0;
11828 }
11829
11830 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11831 {
11832         struct alc_spec *spec = codec->spec;
11833         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11834         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11835         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11836         unsigned int    dac_vol1, dac_vol2;
11837
11838         if (speaker_nid) {
11839                 snd_hda_codec_write(codec, speaker_nid, 0,
11840                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11841                 snd_hda_codec_write(codec, 0x0f, 0,
11842                                     AC_VERB_SET_AMP_GAIN_MUTE,
11843                                     AMP_IN_UNMUTE(1));
11844                 snd_hda_codec_write(codec, 0x10, 0,
11845                                     AC_VERB_SET_AMP_GAIN_MUTE,
11846                                     AMP_IN_UNMUTE(1));
11847         } else {
11848                 snd_hda_codec_write(codec, 0x0f, 0,
11849                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11850                 snd_hda_codec_write(codec, 0x10, 0,
11851                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11852         }
11853
11854         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
11855         if (line_nid == 0x14)
11856                 dac_vol2 = AMP_OUT_ZERO;
11857         else if (line_nid == 0x15)
11858                 dac_vol1 = AMP_OUT_ZERO;
11859         if (hp_nid == 0x14)
11860                 dac_vol2 = AMP_OUT_ZERO;
11861         else if (hp_nid == 0x15)
11862                 dac_vol1 = AMP_OUT_ZERO;
11863         if (line_nid != 0x16 || hp_nid != 0x16 ||
11864             spec->autocfg.line_out_pins[1] != 0x16 ||
11865             spec->autocfg.line_out_pins[2] != 0x16)
11866                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
11867
11868         snd_hda_codec_write(codec, 0x02, 0,
11869                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
11870         snd_hda_codec_write(codec, 0x03, 0,
11871                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
11872 }
11873
11874 /* pcm configuration: identiacal with ALC880 */
11875 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
11876 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
11877 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
11878 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
11879
11880 /*
11881  * BIOS auto configuration
11882  */
11883 static int alc268_parse_auto_config(struct hda_codec *codec)
11884 {
11885         struct alc_spec *spec = codec->spec;
11886         int err;
11887         static hda_nid_t alc268_ignore[] = { 0 };
11888
11889         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11890                                            alc268_ignore);
11891         if (err < 0)
11892                 return err;
11893         if (!spec->autocfg.line_outs) {
11894                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11895                         spec->multiout.max_channels = 2;
11896                         spec->no_analog = 1;
11897                         goto dig_only;
11898                 }
11899                 return 0; /* can't find valid BIOS pin config */
11900         }
11901         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
11902         if (err < 0)
11903                 return err;
11904         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
11905         if (err < 0)
11906                 return err;
11907
11908         spec->multiout.max_channels = 2;
11909
11910  dig_only:
11911         /* digital only support output */
11912         if (spec->autocfg.dig_outs) {
11913                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
11914                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11915         }
11916         if (spec->kctls.list)
11917                 add_mixer(spec, spec->kctls.list);
11918
11919         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
11920                 add_mixer(spec, alc268_beep_mixer);
11921
11922         add_verb(spec, alc268_volume_init_verbs);
11923         spec->num_mux_defs = 1;
11924         spec->input_mux = &spec->private_imux[0];
11925
11926         err = alc_auto_add_mic_boost(codec);
11927         if (err < 0)
11928                 return err;
11929
11930         return 1;
11931 }
11932
11933 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
11934 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
11935 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
11936
11937 /* init callback for auto-configuration model -- overriding the default init */
11938 static void alc268_auto_init(struct hda_codec *codec)
11939 {
11940         struct alc_spec *spec = codec->spec;
11941         alc268_auto_init_multi_out(codec);
11942         alc268_auto_init_hp_out(codec);
11943         alc268_auto_init_mono_speaker_out(codec);
11944         alc268_auto_init_analog_input(codec);
11945         if (spec->unsol_event)
11946                 alc_inithook(codec);
11947 }
11948
11949 /*
11950  * configuration and preset
11951  */
11952 static const char *alc268_models[ALC268_MODEL_LAST] = {
11953         [ALC267_QUANTA_IL1]     = "quanta-il1",
11954         [ALC268_3ST]            = "3stack",
11955         [ALC268_TOSHIBA]        = "toshiba",
11956         [ALC268_ACER]           = "acer",
11957         [ALC268_ACER_DMIC]      = "acer-dmic",
11958         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
11959         [ALC268_DELL]           = "dell",
11960         [ALC268_ZEPTO]          = "zepto",
11961 #ifdef CONFIG_SND_DEBUG
11962         [ALC268_TEST]           = "test",
11963 #endif
11964         [ALC268_AUTO]           = "auto",
11965 };
11966
11967 static struct snd_pci_quirk alc268_cfg_tbl[] = {
11968         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
11969         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
11970         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
11971         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
11972         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
11973         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
11974                                                 ALC268_ACER_ASPIRE_ONE),
11975         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
11976         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
11977         SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
11978         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
11979         SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
11980         SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
11981         SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
11982         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
11983         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
11984         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
11985         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
11986         {}
11987 };
11988
11989 static struct alc_config_preset alc268_presets[] = {
11990         [ALC267_QUANTA_IL1] = {
11991                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
11992                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11993                                 alc267_quanta_il1_verbs },
11994                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11995                 .dac_nids = alc268_dac_nids,
11996                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11997                 .adc_nids = alc268_adc_nids_alt,
11998                 .hp_nid = 0x03,
11999                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12000                 .channel_mode = alc268_modes,
12001                 .input_mux = &alc268_capture_source,
12002                 .unsol_event = alc267_quanta_il1_unsol_event,
12003                 .init_hook = alc267_quanta_il1_automute,
12004         },
12005         [ALC268_3ST] = {
12006                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12007                             alc268_beep_mixer },
12008                 .init_verbs = { alc268_base_init_verbs },
12009                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12010                 .dac_nids = alc268_dac_nids,
12011                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12012                 .adc_nids = alc268_adc_nids_alt,
12013                 .capsrc_nids = alc268_capsrc_nids,
12014                 .hp_nid = 0x03,
12015                 .dig_out_nid = ALC268_DIGOUT_NID,
12016                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12017                 .channel_mode = alc268_modes,
12018                 .input_mux = &alc268_capture_source,
12019         },
12020         [ALC268_TOSHIBA] = {
12021                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12022                             alc268_beep_mixer },
12023                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12024                                 alc268_toshiba_verbs },
12025                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12026                 .dac_nids = alc268_dac_nids,
12027                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12028                 .adc_nids = alc268_adc_nids_alt,
12029                 .capsrc_nids = alc268_capsrc_nids,
12030                 .hp_nid = 0x03,
12031                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12032                 .channel_mode = alc268_modes,
12033                 .input_mux = &alc268_capture_source,
12034                 .unsol_event = alc268_toshiba_unsol_event,
12035                 .init_hook = alc268_toshiba_automute,
12036         },
12037         [ALC268_ACER] = {
12038                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12039                             alc268_beep_mixer },
12040                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12041                                 alc268_acer_verbs },
12042                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12043                 .dac_nids = alc268_dac_nids,
12044                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12045                 .adc_nids = alc268_adc_nids_alt,
12046                 .capsrc_nids = alc268_capsrc_nids,
12047                 .hp_nid = 0x02,
12048                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12049                 .channel_mode = alc268_modes,
12050                 .input_mux = &alc268_acer_capture_source,
12051                 .unsol_event = alc268_acer_unsol_event,
12052                 .init_hook = alc268_acer_init_hook,
12053         },
12054         [ALC268_ACER_DMIC] = {
12055                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12056                             alc268_beep_mixer },
12057                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12058                                 alc268_acer_verbs },
12059                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12060                 .dac_nids = alc268_dac_nids,
12061                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12062                 .adc_nids = alc268_adc_nids_alt,
12063                 .capsrc_nids = alc268_capsrc_nids,
12064                 .hp_nid = 0x02,
12065                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12066                 .channel_mode = alc268_modes,
12067                 .input_mux = &alc268_acer_dmic_capture_source,
12068                 .unsol_event = alc268_acer_unsol_event,
12069                 .init_hook = alc268_acer_init_hook,
12070         },
12071         [ALC268_ACER_ASPIRE_ONE] = {
12072                 .mixers = { alc268_acer_aspire_one_mixer,
12073                             alc268_beep_mixer,
12074                             alc268_capture_alt_mixer },
12075                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12076                                 alc268_acer_aspire_one_verbs },
12077                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12078                 .dac_nids = alc268_dac_nids,
12079                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12080                 .adc_nids = alc268_adc_nids_alt,
12081                 .capsrc_nids = alc268_capsrc_nids,
12082                 .hp_nid = 0x03,
12083                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12084                 .channel_mode = alc268_modes,
12085                 .input_mux = &alc268_acer_lc_capture_source,
12086                 .unsol_event = alc268_acer_lc_unsol_event,
12087                 .init_hook = alc268_acer_lc_init_hook,
12088         },
12089         [ALC268_DELL] = {
12090                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
12091                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12092                                 alc268_dell_verbs },
12093                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12094                 .dac_nids = alc268_dac_nids,
12095                 .hp_nid = 0x02,
12096                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12097                 .channel_mode = alc268_modes,
12098                 .unsol_event = alc268_dell_unsol_event,
12099                 .init_hook = alc268_dell_init_hook,
12100                 .input_mux = &alc268_capture_source,
12101         },
12102         [ALC268_ZEPTO] = {
12103                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12104                             alc268_beep_mixer },
12105                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12106                                 alc268_toshiba_verbs },
12107                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12108                 .dac_nids = alc268_dac_nids,
12109                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12110                 .adc_nids = alc268_adc_nids_alt,
12111                 .capsrc_nids = alc268_capsrc_nids,
12112                 .hp_nid = 0x03,
12113                 .dig_out_nid = ALC268_DIGOUT_NID,
12114                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12115                 .channel_mode = alc268_modes,
12116                 .input_mux = &alc268_capture_source,
12117                 .unsol_event = alc268_toshiba_unsol_event,
12118                 .init_hook = alc268_toshiba_automute
12119         },
12120 #ifdef CONFIG_SND_DEBUG
12121         [ALC268_TEST] = {
12122                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
12123                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12124                                 alc268_volume_init_verbs },
12125                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12126                 .dac_nids = alc268_dac_nids,
12127                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12128                 .adc_nids = alc268_adc_nids_alt,
12129                 .capsrc_nids = alc268_capsrc_nids,
12130                 .hp_nid = 0x03,
12131                 .dig_out_nid = ALC268_DIGOUT_NID,
12132                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12133                 .channel_mode = alc268_modes,
12134                 .input_mux = &alc268_capture_source,
12135         },
12136 #endif
12137 };
12138
12139 static int patch_alc268(struct hda_codec *codec)
12140 {
12141         struct alc_spec *spec;
12142         int board_config;
12143         int i, has_beep, err;
12144
12145         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12146         if (spec == NULL)
12147                 return -ENOMEM;
12148
12149         codec->spec = spec;
12150
12151         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12152                                                   alc268_models,
12153                                                   alc268_cfg_tbl);
12154
12155         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12156                 printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
12157                        "trying auto-probe from BIOS...\n");
12158                 board_config = ALC268_AUTO;
12159         }
12160
12161         if (board_config == ALC268_AUTO) {
12162                 /* automatic parse from the BIOS config */
12163                 err = alc268_parse_auto_config(codec);
12164                 if (err < 0) {
12165                         alc_free(codec);
12166                         return err;
12167                 } else if (!err) {
12168                         printk(KERN_INFO
12169                                "hda_codec: Cannot set up configuration "
12170                                "from BIOS.  Using base mode...\n");
12171                         board_config = ALC268_3ST;
12172                 }
12173         }
12174
12175         if (board_config != ALC268_AUTO)
12176                 setup_preset(spec, &alc268_presets[board_config]);
12177
12178         if (codec->vendor_id == 0x10ec0267) {
12179                 spec->stream_name_analog = "ALC267 Analog";
12180                 spec->stream_name_digital = "ALC267 Digital";
12181         } else {
12182                 spec->stream_name_analog = "ALC268 Analog";
12183                 spec->stream_name_digital = "ALC268 Digital";
12184         }
12185
12186         spec->stream_analog_playback = &alc268_pcm_analog_playback;
12187         spec->stream_analog_capture = &alc268_pcm_analog_capture;
12188         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12189
12190         spec->stream_digital_playback = &alc268_pcm_digital_playback;
12191
12192         has_beep = 0;
12193         for (i = 0; i < spec->num_mixers; i++) {
12194                 if (spec->mixers[i] == alc268_beep_mixer) {
12195                         has_beep = 1;
12196                         break;
12197                 }
12198         }
12199
12200         if (has_beep) {
12201                 err = snd_hda_attach_beep_device(codec, 0x1);
12202                 if (err < 0) {
12203                         alc_free(codec);
12204                         return err;
12205                 }
12206                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12207                         /* override the amp caps for beep generator */
12208                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12209                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12210                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12211                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12212                                           (0 << AC_AMPCAP_MUTE_SHIFT));
12213         }
12214
12215         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12216                 /* check whether NID 0x07 is valid */
12217                 unsigned int wcap = get_wcaps(codec, 0x07);
12218                 int i;
12219
12220                 /* get type */
12221                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
12222                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
12223                         spec->adc_nids = alc268_adc_nids_alt;
12224                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
12225                         add_mixer(spec, alc268_capture_alt_mixer);
12226                 } else {
12227                         spec->adc_nids = alc268_adc_nids;
12228                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
12229                         add_mixer(spec, alc268_capture_mixer);
12230                 }
12231                 spec->capsrc_nids = alc268_capsrc_nids;
12232                 /* set default input source */
12233                 for (i = 0; i < spec->num_adc_nids; i++)
12234                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
12235                                 0, AC_VERB_SET_CONNECT_SEL,
12236                                 spec->input_mux->items[0].index);
12237         }
12238
12239         spec->vmaster_nid = 0x02;
12240
12241         codec->patch_ops = alc_patch_ops;
12242         if (board_config == ALC268_AUTO)
12243                 spec->init_hook = alc268_auto_init;
12244
12245         codec->proc_widget_hook = print_realtek_coef;
12246
12247         return 0;
12248 }
12249
12250 /*
12251  *  ALC269 channel source setting (2 channel)
12252  */
12253 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
12254
12255 #define alc269_dac_nids         alc260_dac_nids
12256
12257 static hda_nid_t alc269_adc_nids[1] = {
12258         /* ADC1 */
12259         0x08,
12260 };
12261
12262 static hda_nid_t alc269_capsrc_nids[1] = {
12263         0x23,
12264 };
12265
12266 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
12267  *       not a mux!
12268  */
12269
12270 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
12271         .num_items = 2,
12272         .items = {
12273                 { "i-Mic", 0x5 },
12274                 { "e-Mic", 0x0 },
12275         },
12276 };
12277
12278 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
12279         .num_items = 2,
12280         .items = {
12281                 { "i-Mic", 0x1 },
12282                 { "e-Mic", 0x0 },
12283         },
12284 };
12285
12286 #define alc269_modes            alc260_modes
12287 #define alc269_capture_source   alc880_lg_lw_capture_source
12288
12289 static struct snd_kcontrol_new alc269_base_mixer[] = {
12290         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12291         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12292         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12293         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12294         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12295         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12296         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12297         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12298         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12299         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12300         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12301         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
12302         { } /* end */
12303 };
12304
12305 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
12306         /* output mixer control */
12307         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12308         {
12309                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12310                 .name = "Master Playback Switch",
12311                 .info = snd_hda_mixer_amp_switch_info,
12312                 .get = snd_hda_mixer_amp_switch_get,
12313                 .put = alc268_acer_master_sw_put,
12314                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12315         },
12316         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12317         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12318         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12319         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12320         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12321         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12322         { }
12323 };
12324
12325 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
12326         /* output mixer control */
12327         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12328         {
12329                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12330                 .name = "Master Playback Switch",
12331                 .info = snd_hda_mixer_amp_switch_info,
12332                 .get = snd_hda_mixer_amp_switch_get,
12333                 .put = alc268_acer_master_sw_put,
12334                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12335         },
12336         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12337         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12338         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12339         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12340         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12341         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12342         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
12343         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
12344         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
12345         { }
12346 };
12347
12348 /* bind volumes of both NID 0x0c and 0x0d */
12349 static struct hda_bind_ctls alc269_epc_bind_vol = {
12350         .ops = &snd_hda_bind_vol,
12351         .values = {
12352                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12353                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12354                 0
12355         },
12356 };
12357
12358 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
12359         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12360         HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
12361         HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12362         { } /* end */
12363 };
12364
12365 /* capture mixer elements */
12366 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
12367         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12368         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12369         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12370         { } /* end */
12371 };
12372
12373 /* FSC amilo */
12374 static struct snd_kcontrol_new alc269_fujitsu_mixer[] = {
12375         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12376         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12377         HDA_BIND_VOL("PCM Playback Volume", &alc269_epc_bind_vol),
12378         { } /* end */
12379 };
12380
12381 static struct hda_verb alc269_quanta_fl1_verbs[] = {
12382         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12383         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12384         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12385         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12386         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12387         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12388         { }
12389 };
12390
12391 static struct hda_verb alc269_lifebook_verbs[] = {
12392         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12393         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
12394         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12395         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12396         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12397         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12398         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12399         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12400         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12401         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12402         { }
12403 };
12404
12405 /* toggle speaker-output according to the hp-jack state */
12406 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
12407 {
12408         unsigned int present;
12409         unsigned char bits;
12410
12411         present = snd_hda_codec_read(codec, 0x15, 0,
12412                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12413         bits = present ? AMP_IN_MUTE(0) : 0;
12414         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12415                         AMP_IN_MUTE(0), bits);
12416         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12417                         AMP_IN_MUTE(0), bits);
12418
12419         snd_hda_codec_write(codec, 0x20, 0,
12420                         AC_VERB_SET_COEF_INDEX, 0x0c);
12421         snd_hda_codec_write(codec, 0x20, 0,
12422                         AC_VERB_SET_PROC_COEF, 0x680);
12423
12424         snd_hda_codec_write(codec, 0x20, 0,
12425                         AC_VERB_SET_COEF_INDEX, 0x0c);
12426         snd_hda_codec_write(codec, 0x20, 0,
12427                         AC_VERB_SET_PROC_COEF, 0x480);
12428 }
12429
12430 /* toggle speaker-output according to the hp-jacks state */
12431 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
12432 {
12433         unsigned int present;
12434         unsigned char bits;
12435
12436         /* Check laptop headphone socket */
12437         present = snd_hda_codec_read(codec, 0x15, 0,
12438                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12439
12440         /* Check port replicator headphone socket */
12441         present |= snd_hda_codec_read(codec, 0x1a, 0,
12442                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12443
12444         bits = present ? AMP_IN_MUTE(0) : 0;
12445         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12446                         AMP_IN_MUTE(0), bits);
12447         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12448                         AMP_IN_MUTE(0), bits);
12449
12450         snd_hda_codec_write(codec, 0x20, 0,
12451                         AC_VERB_SET_COEF_INDEX, 0x0c);
12452         snd_hda_codec_write(codec, 0x20, 0,
12453                         AC_VERB_SET_PROC_COEF, 0x680);
12454
12455         snd_hda_codec_write(codec, 0x20, 0,
12456                         AC_VERB_SET_COEF_INDEX, 0x0c);
12457         snd_hda_codec_write(codec, 0x20, 0,
12458                         AC_VERB_SET_PROC_COEF, 0x480);
12459 }
12460
12461 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
12462 {
12463         unsigned int present;
12464
12465         present = snd_hda_codec_read(codec, 0x18, 0,
12466                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12467         snd_hda_codec_write(codec, 0x23, 0,
12468                             AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
12469 }
12470
12471 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
12472 {
12473         unsigned int present_laptop;
12474         unsigned int present_dock;
12475
12476         present_laptop = snd_hda_codec_read(codec, 0x18, 0,
12477                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12478
12479         present_dock = snd_hda_codec_read(codec, 0x1b, 0,
12480                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12481
12482         /* Laptop mic port overrides dock mic port, design decision */
12483         if (present_dock)
12484                 snd_hda_codec_write(codec, 0x23, 0,
12485                                 AC_VERB_SET_CONNECT_SEL, 0x3);
12486         if (present_laptop)
12487                 snd_hda_codec_write(codec, 0x23, 0,
12488                                 AC_VERB_SET_CONNECT_SEL, 0x0);
12489         if (!present_dock && !present_laptop)
12490                 snd_hda_codec_write(codec, 0x23, 0,
12491                                 AC_VERB_SET_CONNECT_SEL, 0x1);
12492 }
12493
12494 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
12495                                     unsigned int res)
12496 {
12497         if ((res >> 26) == ALC880_HP_EVENT)
12498                 alc269_quanta_fl1_speaker_automute(codec);
12499         if ((res >> 26) == ALC880_MIC_EVENT)
12500                 alc269_quanta_fl1_mic_automute(codec);
12501 }
12502
12503 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
12504                                         unsigned int res)
12505 {
12506         if ((res >> 26) == ALC880_HP_EVENT)
12507                 alc269_lifebook_speaker_automute(codec);
12508         if ((res >> 26) == ALC880_MIC_EVENT)
12509                 alc269_lifebook_mic_autoswitch(codec);
12510 }
12511
12512 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
12513 {
12514         alc269_quanta_fl1_speaker_automute(codec);
12515         alc269_quanta_fl1_mic_automute(codec);
12516 }
12517
12518 static void alc269_lifebook_init_hook(struct hda_codec *codec)
12519 {
12520         alc269_lifebook_speaker_automute(codec);
12521         alc269_lifebook_mic_autoswitch(codec);
12522 }
12523
12524 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
12525         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12526         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
12527         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12528         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
12529         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12530         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12531         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12532         {}
12533 };
12534
12535 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
12536         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12537         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
12538         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12539         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
12540         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12541         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12542         {}
12543 };
12544
12545 /* toggle speaker-output according to the hp-jack state */
12546 static void alc269_speaker_automute(struct hda_codec *codec)
12547 {
12548         unsigned int present;
12549         unsigned char bits;
12550
12551         present = snd_hda_codec_read(codec, 0x15, 0,
12552                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12553         bits = present ? AMP_IN_MUTE(0) : 0;
12554         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12555                                 AMP_IN_MUTE(0), bits);
12556         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12557                                 AMP_IN_MUTE(0), bits);
12558 }
12559
12560 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
12561 {
12562         unsigned int present;
12563
12564         present = snd_hda_codec_read(codec, 0x18, 0,
12565                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12566         snd_hda_codec_write(codec, 0x23, 0,
12567                                 AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
12568 }
12569
12570 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
12571 {
12572         unsigned int present;
12573
12574         present = snd_hda_codec_read(codec, 0x18, 0,
12575                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12576         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12577                                 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
12578         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12579                                 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
12580 }
12581
12582 /* unsolicited event for HP jack sensing */
12583 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
12584                                      unsigned int res)
12585 {
12586         if ((res >> 26) == ALC880_HP_EVENT)
12587                 alc269_speaker_automute(codec);
12588
12589         if ((res >> 26) == ALC880_MIC_EVENT)
12590                 alc269_eeepc_dmic_automute(codec);
12591 }
12592
12593 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
12594 {
12595         alc269_speaker_automute(codec);
12596         alc269_eeepc_dmic_automute(codec);
12597 }
12598
12599 /* unsolicited event for HP jack sensing */
12600 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
12601                                      unsigned int res)
12602 {
12603         if ((res >> 26) == ALC880_HP_EVENT)
12604                 alc269_speaker_automute(codec);
12605
12606         if ((res >> 26) == ALC880_MIC_EVENT)
12607                 alc269_eeepc_amic_automute(codec);
12608 }
12609
12610 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12611 {
12612         alc269_speaker_automute(codec);
12613         alc269_eeepc_amic_automute(codec);
12614 }
12615
12616 /*
12617  * generic initialization of ADC, input mixers and output mixers
12618  */
12619 static struct hda_verb alc269_init_verbs[] = {
12620         /*
12621          * Unmute ADC0 and set the default input to mic-in
12622          */
12623         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12624
12625         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12626          * analog-loopback mixer widget
12627          * Note: PASD motherboards uses the Line In 2 as the input for
12628          * front panel mic (mic 2)
12629          */
12630         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12631         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12632         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12633         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12634         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12635         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12636
12637         /*
12638          * Set up output mixers (0x0c - 0x0e)
12639          */
12640         /* set vol=0 to output mixers */
12641         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12642         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12643
12644         /* set up input amps for analog loopback */
12645         /* Amp Indices: DAC = 0, mixer = 1 */
12646         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12647         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12648         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12649         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12650         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12651         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12652
12653         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12654         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12655         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12656         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12657         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12658         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12659         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12660
12661         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12662         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12663         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12664         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12665         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12666         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12667         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12668
12669         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12670         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12671
12672         /* FIXME: use matrix-type input source selection */
12673         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12674         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12675         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12676         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12677         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12678         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12679
12680         /* set EAPD */
12681         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12682         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12683         { }
12684 };
12685
12686 /* add playback controls from the parsed DAC table */
12687 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12688                                              const struct auto_pin_cfg *cfg)
12689 {
12690         hda_nid_t nid;
12691         int err;
12692
12693         spec->multiout.num_dacs = 1;    /* only use one dac */
12694         spec->multiout.dac_nids = spec->private_dac_nids;
12695         spec->multiout.dac_nids[0] = 2;
12696
12697         nid = cfg->line_out_pins[0];
12698         if (nid) {
12699                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12700                                   "Front Playback Volume",
12701                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12702                 if (err < 0)
12703                         return err;
12704                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12705                                   "Front Playback Switch",
12706                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12707                 if (err < 0)
12708                         return err;
12709         }
12710
12711         nid = cfg->speaker_pins[0];
12712         if (nid) {
12713                 if (!cfg->line_out_pins[0]) {
12714                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12715                                           "Speaker Playback Volume",
12716                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12717                                                               HDA_OUTPUT));
12718                         if (err < 0)
12719                                 return err;
12720                 }
12721                 if (nid == 0x16) {
12722                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12723                                           "Speaker Playback Switch",
12724                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12725                                                               HDA_OUTPUT));
12726                         if (err < 0)
12727                                 return err;
12728                 } else {
12729                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12730                                           "Speaker Playback Switch",
12731                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12732                                                               HDA_OUTPUT));
12733                         if (err < 0)
12734                                 return err;
12735                 }
12736         }
12737         nid = cfg->hp_pins[0];
12738         if (nid) {
12739                 /* spec->multiout.hp_nid = 2; */
12740                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12741                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12742                                           "Headphone Playback Volume",
12743                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12744                                                               HDA_OUTPUT));
12745                         if (err < 0)
12746                                 return err;
12747                 }
12748                 if (nid == 0x16) {
12749                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12750                                           "Headphone Playback Switch",
12751                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12752                                                               HDA_OUTPUT));
12753                         if (err < 0)
12754                                 return err;
12755                 } else {
12756                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12757                                           "Headphone Playback Switch",
12758                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12759                                                               HDA_OUTPUT));
12760                         if (err < 0)
12761                                 return err;
12762                 }
12763         }
12764         return 0;
12765 }
12766
12767 static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec,
12768                                                 const struct auto_pin_cfg *cfg)
12769 {
12770         int err;
12771
12772         err = alc880_auto_create_analog_input_ctls(spec, cfg);
12773         if (err < 0)
12774                 return err;
12775         /* digital-mic input pin is excluded in alc880_auto_create..()
12776          * because it's under 0x18
12777          */
12778         if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
12779             cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
12780                 struct hda_input_mux *imux = &spec->private_imux[0];
12781                 imux->items[imux->num_items].label = "Int Mic";
12782                 imux->items[imux->num_items].index = 0x05;
12783                 imux->num_items++;
12784         }
12785         return 0;
12786 }
12787
12788 #ifdef CONFIG_SND_HDA_POWER_SAVE
12789 #define alc269_loopbacks        alc880_loopbacks
12790 #endif
12791
12792 /* pcm configuration: identiacal with ALC880 */
12793 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
12794 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
12795 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
12796 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
12797
12798 /*
12799  * BIOS auto configuration
12800  */
12801 static int alc269_parse_auto_config(struct hda_codec *codec)
12802 {
12803         struct alc_spec *spec = codec->spec;
12804         int err;
12805         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12806
12807         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12808                                            alc269_ignore);
12809         if (err < 0)
12810                 return err;
12811
12812         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12813         if (err < 0)
12814                 return err;
12815         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12816         if (err < 0)
12817                 return err;
12818
12819         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12820
12821         if (spec->autocfg.dig_outs)
12822                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12823
12824         if (spec->kctls.list)
12825                 add_mixer(spec, spec->kctls.list);
12826
12827         add_verb(spec, alc269_init_verbs);
12828         spec->num_mux_defs = 1;
12829         spec->input_mux = &spec->private_imux[0];
12830         /* set default input source */
12831         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12832                                   0, AC_VERB_SET_CONNECT_SEL,
12833                                   spec->input_mux->items[0].index);
12834
12835         err = alc_auto_add_mic_boost(codec);
12836         if (err < 0)
12837                 return err;
12838
12839         if (!spec->cap_mixer && !spec->no_analog)
12840                 set_capture_mixer(spec);
12841
12842         return 1;
12843 }
12844
12845 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
12846 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
12847 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
12848
12849
12850 /* init callback for auto-configuration model -- overriding the default init */
12851 static void alc269_auto_init(struct hda_codec *codec)
12852 {
12853         struct alc_spec *spec = codec->spec;
12854         alc269_auto_init_multi_out(codec);
12855         alc269_auto_init_hp_out(codec);
12856         alc269_auto_init_analog_input(codec);
12857         if (spec->unsol_event)
12858                 alc_inithook(codec);
12859 }
12860
12861 /*
12862  * configuration and preset
12863  */
12864 static const char *alc269_models[ALC269_MODEL_LAST] = {
12865         [ALC269_BASIC]                  = "basic",
12866         [ALC269_QUANTA_FL1]             = "quanta",
12867         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
12868         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
12869         [ALC269_FUJITSU]                = "fujitsu",
12870         [ALC269_LIFEBOOK]               = "lifebook"
12871 };
12872
12873 static struct snd_pci_quirk alc269_cfg_tbl[] = {
12874         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
12875         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
12876                       ALC269_ASUS_EEEPC_P703),
12877         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
12878                       ALC269_ASUS_EEEPC_P901),
12879         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
12880                       ALC269_ASUS_EEEPC_P901),
12881         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
12882         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
12883         {}
12884 };
12885
12886 static struct alc_config_preset alc269_presets[] = {
12887         [ALC269_BASIC] = {
12888                 .mixers = { alc269_base_mixer },
12889                 .init_verbs = { alc269_init_verbs },
12890                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12891                 .dac_nids = alc269_dac_nids,
12892                 .hp_nid = 0x03,
12893                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12894                 .channel_mode = alc269_modes,
12895                 .input_mux = &alc269_capture_source,
12896         },
12897         [ALC269_QUANTA_FL1] = {
12898                 .mixers = { alc269_quanta_fl1_mixer },
12899                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
12900                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12901                 .dac_nids = alc269_dac_nids,
12902                 .hp_nid = 0x03,
12903                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12904                 .channel_mode = alc269_modes,
12905                 .input_mux = &alc269_capture_source,
12906                 .unsol_event = alc269_quanta_fl1_unsol_event,
12907                 .init_hook = alc269_quanta_fl1_init_hook,
12908         },
12909         [ALC269_ASUS_EEEPC_P703] = {
12910                 .mixers = { alc269_eeepc_mixer },
12911                 .cap_mixer = alc269_epc_capture_mixer,
12912                 .init_verbs = { alc269_init_verbs,
12913                                 alc269_eeepc_amic_init_verbs },
12914                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12915                 .dac_nids = alc269_dac_nids,
12916                 .hp_nid = 0x03,
12917                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12918                 .channel_mode = alc269_modes,
12919                 .input_mux = &alc269_eeepc_amic_capture_source,
12920                 .unsol_event = alc269_eeepc_amic_unsol_event,
12921                 .init_hook = alc269_eeepc_amic_inithook,
12922         },
12923         [ALC269_ASUS_EEEPC_P901] = {
12924                 .mixers = { alc269_eeepc_mixer },
12925                 .cap_mixer = alc269_epc_capture_mixer,
12926                 .init_verbs = { alc269_init_verbs,
12927                                 alc269_eeepc_dmic_init_verbs },
12928                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12929                 .dac_nids = alc269_dac_nids,
12930                 .hp_nid = 0x03,
12931                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12932                 .channel_mode = alc269_modes,
12933                 .input_mux = &alc269_eeepc_dmic_capture_source,
12934                 .unsol_event = alc269_eeepc_dmic_unsol_event,
12935                 .init_hook = alc269_eeepc_dmic_inithook,
12936         },
12937         [ALC269_FUJITSU] = {
12938                 .mixers = { alc269_fujitsu_mixer },
12939                 .cap_mixer = alc269_epc_capture_mixer,
12940                 .init_verbs = { alc269_init_verbs,
12941                                 alc269_eeepc_dmic_init_verbs },
12942                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12943                 .dac_nids = alc269_dac_nids,
12944                 .hp_nid = 0x03,
12945                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12946                 .channel_mode = alc269_modes,
12947                 .input_mux = &alc269_eeepc_dmic_capture_source,
12948                 .unsol_event = alc269_eeepc_dmic_unsol_event,
12949                 .init_hook = alc269_eeepc_dmic_inithook,
12950         },
12951         [ALC269_LIFEBOOK] = {
12952                 .mixers = { alc269_lifebook_mixer },
12953                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
12954                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12955                 .dac_nids = alc269_dac_nids,
12956                 .hp_nid = 0x03,
12957                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12958                 .channel_mode = alc269_modes,
12959                 .input_mux = &alc269_capture_source,
12960                 .unsol_event = alc269_lifebook_unsol_event,
12961                 .init_hook = alc269_lifebook_init_hook,
12962         },
12963 };
12964
12965 static int patch_alc269(struct hda_codec *codec)
12966 {
12967         struct alc_spec *spec;
12968         int board_config;
12969         int err;
12970
12971         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12972         if (spec == NULL)
12973                 return -ENOMEM;
12974
12975         codec->spec = spec;
12976
12977         alc_fix_pll_init(codec, 0x20, 0x04, 15);
12978
12979         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
12980                                                   alc269_models,
12981                                                   alc269_cfg_tbl);
12982
12983         if (board_config < 0) {
12984                 printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
12985                        "trying auto-probe from BIOS...\n");
12986                 board_config = ALC269_AUTO;
12987         }
12988
12989         if (board_config == ALC269_AUTO) {
12990                 /* automatic parse from the BIOS config */
12991                 err = alc269_parse_auto_config(codec);
12992                 if (err < 0) {
12993                         alc_free(codec);
12994                         return err;
12995                 } else if (!err) {
12996                         printk(KERN_INFO
12997                                "hda_codec: Cannot set up configuration "
12998                                "from BIOS.  Using base mode...\n");
12999                         board_config = ALC269_BASIC;
13000                 }
13001         }
13002
13003         err = snd_hda_attach_beep_device(codec, 0x1);
13004         if (err < 0) {
13005                 alc_free(codec);
13006                 return err;
13007         }
13008
13009         if (board_config != ALC269_AUTO)
13010                 setup_preset(spec, &alc269_presets[board_config]);
13011
13012         spec->stream_name_analog = "ALC269 Analog";
13013         spec->stream_analog_playback = &alc269_pcm_analog_playback;
13014         spec->stream_analog_capture = &alc269_pcm_analog_capture;
13015
13016         spec->stream_name_digital = "ALC269 Digital";
13017         spec->stream_digital_playback = &alc269_pcm_digital_playback;
13018         spec->stream_digital_capture = &alc269_pcm_digital_capture;
13019
13020         spec->adc_nids = alc269_adc_nids;
13021         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13022         spec->capsrc_nids = alc269_capsrc_nids;
13023         if (!spec->cap_mixer)
13024                 set_capture_mixer(spec);
13025         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13026
13027         codec->patch_ops = alc_patch_ops;
13028         if (board_config == ALC269_AUTO)
13029                 spec->init_hook = alc269_auto_init;
13030 #ifdef CONFIG_SND_HDA_POWER_SAVE
13031         if (!spec->loopback.amplist)
13032                 spec->loopback.amplist = alc269_loopbacks;
13033 #endif
13034         codec->proc_widget_hook = print_realtek_coef;
13035
13036         return 0;
13037 }
13038
13039 /*
13040  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13041  */
13042
13043 /*
13044  * set the path ways for 2 channel output
13045  * need to set the codec line out and mic 1 pin widgets to inputs
13046  */
13047 static struct hda_verb alc861_threestack_ch2_init[] = {
13048         /* set pin widget 1Ah (line in) for input */
13049         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13050         /* set pin widget 18h (mic1/2) for input, for mic also enable
13051          * the vref
13052          */
13053         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13054
13055         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13056 #if 0
13057         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13058         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13059 #endif
13060         { } /* end */
13061 };
13062 /*
13063  * 6ch mode
13064  * need to set the codec line out and mic 1 pin widgets to outputs
13065  */
13066 static struct hda_verb alc861_threestack_ch6_init[] = {
13067         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13068         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13069         /* set pin widget 18h (mic1) for output (CLFE)*/
13070         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13071
13072         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13073         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13074
13075         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13076 #if 0
13077         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13078         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13079 #endif
13080         { } /* end */
13081 };
13082
13083 static struct hda_channel_mode alc861_threestack_modes[2] = {
13084         { 2, alc861_threestack_ch2_init },
13085         { 6, alc861_threestack_ch6_init },
13086 };
13087 /* Set mic1 as input and unmute the mixer */
13088 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13089         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13090         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13091         { } /* end */
13092 };
13093 /* Set mic1 as output and mute mixer */
13094 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13095         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13096         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13097         { } /* end */
13098 };
13099
13100 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13101         { 2, alc861_uniwill_m31_ch2_init },
13102         { 4, alc861_uniwill_m31_ch4_init },
13103 };
13104
13105 /* Set mic1 and line-in as input and unmute the mixer */
13106 static struct hda_verb alc861_asus_ch2_init[] = {
13107         /* set pin widget 1Ah (line in) for input */
13108         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13109         /* set pin widget 18h (mic1/2) for input, for mic also enable
13110          * the vref
13111          */
13112         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13113
13114         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13115 #if 0
13116         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13117         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13118 #endif
13119         { } /* end */
13120 };
13121 /* Set mic1 nad line-in as output and mute mixer */
13122 static struct hda_verb alc861_asus_ch6_init[] = {
13123         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13124         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13125         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13126         /* set pin widget 18h (mic1) for output (CLFE)*/
13127         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13128         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13129         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13130         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13131
13132         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13133 #if 0
13134         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13135         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13136 #endif
13137         { } /* end */
13138 };
13139
13140 static struct hda_channel_mode alc861_asus_modes[2] = {
13141         { 2, alc861_asus_ch2_init },
13142         { 6, alc861_asus_ch6_init },
13143 };
13144
13145 /* patch-ALC861 */
13146
13147 static struct snd_kcontrol_new alc861_base_mixer[] = {
13148         /* output mixer control */
13149         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13150         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13151         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13152         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13153         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13154
13155         /*Input mixer control */
13156         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13157            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13158         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13159         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13160         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13161         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13162         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13163         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13164         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13165         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13166
13167         { } /* end */
13168 };
13169
13170 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13171         /* output mixer control */
13172         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13173         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13174         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13175         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13176         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13177
13178         /* Input mixer control */
13179         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13180            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13181         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13182         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13183         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13184         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13185         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13186         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13187         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13188         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13189
13190         {
13191                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13192                 .name = "Channel Mode",
13193                 .info = alc_ch_mode_info,
13194                 .get = alc_ch_mode_get,
13195                 .put = alc_ch_mode_put,
13196                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13197         },
13198         { } /* end */
13199 };
13200
13201 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13202         /* output mixer control */
13203         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13204         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13205         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13206
13207         { } /* end */
13208 };
13209
13210 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13211         /* output mixer control */
13212         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13213         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13214         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13215         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13216         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13217
13218         /* Input mixer control */
13219         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13220            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13221         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13222         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13223         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13224         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13225         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13226         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13227         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13228         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13229
13230         {
13231                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13232                 .name = "Channel Mode",
13233                 .info = alc_ch_mode_info,
13234                 .get = alc_ch_mode_get,
13235                 .put = alc_ch_mode_put,
13236                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13237         },
13238         { } /* end */
13239 };
13240
13241 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13242         /* output mixer control */
13243         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13244         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13245         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13246         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13247         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13248
13249         /* Input mixer control */
13250         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13251         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13252         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13253         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13254         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13255         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13256         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13257         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13258         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13259         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13260
13261         {
13262                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13263                 .name = "Channel Mode",
13264                 .info = alc_ch_mode_info,
13265                 .get = alc_ch_mode_get,
13266                 .put = alc_ch_mode_put,
13267                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13268         },
13269         { }
13270 };
13271
13272 /* additional mixer */
13273 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13274         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13275         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13276         { }
13277 };
13278
13279 /*
13280  * generic initialization of ADC, input mixers and output mixers
13281  */
13282 static struct hda_verb alc861_base_init_verbs[] = {
13283         /*
13284          * Unmute ADC0 and set the default input to mic-in
13285          */
13286         /* port-A for surround (rear panel) */
13287         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13288         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
13289         /* port-B for mic-in (rear panel) with vref */
13290         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13291         /* port-C for line-in (rear panel) */
13292         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13293         /* port-D for Front */
13294         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13295         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13296         /* port-E for HP out (front panel) */
13297         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13298         /* route front PCM to HP */
13299         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13300         /* port-F for mic-in (front panel) with vref */
13301         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13302         /* port-G for CLFE (rear panel) */
13303         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13304         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13305         /* port-H for side (rear panel) */
13306         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13307         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
13308         /* CD-in */
13309         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13310         /* route front mic to ADC1*/
13311         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13312         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13313
13314         /* Unmute DAC0~3 & spdif out*/
13315         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13316         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13317         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13318         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13319         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13320
13321         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13322         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13323         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13324         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13325         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13326
13327         /* Unmute Stereo Mixer 15 */
13328         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13329         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13330         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13331         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13332
13333         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13334         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13335         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13336         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13337         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13338         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13339         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13340         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13341         /* hp used DAC 3 (Front) */
13342         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13343         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13344
13345         { }
13346 };
13347
13348 static struct hda_verb alc861_threestack_init_verbs[] = {
13349         /*
13350          * Unmute ADC0 and set the default input to mic-in
13351          */
13352         /* port-A for surround (rear panel) */
13353         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13354         /* port-B for mic-in (rear panel) with vref */
13355         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13356         /* port-C for line-in (rear panel) */
13357         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13358         /* port-D for Front */
13359         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13360         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13361         /* port-E for HP out (front panel) */
13362         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13363         /* route front PCM to HP */
13364         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13365         /* port-F for mic-in (front panel) with vref */
13366         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13367         /* port-G for CLFE (rear panel) */
13368         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13369         /* port-H for side (rear panel) */
13370         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13371         /* CD-in */
13372         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13373         /* route front mic to ADC1*/
13374         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13375         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13376         /* Unmute DAC0~3 & spdif out*/
13377         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13378         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13379         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13380         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13381         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13382
13383         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13384         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13385         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13386         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13387         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13388
13389         /* Unmute Stereo Mixer 15 */
13390         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13391         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13392         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13393         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13394
13395         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13396         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13397         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13398         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13399         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13400         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13401         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13402         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13403         /* hp used DAC 3 (Front) */
13404         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13405         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13406         { }
13407 };
13408
13409 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
13410         /*
13411          * Unmute ADC0 and set the default input to mic-in
13412          */
13413         /* port-A for surround (rear panel) */
13414         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13415         /* port-B for mic-in (rear panel) with vref */
13416         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13417         /* port-C for line-in (rear panel) */
13418         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13419         /* port-D for Front */
13420         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13421         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13422         /* port-E for HP out (front panel) */
13423         /* this has to be set to VREF80 */
13424         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13425         /* route front PCM to HP */
13426         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13427         /* port-F for mic-in (front panel) with vref */
13428         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13429         /* port-G for CLFE (rear panel) */
13430         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13431         /* port-H for side (rear panel) */
13432         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13433         /* CD-in */
13434         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13435         /* route front mic to ADC1*/
13436         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13437         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13438         /* Unmute DAC0~3 & spdif out*/
13439         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13440         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13441         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13442         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13443         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13444
13445         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13446         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13447         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13448         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13449         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13450
13451         /* Unmute Stereo Mixer 15 */
13452         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13453         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13454         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13455         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13456
13457         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13458         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13459         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13460         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13461         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13462         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13463         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13464         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13465         /* hp used DAC 3 (Front) */
13466         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13467         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13468         { }
13469 };
13470
13471 static struct hda_verb alc861_asus_init_verbs[] = {
13472         /*
13473          * Unmute ADC0 and set the default input to mic-in
13474          */
13475         /* port-A for surround (rear panel)
13476          * according to codec#0 this is the HP jack
13477          */
13478         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
13479         /* route front PCM to HP */
13480         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
13481         /* port-B for mic-in (rear panel) with vref */
13482         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13483         /* port-C for line-in (rear panel) */
13484         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13485         /* port-D for Front */
13486         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13487         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13488         /* port-E for HP out (front panel) */
13489         /* this has to be set to VREF80 */
13490         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13491         /* route front PCM to HP */
13492         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13493         /* port-F for mic-in (front panel) with vref */
13494         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13495         /* port-G for CLFE (rear panel) */
13496         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13497         /* port-H for side (rear panel) */
13498         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13499         /* CD-in */
13500         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13501         /* route front mic to ADC1*/
13502         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13503         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13504         /* Unmute DAC0~3 & spdif out*/
13505         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13506         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13507         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13508         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13509         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13510         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13511         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13512         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13513         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13514         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13515
13516         /* Unmute Stereo Mixer 15 */
13517         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13518         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13519         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13520         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13521
13522         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13523         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13524         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13525         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13526         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13527         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13528         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13529         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13530         /* hp used DAC 3 (Front) */
13531         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13532         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13533         { }
13534 };
13535
13536 /* additional init verbs for ASUS laptops */
13537 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
13538         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
13539         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
13540         { }
13541 };
13542
13543 /*
13544  * generic initialization of ADC, input mixers and output mixers
13545  */
13546 static struct hda_verb alc861_auto_init_verbs[] = {
13547         /*
13548          * Unmute ADC0 and set the default input to mic-in
13549          */
13550         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
13551         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13552
13553         /* Unmute DAC0~3 & spdif out*/
13554         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13555         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13556         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13557         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13558         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13559
13560         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13561         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13562         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13563         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13564         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13565
13566         /* Unmute Stereo Mixer 15 */
13567         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13568         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13569         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13570         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
13571
13572         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13573         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13574         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13575         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13576         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13577         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13578         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13579         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13580
13581         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13582         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13583         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13584         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13585         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13586         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13587         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13588         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13589
13590         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
13591
13592         { }
13593 };
13594
13595 static struct hda_verb alc861_toshiba_init_verbs[] = {
13596         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13597
13598         { }
13599 };
13600
13601 /* toggle speaker-output according to the hp-jack state */
13602 static void alc861_toshiba_automute(struct hda_codec *codec)
13603 {
13604         unsigned int present;
13605
13606         present = snd_hda_codec_read(codec, 0x0f, 0,
13607                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13608         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13609                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13610         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13611                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13612 }
13613
13614 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13615                                        unsigned int res)
13616 {
13617         if ((res >> 26) == ALC880_HP_EVENT)
13618                 alc861_toshiba_automute(codec);
13619 }
13620
13621 /* pcm configuration: identiacal with ALC880 */
13622 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
13623 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
13624 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
13625 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
13626
13627
13628 #define ALC861_DIGOUT_NID       0x07
13629
13630 static struct hda_channel_mode alc861_8ch_modes[1] = {
13631         { 8, NULL }
13632 };
13633
13634 static hda_nid_t alc861_dac_nids[4] = {
13635         /* front, surround, clfe, side */
13636         0x03, 0x06, 0x05, 0x04
13637 };
13638
13639 static hda_nid_t alc660_dac_nids[3] = {
13640         /* front, clfe, surround */
13641         0x03, 0x05, 0x06
13642 };
13643
13644 static hda_nid_t alc861_adc_nids[1] = {
13645         /* ADC0-2 */
13646         0x08,
13647 };
13648
13649 static struct hda_input_mux alc861_capture_source = {
13650         .num_items = 5,
13651         .items = {
13652                 { "Mic", 0x0 },
13653                 { "Front Mic", 0x3 },
13654                 { "Line", 0x1 },
13655                 { "CD", 0x4 },
13656                 { "Mixer", 0x5 },
13657         },
13658 };
13659
13660 /* fill in the dac_nids table from the parsed pin configuration */
13661 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13662                                      const struct auto_pin_cfg *cfg)
13663 {
13664         int i;
13665         hda_nid_t nid;
13666
13667         spec->multiout.dac_nids = spec->private_dac_nids;
13668         for (i = 0; i < cfg->line_outs; i++) {
13669                 nid = cfg->line_out_pins[i];
13670                 if (nid) {
13671                         if (i >= ARRAY_SIZE(alc861_dac_nids))
13672                                 continue;
13673                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13674                 }
13675         }
13676         spec->multiout.num_dacs = cfg->line_outs;
13677         return 0;
13678 }
13679
13680 /* add playback controls from the parsed DAC table */
13681 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13682                                              const struct auto_pin_cfg *cfg)
13683 {
13684         char name[32];
13685         static const char *chname[4] = {
13686                 "Front", "Surround", NULL /*CLFE*/, "Side"
13687         };
13688         hda_nid_t nid;
13689         int i, idx, err;
13690
13691         for (i = 0; i < cfg->line_outs; i++) {
13692                 nid = spec->multiout.dac_nids[i];
13693                 if (!nid)
13694                         continue;
13695                 if (nid == 0x05) {
13696                         /* Center/LFE */
13697                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13698                                           "Center Playback Switch",
13699                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13700                                                               HDA_OUTPUT));
13701                         if (err < 0)
13702                                 return err;
13703                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13704                                           "LFE Playback Switch",
13705                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13706                                                               HDA_OUTPUT));
13707                         if (err < 0)
13708                                 return err;
13709                 } else {
13710                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13711                              idx++)
13712                                 if (nid == alc861_dac_nids[idx])
13713                                         break;
13714                         sprintf(name, "%s Playback Switch", chname[idx]);
13715                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13716                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13717                                                               HDA_OUTPUT));
13718                         if (err < 0)
13719                                 return err;
13720                 }
13721         }
13722         return 0;
13723 }
13724
13725 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13726 {
13727         int err;
13728         hda_nid_t nid;
13729
13730         if (!pin)
13731                 return 0;
13732
13733         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13734                 nid = 0x03;
13735                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13736                                   "Headphone Playback Switch",
13737                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13738                 if (err < 0)
13739                         return err;
13740                 spec->multiout.hp_nid = nid;
13741         }
13742         return 0;
13743 }
13744
13745 /* create playback/capture controls for input pins */
13746 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13747                                                 const struct auto_pin_cfg *cfg)
13748 {
13749         struct hda_input_mux *imux = &spec->private_imux[0];
13750         int i, err, idx, idx1;
13751
13752         for (i = 0; i < AUTO_PIN_LAST; i++) {
13753                 switch (cfg->input_pins[i]) {
13754                 case 0x0c:
13755                         idx1 = 1;
13756                         idx = 2;        /* Line In */
13757                         break;
13758                 case 0x0f:
13759                         idx1 = 2;
13760                         idx = 2;        /* Line In */
13761                         break;
13762                 case 0x0d:
13763                         idx1 = 0;
13764                         idx = 1;        /* Mic In */
13765                         break;
13766                 case 0x10:
13767                         idx1 = 3;
13768                         idx = 1;        /* Mic In */
13769                         break;
13770                 case 0x11:
13771                         idx1 = 4;
13772                         idx = 0;        /* CD */
13773                         break;
13774                 default:
13775                         continue;
13776                 }
13777
13778                 err = new_analog_input(spec, cfg->input_pins[i],
13779                                        auto_pin_cfg_labels[i], idx, 0x15);
13780                 if (err < 0)
13781                         return err;
13782
13783                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13784                 imux->items[imux->num_items].index = idx1;
13785                 imux->num_items++;
13786         }
13787         return 0;
13788 }
13789
13790 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13791                                               hda_nid_t nid,
13792                                               int pin_type, int dac_idx)
13793 {
13794         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13795                             pin_type);
13796         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13797                             AMP_OUT_UNMUTE);
13798 }
13799
13800 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13801 {
13802         struct alc_spec *spec = codec->spec;
13803         int i;
13804
13805         alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
13806         for (i = 0; i < spec->autocfg.line_outs; i++) {
13807                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13808                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13809                 if (nid)
13810                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13811                                                           spec->multiout.dac_nids[i]);
13812         }
13813 }
13814
13815 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13816 {
13817         struct alc_spec *spec = codec->spec;
13818         hda_nid_t pin;
13819
13820         pin = spec->autocfg.hp_pins[0];
13821         if (pin) /* connect to front */
13822                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13823                                                   spec->multiout.dac_nids[0]);
13824         pin = spec->autocfg.speaker_pins[0];
13825         if (pin)
13826                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13827 }
13828
13829 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13830 {
13831         struct alc_spec *spec = codec->spec;
13832         int i;
13833
13834         for (i = 0; i < AUTO_PIN_LAST; i++) {
13835                 hda_nid_t nid = spec->autocfg.input_pins[i];
13836                 if (nid >= 0x0c && nid <= 0x11)
13837                         alc_set_input_pin(codec, nid, i);
13838         }
13839 }
13840
13841 /* parse the BIOS configuration and set up the alc_spec */
13842 /* return 1 if successful, 0 if the proper config is not found,
13843  * or a negative error code
13844  */
13845 static int alc861_parse_auto_config(struct hda_codec *codec)
13846 {
13847         struct alc_spec *spec = codec->spec;
13848         int err;
13849         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
13850
13851         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13852                                            alc861_ignore);
13853         if (err < 0)
13854                 return err;
13855         if (!spec->autocfg.line_outs)
13856                 return 0; /* can't find valid BIOS pin config */
13857
13858         err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
13859         if (err < 0)
13860                 return err;
13861         err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
13862         if (err < 0)
13863                 return err;
13864         err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
13865         if (err < 0)
13866                 return err;
13867         err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
13868         if (err < 0)
13869                 return err;
13870
13871         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13872
13873         if (spec->autocfg.dig_outs)
13874                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
13875
13876         if (spec->kctls.list)
13877                 add_mixer(spec, spec->kctls.list);
13878
13879         add_verb(spec, alc861_auto_init_verbs);
13880
13881         spec->num_mux_defs = 1;
13882         spec->input_mux = &spec->private_imux[0];
13883
13884         spec->adc_nids = alc861_adc_nids;
13885         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
13886         set_capture_mixer(spec);
13887
13888         return 1;
13889 }
13890
13891 /* additional initialization for auto-configuration model */
13892 static void alc861_auto_init(struct hda_codec *codec)
13893 {
13894         struct alc_spec *spec = codec->spec;
13895         alc861_auto_init_multi_out(codec);
13896         alc861_auto_init_hp_out(codec);
13897         alc861_auto_init_analog_input(codec);
13898         if (spec->unsol_event)
13899                 alc_inithook(codec);
13900 }
13901
13902 #ifdef CONFIG_SND_HDA_POWER_SAVE
13903 static struct hda_amp_list alc861_loopbacks[] = {
13904         { 0x15, HDA_INPUT, 0 },
13905         { 0x15, HDA_INPUT, 1 },
13906         { 0x15, HDA_INPUT, 2 },
13907         { 0x15, HDA_INPUT, 3 },
13908         { } /* end */
13909 };
13910 #endif
13911
13912
13913 /*
13914  * configuration and preset
13915  */
13916 static const char *alc861_models[ALC861_MODEL_LAST] = {
13917         [ALC861_3ST]            = "3stack",
13918         [ALC660_3ST]            = "3stack-660",
13919         [ALC861_3ST_DIG]        = "3stack-dig",
13920         [ALC861_6ST_DIG]        = "6stack-dig",
13921         [ALC861_UNIWILL_M31]    = "uniwill-m31",
13922         [ALC861_TOSHIBA]        = "toshiba",
13923         [ALC861_ASUS]           = "asus",
13924         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
13925         [ALC861_AUTO]           = "auto",
13926 };
13927
13928 static struct snd_pci_quirk alc861_cfg_tbl[] = {
13929         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
13930         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13931         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13932         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
13933         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
13934         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
13935         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
13936         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
13937          *        Any other models that need this preset?
13938          */
13939         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
13940         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
13941         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
13942         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
13943         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
13944         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
13945         /* FIXME: the below seems conflict */
13946         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
13947         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
13948         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
13949         {}
13950 };
13951
13952 static struct alc_config_preset alc861_presets[] = {
13953         [ALC861_3ST] = {
13954                 .mixers = { alc861_3ST_mixer },
13955                 .init_verbs = { alc861_threestack_init_verbs },
13956                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13957                 .dac_nids = alc861_dac_nids,
13958                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13959                 .channel_mode = alc861_threestack_modes,
13960                 .need_dac_fix = 1,
13961                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13962                 .adc_nids = alc861_adc_nids,
13963                 .input_mux = &alc861_capture_source,
13964         },
13965         [ALC861_3ST_DIG] = {
13966                 .mixers = { alc861_base_mixer },
13967                 .init_verbs = { alc861_threestack_init_verbs },
13968                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13969                 .dac_nids = alc861_dac_nids,
13970                 .dig_out_nid = ALC861_DIGOUT_NID,
13971                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13972                 .channel_mode = alc861_threestack_modes,
13973                 .need_dac_fix = 1,
13974                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13975                 .adc_nids = alc861_adc_nids,
13976                 .input_mux = &alc861_capture_source,
13977         },
13978         [ALC861_6ST_DIG] = {
13979                 .mixers = { alc861_base_mixer },
13980                 .init_verbs = { alc861_base_init_verbs },
13981                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13982                 .dac_nids = alc861_dac_nids,
13983                 .dig_out_nid = ALC861_DIGOUT_NID,
13984                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
13985                 .channel_mode = alc861_8ch_modes,
13986                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13987                 .adc_nids = alc861_adc_nids,
13988                 .input_mux = &alc861_capture_source,
13989         },
13990         [ALC660_3ST] = {
13991                 .mixers = { alc861_3ST_mixer },
13992                 .init_verbs = { alc861_threestack_init_verbs },
13993                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
13994                 .dac_nids = alc660_dac_nids,
13995                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13996                 .channel_mode = alc861_threestack_modes,
13997                 .need_dac_fix = 1,
13998                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13999                 .adc_nids = alc861_adc_nids,
14000                 .input_mux = &alc861_capture_source,
14001         },
14002         [ALC861_UNIWILL_M31] = {
14003                 .mixers = { alc861_uniwill_m31_mixer },
14004                 .init_verbs = { alc861_uniwill_m31_init_verbs },
14005                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14006                 .dac_nids = alc861_dac_nids,
14007                 .dig_out_nid = ALC861_DIGOUT_NID,
14008                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14009                 .channel_mode = alc861_uniwill_m31_modes,
14010                 .need_dac_fix = 1,
14011                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14012                 .adc_nids = alc861_adc_nids,
14013                 .input_mux = &alc861_capture_source,
14014         },
14015         [ALC861_TOSHIBA] = {
14016                 .mixers = { alc861_toshiba_mixer },
14017                 .init_verbs = { alc861_base_init_verbs,
14018                                 alc861_toshiba_init_verbs },
14019                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14020                 .dac_nids = alc861_dac_nids,
14021                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14022                 .channel_mode = alc883_3ST_2ch_modes,
14023                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14024                 .adc_nids = alc861_adc_nids,
14025                 .input_mux = &alc861_capture_source,
14026                 .unsol_event = alc861_toshiba_unsol_event,
14027                 .init_hook = alc861_toshiba_automute,
14028         },
14029         [ALC861_ASUS] = {
14030                 .mixers = { alc861_asus_mixer },
14031                 .init_verbs = { alc861_asus_init_verbs },
14032                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14033                 .dac_nids = alc861_dac_nids,
14034                 .dig_out_nid = ALC861_DIGOUT_NID,
14035                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14036                 .channel_mode = alc861_asus_modes,
14037                 .need_dac_fix = 1,
14038                 .hp_nid = 0x06,
14039                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14040                 .adc_nids = alc861_adc_nids,
14041                 .input_mux = &alc861_capture_source,
14042         },
14043         [ALC861_ASUS_LAPTOP] = {
14044                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14045                 .init_verbs = { alc861_asus_init_verbs,
14046                                 alc861_asus_laptop_init_verbs },
14047                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14048                 .dac_nids = alc861_dac_nids,
14049                 .dig_out_nid = ALC861_DIGOUT_NID,
14050                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14051                 .channel_mode = alc883_3ST_2ch_modes,
14052                 .need_dac_fix = 1,
14053                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14054                 .adc_nids = alc861_adc_nids,
14055                 .input_mux = &alc861_capture_source,
14056         },
14057 };
14058
14059
14060 static int patch_alc861(struct hda_codec *codec)
14061 {
14062         struct alc_spec *spec;
14063         int board_config;
14064         int err;
14065
14066         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14067         if (spec == NULL)
14068                 return -ENOMEM;
14069
14070         codec->spec = spec;
14071
14072         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14073                                                   alc861_models,
14074                                                   alc861_cfg_tbl);
14075
14076         if (board_config < 0) {
14077                 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
14078                        "trying auto-probe from BIOS...\n");
14079                 board_config = ALC861_AUTO;
14080         }
14081
14082         if (board_config == ALC861_AUTO) {
14083                 /* automatic parse from the BIOS config */
14084                 err = alc861_parse_auto_config(codec);
14085                 if (err < 0) {
14086                         alc_free(codec);
14087                         return err;
14088                 } else if (!err) {
14089                         printk(KERN_INFO
14090                                "hda_codec: Cannot set up configuration "
14091                                "from BIOS.  Using base mode...\n");
14092                    board_config = ALC861_3ST_DIG;
14093                 }
14094         }
14095
14096         err = snd_hda_attach_beep_device(codec, 0x23);
14097         if (err < 0) {
14098                 alc_free(codec);
14099                 return err;
14100         }
14101
14102         if (board_config != ALC861_AUTO)
14103                 setup_preset(spec, &alc861_presets[board_config]);
14104
14105         spec->stream_name_analog = "ALC861 Analog";
14106         spec->stream_analog_playback = &alc861_pcm_analog_playback;
14107         spec->stream_analog_capture = &alc861_pcm_analog_capture;
14108
14109         spec->stream_name_digital = "ALC861 Digital";
14110         spec->stream_digital_playback = &alc861_pcm_digital_playback;
14111         spec->stream_digital_capture = &alc861_pcm_digital_capture;
14112
14113         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14114
14115         spec->vmaster_nid = 0x03;
14116
14117         codec->patch_ops = alc_patch_ops;
14118         if (board_config == ALC861_AUTO)
14119                 spec->init_hook = alc861_auto_init;
14120 #ifdef CONFIG_SND_HDA_POWER_SAVE
14121         if (!spec->loopback.amplist)
14122                 spec->loopback.amplist = alc861_loopbacks;
14123 #endif
14124         codec->proc_widget_hook = print_realtek_coef;
14125
14126         return 0;
14127 }
14128
14129 /*
14130  * ALC861-VD support
14131  *
14132  * Based on ALC882
14133  *
14134  * In addition, an independent DAC
14135  */
14136 #define ALC861VD_DIGOUT_NID     0x06
14137
14138 static hda_nid_t alc861vd_dac_nids[4] = {
14139         /* front, surr, clfe, side surr */
14140         0x02, 0x03, 0x04, 0x05
14141 };
14142
14143 /* dac_nids for ALC660vd are in a different order - according to
14144  * Realtek's driver.
14145  * This should probably tesult in a different mixer for 6stack models
14146  * of ALC660vd codecs, but for now there is only 3stack mixer
14147  * - and it is the same as in 861vd.
14148  * adc_nids in ALC660vd are (is) the same as in 861vd
14149  */
14150 static hda_nid_t alc660vd_dac_nids[3] = {
14151         /* front, rear, clfe, rear_surr */
14152         0x02, 0x04, 0x03
14153 };
14154
14155 static hda_nid_t alc861vd_adc_nids[1] = {
14156         /* ADC0 */
14157         0x09,
14158 };
14159
14160 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14161
14162 /* input MUX */
14163 /* FIXME: should be a matrix-type input source selection */
14164 static struct hda_input_mux alc861vd_capture_source = {
14165         .num_items = 4,
14166         .items = {
14167                 { "Mic", 0x0 },
14168                 { "Front Mic", 0x1 },
14169                 { "Line", 0x2 },
14170                 { "CD", 0x4 },
14171         },
14172 };
14173
14174 static struct hda_input_mux alc861vd_dallas_capture_source = {
14175         .num_items = 2,
14176         .items = {
14177                 { "Ext Mic", 0x0 },
14178                 { "Int Mic", 0x1 },
14179         },
14180 };
14181
14182 static struct hda_input_mux alc861vd_hp_capture_source = {
14183         .num_items = 2,
14184         .items = {
14185                 { "Front Mic", 0x0 },
14186                 { "ATAPI Mic", 0x1 },
14187         },
14188 };
14189
14190 /*
14191  * 2ch mode
14192  */
14193 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14194         { 2, NULL }
14195 };
14196
14197 /*
14198  * 6ch mode
14199  */
14200 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14201         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14202         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14203         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14204         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14205         { } /* end */
14206 };
14207
14208 /*
14209  * 8ch mode
14210  */
14211 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14212         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14213         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14214         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14215         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14216         { } /* end */
14217 };
14218
14219 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14220         { 6, alc861vd_6stack_ch6_init },
14221         { 8, alc861vd_6stack_ch8_init },
14222 };
14223
14224 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14225         {
14226                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14227                 .name = "Channel Mode",
14228                 .info = alc_ch_mode_info,
14229                 .get = alc_ch_mode_get,
14230                 .put = alc_ch_mode_put,
14231         },
14232         { } /* end */
14233 };
14234
14235 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14236  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14237  */
14238 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14239         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14240         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14241
14242         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14243         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14244
14245         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14246                                 HDA_OUTPUT),
14247         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14248                                 HDA_OUTPUT),
14249         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14250         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14251
14252         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14253         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14254
14255         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14256
14257         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14258         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14259         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14260
14261         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14262         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14263         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14264
14265         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14266         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14267
14268         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14269         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14270
14271         { } /* end */
14272 };
14273
14274 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
14275         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14276         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14277
14278         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14279
14280         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14281         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14282         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14283
14284         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14285         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14286         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14287
14288         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14289         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14290
14291         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14292         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14293
14294         { } /* end */
14295 };
14296
14297 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
14298         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14299         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
14300         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14301
14302         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14303
14304         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14305         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14306         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14307
14308         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14309         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14310         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14311
14312         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14313         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14314
14315         { } /* end */
14316 };
14317
14318 /* Pin assignment: Speaker=0x14, HP = 0x15,
14319  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
14320  */
14321 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
14322         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14323         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
14324         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14325         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14326         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
14327         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14328         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14329         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
14330         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14331         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14332         { } /* end */
14333 };
14334
14335 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
14336  *                 Front Mic=0x18, ATAPI Mic = 0x19,
14337  */
14338 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
14339         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14340         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14341         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14342         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14343         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14344         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14345         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14346         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14347
14348         { } /* end */
14349 };
14350
14351 /*
14352  * generic initialization of ADC, input mixers and output mixers
14353  */
14354 static struct hda_verb alc861vd_volume_init_verbs[] = {
14355         /*
14356          * Unmute ADC0 and set the default input to mic-in
14357          */
14358         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14359         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14360
14361         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
14362          * the analog-loopback mixer widget
14363          */
14364         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14365         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14366         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14367         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14368         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14369         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14370
14371         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
14372         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14373         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14374         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14375         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14376
14377         /*
14378          * Set up output mixers (0x02 - 0x05)
14379          */
14380         /* set vol=0 to output mixers */
14381         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14382         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14383         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14384         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14385
14386         /* set up input amps for analog loopback */
14387         /* Amp Indices: DAC = 0, mixer = 1 */
14388         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14389         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14390         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14391         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14392         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14393         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14394         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14395         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14396
14397         { }
14398 };
14399
14400 /*
14401  * 3-stack pin configuration:
14402  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
14403  */
14404 static struct hda_verb alc861vd_3stack_init_verbs[] = {
14405         /*
14406          * Set pin mode and muting
14407          */
14408         /* set front pin widgets 0x14 for output */
14409         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14410         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14411         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14412
14413         /* Mic (rear) pin: input vref at 80% */
14414         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14415         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14416         /* Front Mic pin: input vref at 80% */
14417         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14418         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14419         /* Line In pin: input */
14420         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14421         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14422         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14423         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14424         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14425         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14426         /* CD pin widget for input */
14427         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14428
14429         { }
14430 };
14431
14432 /*
14433  * 6-stack pin configuration:
14434  */
14435 static struct hda_verb alc861vd_6stack_init_verbs[] = {
14436         /*
14437          * Set pin mode and muting
14438          */
14439         /* set front pin widgets 0x14 for output */
14440         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14441         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14442         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14443
14444         /* Rear Pin: output 1 (0x0d) */
14445         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14446         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14447         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14448         /* CLFE Pin: output 2 (0x0e) */
14449         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14450         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14451         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
14452         /* Side Pin: output 3 (0x0f) */
14453         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14454         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14455         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
14456
14457         /* Mic (rear) pin: input vref at 80% */
14458         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14459         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14460         /* Front Mic pin: input vref at 80% */
14461         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14462         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14463         /* Line In pin: input */
14464         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14465         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14466         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14467         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14468         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14469         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14470         /* CD pin widget for input */
14471         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14472
14473         { }
14474 };
14475
14476 static struct hda_verb alc861vd_eapd_verbs[] = {
14477         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14478         { }
14479 };
14480
14481 static struct hda_verb alc660vd_eapd_verbs[] = {
14482         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14483         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14484         { }
14485 };
14486
14487 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
14488         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14489         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14490         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
14491         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14492         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14493         {}
14494 };
14495
14496 /* toggle speaker-output according to the hp-jack state */
14497 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
14498 {
14499         unsigned int present;
14500         unsigned char bits;
14501
14502         present = snd_hda_codec_read(codec, 0x1b, 0,
14503                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14504         bits = present ? HDA_AMP_MUTE : 0;
14505         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14506                                  HDA_AMP_MUTE, bits);
14507 }
14508
14509 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
14510 {
14511         unsigned int present;
14512         unsigned char bits;
14513
14514         present = snd_hda_codec_read(codec, 0x18, 0,
14515                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14516         bits = present ? HDA_AMP_MUTE : 0;
14517         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
14518                                  HDA_AMP_MUTE, bits);
14519 }
14520
14521 static void alc861vd_lenovo_automute(struct hda_codec *codec)
14522 {
14523         alc861vd_lenovo_hp_automute(codec);
14524         alc861vd_lenovo_mic_automute(codec);
14525 }
14526
14527 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
14528                                         unsigned int res)
14529 {
14530         switch (res >> 26) {
14531         case ALC880_HP_EVENT:
14532                 alc861vd_lenovo_hp_automute(codec);
14533                 break;
14534         case ALC880_MIC_EVENT:
14535                 alc861vd_lenovo_mic_automute(codec);
14536                 break;
14537         }
14538 }
14539
14540 static struct hda_verb alc861vd_dallas_verbs[] = {
14541         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14542         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14543         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14544         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14545
14546         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14547         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14548         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14549         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14550         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14551         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14552         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14553         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14554
14555         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14556         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14557         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14558         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14559         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14560         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14561         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14562         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14563
14564         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14565         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14566         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14567         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14568         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14569         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14570         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14571         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14572
14573         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14574         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14575         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14576         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14577
14578         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14579         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14580         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14581
14582         { } /* end */
14583 };
14584
14585 /* toggle speaker-output according to the hp-jack state */
14586 static void alc861vd_dallas_automute(struct hda_codec *codec)
14587 {
14588         unsigned int present;
14589
14590         present = snd_hda_codec_read(codec, 0x15, 0,
14591                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14592         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14593                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14594 }
14595
14596 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
14597 {
14598         if ((res >> 26) == ALC880_HP_EVENT)
14599                 alc861vd_dallas_automute(codec);
14600 }
14601
14602 #ifdef CONFIG_SND_HDA_POWER_SAVE
14603 #define alc861vd_loopbacks      alc880_loopbacks
14604 #endif
14605
14606 /* pcm configuration: identiacal with ALC880 */
14607 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
14608 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
14609 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
14610 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
14611
14612 /*
14613  * configuration and preset
14614  */
14615 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14616         [ALC660VD_3ST]          = "3stack-660",
14617         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
14618         [ALC660VD_ASUS_V1S]     = "asus-v1s",
14619         [ALC861VD_3ST]          = "3stack",
14620         [ALC861VD_3ST_DIG]      = "3stack-digout",
14621         [ALC861VD_6ST_DIG]      = "6stack-digout",
14622         [ALC861VD_LENOVO]       = "lenovo",
14623         [ALC861VD_DALLAS]       = "dallas",
14624         [ALC861VD_HP]           = "hp",
14625         [ALC861VD_AUTO]         = "auto",
14626 };
14627
14628 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14629         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14630         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14631         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14632         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14633         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
14634         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14635         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14636         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14637         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14638         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14639         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14640         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14641         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14642         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
14643         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14644         {}
14645 };
14646
14647 static struct alc_config_preset alc861vd_presets[] = {
14648         [ALC660VD_3ST] = {
14649                 .mixers = { alc861vd_3st_mixer },
14650                 .init_verbs = { alc861vd_volume_init_verbs,
14651                                  alc861vd_3stack_init_verbs },
14652                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14653                 .dac_nids = alc660vd_dac_nids,
14654                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14655                 .channel_mode = alc861vd_3stack_2ch_modes,
14656                 .input_mux = &alc861vd_capture_source,
14657         },
14658         [ALC660VD_3ST_DIG] = {
14659                 .mixers = { alc861vd_3st_mixer },
14660                 .init_verbs = { alc861vd_volume_init_verbs,
14661                                  alc861vd_3stack_init_verbs },
14662                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14663                 .dac_nids = alc660vd_dac_nids,
14664                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14665                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14666                 .channel_mode = alc861vd_3stack_2ch_modes,
14667                 .input_mux = &alc861vd_capture_source,
14668         },
14669         [ALC861VD_3ST] = {
14670                 .mixers = { alc861vd_3st_mixer },
14671                 .init_verbs = { alc861vd_volume_init_verbs,
14672                                  alc861vd_3stack_init_verbs },
14673                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14674                 .dac_nids = alc861vd_dac_nids,
14675                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14676                 .channel_mode = alc861vd_3stack_2ch_modes,
14677                 .input_mux = &alc861vd_capture_source,
14678         },
14679         [ALC861VD_3ST_DIG] = {
14680                 .mixers = { alc861vd_3st_mixer },
14681                 .init_verbs = { alc861vd_volume_init_verbs,
14682                                  alc861vd_3stack_init_verbs },
14683                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14684                 .dac_nids = alc861vd_dac_nids,
14685                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14686                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14687                 .channel_mode = alc861vd_3stack_2ch_modes,
14688                 .input_mux = &alc861vd_capture_source,
14689         },
14690         [ALC861VD_6ST_DIG] = {
14691                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14692                 .init_verbs = { alc861vd_volume_init_verbs,
14693                                 alc861vd_6stack_init_verbs },
14694                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14695                 .dac_nids = alc861vd_dac_nids,
14696                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14697                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14698                 .channel_mode = alc861vd_6stack_modes,
14699                 .input_mux = &alc861vd_capture_source,
14700         },
14701         [ALC861VD_LENOVO] = {
14702                 .mixers = { alc861vd_lenovo_mixer },
14703                 .init_verbs = { alc861vd_volume_init_verbs,
14704                                 alc861vd_3stack_init_verbs,
14705                                 alc861vd_eapd_verbs,
14706                                 alc861vd_lenovo_unsol_verbs },
14707                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14708                 .dac_nids = alc660vd_dac_nids,
14709                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14710                 .channel_mode = alc861vd_3stack_2ch_modes,
14711                 .input_mux = &alc861vd_capture_source,
14712                 .unsol_event = alc861vd_lenovo_unsol_event,
14713                 .init_hook = alc861vd_lenovo_automute,
14714         },
14715         [ALC861VD_DALLAS] = {
14716                 .mixers = { alc861vd_dallas_mixer },
14717                 .init_verbs = { alc861vd_dallas_verbs },
14718                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14719                 .dac_nids = alc861vd_dac_nids,
14720                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14721                 .channel_mode = alc861vd_3stack_2ch_modes,
14722                 .input_mux = &alc861vd_dallas_capture_source,
14723                 .unsol_event = alc861vd_dallas_unsol_event,
14724                 .init_hook = alc861vd_dallas_automute,
14725         },
14726         [ALC861VD_HP] = {
14727                 .mixers = { alc861vd_hp_mixer },
14728                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14729                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14730                 .dac_nids = alc861vd_dac_nids,
14731                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14732                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14733                 .channel_mode = alc861vd_3stack_2ch_modes,
14734                 .input_mux = &alc861vd_hp_capture_source,
14735                 .unsol_event = alc861vd_dallas_unsol_event,
14736                 .init_hook = alc861vd_dallas_automute,
14737         },
14738         [ALC660VD_ASUS_V1S] = {
14739                 .mixers = { alc861vd_lenovo_mixer },
14740                 .init_verbs = { alc861vd_volume_init_verbs,
14741                                 alc861vd_3stack_init_verbs,
14742                                 alc861vd_eapd_verbs,
14743                                 alc861vd_lenovo_unsol_verbs },
14744                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14745                 .dac_nids = alc660vd_dac_nids,
14746                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14747                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14748                 .channel_mode = alc861vd_3stack_2ch_modes,
14749                 .input_mux = &alc861vd_capture_source,
14750                 .unsol_event = alc861vd_lenovo_unsol_event,
14751                 .init_hook = alc861vd_lenovo_automute,
14752         },
14753 };
14754
14755 /*
14756  * BIOS auto configuration
14757  */
14758 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14759                                 hda_nid_t nid, int pin_type, int dac_idx)
14760 {
14761         alc_set_pin_output(codec, nid, pin_type);
14762 }
14763
14764 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14765 {
14766         struct alc_spec *spec = codec->spec;
14767         int i;
14768
14769         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14770         for (i = 0; i <= HDA_SIDE; i++) {
14771                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14772                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14773                 if (nid)
14774                         alc861vd_auto_set_output_and_unmute(codec, nid,
14775                                                             pin_type, i);
14776         }
14777 }
14778
14779
14780 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14781 {
14782         struct alc_spec *spec = codec->spec;
14783         hda_nid_t pin;
14784
14785         pin = spec->autocfg.hp_pins[0];
14786         if (pin) /* connect to front and  use dac 0 */
14787                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14788         pin = spec->autocfg.speaker_pins[0];
14789         if (pin)
14790                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14791 }
14792
14793 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
14794 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
14795
14796 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14797 {
14798         struct alc_spec *spec = codec->spec;
14799         int i;
14800
14801         for (i = 0; i < AUTO_PIN_LAST; i++) {
14802                 hda_nid_t nid = spec->autocfg.input_pins[i];
14803                 if (alc861vd_is_input_pin(nid)) {
14804                         alc_set_input_pin(codec, nid, i);
14805                         if (nid != ALC861VD_PIN_CD_NID)
14806                                 snd_hda_codec_write(codec, nid, 0,
14807                                                 AC_VERB_SET_AMP_GAIN_MUTE,
14808                                                 AMP_OUT_MUTE);
14809                 }
14810         }
14811 }
14812
14813 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
14814
14815 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
14816 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
14817
14818 /* add playback controls from the parsed DAC table */
14819 /* Based on ALC880 version. But ALC861VD has separate,
14820  * different NIDs for mute/unmute switch and volume control */
14821 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14822                                              const struct auto_pin_cfg *cfg)
14823 {
14824         char name[32];
14825         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14826         hda_nid_t nid_v, nid_s;
14827         int i, err;
14828
14829         for (i = 0; i < cfg->line_outs; i++) {
14830                 if (!spec->multiout.dac_nids[i])
14831                         continue;
14832                 nid_v = alc861vd_idx_to_mixer_vol(
14833                                 alc880_dac_to_idx(
14834                                         spec->multiout.dac_nids[i]));
14835                 nid_s = alc861vd_idx_to_mixer_switch(
14836                                 alc880_dac_to_idx(
14837                                         spec->multiout.dac_nids[i]));
14838
14839                 if (i == 2) {
14840                         /* Center/LFE */
14841                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14842                                           "Center Playback Volume",
14843                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14844                                                               HDA_OUTPUT));
14845                         if (err < 0)
14846                                 return err;
14847                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14848                                           "LFE Playback Volume",
14849                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14850                                                               HDA_OUTPUT));
14851                         if (err < 0)
14852                                 return err;
14853                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14854                                           "Center Playback Switch",
14855                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
14856                                                               HDA_INPUT));
14857                         if (err < 0)
14858                                 return err;
14859                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14860                                           "LFE Playback Switch",
14861                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
14862                                                               HDA_INPUT));
14863                         if (err < 0)
14864                                 return err;
14865                 } else {
14866                         sprintf(name, "%s Playback Volume", chname[i]);
14867                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14868                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
14869                                                               HDA_OUTPUT));
14870                         if (err < 0)
14871                                 return err;
14872                         sprintf(name, "%s Playback Switch", chname[i]);
14873                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14874                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
14875                                                               HDA_INPUT));
14876                         if (err < 0)
14877                                 return err;
14878                 }
14879         }
14880         return 0;
14881 }
14882
14883 /* add playback controls for speaker and HP outputs */
14884 /* Based on ALC880 version. But ALC861VD has separate,
14885  * different NIDs for mute/unmute switch and volume control */
14886 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
14887                                         hda_nid_t pin, const char *pfx)
14888 {
14889         hda_nid_t nid_v, nid_s;
14890         int err;
14891         char name[32];
14892
14893         if (!pin)
14894                 return 0;
14895
14896         if (alc880_is_fixed_pin(pin)) {
14897                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14898                 /* specify the DAC as the extra output */
14899                 if (!spec->multiout.hp_nid)
14900                         spec->multiout.hp_nid = nid_v;
14901                 else
14902                         spec->multiout.extra_out_nid[0] = nid_v;
14903                 /* control HP volume/switch on the output mixer amp */
14904                 nid_v = alc861vd_idx_to_mixer_vol(
14905                                 alc880_fixed_pin_idx(pin));
14906                 nid_s = alc861vd_idx_to_mixer_switch(
14907                                 alc880_fixed_pin_idx(pin));
14908
14909                 sprintf(name, "%s Playback Volume", pfx);
14910                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14911                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
14912                 if (err < 0)
14913                         return err;
14914                 sprintf(name, "%s Playback Switch", pfx);
14915                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14916                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
14917                 if (err < 0)
14918                         return err;
14919         } else if (alc880_is_multi_pin(pin)) {
14920                 /* set manual connection */
14921                 /* we have only a switch on HP-out PIN */
14922                 sprintf(name, "%s Playback Switch", pfx);
14923                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
14924                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
14925                 if (err < 0)
14926                         return err;
14927         }
14928         return 0;
14929 }
14930
14931 /* parse the BIOS configuration and set up the alc_spec
14932  * return 1 if successful, 0 if the proper config is not found,
14933  * or a negative error code
14934  * Based on ALC880 version - had to change it to override
14935  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
14936 static int alc861vd_parse_auto_config(struct hda_codec *codec)
14937 {
14938         struct alc_spec *spec = codec->spec;
14939         int err;
14940         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
14941
14942         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14943                                            alc861vd_ignore);
14944         if (err < 0)
14945                 return err;
14946         if (!spec->autocfg.line_outs)
14947                 return 0; /* can't find valid BIOS pin config */
14948
14949         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
14950         if (err < 0)
14951                 return err;
14952         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
14953         if (err < 0)
14954                 return err;
14955         err = alc861vd_auto_create_extra_out(spec,
14956                                              spec->autocfg.speaker_pins[0],
14957                                              "Speaker");
14958         if (err < 0)
14959                 return err;
14960         err = alc861vd_auto_create_extra_out(spec,
14961                                              spec->autocfg.hp_pins[0],
14962                                              "Headphone");
14963         if (err < 0)
14964                 return err;
14965         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
14966         if (err < 0)
14967                 return err;
14968
14969         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14970
14971         if (spec->autocfg.dig_outs)
14972                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
14973
14974         if (spec->kctls.list)
14975                 add_mixer(spec, spec->kctls.list);
14976
14977         add_verb(spec, alc861vd_volume_init_verbs);
14978
14979         spec->num_mux_defs = 1;
14980         spec->input_mux = &spec->private_imux[0];
14981
14982         err = alc_auto_add_mic_boost(codec);
14983         if (err < 0)
14984                 return err;
14985
14986         return 1;
14987 }
14988
14989 /* additional initialization for auto-configuration model */
14990 static void alc861vd_auto_init(struct hda_codec *codec)
14991 {
14992         struct alc_spec *spec = codec->spec;
14993         alc861vd_auto_init_multi_out(codec);
14994         alc861vd_auto_init_hp_out(codec);
14995         alc861vd_auto_init_analog_input(codec);
14996         alc861vd_auto_init_input_src(codec);
14997         if (spec->unsol_event)
14998                 alc_inithook(codec);
14999 }
15000
15001 static int patch_alc861vd(struct hda_codec *codec)
15002 {
15003         struct alc_spec *spec;
15004         int err, board_config;
15005
15006         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15007         if (spec == NULL)
15008                 return -ENOMEM;
15009
15010         codec->spec = spec;
15011
15012         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15013                                                   alc861vd_models,
15014                                                   alc861vd_cfg_tbl);
15015
15016         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15017                 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
15018                         "ALC861VD, trying auto-probe from BIOS...\n");
15019                 board_config = ALC861VD_AUTO;
15020         }
15021
15022         if (board_config == ALC861VD_AUTO) {
15023                 /* automatic parse from the BIOS config */
15024                 err = alc861vd_parse_auto_config(codec);
15025                 if (err < 0) {
15026                         alc_free(codec);
15027                         return err;
15028                 } else if (!err) {
15029                         printk(KERN_INFO
15030                                "hda_codec: Cannot set up configuration "
15031                                "from BIOS.  Using base mode...\n");
15032                         board_config = ALC861VD_3ST;
15033                 }
15034         }
15035
15036         err = snd_hda_attach_beep_device(codec, 0x23);
15037         if (err < 0) {
15038                 alc_free(codec);
15039                 return err;
15040         }
15041
15042         if (board_config != ALC861VD_AUTO)
15043                 setup_preset(spec, &alc861vd_presets[board_config]);
15044
15045         if (codec->vendor_id == 0x10ec0660) {
15046                 spec->stream_name_analog = "ALC660-VD Analog";
15047                 spec->stream_name_digital = "ALC660-VD Digital";
15048                 /* always turn on EAPD */
15049                 add_verb(spec, alc660vd_eapd_verbs);
15050         } else {
15051                 spec->stream_name_analog = "ALC861VD Analog";
15052                 spec->stream_name_digital = "ALC861VD Digital";
15053         }
15054
15055         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15056         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15057
15058         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15059         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15060
15061         spec->adc_nids = alc861vd_adc_nids;
15062         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15063         spec->capsrc_nids = alc861vd_capsrc_nids;
15064         spec->capture_style = CAPT_MIX;
15065
15066         set_capture_mixer(spec);
15067         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15068
15069         spec->vmaster_nid = 0x02;
15070
15071         codec->patch_ops = alc_patch_ops;
15072
15073         if (board_config == ALC861VD_AUTO)
15074                 spec->init_hook = alc861vd_auto_init;
15075 #ifdef CONFIG_SND_HDA_POWER_SAVE
15076         if (!spec->loopback.amplist)
15077                 spec->loopback.amplist = alc861vd_loopbacks;
15078 #endif
15079         codec->proc_widget_hook = print_realtek_coef;
15080
15081         return 0;
15082 }
15083
15084 /*
15085  * ALC662 support
15086  *
15087  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15088  * configuration.  Each pin widget can choose any input DACs and a mixer.
15089  * Each ADC is connected from a mixer of all inputs.  This makes possible
15090  * 6-channel independent captures.
15091  *
15092  * In addition, an independent DAC for the multi-playback (not used in this
15093  * driver yet).
15094  */
15095 #define ALC662_DIGOUT_NID       0x06
15096 #define ALC662_DIGIN_NID        0x0a
15097
15098 static hda_nid_t alc662_dac_nids[4] = {
15099         /* front, rear, clfe, rear_surr */
15100         0x02, 0x03, 0x04
15101 };
15102
15103 static hda_nid_t alc662_adc_nids[1] = {
15104         /* ADC1-2 */
15105         0x09,
15106 };
15107
15108 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
15109
15110 /* input MUX */
15111 /* FIXME: should be a matrix-type input source selection */
15112 static struct hda_input_mux alc662_capture_source = {
15113         .num_items = 4,
15114         .items = {
15115                 { "Mic", 0x0 },
15116                 { "Front Mic", 0x1 },
15117                 { "Line", 0x2 },
15118                 { "CD", 0x4 },
15119         },
15120 };
15121
15122 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15123         .num_items = 2,
15124         .items = {
15125                 { "Mic", 0x1 },
15126                 { "Line", 0x2 },
15127         },
15128 };
15129
15130 static struct hda_input_mux alc662_eeepc_capture_source = {
15131         .num_items = 2,
15132         .items = {
15133                 { "i-Mic", 0x1 },
15134                 { "e-Mic", 0x0 },
15135         },
15136 };
15137
15138 static struct hda_input_mux alc663_capture_source = {
15139         .num_items = 3,
15140         .items = {
15141                 { "Mic", 0x0 },
15142                 { "Front Mic", 0x1 },
15143                 { "Line", 0x2 },
15144         },
15145 };
15146
15147 static struct hda_input_mux alc663_m51va_capture_source = {
15148         .num_items = 2,
15149         .items = {
15150                 { "Ext-Mic", 0x0 },
15151                 { "D-Mic", 0x9 },
15152         },
15153 };
15154
15155 /*
15156  * 2ch mode
15157  */
15158 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15159         { 2, NULL }
15160 };
15161
15162 /*
15163  * 2ch mode
15164  */
15165 static struct hda_verb alc662_3ST_ch2_init[] = {
15166         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15167         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15168         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15169         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15170         { } /* end */
15171 };
15172
15173 /*
15174  * 6ch mode
15175  */
15176 static struct hda_verb alc662_3ST_ch6_init[] = {
15177         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15178         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15179         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15180         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15181         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15182         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15183         { } /* end */
15184 };
15185
15186 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15187         { 2, alc662_3ST_ch2_init },
15188         { 6, alc662_3ST_ch6_init },
15189 };
15190
15191 /*
15192  * 2ch mode
15193  */
15194 static struct hda_verb alc662_sixstack_ch6_init[] = {
15195         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15196         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15197         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15198         { } /* end */
15199 };
15200
15201 /*
15202  * 6ch mode
15203  */
15204 static struct hda_verb alc662_sixstack_ch8_init[] = {
15205         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15206         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15207         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15208         { } /* end */
15209 };
15210
15211 static struct hda_channel_mode alc662_5stack_modes[2] = {
15212         { 2, alc662_sixstack_ch6_init },
15213         { 6, alc662_sixstack_ch8_init },
15214 };
15215
15216 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15217  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15218  */
15219
15220 static struct snd_kcontrol_new alc662_base_mixer[] = {
15221         /* output mixer control */
15222         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
15223         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15224         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
15225         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15226         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15227         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15228         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15229         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15230         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15231
15232         /*Input mixer control */
15233         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
15234         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
15235         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
15236         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
15237         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
15238         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
15239         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
15240         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
15241         { } /* end */
15242 };
15243
15244 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
15245         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15246         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15247         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15248         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15249         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15250         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15251         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15252         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15253         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15254         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15255         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15256         { } /* end */
15257 };
15258
15259 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
15260         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15261         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15262         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15263         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15264         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15265         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15266         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15267         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15268         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15269         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15270         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15271         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15272         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15273         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15274         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15275         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15276         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15277         { } /* end */
15278 };
15279
15280 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
15281         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15282         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
15283         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15284         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
15285         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15286         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15287         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15288         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15289         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15290         { } /* end */
15291 };
15292
15293 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
15294         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15295
15296         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15297         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15298
15299         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
15300         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15301         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15302
15303         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15304         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15305         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15306         { } /* end */
15307 };
15308
15309 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
15310         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15311         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15312         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15313         HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
15314         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15315         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15316         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
15317         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
15318         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15319         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
15320         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15321         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15322         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15323         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15324         { } /* end */
15325 };
15326
15327 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
15328         .ops = &snd_hda_bind_vol,
15329         .values = {
15330                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15331                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
15332                 0
15333         },
15334 };
15335
15336 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
15337         .ops = &snd_hda_bind_sw,
15338         .values = {
15339                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15340                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15341                 0
15342         },
15343 };
15344
15345 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
15346         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15347         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
15348         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15349         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15350         { } /* end */
15351 };
15352
15353 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
15354         .ops = &snd_hda_bind_sw,
15355         .values = {
15356                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15357                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15358                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15359                 0
15360         },
15361 };
15362
15363 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
15364         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15365         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
15366         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15367         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15368         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15369         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15370
15371         { } /* end */
15372 };
15373
15374 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
15375         .ops = &snd_hda_bind_sw,
15376         .values = {
15377                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15378                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15379                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15380                 0
15381         },
15382 };
15383
15384 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
15385         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15386         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
15387         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15388         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15389         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15390         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15391         { } /* end */
15392 };
15393
15394 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
15395         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15396         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15397         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15398         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15399         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15400         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15401         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15402         { } /* end */
15403 };
15404
15405 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
15406         .ops = &snd_hda_bind_vol,
15407         .values = {
15408                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15409                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
15410                 0
15411         },
15412 };
15413
15414 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
15415         .ops = &snd_hda_bind_sw,
15416         .values = {
15417                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15418                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
15419                 0
15420         },
15421 };
15422
15423 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
15424         HDA_BIND_VOL("Master Playback Volume",
15425                                 &alc663_asus_two_bind_master_vol),
15426         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15427         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15428         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15429         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15430         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15431         { } /* end */
15432 };
15433
15434 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
15435         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15436         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15437         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15438         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15439         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15440         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15441         { } /* end */
15442 };
15443
15444 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
15445         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15446         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15447         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15448         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15449         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15450
15451         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15452         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15453         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15454         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15455         { } /* end */
15456 };
15457
15458 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
15459         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15460         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15461         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15462
15463         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15464         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15465         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15466         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15467         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15468         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15469         { } /* end */
15470 };
15471
15472 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
15473         {
15474                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15475                 .name = "Channel Mode",
15476                 .info = alc_ch_mode_info,
15477                 .get = alc_ch_mode_get,
15478                 .put = alc_ch_mode_put,
15479         },
15480         { } /* end */
15481 };
15482
15483 static struct hda_verb alc662_init_verbs[] = {
15484         /* ADC: mute amp left and right */
15485         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15486         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15487         /* Front mixer: unmute input/output amp left and right (volume = 0) */
15488
15489         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15490         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15491         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15492         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15493         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15494
15495         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15496         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15497         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15498         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15499         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15500         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15501
15502         /* Front Pin: output 0 (0x0c) */
15503         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15504         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15505
15506         /* Rear Pin: output 1 (0x0d) */
15507         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15508         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15509
15510         /* CLFE Pin: output 2 (0x0e) */
15511         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15512         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15513
15514         /* Mic (rear) pin: input vref at 80% */
15515         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15516         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15517         /* Front Mic pin: input vref at 80% */
15518         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15519         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15520         /* Line In pin: input */
15521         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15522         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15523         /* Line-2 In: Headphone output (output 0 - 0x0c) */
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},
15527         /* CD pin widget for input */
15528         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15529
15530         /* FIXME: use matrix-type input source selection */
15531         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15532         /* Input mixer */
15533         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15534         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15535         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15536         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15537
15538         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15539         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15540         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15541         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15542
15543         /* always trun on EAPD */
15544         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15545         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15546
15547         { }
15548 };
15549
15550 static struct hda_verb alc662_sue_init_verbs[] = {
15551         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15552         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15553         {}
15554 };
15555
15556 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
15557         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15558         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15559         {}
15560 };
15561
15562 /* Set Unsolicited Event*/
15563 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15564         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15565         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15566         {}
15567 };
15568
15569 /*
15570  * generic initialization of ADC, input mixers and output mixers
15571  */
15572 static struct hda_verb alc662_auto_init_verbs[] = {
15573         /*
15574          * Unmute ADC and set the default input to mic-in
15575          */
15576         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15577         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15578
15579         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15580          * mixer widget
15581          * Note: PASD motherboards uses the Line In 2 as the input for front
15582          * panel mic (mic 2)
15583          */
15584         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15585         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15586         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15587         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15588         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15589         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15590
15591         /*
15592          * Set up output mixers (0x0c - 0x0f)
15593          */
15594         /* set vol=0 to output mixers */
15595         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15596         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15597         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15598
15599         /* set up input amps for analog loopback */
15600         /* Amp Indices: DAC = 0, mixer = 1 */
15601         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15602         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15603         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15604         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15605         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15606         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15607
15608
15609         /* FIXME: use matrix-type input source selection */
15610         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15611         /* Input mixer */
15612         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15613         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15614         { }
15615 };
15616
15617 /* additional verbs for ALC663 */
15618 static struct hda_verb alc663_auto_init_verbs[] = {
15619         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15620         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15621         { }
15622 };
15623
15624 static struct hda_verb alc663_m51va_init_verbs[] = {
15625         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15626         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15627         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15628         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15629         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15630         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15631         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15632         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15633         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15634         {}
15635 };
15636
15637 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15638         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15639         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15640         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15641         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15642         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15643         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15644         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15645         {}
15646 };
15647
15648 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15649         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15650         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15651         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15652         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15653         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15654         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15655         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15656         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15657         {}
15658 };
15659
15660 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15661         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15662         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15663         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15664         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15665         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15666         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15667         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15668         {}
15669 };
15670
15671 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15672         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15673         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15674         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15675         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15676         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15677         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15678         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15679         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15680         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15681         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15682         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15683         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15684         {}
15685 };
15686
15687 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15688         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15689         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15690         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15691         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15692         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15693         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15694         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15695         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15696         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15697         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15698         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15699         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15700         {}
15701 };
15702
15703 static struct hda_verb alc663_g71v_init_verbs[] = {
15704         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15705         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15706         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15707
15708         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15709         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15710         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15711
15712         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15713         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15714         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15715         {}
15716 };
15717
15718 static struct hda_verb alc663_g50v_init_verbs[] = {
15719         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15720         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15721         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15722
15723         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15724         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15725         {}
15726 };
15727
15728 static struct hda_verb alc662_ecs_init_verbs[] = {
15729         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15730         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15731         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15732         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15733         {}
15734 };
15735
15736 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15737         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15738         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15739         { } /* end */
15740 };
15741
15742 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15743 {
15744         unsigned int present;
15745         unsigned char bits;
15746
15747         present = snd_hda_codec_read(codec, 0x14, 0,
15748                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15749         bits = present ? HDA_AMP_MUTE : 0;
15750         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15751                                  HDA_AMP_MUTE, bits);
15752 }
15753
15754 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15755 {
15756         unsigned int present;
15757         unsigned char bits;
15758
15759         present = snd_hda_codec_read(codec, 0x1b, 0,
15760                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15761         bits = present ? HDA_AMP_MUTE : 0;
15762         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15763                                  HDA_AMP_MUTE, bits);
15764         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15765                                  HDA_AMP_MUTE, bits);
15766 }
15767
15768 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15769                                            unsigned int res)
15770 {
15771         if ((res >> 26) == ALC880_HP_EVENT)
15772                 alc662_lenovo_101e_all_automute(codec);
15773         if ((res >> 26) == ALC880_FRONT_EVENT)
15774                 alc662_lenovo_101e_ispeaker_automute(codec);
15775 }
15776
15777 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15778 {
15779         unsigned int present;
15780
15781         present = snd_hda_codec_read(codec, 0x18, 0,
15782                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15783         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15784                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15785         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15786                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15787         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15788                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15789         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15790                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15791 }
15792
15793 /* unsolicited event for HP jack sensing */
15794 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
15795                                      unsigned int res)
15796 {
15797         if ((res >> 26) == ALC880_HP_EVENT)
15798                 alc262_hippo1_automute( codec );
15799
15800         if ((res >> 26) == ALC880_MIC_EVENT)
15801                 alc662_eeepc_mic_automute(codec);
15802 }
15803
15804 static void alc662_eeepc_inithook(struct hda_codec *codec)
15805 {
15806         alc262_hippo1_automute( codec );
15807         alc662_eeepc_mic_automute(codec);
15808 }
15809
15810 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
15811 {
15812         unsigned int mute;
15813         unsigned int present;
15814
15815         snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
15816         present = snd_hda_codec_read(codec, 0x14, 0,
15817                                      AC_VERB_GET_PIN_SENSE, 0);
15818         present = (present & 0x80000000) != 0;
15819         if (present) {
15820                 /* mute internal speaker */
15821                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15822                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
15823         } else {
15824                 /* unmute internal speaker if necessary */
15825                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
15826                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15827                                         HDA_AMP_MUTE, mute);
15828         }
15829 }
15830
15831 /* unsolicited event for HP jack sensing */
15832 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
15833                                           unsigned int res)
15834 {
15835         if ((res >> 26) == ALC880_HP_EVENT)
15836                 alc662_eeepc_ep20_automute(codec);
15837 }
15838
15839 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
15840 {
15841         alc662_eeepc_ep20_automute(codec);
15842 }
15843
15844 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
15845 {
15846         unsigned int present;
15847         unsigned char bits;
15848
15849         present = snd_hda_codec_read(codec, 0x21, 0,
15850                         AC_VERB_GET_PIN_SENSE, 0)
15851                         & AC_PINSENSE_PRESENCE;
15852         bits = present ? HDA_AMP_MUTE : 0;
15853         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15854                                 AMP_IN_MUTE(0), bits);
15855         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15856                                 AMP_IN_MUTE(0), bits);
15857 }
15858
15859 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
15860 {
15861         unsigned int present;
15862         unsigned char bits;
15863
15864         present = snd_hda_codec_read(codec, 0x21, 0,
15865                         AC_VERB_GET_PIN_SENSE, 0)
15866                         & AC_PINSENSE_PRESENCE;
15867         bits = present ? HDA_AMP_MUTE : 0;
15868         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15869                                 AMP_IN_MUTE(0), bits);
15870         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15871                                 AMP_IN_MUTE(0), bits);
15872         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15873                                 AMP_IN_MUTE(0), bits);
15874         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15875                                 AMP_IN_MUTE(0), bits);
15876 }
15877
15878 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
15879 {
15880         unsigned int present;
15881         unsigned char bits;
15882
15883         present = snd_hda_codec_read(codec, 0x15, 0,
15884                         AC_VERB_GET_PIN_SENSE, 0)
15885                         & AC_PINSENSE_PRESENCE;
15886         bits = present ? HDA_AMP_MUTE : 0;
15887         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15888                                 AMP_IN_MUTE(0), bits);
15889         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15890                                 AMP_IN_MUTE(0), bits);
15891         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15892                                 AMP_IN_MUTE(0), bits);
15893         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15894                                 AMP_IN_MUTE(0), bits);
15895 }
15896
15897 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
15898 {
15899         unsigned int present;
15900         unsigned char bits;
15901
15902         present = snd_hda_codec_read(codec, 0x1b, 0,
15903                         AC_VERB_GET_PIN_SENSE, 0)
15904                         & AC_PINSENSE_PRESENCE;
15905         bits = present ? 0 : PIN_OUT;
15906         snd_hda_codec_write(codec, 0x14, 0,
15907                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
15908 }
15909
15910 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
15911 {
15912         unsigned int present1, present2;
15913
15914         present1 = snd_hda_codec_read(codec, 0x21, 0,
15915                         AC_VERB_GET_PIN_SENSE, 0)
15916                         & AC_PINSENSE_PRESENCE;
15917         present2 = snd_hda_codec_read(codec, 0x15, 0,
15918                         AC_VERB_GET_PIN_SENSE, 0)
15919                         & AC_PINSENSE_PRESENCE;
15920
15921         if (present1 || present2) {
15922                 snd_hda_codec_write_cache(codec, 0x14, 0,
15923                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
15924         } else {
15925                 snd_hda_codec_write_cache(codec, 0x14, 0,
15926                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
15927         }
15928 }
15929
15930 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
15931 {
15932         unsigned int present1, present2;
15933
15934         present1 = snd_hda_codec_read(codec, 0x1b, 0,
15935                                 AC_VERB_GET_PIN_SENSE, 0)
15936                                 & AC_PINSENSE_PRESENCE;
15937         present2 = snd_hda_codec_read(codec, 0x15, 0,
15938                                 AC_VERB_GET_PIN_SENSE, 0)
15939                                 & AC_PINSENSE_PRESENCE;
15940
15941         if (present1 || present2) {
15942                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15943                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15944                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15945                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15946         } else {
15947                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15948                                 AMP_IN_MUTE(0), 0);
15949                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15950                                 AMP_IN_MUTE(0), 0);
15951         }
15952 }
15953
15954 static void alc663_m51va_mic_automute(struct hda_codec *codec)
15955 {
15956         unsigned int present;
15957
15958         present = snd_hda_codec_read(codec, 0x18, 0,
15959                         AC_VERB_GET_PIN_SENSE, 0)
15960                         & AC_PINSENSE_PRESENCE;
15961         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15962                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15963         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15964                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15965         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15966                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15967         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15968                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15969 }
15970
15971 static void alc663_m51va_unsol_event(struct hda_codec *codec,
15972                                            unsigned int res)
15973 {
15974         switch (res >> 26) {
15975         case ALC880_HP_EVENT:
15976                 alc663_m51va_speaker_automute(codec);
15977                 break;
15978         case ALC880_MIC_EVENT:
15979                 alc663_m51va_mic_automute(codec);
15980                 break;
15981         }
15982 }
15983
15984 static void alc663_m51va_inithook(struct hda_codec *codec)
15985 {
15986         alc663_m51va_speaker_automute(codec);
15987         alc663_m51va_mic_automute(codec);
15988 }
15989
15990 /* ***************** Mode1 ******************************/
15991 static void alc663_mode1_unsol_event(struct hda_codec *codec,
15992                                            unsigned int res)
15993 {
15994         switch (res >> 26) {
15995         case ALC880_HP_EVENT:
15996                 alc663_m51va_speaker_automute(codec);
15997                 break;
15998         case ALC880_MIC_EVENT:
15999                 alc662_eeepc_mic_automute(codec);
16000                 break;
16001         }
16002 }
16003
16004 static void alc663_mode1_inithook(struct hda_codec *codec)
16005 {
16006         alc663_m51va_speaker_automute(codec);
16007         alc662_eeepc_mic_automute(codec);
16008 }
16009 /* ***************** Mode2 ******************************/
16010 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16011                                            unsigned int res)
16012 {
16013         switch (res >> 26) {
16014         case ALC880_HP_EVENT:
16015                 alc662_f5z_speaker_automute(codec);
16016                 break;
16017         case ALC880_MIC_EVENT:
16018                 alc662_eeepc_mic_automute(codec);
16019                 break;
16020         }
16021 }
16022
16023 static void alc662_mode2_inithook(struct hda_codec *codec)
16024 {
16025         alc662_f5z_speaker_automute(codec);
16026         alc662_eeepc_mic_automute(codec);
16027 }
16028 /* ***************** Mode3 ******************************/
16029 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16030                                            unsigned int res)
16031 {
16032         switch (res >> 26) {
16033         case ALC880_HP_EVENT:
16034                 alc663_two_hp_m1_speaker_automute(codec);
16035                 break;
16036         case ALC880_MIC_EVENT:
16037                 alc662_eeepc_mic_automute(codec);
16038                 break;
16039         }
16040 }
16041
16042 static void alc663_mode3_inithook(struct hda_codec *codec)
16043 {
16044         alc663_two_hp_m1_speaker_automute(codec);
16045         alc662_eeepc_mic_automute(codec);
16046 }
16047 /* ***************** Mode4 ******************************/
16048 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16049                                            unsigned int res)
16050 {
16051         switch (res >> 26) {
16052         case ALC880_HP_EVENT:
16053                 alc663_21jd_two_speaker_automute(codec);
16054                 break;
16055         case ALC880_MIC_EVENT:
16056                 alc662_eeepc_mic_automute(codec);
16057                 break;
16058         }
16059 }
16060
16061 static void alc663_mode4_inithook(struct hda_codec *codec)
16062 {
16063         alc663_21jd_two_speaker_automute(codec);
16064         alc662_eeepc_mic_automute(codec);
16065 }
16066 /* ***************** Mode5 ******************************/
16067 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16068                                            unsigned int res)
16069 {
16070         switch (res >> 26) {
16071         case ALC880_HP_EVENT:
16072                 alc663_15jd_two_speaker_automute(codec);
16073                 break;
16074         case ALC880_MIC_EVENT:
16075                 alc662_eeepc_mic_automute(codec);
16076                 break;
16077         }
16078 }
16079
16080 static void alc663_mode5_inithook(struct hda_codec *codec)
16081 {
16082         alc663_15jd_two_speaker_automute(codec);
16083         alc662_eeepc_mic_automute(codec);
16084 }
16085 /* ***************** Mode6 ******************************/
16086 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16087                                            unsigned int res)
16088 {
16089         switch (res >> 26) {
16090         case ALC880_HP_EVENT:
16091                 alc663_two_hp_m2_speaker_automute(codec);
16092                 break;
16093         case ALC880_MIC_EVENT:
16094                 alc662_eeepc_mic_automute(codec);
16095                 break;
16096         }
16097 }
16098
16099 static void alc663_mode6_inithook(struct hda_codec *codec)
16100 {
16101         alc663_two_hp_m2_speaker_automute(codec);
16102         alc662_eeepc_mic_automute(codec);
16103 }
16104
16105 static void alc663_g71v_hp_automute(struct hda_codec *codec)
16106 {
16107         unsigned int present;
16108         unsigned char bits;
16109
16110         present = snd_hda_codec_read(codec, 0x21, 0,
16111                                      AC_VERB_GET_PIN_SENSE, 0)
16112                 & AC_PINSENSE_PRESENCE;
16113         bits = present ? HDA_AMP_MUTE : 0;
16114         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16115                                  HDA_AMP_MUTE, bits);
16116         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16117                                  HDA_AMP_MUTE, bits);
16118 }
16119
16120 static void alc663_g71v_front_automute(struct hda_codec *codec)
16121 {
16122         unsigned int present;
16123         unsigned char bits;
16124
16125         present = snd_hda_codec_read(codec, 0x15, 0,
16126                                      AC_VERB_GET_PIN_SENSE, 0)
16127                 & AC_PINSENSE_PRESENCE;
16128         bits = present ? HDA_AMP_MUTE : 0;
16129         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16130                                  HDA_AMP_MUTE, bits);
16131 }
16132
16133 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16134                                            unsigned int res)
16135 {
16136         switch (res >> 26) {
16137         case ALC880_HP_EVENT:
16138                 alc663_g71v_hp_automute(codec);
16139                 break;
16140         case ALC880_FRONT_EVENT:
16141                 alc663_g71v_front_automute(codec);
16142                 break;
16143         case ALC880_MIC_EVENT:
16144                 alc662_eeepc_mic_automute(codec);
16145                 break;
16146         }
16147 }
16148
16149 static void alc663_g71v_inithook(struct hda_codec *codec)
16150 {
16151         alc663_g71v_front_automute(codec);
16152         alc663_g71v_hp_automute(codec);
16153         alc662_eeepc_mic_automute(codec);
16154 }
16155
16156 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16157                                            unsigned int res)
16158 {
16159         switch (res >> 26) {
16160         case ALC880_HP_EVENT:
16161                 alc663_m51va_speaker_automute(codec);
16162                 break;
16163         case ALC880_MIC_EVENT:
16164                 alc662_eeepc_mic_automute(codec);
16165                 break;
16166         }
16167 }
16168
16169 static void alc663_g50v_inithook(struct hda_codec *codec)
16170 {
16171         alc663_m51va_speaker_automute(codec);
16172         alc662_eeepc_mic_automute(codec);
16173 }
16174
16175 /* bind hp and internal speaker mute (with plug check) */
16176 static int alc662_ecs_master_sw_put(struct snd_kcontrol *kcontrol,
16177                                      struct snd_ctl_elem_value *ucontrol)
16178 {
16179         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
16180         long *valp = ucontrol->value.integer.value;
16181         int change;
16182
16183         change = snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
16184                                           HDA_AMP_MUTE,
16185                                           valp[0] ? 0 : HDA_AMP_MUTE);
16186         change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
16187                                            HDA_AMP_MUTE,
16188                                            valp[1] ? 0 : HDA_AMP_MUTE);
16189         if (change)
16190                 alc262_hippo1_automute(codec);
16191         return change;
16192 }
16193
16194 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16195         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16196         {
16197                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16198                 .name = "Master Playback Switch",
16199                 .info = snd_hda_mixer_amp_switch_info,
16200                 .get = snd_hda_mixer_amp_switch_get,
16201                 .put = alc662_ecs_master_sw_put,
16202                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16203         },
16204
16205         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16206         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16207         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16208
16209         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16210         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16211         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16212         { } /* end */
16213 };
16214
16215 #ifdef CONFIG_SND_HDA_POWER_SAVE
16216 #define alc662_loopbacks        alc880_loopbacks
16217 #endif
16218
16219
16220 /* pcm configuration: identiacal with ALC880 */
16221 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
16222 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
16223 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
16224 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
16225
16226 /*
16227  * configuration and preset
16228  */
16229 static const char *alc662_models[ALC662_MODEL_LAST] = {
16230         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
16231         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
16232         [ALC662_3ST_6ch]        = "3stack-6ch",
16233         [ALC662_5ST_DIG]        = "6stack-dig",
16234         [ALC662_LENOVO_101E]    = "lenovo-101e",
16235         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
16236         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
16237         [ALC662_ECS] = "ecs",
16238         [ALC663_ASUS_M51VA] = "m51va",
16239         [ALC663_ASUS_G71V] = "g71v",
16240         [ALC663_ASUS_H13] = "h13",
16241         [ALC663_ASUS_G50V] = "g50v",
16242         [ALC663_ASUS_MODE1] = "asus-mode1",
16243         [ALC662_ASUS_MODE2] = "asus-mode2",
16244         [ALC663_ASUS_MODE3] = "asus-mode3",
16245         [ALC663_ASUS_MODE4] = "asus-mode4",
16246         [ALC663_ASUS_MODE5] = "asus-mode5",
16247         [ALC663_ASUS_MODE6] = "asus-mode6",
16248         [ALC662_AUTO]           = "auto",
16249 };
16250
16251 static struct snd_pci_quirk alc662_cfg_tbl[] = {
16252         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
16253         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
16254         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
16255         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
16256         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
16257         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
16258         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
16259         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
16260         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
16261         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
16262         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
16263         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
16264         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
16265         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
16266         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
16267         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
16268         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
16269         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
16270         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
16271         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
16272         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
16273         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
16274         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
16275         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
16276         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
16277         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
16278         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
16279         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
16280         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
16281         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
16282         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
16283         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
16284         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
16285         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
16286         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
16287         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
16288         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
16289         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
16290         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
16291         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
16292                       ALC662_3ST_6ch_DIG),
16293         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
16294                       ALC662_3ST_6ch_DIG),
16295         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
16296         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
16297         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
16298                                         ALC662_3ST_6ch_DIG),
16299         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
16300                            ALC663_ASUS_H13),
16301         {}
16302 };
16303
16304 static struct alc_config_preset alc662_presets[] = {
16305         [ALC662_3ST_2ch_DIG] = {
16306                 .mixers = { alc662_3ST_2ch_mixer },
16307                 .init_verbs = { alc662_init_verbs },
16308                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16309                 .dac_nids = alc662_dac_nids,
16310                 .dig_out_nid = ALC662_DIGOUT_NID,
16311                 .dig_in_nid = ALC662_DIGIN_NID,
16312                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16313                 .channel_mode = alc662_3ST_2ch_modes,
16314                 .input_mux = &alc662_capture_source,
16315         },
16316         [ALC662_3ST_6ch_DIG] = {
16317                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16318                 .init_verbs = { alc662_init_verbs },
16319                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16320                 .dac_nids = alc662_dac_nids,
16321                 .dig_out_nid = ALC662_DIGOUT_NID,
16322                 .dig_in_nid = ALC662_DIGIN_NID,
16323                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16324                 .channel_mode = alc662_3ST_6ch_modes,
16325                 .need_dac_fix = 1,
16326                 .input_mux = &alc662_capture_source,
16327         },
16328         [ALC662_3ST_6ch] = {
16329                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16330                 .init_verbs = { alc662_init_verbs },
16331                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16332                 .dac_nids = alc662_dac_nids,
16333                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16334                 .channel_mode = alc662_3ST_6ch_modes,
16335                 .need_dac_fix = 1,
16336                 .input_mux = &alc662_capture_source,
16337         },
16338         [ALC662_5ST_DIG] = {
16339                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
16340                 .init_verbs = { alc662_init_verbs },
16341                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16342                 .dac_nids = alc662_dac_nids,
16343                 .dig_out_nid = ALC662_DIGOUT_NID,
16344                 .dig_in_nid = ALC662_DIGIN_NID,
16345                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
16346                 .channel_mode = alc662_5stack_modes,
16347                 .input_mux = &alc662_capture_source,
16348         },
16349         [ALC662_LENOVO_101E] = {
16350                 .mixers = { alc662_lenovo_101e_mixer },
16351                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
16352                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16353                 .dac_nids = alc662_dac_nids,
16354                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16355                 .channel_mode = alc662_3ST_2ch_modes,
16356                 .input_mux = &alc662_lenovo_101e_capture_source,
16357                 .unsol_event = alc662_lenovo_101e_unsol_event,
16358                 .init_hook = alc662_lenovo_101e_all_automute,
16359         },
16360         [ALC662_ASUS_EEEPC_P701] = {
16361                 .mixers = { alc662_eeepc_p701_mixer },
16362                 .init_verbs = { alc662_init_verbs,
16363                                 alc662_eeepc_sue_init_verbs },
16364                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16365                 .dac_nids = alc662_dac_nids,
16366                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16367                 .channel_mode = alc662_3ST_2ch_modes,
16368                 .input_mux = &alc662_eeepc_capture_source,
16369                 .unsol_event = alc662_eeepc_unsol_event,
16370                 .init_hook = alc662_eeepc_inithook,
16371         },
16372         [ALC662_ASUS_EEEPC_EP20] = {
16373                 .mixers = { alc662_eeepc_ep20_mixer,
16374                             alc662_chmode_mixer },
16375                 .init_verbs = { alc662_init_verbs,
16376                                 alc662_eeepc_ep20_sue_init_verbs },
16377                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16378                 .dac_nids = alc662_dac_nids,
16379                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16380                 .channel_mode = alc662_3ST_6ch_modes,
16381                 .input_mux = &alc662_lenovo_101e_capture_source,
16382                 .unsol_event = alc662_eeepc_ep20_unsol_event,
16383                 .init_hook = alc662_eeepc_ep20_inithook,
16384         },
16385         [ALC662_ECS] = {
16386                 .mixers = { alc662_ecs_mixer },
16387                 .init_verbs = { alc662_init_verbs,
16388                                 alc662_ecs_init_verbs },
16389                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16390                 .dac_nids = alc662_dac_nids,
16391                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16392                 .channel_mode = alc662_3ST_2ch_modes,
16393                 .input_mux = &alc662_eeepc_capture_source,
16394                 .unsol_event = alc662_eeepc_unsol_event,
16395                 .init_hook = alc662_eeepc_inithook,
16396         },
16397         [ALC663_ASUS_M51VA] = {
16398                 .mixers = { alc663_m51va_mixer },
16399                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16400                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16401                 .dac_nids = alc662_dac_nids,
16402                 .dig_out_nid = ALC662_DIGOUT_NID,
16403                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16404                 .channel_mode = alc662_3ST_2ch_modes,
16405                 .input_mux = &alc663_m51va_capture_source,
16406                 .unsol_event = alc663_m51va_unsol_event,
16407                 .init_hook = alc663_m51va_inithook,
16408         },
16409         [ALC663_ASUS_G71V] = {
16410                 .mixers = { alc663_g71v_mixer },
16411                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
16412                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16413                 .dac_nids = alc662_dac_nids,
16414                 .dig_out_nid = ALC662_DIGOUT_NID,
16415                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16416                 .channel_mode = alc662_3ST_2ch_modes,
16417                 .input_mux = &alc662_eeepc_capture_source,
16418                 .unsol_event = alc663_g71v_unsol_event,
16419                 .init_hook = alc663_g71v_inithook,
16420         },
16421         [ALC663_ASUS_H13] = {
16422                 .mixers = { alc663_m51va_mixer },
16423                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16424                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16425                 .dac_nids = alc662_dac_nids,
16426                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16427                 .channel_mode = alc662_3ST_2ch_modes,
16428                 .input_mux = &alc663_m51va_capture_source,
16429                 .unsol_event = alc663_m51va_unsol_event,
16430                 .init_hook = alc663_m51va_inithook,
16431         },
16432         [ALC663_ASUS_G50V] = {
16433                 .mixers = { alc663_g50v_mixer },
16434                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
16435                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16436                 .dac_nids = alc662_dac_nids,
16437                 .dig_out_nid = ALC662_DIGOUT_NID,
16438                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16439                 .channel_mode = alc662_3ST_6ch_modes,
16440                 .input_mux = &alc663_capture_source,
16441                 .unsol_event = alc663_g50v_unsol_event,
16442                 .init_hook = alc663_g50v_inithook,
16443         },
16444         [ALC663_ASUS_MODE1] = {
16445                 .mixers = { alc663_m51va_mixer },
16446                 .cap_mixer = alc662_auto_capture_mixer,
16447                 .init_verbs = { alc662_init_verbs,
16448                                 alc663_21jd_amic_init_verbs },
16449                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16450                 .hp_nid = 0x03,
16451                 .dac_nids = alc662_dac_nids,
16452                 .dig_out_nid = ALC662_DIGOUT_NID,
16453                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16454                 .channel_mode = alc662_3ST_2ch_modes,
16455                 .input_mux = &alc662_eeepc_capture_source,
16456                 .unsol_event = alc663_mode1_unsol_event,
16457                 .init_hook = alc663_mode1_inithook,
16458         },
16459         [ALC662_ASUS_MODE2] = {
16460                 .mixers = { alc662_1bjd_mixer },
16461                 .cap_mixer = alc662_auto_capture_mixer,
16462                 .init_verbs = { alc662_init_verbs,
16463                                 alc662_1bjd_amic_init_verbs },
16464                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16465                 .dac_nids = alc662_dac_nids,
16466                 .dig_out_nid = ALC662_DIGOUT_NID,
16467                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16468                 .channel_mode = alc662_3ST_2ch_modes,
16469                 .input_mux = &alc662_eeepc_capture_source,
16470                 .unsol_event = alc662_mode2_unsol_event,
16471                 .init_hook = alc662_mode2_inithook,
16472         },
16473         [ALC663_ASUS_MODE3] = {
16474                 .mixers = { alc663_two_hp_m1_mixer },
16475                 .cap_mixer = alc662_auto_capture_mixer,
16476                 .init_verbs = { alc662_init_verbs,
16477                                 alc663_two_hp_amic_m1_init_verbs },
16478                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16479                 .hp_nid = 0x03,
16480                 .dac_nids = alc662_dac_nids,
16481                 .dig_out_nid = ALC662_DIGOUT_NID,
16482                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16483                 .channel_mode = alc662_3ST_2ch_modes,
16484                 .input_mux = &alc662_eeepc_capture_source,
16485                 .unsol_event = alc663_mode3_unsol_event,
16486                 .init_hook = alc663_mode3_inithook,
16487         },
16488         [ALC663_ASUS_MODE4] = {
16489                 .mixers = { alc663_asus_21jd_clfe_mixer },
16490                 .cap_mixer = alc662_auto_capture_mixer,
16491                 .init_verbs = { alc662_init_verbs,
16492                                 alc663_21jd_amic_init_verbs},
16493                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16494                 .hp_nid = 0x03,
16495                 .dac_nids = alc662_dac_nids,
16496                 .dig_out_nid = ALC662_DIGOUT_NID,
16497                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16498                 .channel_mode = alc662_3ST_2ch_modes,
16499                 .input_mux = &alc662_eeepc_capture_source,
16500                 .unsol_event = alc663_mode4_unsol_event,
16501                 .init_hook = alc663_mode4_inithook,
16502         },
16503         [ALC663_ASUS_MODE5] = {
16504                 .mixers = { alc663_asus_15jd_clfe_mixer },
16505                 .cap_mixer = alc662_auto_capture_mixer,
16506                 .init_verbs = { alc662_init_verbs,
16507                                 alc663_15jd_amic_init_verbs },
16508                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16509                 .hp_nid = 0x03,
16510                 .dac_nids = alc662_dac_nids,
16511                 .dig_out_nid = ALC662_DIGOUT_NID,
16512                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16513                 .channel_mode = alc662_3ST_2ch_modes,
16514                 .input_mux = &alc662_eeepc_capture_source,
16515                 .unsol_event = alc663_mode5_unsol_event,
16516                 .init_hook = alc663_mode5_inithook,
16517         },
16518         [ALC663_ASUS_MODE6] = {
16519                 .mixers = { alc663_two_hp_m2_mixer },
16520                 .cap_mixer = alc662_auto_capture_mixer,
16521                 .init_verbs = { alc662_init_verbs,
16522                                 alc663_two_hp_amic_m2_init_verbs },
16523                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16524                 .hp_nid = 0x03,
16525                 .dac_nids = alc662_dac_nids,
16526                 .dig_out_nid = ALC662_DIGOUT_NID,
16527                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16528                 .channel_mode = alc662_3ST_2ch_modes,
16529                 .input_mux = &alc662_eeepc_capture_source,
16530                 .unsol_event = alc663_mode6_unsol_event,
16531                 .init_hook = alc663_mode6_inithook,
16532         },
16533 };
16534
16535
16536 /*
16537  * BIOS auto configuration
16538  */
16539
16540 /* add playback controls from the parsed DAC table */
16541 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
16542                                              const struct auto_pin_cfg *cfg)
16543 {
16544         char name[32];
16545         static const char *chname[4] = {
16546                 "Front", "Surround", NULL /*CLFE*/, "Side"
16547         };
16548         hda_nid_t nid;
16549         int i, err;
16550
16551         for (i = 0; i < cfg->line_outs; i++) {
16552                 if (!spec->multiout.dac_nids[i])
16553                         continue;
16554                 nid = alc880_idx_to_dac(i);
16555                 if (i == 2) {
16556                         /* Center/LFE */
16557                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16558                                           "Center Playback Volume",
16559                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16560                                                               HDA_OUTPUT));
16561                         if (err < 0)
16562                                 return err;
16563                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16564                                           "LFE Playback Volume",
16565                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16566                                                               HDA_OUTPUT));
16567                         if (err < 0)
16568                                 return err;
16569                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16570                                           "Center Playback Switch",
16571                                           HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16572                                                               HDA_INPUT));
16573                         if (err < 0)
16574                                 return err;
16575                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16576                                           "LFE Playback Switch",
16577                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16578                                                               HDA_INPUT));
16579                         if (err < 0)
16580                                 return err;
16581                 } else {
16582                         sprintf(name, "%s Playback Volume", chname[i]);
16583                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16584                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16585                                                               HDA_OUTPUT));
16586                         if (err < 0)
16587                                 return err;
16588                         sprintf(name, "%s Playback Switch", chname[i]);
16589                         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16590                                 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16591                                                     3, 0, HDA_INPUT));
16592                         if (err < 0)
16593                                 return err;
16594                 }
16595         }
16596         return 0;
16597 }
16598
16599 /* add playback controls for speaker and HP outputs */
16600 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16601                                         const char *pfx)
16602 {
16603         hda_nid_t nid;
16604         int err;
16605         char name[32];
16606
16607         if (!pin)
16608                 return 0;
16609
16610         if (pin == 0x17) {
16611                 /* ALC663 has a mono output pin on 0x17 */
16612                 sprintf(name, "%s Playback Switch", pfx);
16613                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16614                                   HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16615                 return err;
16616         }
16617
16618         if (alc880_is_fixed_pin(pin)) {
16619                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16620                 /* printk(KERN_DEBUG "DAC nid=%x\n",nid); */
16621                 /* specify the DAC as the extra output */
16622                 if (!spec->multiout.hp_nid)
16623                         spec->multiout.hp_nid = nid;
16624                 else
16625                         spec->multiout.extra_out_nid[0] = nid;
16626                 /* control HP volume/switch on the output mixer amp */
16627                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16628                 sprintf(name, "%s Playback Volume", pfx);
16629                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16630                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16631                 if (err < 0)
16632                         return err;
16633                 sprintf(name, "%s Playback Switch", pfx);
16634                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16635                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16636                 if (err < 0)
16637                         return err;
16638         } else if (alc880_is_multi_pin(pin)) {
16639                 /* set manual connection */
16640                 /* we have only a switch on HP-out PIN */
16641                 sprintf(name, "%s Playback Switch", pfx);
16642                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16643                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16644                 if (err < 0)
16645                         return err;
16646         }
16647         return 0;
16648 }
16649
16650 /* create playback/capture controls for input pins */
16651 static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec,
16652                                                 const struct auto_pin_cfg *cfg)
16653 {
16654         struct hda_input_mux *imux = &spec->private_imux[0];
16655         int i, err, idx;
16656
16657         for (i = 0; i < AUTO_PIN_LAST; i++) {
16658                 if (alc880_is_input_pin(cfg->input_pins[i])) {
16659                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
16660                         err = new_analog_input(spec, cfg->input_pins[i],
16661                                                auto_pin_cfg_labels[i],
16662                                                idx, 0x0b);
16663                         if (err < 0)
16664                                 return err;
16665                         imux->items[imux->num_items].label =
16666                                 auto_pin_cfg_labels[i];
16667                         imux->items[imux->num_items].index =
16668                                 alc880_input_pin_idx(cfg->input_pins[i]);
16669                         imux->num_items++;
16670                 }
16671         }
16672         return 0;
16673 }
16674
16675 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16676                                               hda_nid_t nid, int pin_type,
16677                                               int dac_idx)
16678 {
16679         alc_set_pin_output(codec, nid, pin_type);
16680         /* need the manual connection? */
16681         if (alc880_is_multi_pin(nid)) {
16682                 struct alc_spec *spec = codec->spec;
16683                 int idx = alc880_multi_pin_idx(nid);
16684                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16685                                     AC_VERB_SET_CONNECT_SEL,
16686                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16687         }
16688 }
16689
16690 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16691 {
16692         struct alc_spec *spec = codec->spec;
16693         int i;
16694
16695         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
16696         for (i = 0; i <= HDA_SIDE; i++) {
16697                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16698                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16699                 if (nid)
16700                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16701                                                           i);
16702         }
16703 }
16704
16705 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16706 {
16707         struct alc_spec *spec = codec->spec;
16708         hda_nid_t pin;
16709
16710         pin = spec->autocfg.hp_pins[0];
16711         if (pin) /* connect to front */
16712                 /* use dac 0 */
16713                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16714         pin = spec->autocfg.speaker_pins[0];
16715         if (pin)
16716                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16717 }
16718
16719 #define alc662_is_input_pin(nid)        alc880_is_input_pin(nid)
16720 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
16721
16722 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16723 {
16724         struct alc_spec *spec = codec->spec;
16725         int i;
16726
16727         for (i = 0; i < AUTO_PIN_LAST; i++) {
16728                 hda_nid_t nid = spec->autocfg.input_pins[i];
16729                 if (alc662_is_input_pin(nid)) {
16730                         alc_set_input_pin(codec, nid, i);
16731                         if (nid != ALC662_PIN_CD_NID)
16732                                 snd_hda_codec_write(codec, nid, 0,
16733                                                     AC_VERB_SET_AMP_GAIN_MUTE,
16734                                                     AMP_OUT_MUTE);
16735                 }
16736         }
16737 }
16738
16739 #define alc662_auto_init_input_src      alc882_auto_init_input_src
16740
16741 static int alc662_parse_auto_config(struct hda_codec *codec)
16742 {
16743         struct alc_spec *spec = codec->spec;
16744         int err;
16745         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
16746
16747         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16748                                            alc662_ignore);
16749         if (err < 0)
16750                 return err;
16751         if (!spec->autocfg.line_outs)
16752                 return 0; /* can't find valid BIOS pin config */
16753
16754         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16755         if (err < 0)
16756                 return err;
16757         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
16758         if (err < 0)
16759                 return err;
16760         err = alc662_auto_create_extra_out(spec,
16761                                            spec->autocfg.speaker_pins[0],
16762                                            "Speaker");
16763         if (err < 0)
16764                 return err;
16765         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
16766                                            "Headphone");
16767         if (err < 0)
16768                 return err;
16769         err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg);
16770         if (err < 0)
16771                 return err;
16772
16773         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16774
16775         if (spec->autocfg.dig_outs)
16776                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
16777
16778         if (spec->kctls.list)
16779                 add_mixer(spec, spec->kctls.list);
16780
16781         spec->num_mux_defs = 1;
16782         spec->input_mux = &spec->private_imux[0];
16783
16784         add_verb(spec, alc662_auto_init_verbs);
16785         if (codec->vendor_id == 0x10ec0663)
16786                 add_verb(spec, alc663_auto_init_verbs);
16787
16788         err = alc_auto_add_mic_boost(codec);
16789         if (err < 0)
16790                 return err;
16791
16792         return 1;
16793 }
16794
16795 /* additional initialization for auto-configuration model */
16796 static void alc662_auto_init(struct hda_codec *codec)
16797 {
16798         struct alc_spec *spec = codec->spec;
16799         alc662_auto_init_multi_out(codec);
16800         alc662_auto_init_hp_out(codec);
16801         alc662_auto_init_analog_input(codec);
16802         alc662_auto_init_input_src(codec);
16803         if (spec->unsol_event)
16804                 alc_inithook(codec);
16805 }
16806
16807 static int patch_alc662(struct hda_codec *codec)
16808 {
16809         struct alc_spec *spec;
16810         int err, board_config;
16811
16812         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16813         if (!spec)
16814                 return -ENOMEM;
16815
16816         codec->spec = spec;
16817
16818         alc_fix_pll_init(codec, 0x20, 0x04, 15);
16819
16820         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
16821                                                   alc662_models,
16822                                                   alc662_cfg_tbl);
16823         if (board_config < 0) {
16824                 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
16825                        "trying auto-probe from BIOS...\n");
16826                 board_config = ALC662_AUTO;
16827         }
16828
16829         if (board_config == ALC662_AUTO) {
16830                 /* automatic parse from the BIOS config */
16831                 err = alc662_parse_auto_config(codec);
16832                 if (err < 0) {
16833                         alc_free(codec);
16834                         return err;
16835                 } else if (!err) {
16836                         printk(KERN_INFO
16837                                "hda_codec: Cannot set up configuration "
16838                                "from BIOS.  Using base mode...\n");
16839                         board_config = ALC662_3ST_2ch_DIG;
16840                 }
16841         }
16842
16843         err = snd_hda_attach_beep_device(codec, 0x1);
16844         if (err < 0) {
16845                 alc_free(codec);
16846                 return err;
16847         }
16848
16849         if (board_config != ALC662_AUTO)
16850                 setup_preset(spec, &alc662_presets[board_config]);
16851
16852         if (codec->vendor_id == 0x10ec0663) {
16853                 spec->stream_name_analog = "ALC663 Analog";
16854                 spec->stream_name_digital = "ALC663 Digital";
16855         } else if (codec->vendor_id == 0x10ec0272) {
16856                 spec->stream_name_analog = "ALC272 Analog";
16857                 spec->stream_name_digital = "ALC272 Digital";
16858         } else {
16859                 spec->stream_name_analog = "ALC662 Analog";
16860                 spec->stream_name_digital = "ALC662 Digital";
16861         }
16862
16863         spec->stream_analog_playback = &alc662_pcm_analog_playback;
16864         spec->stream_analog_capture = &alc662_pcm_analog_capture;
16865
16866         spec->stream_digital_playback = &alc662_pcm_digital_playback;
16867         spec->stream_digital_capture = &alc662_pcm_digital_capture;
16868
16869         spec->adc_nids = alc662_adc_nids;
16870         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
16871         spec->capsrc_nids = alc662_capsrc_nids;
16872         spec->capture_style = CAPT_MIX;
16873
16874         if (!spec->cap_mixer)
16875                 set_capture_mixer(spec);
16876         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
16877
16878         spec->vmaster_nid = 0x02;
16879
16880         codec->patch_ops = alc_patch_ops;
16881         if (board_config == ALC662_AUTO)
16882                 spec->init_hook = alc662_auto_init;
16883 #ifdef CONFIG_SND_HDA_POWER_SAVE
16884         if (!spec->loopback.amplist)
16885                 spec->loopback.amplist = alc662_loopbacks;
16886 #endif
16887         codec->proc_widget_hook = print_realtek_coef;
16888
16889         return 0;
16890 }
16891
16892 /*
16893  * patch entries
16894  */
16895 static struct hda_codec_preset snd_hda_preset_realtek[] = {
16896         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
16897         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
16898         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
16899         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
16900         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
16901         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
16902         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
16903           .patch = patch_alc861 },
16904         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
16905         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
16906         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
16907         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
16908           .patch = patch_alc883 },
16909         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
16910           .patch = patch_alc662 },
16911         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
16912         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
16913         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
16914         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
16915         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
16916           .patch = patch_alc882 }, /* should be patch_alc883() in future */
16917         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
16918           .patch = patch_alc882 }, /* should be patch_alc883() in future */
16919         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
16920         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
16921         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
16922           .patch = patch_alc883 },
16923         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
16924         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
16925         {} /* terminator */
16926 };
16927
16928 MODULE_ALIAS("snd-hda-codec-id:10ec*");
16929
16930 MODULE_LICENSE("GPL");
16931 MODULE_DESCRIPTION("Realtek HD-audio codec");
16932
16933 static struct hda_codec_preset_list realtek_list = {
16934         .preset = snd_hda_preset_realtek,
16935         .owner = THIS_MODULE,
16936 };
16937
16938 static int __init patch_realtek_init(void)
16939 {
16940         return snd_hda_add_codec_preset(&realtek_list);
16941 }
16942
16943 static void __exit patch_realtek_exit(void)
16944 {
16945         snd_hda_delete_codec_preset(&realtek_list);
16946 }
16947
16948 module_init(patch_realtek_init)
16949 module_exit(patch_realtek_exit)