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         ALC272_DELL,
 192         ALC272_DELL_ZM1,
 193         ALC272_SAMSUNG_NC10,
 194         ALC662_AUTO,
 195         ALC662_MODEL_LAST,
 196 };
 197
 198 /* ALC882 models */
 199 enum {
 200         ALC882_3ST_DIG,
 201         ALC882_6ST_DIG,
 202         ALC882_ARIMA,
 203         ALC882_W2JC,
 204         ALC882_TARGA,
 205         ALC882_ASUS_A7J,
 206         ALC882_ASUS_A7M,
 207         ALC885_MACPRO,
 208         ALC885_MBP3,
 209         ALC885_MB5,
 210         ALC885_IMAC24,
 211         ALC882_AUTO,
 212         ALC882_MODEL_LAST,
 213 };
 214
 215 /* ALC883 models */
 216 enum {
 217         ALC883_3ST_2ch_DIG,
 218         ALC883_3ST_6ch_DIG,
 219         ALC883_3ST_6ch,
 220         ALC883_6ST_DIG,
 221         ALC883_TARGA_DIG,
 222         ALC883_TARGA_2ch_DIG,
 223         ALC883_ACER,
 224         ALC883_ACER_ASPIRE,
 225         ALC888_ACER_ASPIRE_4930G,
 226         ALC883_MEDION,
 227         ALC883_MEDION_MD2,
 228         ALC883_LAPTOP_EAPD,
 229         ALC883_LENOVO_101E_2ch,
 230         ALC883_LENOVO_NB0763,
 231         ALC888_LENOVO_MS7195_DIG,
 232         ALC888_LENOVO_SKY,
 233         ALC883_HAIER_W66,
 234         ALC888_3ST_HP,
 235         ALC888_6ST_DELL,
 236         ALC883_MITAC,
 237         ALC883_CLEVO_M720,
 238         ALC883_FUJITSU_PI2515,
 239         ALC888_FUJITSU_XA3530,
 240         ALC883_3ST_6ch_INTEL,
 241         ALC888_ASUS_M90V,
 242         ALC888_ASUS_EEE1601,
 243         ALC889A_MB31,
 244         ALC1200_ASUS_P5Q,
 245         ALC883_AUTO,
 246         ALC883_MODEL_LAST,
 247 };
 248
 249 /* styles of capture selection */
 250 enum {
 251         CAPT_MUX = 0,   /* only mux based */
 252         CAPT_MIX,       /* only mixer based */
 253         CAPT_1MUX_MIX,  /* first mux and other mixers */
 254 };
 255
 256 /* for GPIO Poll */
 257 #define GPIO_MASK       0x03
 258
 259 /* extra amp-initialization sequence types */
 260 enum {
 261         ALC_INIT_NONE,
 262         ALC_INIT_DEFAULT,
 263         ALC_INIT_GPIO1,
 264         ALC_INIT_GPIO2,
 265         ALC_INIT_GPIO3,
 266 };
 267
 268 struct alc_spec {
 269         /* codec parameterization */
 270         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 271         unsigned int num_mixers;
 272         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 273         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 274
 275         const struct hda_verb *init_verbs[5];   /* initialization verbs
 276                                                  * don't forget NULL
 277                                                  * termination!
 278                                                  */
 279         unsigned int num_init_verbs;
 280
 281         char stream_name_analog[16];    /* analog PCM stream */
 282         struct hda_pcm_stream *stream_analog_playback;
 283         struct hda_pcm_stream *stream_analog_capture;
 284         struct hda_pcm_stream *stream_analog_alt_playback;
 285         struct hda_pcm_stream *stream_analog_alt_capture;
 286
 287         char stream_name_digital[16];   /* digital PCM stream */
 288         struct hda_pcm_stream *stream_digital_playback;
 289         struct hda_pcm_stream *stream_digital_capture;
 290
 291         /* playback */
 292         struct hda_multi_out multiout;  /* playback set-up
 293                                          * max_channels, dacs must be set
 294                                          * dig_out_nid and hp_nid are optional
 295                                          */
 296         hda_nid_t alt_dac_nid;
 297         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 298         int dig_out_type;
 299
 300         /* capture */
 301         unsigned int num_adc_nids;
 302         hda_nid_t *adc_nids;
 303         hda_nid_t *capsrc_nids;
 304         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 305         int capture_style;              /* capture style (CAPT_*) */
 306
 307         /* capture source */
 308         unsigned int num_mux_defs;
 309         const struct hda_input_mux *input_mux;
 310         unsigned int cur_mux[3];
 311
 312         /* channel model */
 313         const struct hda_channel_mode *channel_mode;
 314         int num_channel_mode;
 315         int need_dac_fix;
 316
 317         /* PCM information */
 318         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 319
 320         /* dynamic controls, init_verbs and input_mux */
 321         struct auto_pin_cfg autocfg;
 322         struct snd_array kctls;
 323         struct hda_input_mux private_imux[3];
 324         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 325
 326         /* hooks */
 327         void (*init_hook)(struct hda_codec *codec);
 328         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 329
 330         /* for pin sensing */
 331         unsigned int sense_updated: 1;
 332         unsigned int jack_present: 1;
 333         unsigned int master_sw: 1;
 334
 335         /* other flags */
 336         unsigned int no_analog :1; /* digital I/O only */
 337         int init_amp;
 338
 339         /* for virtual master */
 340         hda_nid_t vmaster_nid;
 341 #ifdef CONFIG_SND_HDA_POWER_SAVE
 342         struct hda_loopback_check loopback;
 343 #endif
 344
 345         /* for PLL fix */
 346         hda_nid_t pll_nid;
 347         unsigned int pll_coef_idx, pll_coef_bit;
 348 };
 349
 350 /*
 351  * configuration template - to be copied to the spec instance
 352  */
 353 struct alc_config_preset {
 354         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 355                                              * with spec
 356                                              */
 357         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 358         const struct hda_verb *init_verbs[5];
 359         unsigned int num_dacs;
 360         hda_nid_t *dac_nids;
 361         hda_nid_t dig_out_nid;          /* optional */
 362         hda_nid_t hp_nid;               /* optional */
 363         hda_nid_t *slave_dig_outs;
 364         unsigned int num_adc_nids;
 365         hda_nid_t *adc_nids;
 366         hda_nid_t *capsrc_nids;
 367         hda_nid_t dig_in_nid;
 368         unsigned int num_channel_mode;
 369         const struct hda_channel_mode *channel_mode;
 370         int need_dac_fix;
 371         unsigned int num_mux_defs;
 372         const struct hda_input_mux *input_mux;
 373         void (*unsol_event)(struct hda_codec *, unsigned int);
 374         void (*init_hook)(struct hda_codec *);
 375 #ifdef CONFIG_SND_HDA_POWER_SAVE
 376         struct hda_amp_list *loopbacks;
 377 #endif
 378 };
 379
 380
 381 /*
 382  * input MUX handling
 383  */
 384 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 385                              struct snd_ctl_elem_info *uinfo)
 386 {
 387         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 388         struct alc_spec *spec = codec->spec;
 389         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 390         if (mux_idx >= spec->num_mux_defs)
 391                 mux_idx = 0;
 392         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 393 }
 394
 395 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 396                             struct snd_ctl_elem_value *ucontrol)
 397 {
 398         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 399         struct alc_spec *spec = codec->spec;
 400         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 401
 402         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 403         return 0;
 404 }
 405
 406 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 407                             struct snd_ctl_elem_value *ucontrol)
 408 {
 409         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 410         struct alc_spec *spec = codec->spec;
 411         const struct hda_input_mux *imux;
 412         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 413         unsigned int mux_idx;
 414         hda_nid_t nid = spec->capsrc_nids ?
 415                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 416
 417         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 418         imux = &spec->input_mux[mux_idx];
 419
 420         if (spec->capture_style &&
 421             !(spec->capture_style == CAPT_1MUX_MIX && !adc_idx)) {
 422                 /* Matrix-mixer style (e.g. ALC882) */
 423                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 424                 unsigned int i, idx;
 425
 426                 idx = ucontrol->value.enumerated.item[0];
 427                 if (idx >= imux->num_items)
 428                         idx = imux->num_items - 1;
 429                 if (*cur_val == idx)
 430                         return 0;
 431                 for (i = 0; i < imux->num_items; i++) {
 432                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 433                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 434                                                  imux->items[i].index,
 435                                                  HDA_AMP_MUTE, v);
 436                 }
 437                 *cur_val = idx;
 438                 return 1;
 439         } else {
 440                 /* MUX style (e.g. ALC880) */
 441                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 442                                              &spec->cur_mux[adc_idx]);
 443         }
 444 }
 445
 446 /*
 447  * channel mode setting
 448  */
 449 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 450                             struct snd_ctl_elem_info *uinfo)
 451 {
 452         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 453         struct alc_spec *spec = codec->spec;
 454         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 455                                     spec->num_channel_mode);
 456 }
 457
 458 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 459                            struct snd_ctl_elem_value *ucontrol)
 460 {
 461         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 462         struct alc_spec *spec = codec->spec;
 463         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 464                                    spec->num_channel_mode,
 465                                    spec->multiout.max_channels);
 466 }
 467
 468 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 469                            struct snd_ctl_elem_value *ucontrol)
 470 {
 471         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 472         struct alc_spec *spec = codec->spec;
 473         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 474                                       spec->num_channel_mode,
 475                                       &spec->multiout.max_channels);
 476         if (err >= 0 && spec->need_dac_fix)
 477                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 478         return err;
 479 }
 480
 481 /*
 482  * Control the mode of pin widget settings via the mixer.  "pc" is used
 483  * instead of "%" to avoid consequences of accidently treating the % as
 484  * being part of a format specifier.  Maximum allowed length of a value is
 485  * 63 characters plus NULL terminator.
 486  *
 487  * Note: some retasking pin complexes seem to ignore requests for input
 488  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 489  * are requested.  Therefore order this list so that this behaviour will not
 490  * cause problems when mixer clients move through the enum sequentially.
 491  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 492  * March 2006.
 493  */
 494 static char *alc_pin_mode_names[] = {
 495         "Mic 50pc bias", "Mic 80pc bias",
 496         "Line in", "Line out", "Headphone out",
 497 };
 498 static unsigned char alc_pin_mode_values[] = {
 499         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 500 };
 501 /* The control can present all 5 options, or it can limit the options based
 502  * in the pin being assumed to be exclusively an input or an output pin.  In
 503  * addition, "input" pins may or may not process the mic bias option
 504  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 505  * accept requests for bias as of chip versions up to March 2006) and/or
 506  * wiring in the computer.
 507  */
 508 #define ALC_PIN_DIR_IN              0x00
 509 #define ALC_PIN_DIR_OUT             0x01
 510 #define ALC_PIN_DIR_INOUT           0x02
 511 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 512 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 513
 514 /* Info about the pin modes supported by the different pin direction modes.
 515  * For each direction the minimum and maximum values are given.
 516  */
 517 static signed char alc_pin_mode_dir_info[5][2] = {
 518         { 0, 2 },    /* ALC_PIN_DIR_IN */
 519         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 520         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 521         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 522         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 523 };
 524 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 525 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 526 #define alc_pin_mode_n_items(_dir) \
 527         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 528
 529 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 530                              struct snd_ctl_elem_info *uinfo)
 531 {
 532         unsigned int item_num = uinfo->value.enumerated.item;
 533         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 534
 535         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 536         uinfo->count = 1;
 537         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 538
 539         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 540                 item_num = alc_pin_mode_min(dir);
 541         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 542         return 0;
 543 }
 544
 545 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 546                             struct snd_ctl_elem_value *ucontrol)
 547 {
 548         unsigned int i;
 549         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 550         hda_nid_t nid = kcontrol->private_value & 0xffff;
 551         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 552         long *valp = ucontrol->value.integer.value;
 553         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 554                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 555                                                  0x00);
 556
 557         /* Find enumerated value for current pinctl setting */
 558         i = alc_pin_mode_min(dir);
 559         while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
 560                 i++;
 561         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 562         return 0;
 563 }
 564
 565 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 566                             struct snd_ctl_elem_value *ucontrol)
 567 {
 568         signed int change;
 569         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 570         hda_nid_t nid = kcontrol->private_value & 0xffff;
 571         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 572         long val = *ucontrol->value.integer.value;
 573         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 574                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 575                                                  0x00);
 576
 577         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 578                 val = alc_pin_mode_min(dir);
 579
 580         change = pinctl != alc_pin_mode_values[val];
 581         if (change) {
 582                 /* Set pin mode to that requested */
 583                 snd_hda_codec_write_cache(codec, nid, 0,
 584                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 585                                           alc_pin_mode_values[val]);
 586
 587                 /* Also enable the retasking pin's input/output as required
 588                  * for the requested pin mode.  Enum values of 2 or less are
 589                  * input modes.
 590                  *
 591                  * Dynamically switching the input/output buffers probably
 592                  * reduces noise slightly (particularly on input) so we'll
 593                  * do it.  However, having both input and output buffers
 594                  * enabled simultaneously doesn't seem to be problematic if
 595                  * this turns out to be necessary in the future.
 596                  */
 597                 if (val <= 2) {
 598                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 599                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 600                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 601                                                  HDA_AMP_MUTE, 0);
 602                 } else {
 603                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 604                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 605                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 606                                                  HDA_AMP_MUTE, 0);
 607                 }
 608         }
 609         return change;
 610 }
 611
 612 #define ALC_PIN_MODE(xname, nid, dir) \
 613         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 614           .info = alc_pin_mode_info, \
 615           .get = alc_pin_mode_get, \
 616           .put = alc_pin_mode_put, \
 617           .private_value = nid | (dir<<16) }
 618
 619 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 620  * together using a mask with more than one bit set.  This control is
 621  * currently used only by the ALC260 test model.  At this stage they are not
 622  * needed for any "production" models.
 623  */
 624 #ifdef CONFIG_SND_DEBUG
 625 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 626
 627 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 628                              struct snd_ctl_elem_value *ucontrol)
 629 {
 630         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 631         hda_nid_t nid = kcontrol->private_value & 0xffff;
 632         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 633         long *valp = ucontrol->value.integer.value;
 634         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 635                                               AC_VERB_GET_GPIO_DATA, 0x00);
 636
 637         *valp = (val & mask) != 0;
 638         return 0;
 639 }
 640 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 641                              struct snd_ctl_elem_value *ucontrol)
 642 {
 643         signed int change;
 644         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 645         hda_nid_t nid = kcontrol->private_value & 0xffff;
 646         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 647         long val = *ucontrol->value.integer.value;
 648         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 649                                                     AC_VERB_GET_GPIO_DATA,
 650                                                     0x00);
 651
 652         /* Set/unset the masked GPIO bit(s) as needed */
 653         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 654         if (val == 0)
 655                 gpio_data &= ~mask;
 656         else
 657                 gpio_data |= mask;
 658         snd_hda_codec_write_cache(codec, nid, 0,
 659                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 660
 661         return change;
 662 }
 663 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 664         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 665           .info = alc_gpio_data_info, \
 666           .get = alc_gpio_data_get, \
 667           .put = alc_gpio_data_put, \
 668           .private_value = nid | (mask<<16) }
 669 #endif   /* CONFIG_SND_DEBUG */
 670
 671 /* A switch control to allow the enabling of the digital IO pins on the
 672  * ALC260.  This is incredibly simplistic; the intention of this control is
 673  * to provide something in the test model allowing digital outputs to be
 674  * identified if present.  If models are found which can utilise these
 675  * outputs a more complete mixer control can be devised for those models if
 676  * necessary.
 677  */
 678 #ifdef CONFIG_SND_DEBUG
 679 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 680
 681 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 682                               struct snd_ctl_elem_value *ucontrol)
 683 {
 684         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 685         hda_nid_t nid = kcontrol->private_value & 0xffff;
 686         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 687         long *valp = ucontrol->value.integer.value;
 688         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 689                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 690
 691         *valp = (val & mask) != 0;
 692         return 0;
 693 }
 694 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 695                               struct snd_ctl_elem_value *ucontrol)
 696 {
 697         signed int change;
 698         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 699         hda_nid_t nid = kcontrol->private_value & 0xffff;
 700         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 701         long val = *ucontrol->value.integer.value;
 702         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 703                                                     AC_VERB_GET_DIGI_CONVERT_1,
 704                                                     0x00);
 705
 706         /* Set/unset the masked control bit(s) as needed */
 707         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 708         if (val==0)
 709                 ctrl_data &= ~mask;
 710         else
 711                 ctrl_data |= mask;
 712         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 713                                   ctrl_data);
 714
 715         return change;
 716 }
 717 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 718         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 719           .info = alc_spdif_ctrl_info, \
 720           .get = alc_spdif_ctrl_get, \
 721           .put = alc_spdif_ctrl_put, \
 722           .private_value = nid | (mask<<16) }
 723 #endif   /* CONFIG_SND_DEBUG */
 724
 725 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 726  * Again, this is only used in the ALC26x test models to help identify when
 727  * the EAPD line must be asserted for features to work.
 728  */
 729 #ifdef CONFIG_SND_DEBUG
 730 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 731
 732 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 733                               struct snd_ctl_elem_value *ucontrol)
 734 {
 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 *valp = ucontrol->value.integer.value;
 739         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 740                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 741
 742         *valp = (val & mask) != 0;
 743         return 0;
 744 }
 745
 746 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 747                               struct snd_ctl_elem_value *ucontrol)
 748 {
 749         int change;
 750         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 751         hda_nid_t nid = kcontrol->private_value & 0xffff;
 752         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 753         long val = *ucontrol->value.integer.value;
 754         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 755                                                     AC_VERB_GET_EAPD_BTLENABLE,
 756                                                     0x00);
 757
 758         /* Set/unset the masked control bit(s) as needed */
 759         change = (!val ? 0 : mask) != (ctrl_data & mask);
 760         if (!val)
 761                 ctrl_data &= ~mask;
 762         else
 763                 ctrl_data |= mask;
 764         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 765                                   ctrl_data);
 766
 767         return change;
 768 }
 769
 770 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 771         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 772           .info = alc_eapd_ctrl_info, \
 773           .get = alc_eapd_ctrl_get, \
 774           .put = alc_eapd_ctrl_put, \
 775           .private_value = nid | (mask<<16) }
 776 #endif   /* CONFIG_SND_DEBUG */
 777
 778 /*
 779  * set up the input pin config (depending on the given auto-pin type)
 780  */
 781 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 782                               int auto_pin_type)
 783 {
 784         unsigned int val = PIN_IN;
 785
 786         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 787                 unsigned int pincap;
 788                 pincap = snd_hda_query_pin_caps(codec, nid);
 789                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 790                 if (pincap & AC_PINCAP_VREF_80)
 791                         val = PIN_VREF80;
 792                 else if (pincap & AC_PINCAP_VREF_50)
 793                         val = PIN_VREF50;
 794                 else if (pincap & AC_PINCAP_VREF_100)
 795                         val = PIN_VREF100;
 796                 else if (pincap & AC_PINCAP_VREF_GRD)
 797                         val = PIN_VREFGRD;
 798         }
 799         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 800 }
 801
 802 /*
 803  */
 804 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 805 {
 806         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 807                 return;
 808         spec->mixers[spec->num_mixers++] = mix;
 809 }
 810
 811 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 812 {
 813         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 814                 return;
 815         spec->init_verbs[spec->num_init_verbs++] = verb;
 816 }
 817
 818 #ifdef CONFIG_PROC_FS
 819 /*
 820  * hook for proc
 821  */
 822 static void print_realtek_coef(struct snd_info_buffer *buffer,
 823                                struct hda_codec *codec, hda_nid_t nid)
 824 {
 825         int coeff;
 826
 827         if (nid != 0x20)
 828                 return;
 829         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 830         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 831         coeff = snd_hda_codec_read(codec, nid, 0,
 832                                    AC_VERB_GET_COEF_INDEX, 0);
 833         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 834 }
 835 #else
 836 #define print_realtek_coef      NULL
 837 #endif
 838
 839 /*
 840  * set up from the preset table
 841  */
 842 static void setup_preset(struct alc_spec *spec,
 843                          const struct alc_config_preset *preset)
 844 {
 845         int i;
 846
 847         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 848                 add_mixer(spec, preset->mixers[i]);
 849         spec->cap_mixer = preset->cap_mixer;
 850         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 851              i++)
 852                 add_verb(spec, preset->init_verbs[i]);
 853
 854         spec->channel_mode = preset->channel_mode;
 855         spec->num_channel_mode = preset->num_channel_mode;
 856         spec->need_dac_fix = preset->need_dac_fix;
 857
 858         spec->multiout.max_channels = spec->channel_mode[0].channels;
 859
 860         spec->multiout.num_dacs = preset->num_dacs;
 861         spec->multiout.dac_nids = preset->dac_nids;
 862         spec->multiout.dig_out_nid = preset->dig_out_nid;
 863         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 864         spec->multiout.hp_nid = preset->hp_nid;
 865
 866         spec->num_mux_defs = preset->num_mux_defs;
 867         if (!spec->num_mux_defs)
 868                 spec->num_mux_defs = 1;
 869         spec->input_mux = preset->input_mux;
 870
 871         spec->num_adc_nids = preset->num_adc_nids;
 872         spec->adc_nids = preset->adc_nids;
 873         spec->capsrc_nids = preset->capsrc_nids;
 874         spec->dig_in_nid = preset->dig_in_nid;
 875
 876         spec->unsol_event = preset->unsol_event;
 877         spec->init_hook = preset->init_hook;
 878 #ifdef CONFIG_SND_HDA_POWER_SAVE
 879         spec->loopback.amplist = preset->loopbacks;
 880 #endif
 881 }
 882
 883 /* Enable GPIO mask and set output */
 884 static struct hda_verb alc_gpio1_init_verbs[] = {
 885         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 886         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 887         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 888         { }
 889 };
 890
 891 static struct hda_verb alc_gpio2_init_verbs[] = {
 892         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 893         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 894         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 895         { }
 896 };
 897
 898 static struct hda_verb alc_gpio3_init_verbs[] = {
 899         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 900         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 901         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 902         { }
 903 };
 904
 905 /*
 906  * Fix hardware PLL issue
 907  * On some codecs, the analog PLL gating control must be off while
 908  * the default value is 1.
 909  */
 910 static void alc_fix_pll(struct hda_codec *codec)
 911 {
 912         struct alc_spec *spec = codec->spec;
 913         unsigned int val;
 914
 915         if (!spec->pll_nid)
 916                 return;
 917         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 918                             spec->pll_coef_idx);
 919         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 920                                  AC_VERB_GET_PROC_COEF, 0);
 921         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 922                             spec->pll_coef_idx);
 923         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 924                             val & ~(1 << spec->pll_coef_bit));
 925 }
 926
 927 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 928                              unsigned int coef_idx, unsigned int coef_bit)
 929 {
 930         struct alc_spec *spec = codec->spec;
 931         spec->pll_nid = nid;
 932         spec->pll_coef_idx = coef_idx;
 933         spec->pll_coef_bit = coef_bit;
 934         alc_fix_pll(codec);
 935 }
 936
 937 static void alc_automute_pin(struct hda_codec *codec)
 938 {
 939         struct alc_spec *spec = codec->spec;
 940         unsigned int present;
 941         unsigned int nid = spec->autocfg.hp_pins[0];
 942         int i;
 943
 944         /* need to execute and sync at first */
 945         snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 946         present = snd_hda_codec_read(codec, nid, 0,
 947                                      AC_VERB_GET_PIN_SENSE, 0);
 948         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
 949         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
 950                 nid = spec->autocfg.speaker_pins[i];
 951                 if (!nid)
 952                         break;
 953                 snd_hda_codec_write(codec, nid, 0,
 954                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 955                                     spec->jack_present ? 0 : PIN_OUT);
 956         }
 957 }
 958
 959 #if 0 /* it's broken in some acses -- temporarily disabled */
 960 static void alc_mic_automute(struct hda_codec *codec)
 961 {
 962         struct alc_spec *spec = codec->spec;
 963         unsigned int present;
 964         unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
 965         unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
 966         unsigned int mix_nid = spec->capsrc_nids[0];
 967         unsigned int capsrc_idx_mic, capsrc_idx_fmic;
 968
 969         capsrc_idx_mic = mic_nid - 0x18;
 970         capsrc_idx_fmic = fmic_nid - 0x18;
 971         present = snd_hda_codec_read(codec, mic_nid, 0,
 972                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 973         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 974                     0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
 975         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 976                     0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
 977         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
 978                          HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 979 }
 980 #else
 981 #define alc_mic_automute(codec) do {} while(0) /* NOP */
 982 #endif /* disabled */
 983
 984 /* unsolicited event for HP jack sensing */
 985 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 986 {
 987         if (codec->vendor_id == 0x10ec0880)
 988                 res >>= 28;
 989         else
 990                 res >>= 26;
 991         switch (res) {
 992         case ALC880_HP_EVENT:
 993                 alc_automute_pin(codec);
 994                 break;
 995         case ALC880_MIC_EVENT:
 996                 alc_mic_automute(codec);
 997                 break;
 998         }
 999 }
1000
1001 static void alc_inithook(struct hda_codec *codec)
1002 {
1003         alc_automute_pin(codec);
1004         alc_mic_automute(codec);
1005 }
1006
1007 /* additional initialization for ALC888 variants */
1008 static void alc888_coef_init(struct hda_codec *codec)
1009 {
1010         unsigned int tmp;
1011
1012         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1013         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1014         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1015         if ((tmp & 0xf0) == 0x20)
1016                 /* alc888S-VC */
1017                 snd_hda_codec_read(codec, 0x20, 0,
1018                                    AC_VERB_SET_PROC_COEF, 0x830);
1019          else
1020                  /* alc888-VB */
1021                  snd_hda_codec_read(codec, 0x20, 0,
1022                                     AC_VERB_SET_PROC_COEF, 0x3030);
1023 }
1024
1025 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1026 {
1027         unsigned int tmp;
1028
1029         switch (type) {
1030         case ALC_INIT_GPIO1:
1031                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1032                 break;
1033         case ALC_INIT_GPIO2:
1034                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1035                 break;
1036         case ALC_INIT_GPIO3:
1037                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1038                 break;
1039         case ALC_INIT_DEFAULT:
1040                 switch (codec->vendor_id) {
1041                 case 0x10ec0260:
1042                         snd_hda_codec_write(codec, 0x0f, 0,
1043                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1044                         snd_hda_codec_write(codec, 0x10, 0,
1045                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1046                         break;
1047                 case 0x10ec0262:
1048                 case 0x10ec0267:
1049                 case 0x10ec0268:
1050                 case 0x10ec0269:
1051                 case 0x10ec0272:
1052                 case 0x10ec0660:
1053                 case 0x10ec0662:
1054                 case 0x10ec0663:
1055                 case 0x10ec0862:
1056                 case 0x10ec0889:
1057                         snd_hda_codec_write(codec, 0x14, 0,
1058                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1059                         snd_hda_codec_write(codec, 0x15, 0,
1060                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1061                         break;
1062                 }
1063                 switch (codec->vendor_id) {
1064                 case 0x10ec0260:
1065                         snd_hda_codec_write(codec, 0x1a, 0,
1066                                             AC_VERB_SET_COEF_INDEX, 7);
1067                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1068                                                  AC_VERB_GET_PROC_COEF, 0);
1069                         snd_hda_codec_write(codec, 0x1a, 0,
1070                                             AC_VERB_SET_COEF_INDEX, 7);
1071                         snd_hda_codec_write(codec, 0x1a, 0,
1072                                             AC_VERB_SET_PROC_COEF,
1073                                             tmp | 0x2010);
1074                         break;
1075                 case 0x10ec0262:
1076                 case 0x10ec0880:
1077                 case 0x10ec0882:
1078                 case 0x10ec0883:
1079                 case 0x10ec0885:
1080                 case 0x10ec0887:
1081                 case 0x10ec0889:
1082                         snd_hda_codec_write(codec, 0x20, 0,
1083                                             AC_VERB_SET_COEF_INDEX, 7);
1084                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1085                                                  AC_VERB_GET_PROC_COEF, 0);
1086                         snd_hda_codec_write(codec, 0x20, 0,
1087                                             AC_VERB_SET_COEF_INDEX, 7);
1088                         snd_hda_codec_write(codec, 0x20, 0,
1089                                             AC_VERB_SET_PROC_COEF,
1090                                             tmp | 0x2010);
1091                         break;
1092                 case 0x10ec0888:
1093                         alc888_coef_init(codec);
1094                         break;
1095                 case 0x10ec0267:
1096                 case 0x10ec0268:
1097                         snd_hda_codec_write(codec, 0x20, 0,
1098                                             AC_VERB_SET_COEF_INDEX, 7);
1099                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1100                                                  AC_VERB_GET_PROC_COEF, 0);
1101                         snd_hda_codec_write(codec, 0x20, 0,
1102                                             AC_VERB_SET_COEF_INDEX, 7);
1103                         snd_hda_codec_write(codec, 0x20, 0,
1104                                             AC_VERB_SET_PROC_COEF,
1105                                             tmp | 0x3000);
1106                         break;
1107                 }
1108                 break;
1109         }
1110 }
1111
1112 static void alc_init_auto_hp(struct hda_codec *codec)
1113 {
1114         struct alc_spec *spec = codec->spec;
1115
1116         if (!spec->autocfg.hp_pins[0])
1117                 return;
1118
1119         if (!spec->autocfg.speaker_pins[0]) {
1120                 if (spec->autocfg.line_out_pins[0] &&
1121                     spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1122                         spec->autocfg.speaker_pins[0] =
1123                                 spec->autocfg.line_out_pins[0];
1124                 else
1125                         return;
1126         }
1127
1128         snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1129                     spec->autocfg.hp_pins[0]);
1130         snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1131                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1132                                   AC_USRSP_EN | ALC880_HP_EVENT);
1133         spec->unsol_event = alc_sku_unsol_event;
1134 }
1135
1136 /* check subsystem ID and set up device-specific initialization;
1137  * return 1 if initialized, 0 if invalid SSID
1138  */
1139 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1140  *      31 ~ 16 :       Manufacture ID
1141  *      15 ~ 8  :       SKU ID
1142  *      7  ~ 0  :       Assembly ID
1143  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1144  */
1145 static int alc_subsystem_id(struct hda_codec *codec,
1146                             hda_nid_t porta, hda_nid_t porte,
1147                             hda_nid_t portd)
1148 {
1149         unsigned int ass, tmp, i;
1150         unsigned nid;
1151         struct alc_spec *spec = codec->spec;
1152
1153         ass = codec->subsystem_id & 0xffff;
1154         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1155                 goto do_sku;
1156
1157         /* invalid SSID, check the special NID pin defcfg instead */
1158         /*
1159          * 31~30        : port conetcivity
1160          * 29~21        : reserve
1161          * 20           : PCBEEP input
1162          * 19~16        : Check sum (15:1)
1163          * 15~1         : Custom
1164          * 0            : override
1165         */
1166         nid = 0x1d;
1167         if (codec->vendor_id == 0x10ec0260)
1168                 nid = 0x17;
1169         ass = snd_hda_codec_get_pincfg(codec, nid);
1170         snd_printd("realtek: No valid SSID, "
1171                    "checking pincfg 0x%08x for NID 0x%x\n",
1172                    ass, nid);
1173         if (!(ass & 1) && !(ass & 0x100000))
1174                 return 0;
1175         if ((ass >> 30) != 1)   /* no physical connection */
1176                 return 0;
1177
1178         /* check sum */
1179         tmp = 0;
1180         for (i = 1; i < 16; i++) {
1181                 if ((ass >> i) & 1)
1182                         tmp++;
1183         }
1184         if (((ass >> 16) & 0xf) != tmp)
1185                 return 0;
1186 do_sku:
1187         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1188                    ass & 0xffff, codec->vendor_id);
1189         /*
1190          * 0 : override
1191          * 1 :  Swap Jack
1192          * 2 : 0 --> Desktop, 1 --> Laptop
1193          * 3~5 : External Amplifier control
1194          * 7~6 : Reserved
1195         */
1196         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1197         switch (tmp) {
1198         case 1:
1199                 spec->init_amp = ALC_INIT_GPIO1;
1200                 break;
1201         case 3:
1202                 spec->init_amp = ALC_INIT_GPIO2;
1203                 break;
1204         case 7:
1205                 spec->init_amp = ALC_INIT_GPIO3;
1206                 break;
1207         case 5:
1208                 spec->init_amp = ALC_INIT_DEFAULT;
1209                 break;
1210         }
1211
1212         /* is laptop or Desktop and enable the function "Mute internal speaker
1213          * when the external headphone out jack is plugged"
1214          */
1215         if (!(ass & 0x8000))
1216                 return 1;
1217         /*
1218          * 10~8 : Jack location
1219          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1220          * 14~13: Resvered
1221          * 15   : 1 --> enable the function "Mute internal speaker
1222          *              when the external headphone out jack is plugged"
1223          */
1224         if (!spec->autocfg.hp_pins[0]) {
1225                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1226                 if (tmp == 0)
1227                         spec->autocfg.hp_pins[0] = porta;
1228                 else if (tmp == 1)
1229                         spec->autocfg.hp_pins[0] = porte;
1230                 else if (tmp == 2)
1231                         spec->autocfg.hp_pins[0] = portd;
1232                 else
1233                         return 1;
1234         }
1235
1236         alc_init_auto_hp(codec);
1237         return 1;
1238 }
1239
1240 static void alc_ssid_check(struct hda_codec *codec,
1241                            hda_nid_t porta, hda_nid_t porte, hda_nid_t portd)
1242 {
1243         if (!alc_subsystem_id(codec, porta, porte, portd)) {
1244                 struct alc_spec *spec = codec->spec;
1245                 snd_printd("realtek: "
1246                            "Enable default setup for auto mode as fallback\n");
1247                 spec->init_amp = ALC_INIT_DEFAULT;
1248                 alc_init_auto_hp(codec);
1249         }
1250 }
1251
1252 /*
1253  * Fix-up pin default configurations
1254  */
1255
1256 struct alc_pincfg {
1257         hda_nid_t nid;
1258         u32 val;
1259 };
1260
1261 static void alc_fix_pincfg(struct hda_codec *codec,
1262                            const struct snd_pci_quirk *quirk,
1263                            const struct alc_pincfg **pinfix)
1264 {
1265         const struct alc_pincfg *cfg;
1266
1267         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1268         if (!quirk)
1269                 return;
1270
1271         cfg = pinfix[quirk->value];
1272         for (; cfg->nid; cfg++)
1273                 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1274 }
1275
1276 /*
1277  * ALC888
1278  */
1279
1280 /*
1281  * 2ch mode
1282  */
1283 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1284 /* Mic-in jack as mic in */
1285         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1286         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1287 /* Line-in jack as Line in */
1288         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1289         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1290 /* Line-Out as Front */
1291         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1292         { } /* end */
1293 };
1294
1295 /*
1296  * 4ch mode
1297  */
1298 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1299 /* Mic-in jack as mic in */
1300         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1301         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1302 /* Line-in jack as Surround */
1303         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1304         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1305 /* Line-Out as Front */
1306         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1307         { } /* end */
1308 };
1309
1310 /*
1311  * 6ch mode
1312  */
1313 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1314 /* Mic-in jack as CLFE */
1315         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1316         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1317 /* Line-in jack as Surround */
1318         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1319         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1320 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1321         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1322         { } /* end */
1323 };
1324
1325 /*
1326  * 8ch mode
1327  */
1328 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1329 /* Mic-in jack as CLFE */
1330         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1331         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1332 /* Line-in jack as Surround */
1333         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1334         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1335 /* Line-Out as Side */
1336         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1337         { } /* end */
1338 };
1339
1340 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1341         { 2, alc888_4ST_ch2_intel_init },
1342         { 4, alc888_4ST_ch4_intel_init },
1343         { 6, alc888_4ST_ch6_intel_init },
1344         { 8, alc888_4ST_ch8_intel_init },
1345 };
1346
1347 /*
1348  * ALC888 Fujitsu Siemens Amillo xa3530
1349  */
1350
1351 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1352 /* Front Mic: set to PIN_IN (empty by default) */
1353         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1354 /* Connect Internal HP to Front */
1355         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1356         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1357         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1358 /* Connect Bass HP to Front */
1359         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1360         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1361         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1362 /* Connect Line-Out side jack (SPDIF) to Side */
1363         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1364         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1365         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1366 /* Connect Mic jack to CLFE */
1367         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1368         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1369         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1370 /* Connect Line-in jack to Surround */
1371         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1372         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1373         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1374 /* Connect HP out jack to Front */
1375         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1376         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1377         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1378 /* Enable unsolicited event for HP jack and Line-out jack */
1379         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1380         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1381         {}
1382 };
1383
1384 static void alc_automute_amp(struct hda_codec *codec)
1385 {
1386         struct alc_spec *spec = codec->spec;
1387         unsigned int val, mute;
1388         hda_nid_t nid;
1389         int i;
1390
1391         spec->jack_present = 0;
1392         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1393                 nid = spec->autocfg.hp_pins[i];
1394                 if (!nid)
1395                         break;
1396                 val = snd_hda_codec_read(codec, nid, 0,
1397                                          AC_VERB_GET_PIN_SENSE, 0);
1398                 if (val & AC_PINSENSE_PRESENCE) {
1399                         spec->jack_present = 1;
1400                         break;
1401                 }
1402         }
1403
1404         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1405         /* Toggle internal speakers muting */
1406         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1407                 nid = spec->autocfg.speaker_pins[i];
1408                 if (!nid)
1409                         break;
1410                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1411                                          HDA_AMP_MUTE, mute);
1412         }
1413 }
1414
1415 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1416                                          unsigned int res)
1417 {
1418         if (codec->vendor_id == 0x10ec0880)
1419                 res >>= 28;
1420         else
1421                 res >>= 26;
1422         if (res == ALC880_HP_EVENT)
1423                 alc_automute_amp(codec);
1424 }
1425
1426 static void alc888_fujitsu_xa3530_init_hook(struct hda_codec *codec)
1427 {
1428         struct alc_spec *spec = codec->spec;
1429
1430         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1431         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1432         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1433         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1434         alc_automute_amp(codec);
1435 }
1436
1437 /*
1438  * ALC888 Acer Aspire 4930G model
1439  */
1440
1441 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1442 /* Front Mic: set to PIN_IN (empty by default) */
1443         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1444 /* Unselect Front Mic by default in input mixer 3 */
1445         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1446 /* Enable unsolicited event for HP jack */
1447         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1448 /* Connect Internal HP to front */
1449         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1450         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1451         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1452 /* Connect HP out to front */
1453         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1454         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1455         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1456         { }
1457 };
1458
1459 static struct hda_input_mux alc888_2_capture_sources[2] = {
1460         /* Front mic only available on one ADC */
1461         {
1462                 .num_items = 4,
1463                 .items = {
1464                         { "Mic", 0x0 },
1465                         { "Line", 0x2 },
1466                         { "CD", 0x4 },
1467                         { "Front Mic", 0xb },
1468                 },
1469         },
1470         {
1471                 .num_items = 3,
1472                 .items = {
1473                         { "Mic", 0x0 },
1474                         { "Line", 0x2 },
1475                         { "CD", 0x4 },
1476                 },
1477         }
1478 };
1479
1480 static struct snd_kcontrol_new alc888_base_mixer[] = {
1481         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1482         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1483         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1484         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1485         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1486                 HDA_OUTPUT),
1487         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1488         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1489         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1490         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1491         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1492         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1493         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1494         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1495         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1496         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1497         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1498         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1499         { } /* end */
1500 };
1501
1502 static void alc888_acer_aspire_4930g_init_hook(struct hda_codec *codec)
1503 {
1504         struct alc_spec *spec = codec->spec;
1505
1506         spec->autocfg.hp_pins[0] = 0x15;
1507         spec->autocfg.speaker_pins[0] = 0x14;
1508         alc_automute_amp(codec);
1509 }
1510
1511 /*
1512  * ALC880 3-stack model
1513  *
1514  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1515  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1516  *                 F-Mic = 0x1b, HP = 0x19
1517  */
1518
1519 static hda_nid_t alc880_dac_nids[4] = {
1520         /* front, rear, clfe, rear_surr */
1521         0x02, 0x05, 0x04, 0x03
1522 };
1523
1524 static hda_nid_t alc880_adc_nids[3] = {
1525         /* ADC0-2 */
1526         0x07, 0x08, 0x09,
1527 };
1528
1529 /* The datasheet says the node 0x07 is connected from inputs,
1530  * but it shows zero connection in the real implementation on some devices.
1531  * Note: this is a 915GAV bug, fixed on 915GLV
1532  */
1533 static hda_nid_t alc880_adc_nids_alt[2] = {
1534         /* ADC1-2 */
1535         0x08, 0x09,
1536 };
1537
1538 #define ALC880_DIGOUT_NID       0x06
1539 #define ALC880_DIGIN_NID        0x0a
1540
1541 static struct hda_input_mux alc880_capture_source = {
1542         .num_items = 4,
1543         .items = {
1544                 { "Mic", 0x0 },
1545                 { "Front Mic", 0x3 },
1546                 { "Line", 0x2 },
1547                 { "CD", 0x4 },
1548         },
1549 };
1550
1551 /* channel source setting (2/6 channel selection for 3-stack) */
1552 /* 2ch mode */
1553 static struct hda_verb alc880_threestack_ch2_init[] = {
1554         /* set line-in to input, mute it */
1555         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1556         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1557         /* set mic-in to input vref 80%, mute it */
1558         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1559         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1560         { } /* end */
1561 };
1562
1563 /* 6ch mode */
1564 static struct hda_verb alc880_threestack_ch6_init[] = {
1565         /* set line-in to output, unmute it */
1566         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1567         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1568         /* set mic-in to output, unmute it */
1569         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1570         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1571         { } /* end */
1572 };
1573
1574 static struct hda_channel_mode alc880_threestack_modes[2] = {
1575         { 2, alc880_threestack_ch2_init },
1576         { 6, alc880_threestack_ch6_init },
1577 };
1578
1579 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1580         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1581         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1582         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1583         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1584         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1585         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1586         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1587         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1588         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1589         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1590         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1591         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1592         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1593         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1594         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1595         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1596         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1597         {
1598                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1599                 .name = "Channel Mode",
1600                 .info = alc_ch_mode_info,
1601                 .get = alc_ch_mode_get,
1602                 .put = alc_ch_mode_put,
1603         },
1604         { } /* end */
1605 };
1606
1607 /* capture mixer elements */
1608 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1609                             struct snd_ctl_elem_info *uinfo)
1610 {
1611         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1612         struct alc_spec *spec = codec->spec;
1613         int err;
1614
1615         mutex_lock(&codec->control_mutex);
1616         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1617                                                       HDA_INPUT);
1618         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1619         mutex_unlock(&codec->control_mutex);
1620         return err;
1621 }
1622
1623 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1624                            unsigned int size, unsigned int __user *tlv)
1625 {
1626         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1627         struct alc_spec *spec = codec->spec;
1628         int err;
1629
1630         mutex_lock(&codec->control_mutex);
1631         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1632                                                       HDA_INPUT);
1633         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1634         mutex_unlock(&codec->control_mutex);
1635         return err;
1636 }
1637
1638 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1639                              struct snd_ctl_elem_value *ucontrol);
1640
1641 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1642                                  struct snd_ctl_elem_value *ucontrol,
1643                                  getput_call_t func)
1644 {
1645         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1646         struct alc_spec *spec = codec->spec;
1647         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1648         int err;
1649
1650         mutex_lock(&codec->control_mutex);
1651         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1652                                                       3, 0, HDA_INPUT);
1653         err = func(kcontrol, ucontrol);
1654         mutex_unlock(&codec->control_mutex);
1655         return err;
1656 }
1657
1658 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1659                            struct snd_ctl_elem_value *ucontrol)
1660 {
1661         return alc_cap_getput_caller(kcontrol, ucontrol,
1662                                      snd_hda_mixer_amp_volume_get);
1663 }
1664
1665 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1666                            struct snd_ctl_elem_value *ucontrol)
1667 {
1668         return alc_cap_getput_caller(kcontrol, ucontrol,
1669                                      snd_hda_mixer_amp_volume_put);
1670 }
1671
1672 /* capture mixer elements */
1673 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1674
1675 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1676                           struct snd_ctl_elem_value *ucontrol)
1677 {
1678         return alc_cap_getput_caller(kcontrol, ucontrol,
1679                                      snd_hda_mixer_amp_switch_get);
1680 }
1681
1682 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1683                           struct snd_ctl_elem_value *ucontrol)
1684 {
1685         return alc_cap_getput_caller(kcontrol, ucontrol,
1686                                      snd_hda_mixer_amp_switch_put);
1687 }
1688
1689 #define _DEFINE_CAPMIX(num) \
1690         { \
1691                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1692                 .name = "Capture Switch", \
1693                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1694                 .count = num, \
1695                 .info = alc_cap_sw_info, \
1696                 .get = alc_cap_sw_get, \
1697                 .put = alc_cap_sw_put, \
1698         }, \
1699         { \
1700                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1701                 .name = "Capture Volume", \
1702                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1703                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1704                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1705                 .count = num, \
1706                 .info = alc_cap_vol_info, \
1707                 .get = alc_cap_vol_get, \
1708                 .put = alc_cap_vol_put, \
1709                 .tlv = { .c = alc_cap_vol_tlv }, \
1710         }
1711
1712 #define _DEFINE_CAPSRC(num) \
1713         { \
1714                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1715                 /* .name = "Capture Source", */ \
1716                 .name = "Input Source", \
1717                 .count = num, \
1718                 .info = alc_mux_enum_info, \
1719                 .get = alc_mux_enum_get, \
1720                 .put = alc_mux_enum_put, \
1721         }
1722
1723 #define DEFINE_CAPMIX(num) \
1724 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1725         _DEFINE_CAPMIX(num),                                  \
1726         _DEFINE_CAPSRC(num),                                  \
1727         { } /* end */                                         \
1728 }
1729
1730 #define DEFINE_CAPMIX_NOSRC(num) \
1731 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1732         _DEFINE_CAPMIX(num),                                        \
1733         { } /* end */                                               \
1734 }
1735
1736 /* up to three ADCs */
1737 DEFINE_CAPMIX(1);
1738 DEFINE_CAPMIX(2);
1739 DEFINE_CAPMIX(3);
1740 DEFINE_CAPMIX_NOSRC(1);
1741 DEFINE_CAPMIX_NOSRC(2);
1742 DEFINE_CAPMIX_NOSRC(3);
1743
1744 /*
1745  * ALC880 5-stack model
1746  *
1747  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1748  *      Side = 0x02 (0xd)
1749  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1750  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1751  */
1752
1753 /* additional mixers to alc880_three_stack_mixer */
1754 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1755         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1756         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1757         { } /* end */
1758 };
1759
1760 /* channel source setting (6/8 channel selection for 5-stack) */
1761 /* 6ch mode */
1762 static struct hda_verb alc880_fivestack_ch6_init[] = {
1763         /* set line-in to input, mute it */
1764         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1765         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1766         { } /* end */
1767 };
1768
1769 /* 8ch mode */
1770 static struct hda_verb alc880_fivestack_ch8_init[] = {
1771         /* set line-in to output, unmute it */
1772         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1773         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1774         { } /* end */
1775 };
1776
1777 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1778         { 6, alc880_fivestack_ch6_init },
1779         { 8, alc880_fivestack_ch8_init },
1780 };
1781
1782
1783 /*
1784  * ALC880 6-stack model
1785  *
1786  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1787  *      Side = 0x05 (0x0f)
1788  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1789  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1790  */
1791
1792 static hda_nid_t alc880_6st_dac_nids[4] = {
1793         /* front, rear, clfe, rear_surr */
1794         0x02, 0x03, 0x04, 0x05
1795 };
1796
1797 static struct hda_input_mux alc880_6stack_capture_source = {
1798         .num_items = 4,
1799         .items = {
1800                 { "Mic", 0x0 },
1801                 { "Front Mic", 0x1 },
1802                 { "Line", 0x2 },
1803                 { "CD", 0x4 },
1804         },
1805 };
1806
1807 /* fixed 8-channels */
1808 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1809         { 8, NULL },
1810 };
1811
1812 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1813         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1814         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1815         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1816         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1817         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1818         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1819         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1820         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1821         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1822         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1823         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1824         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1825         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1826         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1827         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1828         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1829         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1830         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1831         {
1832                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1833                 .name = "Channel Mode",
1834                 .info = alc_ch_mode_info,
1835                 .get = alc_ch_mode_get,
1836                 .put = alc_ch_mode_put,
1837         },
1838         { } /* end */
1839 };
1840
1841
1842 /*
1843  * ALC880 W810 model
1844  *
1845  * W810 has rear IO for:
1846  * Front (DAC 02)
1847  * Surround (DAC 03)
1848  * Center/LFE (DAC 04)
1849  * Digital out (06)
1850  *
1851  * The system also has a pair of internal speakers, and a headphone jack.
1852  * These are both connected to Line2 on the codec, hence to DAC 02.
1853  *
1854  * There is a variable resistor to control the speaker or headphone
1855  * volume. This is a hardware-only device without a software API.
1856  *
1857  * Plugging headphones in will disable the internal speakers. This is
1858  * implemented in hardware, not via the driver using jack sense. In
1859  * a similar fashion, plugging into the rear socket marked "front" will
1860  * disable both the speakers and headphones.
1861  *
1862  * For input, there's a microphone jack, and an "audio in" jack.
1863  * These may not do anything useful with this driver yet, because I
1864  * haven't setup any initialization verbs for these yet...
1865  */
1866
1867 static hda_nid_t alc880_w810_dac_nids[3] = {
1868         /* front, rear/surround, clfe */
1869         0x02, 0x03, 0x04
1870 };
1871
1872 /* fixed 6 channels */
1873 static struct hda_channel_mode alc880_w810_modes[1] = {
1874         { 6, NULL }
1875 };
1876
1877 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1878 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1879         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1880         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1881         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1882         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1883         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1884         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1885         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1886         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1887         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1888         { } /* end */
1889 };
1890
1891
1892 /*
1893  * Z710V model
1894  *
1895  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1896  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1897  *                 Line = 0x1a
1898  */
1899
1900 static hda_nid_t alc880_z71v_dac_nids[1] = {
1901         0x02
1902 };
1903 #define ALC880_Z71V_HP_DAC      0x03
1904
1905 /* fixed 2 channels */
1906 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1907         { 2, NULL }
1908 };
1909
1910 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1911         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1912         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1913         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1914         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1915         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1916         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1917         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1918         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1919         { } /* end */
1920 };
1921
1922
1923 /*
1924  * ALC880 F1734 model
1925  *
1926  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1927  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1928  */
1929
1930 static hda_nid_t alc880_f1734_dac_nids[1] = {
1931         0x03
1932 };
1933 #define ALC880_F1734_HP_DAC     0x02
1934
1935 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1936         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1937         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1938         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1939         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1940         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1941         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1942         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1943         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1944         { } /* end */
1945 };
1946
1947 static struct hda_input_mux alc880_f1734_capture_source = {
1948         .num_items = 2,
1949         .items = {
1950                 { "Mic", 0x1 },
1951                 { "CD", 0x4 },
1952         },
1953 };
1954
1955
1956 /*
1957  * ALC880 ASUS model
1958  *
1959  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1960  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1961  *  Mic = 0x18, Line = 0x1a
1962  */
1963
1964 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
1965 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
1966
1967 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1968         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1969         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1970         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1971         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1972         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1973         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1974         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1975         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1976         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1977         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1978         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1979         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1980         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1981         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1982         {
1983                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1984                 .name = "Channel Mode",
1985                 .info = alc_ch_mode_info,
1986                 .get = alc_ch_mode_get,
1987                 .put = alc_ch_mode_put,
1988         },
1989         { } /* end */
1990 };
1991
1992 /*
1993  * ALC880 ASUS W1V model
1994  *
1995  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1996  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1997  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1998  */
1999
2000 /* additional mixers to alc880_asus_mixer */
2001 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2002         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2003         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2004         { } /* end */
2005 };
2006
2007 /* TCL S700 */
2008 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2009         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2010         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2011         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2012         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2013         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2014         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2015         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2016         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2017         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2018         { } /* end */
2019 };
2020
2021 /* Uniwill */
2022 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2023         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2024         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2025         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2026         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2027         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2028         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2029         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2030         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2031         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2032         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2033         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2034         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2035         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2036         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2037         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2038         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2039         {
2040                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2041                 .name = "Channel Mode",
2042                 .info = alc_ch_mode_info,
2043                 .get = alc_ch_mode_get,
2044                 .put = alc_ch_mode_put,
2045         },
2046         { } /* end */
2047 };
2048
2049 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2050         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2051         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2052         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2053         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2054         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2055         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2056         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2057         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2058         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2059         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2060         { } /* end */
2061 };
2062
2063 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2064         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2065         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2066         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2067         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2068         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2069         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2070         { } /* end */
2071 };
2072
2073 /*
2074  * virtual master controls
2075  */
2076
2077 /*
2078  * slave controls for virtual master
2079  */
2080 static const char *alc_slave_vols[] = {
2081         "Front Playback Volume",
2082         "Surround Playback Volume",
2083         "Center Playback Volume",
2084         "LFE Playback Volume",
2085         "Side Playback Volume",
2086         "Headphone Playback Volume",
2087         "Speaker Playback Volume",
2088         "Mono Playback Volume",
2089         "Line-Out Playback Volume",
2090         "PCM Playback Volume",
2091         NULL,
2092 };
2093
2094 static const char *alc_slave_sws[] = {
2095         "Front Playback Switch",
2096         "Surround Playback Switch",
2097         "Center Playback Switch",
2098         "LFE Playback Switch",
2099         "Side Playback Switch",
2100         "Headphone Playback Switch",
2101         "Speaker Playback Switch",
2102         "Mono Playback Switch",
2103         "IEC958 Playback Switch",
2104         NULL,
2105 };
2106
2107 /*
2108  * build control elements
2109  */
2110
2111 static void alc_free_kctls(struct hda_codec *codec);
2112
2113 /* additional beep mixers; the actual parameters are overwritten at build */
2114 static struct snd_kcontrol_new alc_beep_mixer[] = {
2115         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2116         HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
2117         { } /* end */
2118 };
2119
2120 static int alc_build_controls(struct hda_codec *codec)
2121 {
2122         struct alc_spec *spec = codec->spec;
2123         int err;
2124         int i;
2125
2126         for (i = 0; i < spec->num_mixers; i++) {
2127                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2128                 if (err < 0)
2129                         return err;
2130         }
2131         if (spec->cap_mixer) {
2132                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2133                 if (err < 0)
2134                         return err;
2135         }
2136         if (spec->multiout.dig_out_nid) {
2137                 err = snd_hda_create_spdif_out_ctls(codec,
2138                                                     spec->multiout.dig_out_nid);
2139                 if (err < 0)
2140                         return err;
2141                 if (!spec->no_analog) {
2142                         err = snd_hda_create_spdif_share_sw(codec,
2143                                                             &spec->multiout);
2144                         if (err < 0)
2145                                 return err;
2146                         spec->multiout.share_spdif = 1;
2147                 }
2148         }
2149         if (spec->dig_in_nid) {
2150                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2151                 if (err < 0)
2152                         return err;
2153         }
2154
2155         /* create beep controls if needed */
2156         if (spec->beep_amp) {
2157                 struct snd_kcontrol_new *knew;
2158                 for (knew = alc_beep_mixer; knew->name; knew++) {
2159                         struct snd_kcontrol *kctl;
2160                         kctl = snd_ctl_new1(knew, codec);
2161                         if (!kctl)
2162                                 return -ENOMEM;
2163                         kctl->private_value = spec->beep_amp;
2164                         err = snd_hda_ctl_add(codec, kctl);
2165                         if (err < 0)
2166                                 return err;
2167                 }
2168         }
2169
2170         /* if we have no master control, let's create it */
2171         if (!spec->no_analog &&
2172             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2173                 unsigned int vmaster_tlv[4];
2174                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2175                                         HDA_OUTPUT, vmaster_tlv);
2176                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2177                                           vmaster_tlv, alc_slave_vols);
2178                 if (err < 0)
2179                         return err;
2180         }
2181         if (!spec->no_analog &&
2182             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2183                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2184                                           NULL, alc_slave_sws);
2185                 if (err < 0)
2186                         return err;
2187         }
2188
2189         alc_free_kctls(codec); /* no longer needed */
2190         return 0;
2191 }
2192
2193
2194 /*
2195  * initialize the codec volumes, etc
2196  */
2197
2198 /*
2199  * generic initialization of ADC, input mixers and output mixers
2200  */
2201 static struct hda_verb alc880_volume_init_verbs[] = {
2202         /*
2203          * Unmute ADC0-2 and set the default input to mic-in
2204          */
2205         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2206         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2207         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2208         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2209         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2210         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2211
2212         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2213          * mixer widget
2214          * Note: PASD motherboards uses the Line In 2 as the input for front
2215          * panel mic (mic 2)
2216          */
2217         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2218         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2219         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2220         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2221         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2222         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2223         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2224         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2225
2226         /*
2227          * Set up output mixers (0x0c - 0x0f)
2228          */
2229         /* set vol=0 to output mixers */
2230         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2231         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2232         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2233         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2234         /* set up input amps for analog loopback */
2235         /* Amp Indices: DAC = 0, mixer = 1 */
2236         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2237         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2238         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2239         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2240         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2241         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2242         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2243         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2244
2245         { }
2246 };
2247
2248 /*
2249  * 3-stack pin configuration:
2250  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2251  */
2252 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2253         /*
2254          * preset connection lists of input pins
2255          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2256          */
2257         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2258         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2259         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2260
2261         /*
2262          * Set pin mode and muting
2263          */
2264         /* set front pin widgets 0x14 for output */
2265         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2266         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2267         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2268         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2269         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2270         /* Mic2 (as headphone out) for HP output */
2271         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2272         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2273         /* Line In pin widget for input */
2274         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2275         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2276         /* Line2 (as front mic) pin widget for input and vref at 80% */
2277         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2278         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2279         /* CD pin widget for input */
2280         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2281
2282         { }
2283 };
2284
2285 /*
2286  * 5-stack pin configuration:
2287  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2288  * line-in/side = 0x1a, f-mic = 0x1b
2289  */
2290 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2291         /*
2292          * preset connection lists of input pins
2293          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2294          */
2295         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2296         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2297
2298         /*
2299          * Set pin mode and muting
2300          */
2301         /* set pin widgets 0x14-0x17 for output */
2302         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2303         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2304         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2305         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2306         /* unmute pins for output (no gain on this amp) */
2307         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2308         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2309         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2310         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2311
2312         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2313         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2314         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2315         /* Mic2 (as headphone out) for HP output */
2316         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2317         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2318         /* Line In pin widget for input */
2319         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2320         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2321         /* Line2 (as front mic) pin widget for input and vref at 80% */
2322         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2323         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2324         /* CD pin widget for input */
2325         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2326
2327         { }
2328 };
2329
2330 /*
2331  * W810 pin configuration:
2332  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2333  */
2334 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2335         /* hphone/speaker input selector: front DAC */
2336         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2337
2338         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2339         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2340         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2341         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2342         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2343         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2344
2345         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2346         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2347
2348         { }
2349 };
2350
2351 /*
2352  * Z71V pin configuration:
2353  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2354  */
2355 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2356         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2357         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2358         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2359         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2360
2361         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2362         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2363         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2364         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2365
2366         { }
2367 };
2368
2369 /*
2370  * 6-stack pin configuration:
2371  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2372  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2373  */
2374 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2375         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2376
2377         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2378         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2379         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2380         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2381         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2382         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2383         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2384         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2385
2386         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2387         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2388         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2389         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2390         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2391         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2392         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2393         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2394         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2395
2396         { }
2397 };
2398
2399 /*
2400  * Uniwill pin configuration:
2401  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2402  * line = 0x1a
2403  */
2404 static struct hda_verb alc880_uniwill_init_verbs[] = {
2405         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2406
2407         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2408         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2409         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2410         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2411         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2412         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2413         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2414         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2415         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2416         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2417         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2418         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2419         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2420         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2421
2422         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2423         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2424         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2425         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2426         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2427         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2428         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2429         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2430         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2431
2432         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2433         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2434
2435         { }
2436 };
2437
2438 /*
2439 * Uniwill P53
2440 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2441  */
2442 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2443         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2444
2445         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2446         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2447         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2448         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2449         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2450         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2451         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2452         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2453         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2454         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2455         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2456         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2457
2458         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2459         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2460         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2461         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2462         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2463         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2464
2465         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2466         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2467
2468         { }
2469 };
2470
2471 static struct hda_verb alc880_beep_init_verbs[] = {
2472         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2473         { }
2474 };
2475
2476 /* auto-toggle front mic */
2477 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2478 {
2479         unsigned int present;
2480         unsigned char bits;
2481
2482         present = snd_hda_codec_read(codec, 0x18, 0,
2483                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2484         bits = present ? HDA_AMP_MUTE : 0;
2485         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2486 }
2487
2488 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2489 {
2490         struct alc_spec *spec = codec->spec;
2491
2492         spec->autocfg.hp_pins[0] = 0x14;
2493         spec->autocfg.speaker_pins[0] = 0x15;
2494         spec->autocfg.speaker_pins[0] = 0x16;
2495         alc_automute_amp(codec);
2496         alc880_uniwill_mic_automute(codec);
2497 }
2498
2499 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2500                                        unsigned int res)
2501 {
2502         /* Looks like the unsol event is incompatible with the standard
2503          * definition.  4bit tag is placed at 28 bit!
2504          */
2505         switch (res >> 28) {
2506         case ALC880_MIC_EVENT:
2507                 alc880_uniwill_mic_automute(codec);
2508                 break;
2509         default:
2510                 alc_automute_amp_unsol_event(codec, res);
2511                 break;
2512         }
2513 }
2514
2515 static void alc880_uniwill_p53_init_hook(struct hda_codec *codec)
2516 {
2517         struct alc_spec *spec = codec->spec;
2518
2519         spec->autocfg.hp_pins[0] = 0x14;
2520         spec->autocfg.speaker_pins[0] = 0x15;
2521         alc_automute_amp(codec);
2522 }
2523
2524 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2525 {
2526         unsigned int present;
2527
2528         present = snd_hda_codec_read(codec, 0x21, 0,
2529                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2530         present &= HDA_AMP_VOLMASK;
2531         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2532                                  HDA_AMP_VOLMASK, present);
2533         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2534                                  HDA_AMP_VOLMASK, present);
2535 }
2536
2537 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2538                                            unsigned int res)
2539 {
2540         /* Looks like the unsol event is incompatible with the standard
2541          * definition.  4bit tag is placed at 28 bit!
2542          */
2543         if ((res >> 28) == ALC880_DCVOL_EVENT)
2544                 alc880_uniwill_p53_dcvol_automute(codec);
2545         else
2546                 alc_automute_amp_unsol_event(codec, res);
2547 }
2548
2549 /*
2550  * F1734 pin configuration:
2551  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2552  */
2553 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2554         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2555         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2556         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2557         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2558         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2559
2560         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2561         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2562         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2563         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2564
2565         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2566         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2567         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2568         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2569         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2570         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2571         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2572         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2573         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2574
2575         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2576         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2577
2578         { }
2579 };
2580
2581 /*
2582  * ASUS pin configuration:
2583  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2584  */
2585 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2586         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2587         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2588         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2589         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2590
2591         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2592         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2593         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2594         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2595         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2596         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2597         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2598         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2599
2600         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2601         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2602         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2603         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2604         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2605         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2606         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2607         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2608         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2609
2610         { }
2611 };
2612
2613 /* Enable GPIO mask and set output */
2614 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2615 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2616
2617 /* Clevo m520g init */
2618 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2619         /* headphone output */
2620         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2621         /* line-out */
2622         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2623         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2624         /* Line-in */
2625         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2626         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2627         /* CD */
2628         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2629         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2630         /* Mic1 (rear panel) */
2631         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2632         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2633         /* Mic2 (front panel) */
2634         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2635         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2636         /* headphone */
2637         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2638         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2639         /* change to EAPD mode */
2640         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2641         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2642
2643         { }
2644 };
2645
2646 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2647         /* change to EAPD mode */
2648         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2649         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2650
2651         /* Headphone output */
2652         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2653         /* Front output*/
2654         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2655         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2656
2657         /* Line In pin widget for input */
2658         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2659         /* CD pin widget for input */
2660         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2661         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2662         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2663
2664         /* change to EAPD mode */
2665         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2666         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2667
2668         { }
2669 };
2670
2671 /*
2672  * LG m1 express dual
2673  *
2674  * Pin assignment:
2675  *   Rear Line-In/Out (blue): 0x14
2676  *   Build-in Mic-In: 0x15
2677  *   Speaker-out: 0x17
2678  *   HP-Out (green): 0x1b
2679  *   Mic-In/Out (red): 0x19
2680  *   SPDIF-Out: 0x1e
2681  */
2682
2683 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2684 static hda_nid_t alc880_lg_dac_nids[3] = {
2685         0x05, 0x02, 0x03
2686 };
2687
2688 /* seems analog CD is not working */
2689 static struct hda_input_mux alc880_lg_capture_source = {
2690         .num_items = 3,
2691         .items = {
2692                 { "Mic", 0x1 },
2693                 { "Line", 0x5 },
2694                 { "Internal Mic", 0x6 },
2695         },
2696 };
2697
2698 /* 2,4,6 channel modes */
2699 static struct hda_verb alc880_lg_ch2_init[] = {
2700         /* set line-in and mic-in to input */
2701         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2702         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2703         { }
2704 };
2705
2706 static struct hda_verb alc880_lg_ch4_init[] = {
2707         /* set line-in to out and mic-in to input */
2708         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2709         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2710         { }
2711 };
2712
2713 static struct hda_verb alc880_lg_ch6_init[] = {
2714         /* set line-in and mic-in to output */
2715         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2716         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2717         { }
2718 };
2719
2720 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2721         { 2, alc880_lg_ch2_init },
2722         { 4, alc880_lg_ch4_init },
2723         { 6, alc880_lg_ch6_init },
2724 };
2725
2726 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2727         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2728         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2729         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2730         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2731         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2732         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2733         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2734         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2735         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2736         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2737         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2738         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2739         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2740         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2741         {
2742                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2743                 .name = "Channel Mode",
2744                 .info = alc_ch_mode_info,
2745                 .get = alc_ch_mode_get,
2746                 .put = alc_ch_mode_put,
2747         },
2748         { } /* end */
2749 };
2750
2751 static struct hda_verb alc880_lg_init_verbs[] = {
2752         /* set capture source to mic-in */
2753         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2754         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2755         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2756         /* mute all amp mixer inputs */
2757         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2758         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2759         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2760         /* line-in to input */
2761         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2762         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2763         /* built-in mic */
2764         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2765         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2766         /* speaker-out */
2767         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2768         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2769         /* mic-in to input */
2770         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2771         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2772         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2773         /* HP-out */
2774         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2775         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2776         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2777         /* jack sense */
2778         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2779         { }
2780 };
2781
2782 /* toggle speaker-output according to the hp-jack state */
2783 static void alc880_lg_init_hook(struct hda_codec *codec)
2784 {
2785         struct alc_spec *spec = codec->spec;
2786
2787         spec->autocfg.hp_pins[0] = 0x1b;
2788         spec->autocfg.speaker_pins[0] = 0x17;
2789         alc_automute_amp(codec);
2790 }
2791
2792 /*
2793  * LG LW20
2794  *
2795  * Pin assignment:
2796  *   Speaker-out: 0x14
2797  *   Mic-In: 0x18
2798  *   Built-in Mic-In: 0x19
2799  *   Line-In: 0x1b
2800  *   HP-Out: 0x1a
2801  *   SPDIF-Out: 0x1e
2802  */
2803
2804 static struct hda_input_mux alc880_lg_lw_capture_source = {
2805         .num_items = 3,
2806         .items = {
2807                 { "Mic", 0x0 },
2808                 { "Internal Mic", 0x1 },
2809                 { "Line In", 0x2 },
2810         },
2811 };
2812
2813 #define alc880_lg_lw_modes alc880_threestack_modes
2814
2815 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2816         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2817         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2818         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2819         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2820         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2821         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2822         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2823         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2824         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2825         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2826         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2827         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2828         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2829         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2830         {
2831                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2832                 .name = "Channel Mode",
2833                 .info = alc_ch_mode_info,
2834                 .get = alc_ch_mode_get,
2835                 .put = alc_ch_mode_put,
2836         },
2837         { } /* end */
2838 };
2839
2840 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2841         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2842         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2843         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2844
2845         /* set capture source to mic-in */
2846         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2847         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2848         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2849         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2850         /* speaker-out */
2851         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2852         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2853         /* HP-out */
2854         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2855         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2856         /* mic-in to input */
2857         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2858         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2859         /* built-in mic */
2860         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2861         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2862         /* jack sense */
2863         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2864         { }
2865 };
2866
2867 /* toggle speaker-output according to the hp-jack state */
2868 static void alc880_lg_lw_init_hook(struct hda_codec *codec)
2869 {
2870         struct alc_spec *spec = codec->spec;
2871
2872         spec->autocfg.hp_pins[0] = 0x1b;
2873         spec->autocfg.speaker_pins[0] = 0x14;
2874         alc_automute_amp(codec);
2875 }
2876
2877 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2878         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2879         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2880         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2881         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2882         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2883         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2884         { } /* end */
2885 };
2886
2887 static struct hda_input_mux alc880_medion_rim_capture_source = {
2888         .num_items = 2,
2889         .items = {
2890                 { "Mic", 0x0 },
2891                 { "Internal Mic", 0x1 },
2892         },
2893 };
2894
2895 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2896         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2897
2898         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2899         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2900
2901         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2902         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2903         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2904         /* Mic2 (as headphone out) for HP output */
2905         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2906         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2907         /* Internal Speaker */
2908         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2909         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2910
2911         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2912         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2913
2914         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2915         { }
2916 };
2917
2918 /* toggle speaker-output according to the hp-jack state */
2919 static void alc880_medion_rim_automute(struct hda_codec *codec)
2920 {
2921         struct alc_spec *spec = codec->spec;
2922         alc_automute_amp(codec);
2923         /* toggle EAPD */
2924         if (spec->jack_present)
2925                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2926         else
2927                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2928 }
2929
2930 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2931                                           unsigned int res)
2932 {
2933         /* Looks like the unsol event is incompatible with the standard
2934          * definition.  4bit tag is placed at 28 bit!
2935          */
2936         if ((res >> 28) == ALC880_HP_EVENT)
2937                 alc880_medion_rim_automute(codec);
2938 }
2939
2940 static void alc880_medion_rim_init_hook(struct hda_codec *codec)
2941 {
2942         struct alc_spec *spec = codec->spec;
2943
2944         spec->autocfg.hp_pins[0] = 0x14;
2945         spec->autocfg.speaker_pins[0] = 0x1b;
2946         alc880_medion_rim_automute(codec);
2947 }
2948
2949 #ifdef CONFIG_SND_HDA_POWER_SAVE
2950 static struct hda_amp_list alc880_loopbacks[] = {
2951         { 0x0b, HDA_INPUT, 0 },
2952         { 0x0b, HDA_INPUT, 1 },
2953         { 0x0b, HDA_INPUT, 2 },
2954         { 0x0b, HDA_INPUT, 3 },
2955         { 0x0b, HDA_INPUT, 4 },
2956         { } /* end */
2957 };
2958
2959 static struct hda_amp_list alc880_lg_loopbacks[] = {
2960         { 0x0b, HDA_INPUT, 1 },
2961         { 0x0b, HDA_INPUT, 6 },
2962         { 0x0b, HDA_INPUT, 7 },
2963         { } /* end */
2964 };
2965 #endif
2966
2967 /*
2968  * Common callbacks
2969  */
2970
2971 static int alc_init(struct hda_codec *codec)
2972 {
2973         struct alc_spec *spec = codec->spec;
2974         unsigned int i;
2975
2976         alc_fix_pll(codec);
2977         alc_auto_init_amp(codec, spec->init_amp);
2978
2979         for (i = 0; i < spec->num_init_verbs; i++)
2980                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2981
2982         if (spec->init_hook)
2983                 spec->init_hook(codec);
2984
2985         return 0;
2986 }
2987
2988 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2989 {
2990         struct alc_spec *spec = codec->spec;
2991
2992         if (spec->unsol_event)
2993                 spec->unsol_event(codec, res);
2994 }
2995
2996 #ifdef CONFIG_SND_HDA_POWER_SAVE
2997 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2998 {
2999         struct alc_spec *spec = codec->spec;
3000         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3001 }
3002 #endif
3003
3004 /*
3005  * Analog playback callbacks
3006  */
3007 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3008                                     struct hda_codec *codec,
3009                                     struct snd_pcm_substream *substream)
3010 {
3011         struct alc_spec *spec = codec->spec;
3012         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3013                                              hinfo);
3014 }
3015
3016 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3017                                        struct hda_codec *codec,
3018                                        unsigned int stream_tag,
3019                                        unsigned int format,
3020                                        struct snd_pcm_substream *substream)
3021 {
3022         struct alc_spec *spec = codec->spec;
3023         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3024                                                 stream_tag, format, substream);
3025 }
3026
3027 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3028                                        struct hda_codec *codec,
3029                                        struct snd_pcm_substream *substream)
3030 {
3031         struct alc_spec *spec = codec->spec;
3032         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3033 }
3034
3035 /*
3036  * Digital out
3037  */
3038 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3039                                         struct hda_codec *codec,
3040                                         struct snd_pcm_substream *substream)
3041 {
3042         struct alc_spec *spec = codec->spec;
3043         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3044 }
3045
3046 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3047                                            struct hda_codec *codec,
3048                                            unsigned int stream_tag,
3049                                            unsigned int format,
3050                                            struct snd_pcm_substream *substream)
3051 {
3052         struct alc_spec *spec = codec->spec;
3053         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3054                                              stream_tag, format, substream);
3055 }
3056
3057 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3058                                            struct hda_codec *codec,
3059                                            struct snd_pcm_substream *substream)
3060 {
3061         struct alc_spec *spec = codec->spec;
3062         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3063 }
3064
3065 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3066                                          struct hda_codec *codec,
3067                                          struct snd_pcm_substream *substream)
3068 {
3069         struct alc_spec *spec = codec->spec;
3070         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3071 }
3072
3073 /*
3074  * Analog capture
3075  */
3076 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3077                                       struct hda_codec *codec,
3078                                       unsigned int stream_tag,
3079                                       unsigned int format,
3080                                       struct snd_pcm_substream *substream)
3081 {
3082         struct alc_spec *spec = codec->spec;
3083
3084         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3085                                    stream_tag, 0, format);
3086         return 0;
3087 }
3088
3089 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3090                                       struct hda_codec *codec,
3091                                       struct snd_pcm_substream *substream)
3092 {
3093         struct alc_spec *spec = codec->spec;
3094
3095         snd_hda_codec_cleanup_stream(codec,
3096                                      spec->adc_nids[substream->number + 1]);
3097         return 0;
3098 }
3099
3100
3101 /*
3102  */
3103 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3104         .substreams = 1,
3105         .channels_min = 2,
3106         .channels_max = 8,
3107         /* NID is set in alc_build_pcms */
3108         .ops = {
3109                 .open = alc880_playback_pcm_open,
3110                 .prepare = alc880_playback_pcm_prepare,
3111                 .cleanup = alc880_playback_pcm_cleanup
3112         },
3113 };
3114
3115 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3116         .substreams = 1,
3117         .channels_min = 2,
3118         .channels_max = 2,
3119         /* NID is set in alc_build_pcms */
3120 };
3121
3122 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3123         .substreams = 1,
3124         .channels_min = 2,
3125         .channels_max = 2,
3126         /* NID is set in alc_build_pcms */
3127 };
3128
3129 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3130         .substreams = 2, /* can be overridden */
3131         .channels_min = 2,
3132         .channels_max = 2,
3133         /* NID is set in alc_build_pcms */
3134         .ops = {
3135                 .prepare = alc880_alt_capture_pcm_prepare,
3136                 .cleanup = alc880_alt_capture_pcm_cleanup
3137         },
3138 };
3139
3140 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3141         .substreams = 1,
3142         .channels_min = 2,
3143         .channels_max = 2,
3144         /* NID is set in alc_build_pcms */
3145         .ops = {
3146                 .open = alc880_dig_playback_pcm_open,
3147                 .close = alc880_dig_playback_pcm_close,
3148                 .prepare = alc880_dig_playback_pcm_prepare,
3149                 .cleanup = alc880_dig_playback_pcm_cleanup
3150         },
3151 };
3152
3153 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3154         .substreams = 1,
3155         .channels_min = 2,
3156         .channels_max = 2,
3157         /* NID is set in alc_build_pcms */
3158 };
3159
3160 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3161 static struct hda_pcm_stream alc_pcm_null_stream = {
3162         .substreams = 0,
3163         .channels_min = 0,
3164         .channels_max = 0,
3165 };
3166
3167 static int alc_build_pcms(struct hda_codec *codec)
3168 {
3169         struct alc_spec *spec = codec->spec;
3170         struct hda_pcm *info = spec->pcm_rec;
3171         int i;
3172
3173         codec->num_pcms = 1;
3174         codec->pcm_info = info;
3175
3176         if (spec->no_analog)
3177                 goto skip_analog;
3178
3179         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3180                  "%s Analog", codec->chip_name);
3181         info->name = spec->stream_name_analog;
3182
3183         if (spec->stream_analog_playback) {
3184                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3185                         return -EINVAL;
3186                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3187                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3188         }
3189         if (spec->stream_analog_capture) {
3190                 if (snd_BUG_ON(!spec->adc_nids))
3191                         return -EINVAL;
3192                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3193                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3194         }
3195
3196         if (spec->channel_mode) {
3197                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3198                 for (i = 0; i < spec->num_channel_mode; i++) {
3199                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3200                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3201                         }
3202                 }
3203         }
3204
3205  skip_analog:
3206         /* SPDIF for stream index #1 */
3207         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3208                 snprintf(spec->stream_name_digital,
3209                          sizeof(spec->stream_name_digital),
3210                          "%s Digital", codec->chip_name);
3211                 codec->num_pcms = 2;
3212                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3213                 info = spec->pcm_rec + 1;
3214                 info->name = spec->stream_name_digital;
3215                 if (spec->dig_out_type)
3216                         info->pcm_type = spec->dig_out_type;
3217                 else
3218                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3219                 if (spec->multiout.dig_out_nid &&
3220                     spec->stream_digital_playback) {
3221                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3222                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3223                 }
3224                 if (spec->dig_in_nid &&
3225                     spec->stream_digital_capture) {
3226                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3227                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3228                 }
3229                 /* FIXME: do we need this for all Realtek codec models? */
3230                 codec->spdif_status_reset = 1;
3231         }
3232
3233         if (spec->no_analog)
3234                 return 0;
3235
3236         /* If the use of more than one ADC is requested for the current
3237          * model, configure a second analog capture-only PCM.
3238          */
3239         /* Additional Analaog capture for index #2 */
3240         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3241             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3242                 codec->num_pcms = 3;
3243                 info = spec->pcm_rec + 2;
3244                 info->name = spec->stream_name_analog;
3245                 if (spec->alt_dac_nid) {
3246                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3247                                 *spec->stream_analog_alt_playback;
3248                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3249                                 spec->alt_dac_nid;
3250                 } else {
3251                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3252                                 alc_pcm_null_stream;
3253                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3254                 }
3255                 if (spec->num_adc_nids > 1) {
3256                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3257                                 *spec->stream_analog_alt_capture;
3258                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3259                                 spec->adc_nids[1];
3260                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3261                                 spec->num_adc_nids - 1;
3262                 } else {
3263                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3264                                 alc_pcm_null_stream;
3265                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3266                 }
3267         }
3268
3269         return 0;
3270 }
3271
3272 static void alc_free_kctls(struct hda_codec *codec)
3273 {
3274         struct alc_spec *spec = codec->spec;
3275
3276         if (spec->kctls.list) {
3277                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3278                 int i;
3279                 for (i = 0; i < spec->kctls.used; i++)
3280                         kfree(kctl[i].name);
3281         }
3282         snd_array_free(&spec->kctls);
3283 }
3284
3285 static void alc_free(struct hda_codec *codec)
3286 {
3287         struct alc_spec *spec = codec->spec;
3288
3289         if (!spec)
3290                 return;
3291
3292         alc_free_kctls(codec);
3293         kfree(spec);
3294         snd_hda_detach_beep_device(codec);
3295 }
3296
3297 #ifdef SND_HDA_NEEDS_RESUME
3298 static int alc_resume(struct hda_codec *codec)
3299 {
3300         codec->patch_ops.init(codec);
3301         snd_hda_codec_resume_amp(codec);
3302         snd_hda_codec_resume_cache(codec);
3303         return 0;
3304 }
3305 #endif
3306
3307 /*
3308  */
3309 static struct hda_codec_ops alc_patch_ops = {
3310         .build_controls = alc_build_controls,
3311         .build_pcms = alc_build_pcms,
3312         .init = alc_init,
3313         .free = alc_free,
3314         .unsol_event = alc_unsol_event,
3315 #ifdef SND_HDA_NEEDS_RESUME
3316         .resume = alc_resume,
3317 #endif
3318 #ifdef CONFIG_SND_HDA_POWER_SAVE
3319         .check_power_status = alc_check_power_status,
3320 #endif
3321 };
3322
3323
3324 /*
3325  * Test configuration for debugging
3326  *
3327  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3328  * enum controls.
3329  */
3330 #ifdef CONFIG_SND_DEBUG
3331 static hda_nid_t alc880_test_dac_nids[4] = {
3332         0x02, 0x03, 0x04, 0x05
3333 };
3334
3335 static struct hda_input_mux alc880_test_capture_source = {
3336         .num_items = 7,
3337         .items = {
3338                 { "In-1", 0x0 },
3339                 { "In-2", 0x1 },
3340                 { "In-3", 0x2 },
3341                 { "In-4", 0x3 },
3342                 { "CD", 0x4 },
3343                 { "Front", 0x5 },
3344                 { "Surround", 0x6 },
3345         },
3346 };
3347
3348 static struct hda_channel_mode alc880_test_modes[4] = {
3349         { 2, NULL },
3350         { 4, NULL },
3351         { 6, NULL },
3352         { 8, NULL },
3353 };
3354
3355 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3356                                  struct snd_ctl_elem_info *uinfo)
3357 {
3358         static char *texts[] = {
3359                 "N/A", "Line Out", "HP Out",
3360                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3361         };
3362         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3363         uinfo->count = 1;
3364         uinfo->value.enumerated.items = 8;
3365         if (uinfo->value.enumerated.item >= 8)
3366                 uinfo->value.enumerated.item = 7;
3367         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3368         return 0;
3369 }
3370
3371 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3372                                 struct snd_ctl_elem_value *ucontrol)
3373 {
3374         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3375         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3376         unsigned int pin_ctl, item = 0;
3377
3378         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3379                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3380         if (pin_ctl & AC_PINCTL_OUT_EN) {
3381                 if (pin_ctl & AC_PINCTL_HP_EN)
3382                         item = 2;
3383                 else
3384                         item = 1;
3385         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3386                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3387                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3388                 case AC_PINCTL_VREF_50:  item = 4; break;
3389                 case AC_PINCTL_VREF_GRD: item = 5; break;
3390                 case AC_PINCTL_VREF_80:  item = 6; break;
3391                 case AC_PINCTL_VREF_100: item = 7; break;
3392                 }
3393         }
3394         ucontrol->value.enumerated.item[0] = item;
3395         return 0;
3396 }
3397
3398 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3399                                 struct snd_ctl_elem_value *ucontrol)
3400 {
3401         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3402         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3403         static unsigned int ctls[] = {
3404                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3405                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3406                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3407                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3408                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3409                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3410         };
3411         unsigned int old_ctl, new_ctl;
3412
3413         old_ctl = snd_hda_codec_read(codec, nid, 0,
3414                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3415         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3416         if (old_ctl != new_ctl) {
3417                 int val;
3418                 snd_hda_codec_write_cache(codec, nid, 0,
3419                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3420                                           new_ctl);
3421                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3422                         HDA_AMP_MUTE : 0;
3423                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3424                                          HDA_AMP_MUTE, val);
3425                 return 1;
3426         }
3427         return 0;
3428 }
3429
3430 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3431                                  struct snd_ctl_elem_info *uinfo)
3432 {
3433         static char *texts[] = {
3434                 "Front", "Surround", "CLFE", "Side"
3435         };
3436         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3437         uinfo->count = 1;
3438         uinfo->value.enumerated.items = 4;
3439         if (uinfo->value.enumerated.item >= 4)
3440                 uinfo->value.enumerated.item = 3;
3441         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3442         return 0;
3443 }
3444
3445 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3446                                 struct snd_ctl_elem_value *ucontrol)
3447 {
3448         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3449         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3450         unsigned int sel;
3451
3452         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3453         ucontrol->value.enumerated.item[0] = sel & 3;
3454         return 0;
3455 }
3456
3457 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3458                                 struct snd_ctl_elem_value *ucontrol)
3459 {
3460         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3461         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3462         unsigned int sel;
3463
3464         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3465         if (ucontrol->value.enumerated.item[0] != sel) {
3466                 sel = ucontrol->value.enumerated.item[0] & 3;
3467                 snd_hda_codec_write_cache(codec, nid, 0,
3468                                           AC_VERB_SET_CONNECT_SEL, sel);
3469                 return 1;
3470         }
3471         return 0;
3472 }
3473
3474 #define PIN_CTL_TEST(xname,nid) {                       \
3475                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3476                         .name = xname,                 \
3477                         .info = alc_test_pin_ctl_info, \
3478                         .get = alc_test_pin_ctl_get,   \
3479                         .put = alc_test_pin_ctl_put,   \
3480                         .private_value = nid           \
3481                         }
3482
3483 #define PIN_SRC_TEST(xname,nid) {                       \
3484                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3485                         .name = xname,                 \
3486                         .info = alc_test_pin_src_info, \
3487                         .get = alc_test_pin_src_get,   \
3488                         .put = alc_test_pin_src_put,   \
3489                         .private_value = nid           \
3490                         }
3491
3492 static struct snd_kcontrol_new alc880_test_mixer[] = {
3493         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3494         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3495         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3496         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3497         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3498         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3499         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3500         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3501         PIN_CTL_TEST("Front Pin Mode", 0x14),
3502         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3503         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3504         PIN_CTL_TEST("Side Pin Mode", 0x17),
3505         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3506         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3507         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3508         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3509         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3510         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3511         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3512         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3513         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3514         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3515         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3516         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3517         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3518         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3519         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3520         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3521         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3522         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3523         {
3524                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3525                 .name = "Channel Mode",
3526                 .info = alc_ch_mode_info,
3527                 .get = alc_ch_mode_get,
3528                 .put = alc_ch_mode_put,
3529         },
3530         { } /* end */
3531 };
3532
3533 static struct hda_verb alc880_test_init_verbs[] = {
3534         /* Unmute inputs of 0x0c - 0x0f */
3535         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3536         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3537         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3538         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3539         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3540         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3541         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3542         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3543         /* Vol output for 0x0c-0x0f */
3544         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3545         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3546         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3547         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3548         /* Set output pins 0x14-0x17 */
3549         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3550         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3551         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3552         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3553         /* Unmute output pins 0x14-0x17 */
3554         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3555         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3556         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3557         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3558         /* Set input pins 0x18-0x1c */
3559         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3560         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3561         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3562         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3563         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3564         /* Mute input pins 0x18-0x1b */
3565         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3566         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3567         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3568         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3569         /* ADC set up */
3570         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3571         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3572         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3573         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3574         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3575         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3576         /* Analog input/passthru */
3577         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3578         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3579         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3580         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3581         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3582         { }
3583 };
3584 #endif
3585
3586 /*
3587  */
3588
3589 static const char *alc880_models[ALC880_MODEL_LAST] = {
3590         [ALC880_3ST]            = "3stack",
3591         [ALC880_TCL_S700]       = "tcl",
3592         [ALC880_3ST_DIG]        = "3stack-digout",
3593         [ALC880_CLEVO]          = "clevo",
3594         [ALC880_5ST]            = "5stack",
3595         [ALC880_5ST_DIG]        = "5stack-digout",
3596         [ALC880_W810]           = "w810",
3597         [ALC880_Z71V]           = "z71v",
3598         [ALC880_6ST]            = "6stack",
3599         [ALC880_6ST_DIG]        = "6stack-digout",
3600         [ALC880_ASUS]           = "asus",
3601         [ALC880_ASUS_W1V]       = "asus-w1v",
3602         [ALC880_ASUS_DIG]       = "asus-dig",
3603         [ALC880_ASUS_DIG2]      = "asus-dig2",
3604         [ALC880_UNIWILL_DIG]    = "uniwill",
3605         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3606         [ALC880_FUJITSU]        = "fujitsu",
3607         [ALC880_F1734]          = "F1734",
3608         [ALC880_LG]             = "lg",
3609         [ALC880_LG_LW]          = "lg-lw",
3610         [ALC880_MEDION_RIM]     = "medion",
3611 #ifdef CONFIG_SND_DEBUG
3612         [ALC880_TEST]           = "test",
3613 #endif
3614         [ALC880_AUTO]           = "auto",
3615 };
3616
3617 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3618         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3619         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3620         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3621         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3622         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3623         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3624         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3625         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3626         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3627         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3628         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3629         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3630         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3631         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3632         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3633         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3634         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3635         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3636         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3637         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3638         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3639         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3640         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3641         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3642         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3643         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
3644         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3645         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3646         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3647         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3648         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3649         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3650         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3651         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3652         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3653         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3654         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3655         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3656         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3657         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3658         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3659         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3660         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3661         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3662         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3663         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3664         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3665         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3666         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3667         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3668         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3669         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3670         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3671         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3672         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3673         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3674         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3675         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3676         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3677         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3678         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3679         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3680         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3681         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3682         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3683         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3684         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3685         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3686         /* default Intel */
3687         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
3688         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3689         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3690         {}
3691 };
3692
3693 /*
3694  * ALC880 codec presets
3695  */
3696 static struct alc_config_preset alc880_presets[] = {
3697         [ALC880_3ST] = {
3698                 .mixers = { alc880_three_stack_mixer },
3699                 .init_verbs = { alc880_volume_init_verbs,
3700                                 alc880_pin_3stack_init_verbs },
3701                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3702                 .dac_nids = alc880_dac_nids,
3703                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3704                 .channel_mode = alc880_threestack_modes,
3705                 .need_dac_fix = 1,
3706                 .input_mux = &alc880_capture_source,
3707         },
3708         [ALC880_3ST_DIG] = {
3709                 .mixers = { alc880_three_stack_mixer },
3710                 .init_verbs = { alc880_volume_init_verbs,
3711                                 alc880_pin_3stack_init_verbs },
3712                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3713                 .dac_nids = alc880_dac_nids,
3714                 .dig_out_nid = ALC880_DIGOUT_NID,
3715                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3716                 .channel_mode = alc880_threestack_modes,
3717                 .need_dac_fix = 1,
3718                 .input_mux = &alc880_capture_source,
3719         },
3720         [ALC880_TCL_S700] = {
3721                 .mixers = { alc880_tcl_s700_mixer },
3722                 .init_verbs = { alc880_volume_init_verbs,
3723                                 alc880_pin_tcl_S700_init_verbs,
3724                                 alc880_gpio2_init_verbs },
3725                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3726                 .dac_nids = alc880_dac_nids,
3727                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
3728                 .num_adc_nids = 1, /* single ADC */
3729                 .hp_nid = 0x03,
3730                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3731                 .channel_mode = alc880_2_jack_modes,
3732                 .input_mux = &alc880_capture_source,
3733         },
3734         [ALC880_5ST] = {
3735                 .mixers = { alc880_three_stack_mixer,
3736                             alc880_five_stack_mixer},
3737                 .init_verbs = { alc880_volume_init_verbs,
3738                                 alc880_pin_5stack_init_verbs },
3739                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3740                 .dac_nids = alc880_dac_nids,
3741                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3742                 .channel_mode = alc880_fivestack_modes,
3743                 .input_mux = &alc880_capture_source,
3744         },
3745         [ALC880_5ST_DIG] = {
3746                 .mixers = { alc880_three_stack_mixer,
3747                             alc880_five_stack_mixer },
3748                 .init_verbs = { alc880_volume_init_verbs,
3749                                 alc880_pin_5stack_init_verbs },
3750                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3751                 .dac_nids = alc880_dac_nids,
3752                 .dig_out_nid = ALC880_DIGOUT_NID,
3753                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3754                 .channel_mode = alc880_fivestack_modes,
3755                 .input_mux = &alc880_capture_source,
3756         },
3757         [ALC880_6ST] = {
3758                 .mixers = { alc880_six_stack_mixer },
3759                 .init_verbs = { alc880_volume_init_verbs,
3760                                 alc880_pin_6stack_init_verbs },
3761                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3762                 .dac_nids = alc880_6st_dac_nids,
3763                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3764                 .channel_mode = alc880_sixstack_modes,
3765                 .input_mux = &alc880_6stack_capture_source,
3766         },
3767         [ALC880_6ST_DIG] = {
3768                 .mixers = { alc880_six_stack_mixer },
3769                 .init_verbs = { alc880_volume_init_verbs,
3770                                 alc880_pin_6stack_init_verbs },
3771                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3772                 .dac_nids = alc880_6st_dac_nids,
3773                 .dig_out_nid = ALC880_DIGOUT_NID,
3774                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3775                 .channel_mode = alc880_sixstack_modes,
3776                 .input_mux = &alc880_6stack_capture_source,
3777         },
3778         [ALC880_W810] = {
3779                 .mixers = { alc880_w810_base_mixer },
3780                 .init_verbs = { alc880_volume_init_verbs,
3781                                 alc880_pin_w810_init_verbs,
3782                                 alc880_gpio2_init_verbs },
3783                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3784                 .dac_nids = alc880_w810_dac_nids,
3785                 .dig_out_nid = ALC880_DIGOUT_NID,
3786                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3787                 .channel_mode = alc880_w810_modes,
3788                 .input_mux = &alc880_capture_source,
3789         },
3790         [ALC880_Z71V] = {
3791                 .mixers = { alc880_z71v_mixer },
3792                 .init_verbs = { alc880_volume_init_verbs,
3793                                 alc880_pin_z71v_init_verbs },
3794                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3795                 .dac_nids = alc880_z71v_dac_nids,
3796                 .dig_out_nid = ALC880_DIGOUT_NID,
3797                 .hp_nid = 0x03,
3798                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3799                 .channel_mode = alc880_2_jack_modes,
3800                 .input_mux = &alc880_capture_source,
3801         },
3802         [ALC880_F1734] = {
3803                 .mixers = { alc880_f1734_mixer },
3804                 .init_verbs = { alc880_volume_init_verbs,
3805                                 alc880_pin_f1734_init_verbs },
3806                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3807                 .dac_nids = alc880_f1734_dac_nids,
3808                 .hp_nid = 0x02,
3809                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3810                 .channel_mode = alc880_2_jack_modes,
3811                 .input_mux = &alc880_f1734_capture_source,
3812                 .unsol_event = alc880_uniwill_p53_unsol_event,
3813                 .init_hook = alc880_uniwill_p53_init_hook,
3814         },
3815         [ALC880_ASUS] = {
3816                 .mixers = { alc880_asus_mixer },
3817                 .init_verbs = { alc880_volume_init_verbs,
3818                                 alc880_pin_asus_init_verbs,
3819                                 alc880_gpio1_init_verbs },
3820                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3821                 .dac_nids = alc880_asus_dac_nids,
3822                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3823                 .channel_mode = alc880_asus_modes,
3824                 .need_dac_fix = 1,
3825                 .input_mux = &alc880_capture_source,
3826         },
3827         [ALC880_ASUS_DIG] = {
3828                 .mixers = { alc880_asus_mixer },
3829                 .init_verbs = { alc880_volume_init_verbs,
3830                                 alc880_pin_asus_init_verbs,
3831                                 alc880_gpio1_init_verbs },
3832                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3833                 .dac_nids = alc880_asus_dac_nids,
3834                 .dig_out_nid = ALC880_DIGOUT_NID,
3835                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3836                 .channel_mode = alc880_asus_modes,
3837                 .need_dac_fix = 1,
3838                 .input_mux = &alc880_capture_source,
3839         },
3840         [ALC880_ASUS_DIG2] = {
3841                 .mixers = { alc880_asus_mixer },
3842                 .init_verbs = { alc880_volume_init_verbs,
3843                                 alc880_pin_asus_init_verbs,
3844                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
3845                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3846                 .dac_nids = alc880_asus_dac_nids,
3847                 .dig_out_nid = ALC880_DIGOUT_NID,
3848                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3849                 .channel_mode = alc880_asus_modes,
3850                 .need_dac_fix = 1,
3851                 .input_mux = &alc880_capture_source,
3852         },
3853         [ALC880_ASUS_W1V] = {
3854                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3855                 .init_verbs = { alc880_volume_init_verbs,
3856                                 alc880_pin_asus_init_verbs,
3857                                 alc880_gpio1_init_verbs },
3858                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3859                 .dac_nids = alc880_asus_dac_nids,
3860                 .dig_out_nid = ALC880_DIGOUT_NID,
3861                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3862                 .channel_mode = alc880_asus_modes,
3863                 .need_dac_fix = 1,
3864                 .input_mux = &alc880_capture_source,
3865         },
3866         [ALC880_UNIWILL_DIG] = {
3867                 .mixers = { alc880_asus_mixer },
3868                 .init_verbs = { alc880_volume_init_verbs,
3869                                 alc880_pin_asus_init_verbs },
3870                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3871                 .dac_nids = alc880_asus_dac_nids,
3872                 .dig_out_nid = ALC880_DIGOUT_NID,
3873                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3874                 .channel_mode = alc880_asus_modes,
3875                 .need_dac_fix = 1,
3876                 .input_mux = &alc880_capture_source,
3877         },
3878         [ALC880_UNIWILL] = {
3879                 .mixers = { alc880_uniwill_mixer },
3880                 .init_verbs = { alc880_volume_init_verbs,
3881                                 alc880_uniwill_init_verbs },
3882                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3883                 .dac_nids = alc880_asus_dac_nids,
3884                 .dig_out_nid = ALC880_DIGOUT_NID,
3885                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3886                 .channel_mode = alc880_threestack_modes,
3887                 .need_dac_fix = 1,
3888                 .input_mux = &alc880_capture_source,
3889                 .unsol_event = alc880_uniwill_unsol_event,
3890                 .init_hook = alc880_uniwill_init_hook,
3891         },
3892         [ALC880_UNIWILL_P53] = {
3893                 .mixers = { alc880_uniwill_p53_mixer },
3894                 .init_verbs = { alc880_volume_init_verbs,
3895                                 alc880_uniwill_p53_init_verbs },
3896                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3897                 .dac_nids = alc880_asus_dac_nids,
3898                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3899                 .channel_mode = alc880_threestack_modes,
3900                 .input_mux = &alc880_capture_source,
3901                 .unsol_event = alc880_uniwill_p53_unsol_event,
3902                 .init_hook = alc880_uniwill_p53_init_hook,
3903         },
3904         [ALC880_FUJITSU] = {
3905                 .mixers = { alc880_fujitsu_mixer },
3906                 .init_verbs = { alc880_volume_init_verbs,
3907                                 alc880_uniwill_p53_init_verbs,
3908                                 alc880_beep_init_verbs },
3909                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3910                 .dac_nids = alc880_dac_nids,
3911                 .dig_out_nid = ALC880_DIGOUT_NID,
3912                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3913                 .channel_mode = alc880_2_jack_modes,
3914                 .input_mux = &alc880_capture_source,
3915                 .unsol_event = alc880_uniwill_p53_unsol_event,
3916                 .init_hook = alc880_uniwill_p53_init_hook,
3917         },
3918         [ALC880_CLEVO] = {
3919                 .mixers = { alc880_three_stack_mixer },
3920                 .init_verbs = { alc880_volume_init_verbs,
3921                                 alc880_pin_clevo_init_verbs },
3922                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3923                 .dac_nids = alc880_dac_nids,
3924                 .hp_nid = 0x03,
3925                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3926                 .channel_mode = alc880_threestack_modes,
3927                 .need_dac_fix = 1,
3928                 .input_mux = &alc880_capture_source,
3929         },
3930         [ALC880_LG] = {
3931                 .mixers = { alc880_lg_mixer },
3932                 .init_verbs = { alc880_volume_init_verbs,
3933                                 alc880_lg_init_verbs },
3934                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3935                 .dac_nids = alc880_lg_dac_nids,
3936                 .dig_out_nid = ALC880_DIGOUT_NID,
3937                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3938                 .channel_mode = alc880_lg_ch_modes,
3939                 .need_dac_fix = 1,
3940                 .input_mux = &alc880_lg_capture_source,
3941                 .unsol_event = alc_automute_amp_unsol_event,
3942                 .init_hook = alc880_lg_init_hook,
3943 #ifdef CONFIG_SND_HDA_POWER_SAVE
3944                 .loopbacks = alc880_lg_loopbacks,
3945 #endif
3946         },
3947         [ALC880_LG_LW] = {
3948                 .mixers = { alc880_lg_lw_mixer },
3949                 .init_verbs = { alc880_volume_init_verbs,
3950                                 alc880_lg_lw_init_verbs },
3951                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3952                 .dac_nids = alc880_dac_nids,
3953                 .dig_out_nid = ALC880_DIGOUT_NID,
3954                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3955                 .channel_mode = alc880_lg_lw_modes,
3956                 .input_mux = &alc880_lg_lw_capture_source,
3957                 .unsol_event = alc_automute_amp_unsol_event,
3958                 .init_hook = alc880_lg_lw_init_hook,
3959         },
3960         [ALC880_MEDION_RIM] = {
3961                 .mixers = { alc880_medion_rim_mixer },
3962                 .init_verbs = { alc880_volume_init_verbs,
3963                                 alc880_medion_rim_init_verbs,
3964                                 alc_gpio2_init_verbs },
3965                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3966                 .dac_nids = alc880_dac_nids,
3967                 .dig_out_nid = ALC880_DIGOUT_NID,
3968                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3969                 .channel_mode = alc880_2_jack_modes,
3970                 .input_mux = &alc880_medion_rim_capture_source,
3971                 .unsol_event = alc880_medion_rim_unsol_event,
3972                 .init_hook = alc880_medion_rim_init_hook,
3973         },
3974 #ifdef CONFIG_SND_DEBUG
3975         [ALC880_TEST] = {
3976                 .mixers = { alc880_test_mixer },
3977                 .init_verbs = { alc880_test_init_verbs },
3978                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3979                 .dac_nids = alc880_test_dac_nids,
3980                 .dig_out_nid = ALC880_DIGOUT_NID,
3981                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3982                 .channel_mode = alc880_test_modes,
3983                 .input_mux = &alc880_test_capture_source,
3984         },
3985 #endif
3986 };
3987
3988 /*
3989  * Automatic parse of I/O pins from the BIOS configuration
3990  */
3991
3992 enum {
3993         ALC_CTL_WIDGET_VOL,
3994         ALC_CTL_WIDGET_MUTE,
3995         ALC_CTL_BIND_MUTE,
3996 };
3997 static struct snd_kcontrol_new alc880_control_templates[] = {
3998         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3999         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4000         HDA_BIND_MUTE(NULL, 0, 0, 0),
4001 };
4002
4003 /* add dynamic controls */
4004 static int add_control(struct alc_spec *spec, int type, const char *name,
4005                        unsigned long val)
4006 {
4007         struct snd_kcontrol_new *knew;
4008
4009         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4010         knew = snd_array_new(&spec->kctls);
4011         if (!knew)
4012                 return -ENOMEM;
4013         *knew = alc880_control_templates[type];
4014         knew->name = kstrdup(name, GFP_KERNEL);
4015         if (!knew->name)
4016                 return -ENOMEM;
4017         knew->private_value = val;
4018         return 0;
4019 }
4020
4021 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4022 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4023 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4024 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4025 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
4026 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
4027 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4028 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4029 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4030 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4031 #define ALC880_PIN_CD_NID               0x1c
4032
4033 /* fill in the dac_nids table from the parsed pin configuration */
4034 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4035                                      const struct auto_pin_cfg *cfg)
4036 {
4037         hda_nid_t nid;
4038         int assigned[4];
4039         int i, j;
4040
4041         memset(assigned, 0, sizeof(assigned));
4042         spec->multiout.dac_nids = spec->private_dac_nids;
4043
4044         /* check the pins hardwired to audio widget */
4045         for (i = 0; i < cfg->line_outs; i++) {
4046                 nid = cfg->line_out_pins[i];
4047                 if (alc880_is_fixed_pin(nid)) {
4048                         int idx = alc880_fixed_pin_idx(nid);
4049                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4050                         assigned[idx] = 1;
4051                 }
4052         }
4053         /* left pins can be connect to any audio widget */
4054         for (i = 0; i < cfg->line_outs; i++) {
4055                 nid = cfg->line_out_pins[i];
4056                 if (alc880_is_fixed_pin(nid))
4057                         continue;
4058                 /* search for an empty channel */
4059                 for (j = 0; j < cfg->line_outs; j++) {
4060                         if (!assigned[j]) {
4061                                 spec->multiout.dac_nids[i] =
4062                                         alc880_idx_to_dac(j);
4063                                 assigned[j] = 1;
4064                                 break;
4065                         }
4066                 }
4067         }
4068         spec->multiout.num_dacs = cfg->line_outs;
4069         return 0;
4070 }
4071
4072 /* add playback controls from the parsed DAC table */
4073 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4074                                              const struct auto_pin_cfg *cfg)
4075 {
4076         char name[32];
4077         static const char *chname[4] = {
4078                 "Front", "Surround", NULL /*CLFE*/, "Side"
4079         };
4080         hda_nid_t nid;
4081         int i, err;
4082
4083         for (i = 0; i < cfg->line_outs; i++) {
4084                 if (!spec->multiout.dac_nids[i])
4085                         continue;
4086                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4087                 if (i == 2) {
4088                         /* Center/LFE */
4089                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4090                                           "Center Playback Volume",
4091                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4092                                                               HDA_OUTPUT));
4093                         if (err < 0)
4094                                 return err;
4095                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4096                                           "LFE Playback Volume",
4097                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4098                                                               HDA_OUTPUT));
4099                         if (err < 0)
4100                                 return err;
4101                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4102                                           "Center Playback Switch",
4103                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4104                                                               HDA_INPUT));
4105                         if (err < 0)
4106                                 return err;
4107                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4108                                           "LFE Playback Switch",
4109                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4110                                                               HDA_INPUT));
4111                         if (err < 0)
4112                                 return err;
4113                 } else {
4114                         sprintf(name, "%s Playback Volume", chname[i]);
4115                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4116                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4117                                                               HDA_OUTPUT));
4118                         if (err < 0)
4119                                 return err;
4120                         sprintf(name, "%s Playback Switch", chname[i]);
4121                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4122                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4123                                                               HDA_INPUT));
4124                         if (err < 0)
4125                                 return err;
4126                 }
4127         }
4128         return 0;
4129 }
4130
4131 /* add playback controls for speaker and HP outputs */
4132 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4133                                         const char *pfx)
4134 {
4135         hda_nid_t nid;
4136         int err;
4137         char name[32];
4138
4139         if (!pin)
4140                 return 0;
4141
4142         if (alc880_is_fixed_pin(pin)) {
4143                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4144                 /* specify the DAC as the extra output */
4145                 if (!spec->multiout.hp_nid)
4146                         spec->multiout.hp_nid = nid;
4147                 else
4148                         spec->multiout.extra_out_nid[0] = nid;
4149                 /* control HP volume/switch on the output mixer amp */
4150                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4151                 sprintf(name, "%s Playback Volume", pfx);
4152                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4153                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4154                 if (err < 0)
4155                         return err;
4156                 sprintf(name, "%s Playback Switch", pfx);
4157                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4158                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4159                 if (err < 0)
4160                         return err;
4161         } else if (alc880_is_multi_pin(pin)) {
4162                 /* set manual connection */
4163                 /* we have only a switch on HP-out PIN */
4164                 sprintf(name, "%s Playback Switch", pfx);
4165                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4166                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4167                 if (err < 0)
4168                         return err;
4169         }
4170         return 0;
4171 }
4172
4173 /* create input playback/capture controls for the given pin */
4174 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4175                             const char *ctlname,
4176                             int idx, hda_nid_t mix_nid)
4177 {
4178         char name[32];
4179         int err;
4180
4181         sprintf(name, "%s Playback Volume", ctlname);
4182         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4183                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4184         if (err < 0)
4185                 return err;
4186         sprintf(name, "%s Playback Switch", ctlname);
4187         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4188                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4189         if (err < 0)
4190                 return err;
4191         return 0;
4192 }
4193
4194 /* create playback/capture controls for input pins */
4195 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
4196                                                 const struct auto_pin_cfg *cfg)
4197 {
4198         struct hda_input_mux *imux = &spec->private_imux[0];
4199         int i, err, idx;
4200
4201         for (i = 0; i < AUTO_PIN_LAST; i++) {
4202                 if (alc880_is_input_pin(cfg->input_pins[i])) {
4203                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
4204                         err = new_analog_input(spec, cfg->input_pins[i],
4205                                                auto_pin_cfg_labels[i],
4206                                                idx, 0x0b);
4207                         if (err < 0)
4208                                 return err;
4209                         imux->items[imux->num_items].label =
4210                                 auto_pin_cfg_labels[i];
4211                         imux->items[imux->num_items].index =
4212                                 alc880_input_pin_idx(cfg->input_pins[i]);
4213                         imux->num_items++;
4214                 }
4215         }
4216         return 0;
4217 }
4218
4219 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4220                                unsigned int pin_type)
4221 {
4222         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4223                             pin_type);
4224         /* unmute pin */
4225         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4226                             AMP_OUT_UNMUTE);
4227 }
4228
4229 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4230                                               hda_nid_t nid, int pin_type,
4231                                               int dac_idx)
4232 {
4233         alc_set_pin_output(codec, nid, pin_type);
4234         /* need the manual connection? */
4235         if (alc880_is_multi_pin(nid)) {
4236                 struct alc_spec *spec = codec->spec;
4237                 int idx = alc880_multi_pin_idx(nid);
4238                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4239                                     AC_VERB_SET_CONNECT_SEL,
4240                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4241         }
4242 }
4243
4244 static int get_pin_type(int line_out_type)
4245 {
4246         if (line_out_type == AUTO_PIN_HP_OUT)
4247                 return PIN_HP;
4248         else
4249                 return PIN_OUT;
4250 }
4251
4252 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4253 {
4254         struct alc_spec *spec = codec->spec;
4255         int i;
4256
4257         for (i = 0; i < spec->autocfg.line_outs; i++) {
4258                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4259                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4260                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4261         }
4262 }
4263
4264 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4265 {
4266         struct alc_spec *spec = codec->spec;
4267         hda_nid_t pin;
4268
4269         pin = spec->autocfg.speaker_pins[0];
4270         if (pin) /* connect to front */
4271                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4272         pin = spec->autocfg.hp_pins[0];
4273         if (pin) /* connect to front */
4274                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4275 }
4276
4277 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4278 {
4279         struct alc_spec *spec = codec->spec;
4280         int i;
4281
4282         for (i = 0; i < AUTO_PIN_LAST; i++) {
4283                 hda_nid_t nid = spec->autocfg.input_pins[i];
4284                 if (alc880_is_input_pin(nid)) {
4285                         alc_set_input_pin(codec, nid, i);
4286                         if (nid != ALC880_PIN_CD_NID &&
4287                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4288                                 snd_hda_codec_write(codec, nid, 0,
4289                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4290                                                     AMP_OUT_MUTE);
4291                 }
4292         }
4293 }
4294
4295 /* parse the BIOS configuration and set up the alc_spec */
4296 /* return 1 if successful, 0 if the proper config is not found,
4297  * or a negative error code
4298  */
4299 static int alc880_parse_auto_config(struct hda_codec *codec)
4300 {
4301         struct alc_spec *spec = codec->spec;
4302         int i, err;
4303         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4304
4305         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4306                                            alc880_ignore);
4307         if (err < 0)
4308                 return err;
4309         if (!spec->autocfg.line_outs)
4310                 return 0; /* can't find valid BIOS pin config */
4311
4312         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4313         if (err < 0)
4314                 return err;
4315         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4316         if (err < 0)
4317                 return err;
4318         err = alc880_auto_create_extra_out(spec,
4319                                            spec->autocfg.speaker_pins[0],
4320                                            "Speaker");
4321         if (err < 0)
4322                 return err;
4323         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4324                                            "Headphone");
4325         if (err < 0)
4326                 return err;
4327         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
4328         if (err < 0)
4329                 return err;
4330
4331         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4332
4333         /* check multiple SPDIF-out (for recent codecs) */
4334         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4335                 hda_nid_t dig_nid;
4336                 err = snd_hda_get_connections(codec,
4337                                               spec->autocfg.dig_out_pins[i],
4338                                               &dig_nid, 1);
4339                 if (err < 0)
4340                         continue;
4341                 if (!i)
4342                         spec->multiout.dig_out_nid = dig_nid;
4343                 else {
4344                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4345                         spec->slave_dig_outs[i - 1] = dig_nid;
4346                         if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
4347                                 break;
4348                 }
4349         }
4350         if (spec->autocfg.dig_in_pin)
4351                 spec->dig_in_nid = ALC880_DIGIN_NID;
4352
4353         if (spec->kctls.list)
4354                 add_mixer(spec, spec->kctls.list);
4355
4356         add_verb(spec, alc880_volume_init_verbs);
4357
4358         spec->num_mux_defs = 1;
4359         spec->input_mux = &spec->private_imux[0];
4360
4361         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
4362
4363         return 1;
4364 }
4365
4366 /* additional initialization for auto-configuration model */
4367 static void alc880_auto_init(struct hda_codec *codec)
4368 {
4369         struct alc_spec *spec = codec->spec;
4370         alc880_auto_init_multi_out(codec);
4371         alc880_auto_init_extra_out(codec);
4372         alc880_auto_init_analog_input(codec);
4373         if (spec->unsol_event)
4374                 alc_inithook(codec);
4375 }
4376
4377 static void set_capture_mixer(struct alc_spec *spec)
4378 {
4379         static struct snd_kcontrol_new *caps[2][3] = {
4380                 { alc_capture_mixer_nosrc1,
4381                   alc_capture_mixer_nosrc2,
4382                   alc_capture_mixer_nosrc3 },
4383                 { alc_capture_mixer1,
4384                   alc_capture_mixer2,
4385                   alc_capture_mixer3 },
4386         };
4387         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4388                 int mux;
4389                 if (spec->input_mux && spec->input_mux->num_items > 1)
4390                         mux = 1;
4391                 else
4392                         mux = 0;
4393                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4394         }
4395 }
4396
4397 #define set_beep_amp(spec, nid, idx, dir) \
4398         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4399
4400 /*
4401  * OK, here we have finally the patch for ALC880
4402  */
4403
4404 static int patch_alc880(struct hda_codec *codec)
4405 {
4406         struct alc_spec *spec;
4407         int board_config;
4408         int err;
4409
4410         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4411         if (spec == NULL)
4412                 return -ENOMEM;
4413
4414         codec->spec = spec;
4415
4416         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4417                                                   alc880_models,
4418                                                   alc880_cfg_tbl);
4419         if (board_config < 0) {
4420                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
4421                        "trying auto-probe from BIOS...\n", codec->chip_name);
4422                 board_config = ALC880_AUTO;
4423         }
4424
4425         if (board_config == ALC880_AUTO) {
4426                 /* automatic parse from the BIOS config */
4427                 err = alc880_parse_auto_config(codec);
4428                 if (err < 0) {
4429                         alc_free(codec);
4430                         return err;
4431                 } else if (!err) {
4432                         printk(KERN_INFO
4433                                "hda_codec: Cannot set up configuration "
4434                                "from BIOS.  Using 3-stack mode...\n");
4435                         board_config = ALC880_3ST;
4436                 }
4437         }
4438
4439         err = snd_hda_attach_beep_device(codec, 0x1);
4440         if (err < 0) {
4441                 alc_free(codec);
4442                 return err;
4443         }
4444
4445         if (board_config != ALC880_AUTO)
4446                 setup_preset(spec, &alc880_presets[board_config]);
4447
4448         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4449         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4450         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4451
4452         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4453         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4454
4455         if (!spec->adc_nids && spec->input_mux) {
4456                 /* check whether NID 0x07 is valid */
4457                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4458                 /* get type */
4459                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
4460                 if (wcap != AC_WID_AUD_IN) {
4461                         spec->adc_nids = alc880_adc_nids_alt;
4462                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4463                 } else {
4464                         spec->adc_nids = alc880_adc_nids;
4465                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4466                 }
4467         }
4468         set_capture_mixer(spec);
4469         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4470
4471         spec->vmaster_nid = 0x0c;
4472
4473         codec->patch_ops = alc_patch_ops;
4474         if (board_config == ALC880_AUTO)
4475                 spec->init_hook = alc880_auto_init;
4476 #ifdef CONFIG_SND_HDA_POWER_SAVE
4477         if (!spec->loopback.amplist)
4478                 spec->loopback.amplist = alc880_loopbacks;
4479 #endif
4480         codec->proc_widget_hook = print_realtek_coef;
4481
4482         return 0;
4483 }
4484
4485
4486 /*
4487  * ALC260 support
4488  */
4489
4490 static hda_nid_t alc260_dac_nids[1] = {
4491         /* front */
4492         0x02,
4493 };
4494
4495 static hda_nid_t alc260_adc_nids[1] = {
4496         /* ADC0 */
4497         0x04,
4498 };
4499
4500 static hda_nid_t alc260_adc_nids_alt[1] = {
4501         /* ADC1 */
4502         0x05,
4503 };
4504
4505 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4506  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4507  */
4508 static hda_nid_t alc260_dual_adc_nids[2] = {
4509         /* ADC0, ADC1 */
4510         0x04, 0x05
4511 };
4512
4513 #define ALC260_DIGOUT_NID       0x03
4514 #define ALC260_DIGIN_NID        0x06
4515
4516 static struct hda_input_mux alc260_capture_source = {
4517         .num_items = 4,
4518         .items = {
4519                 { "Mic", 0x0 },
4520                 { "Front Mic", 0x1 },
4521                 { "Line", 0x2 },
4522                 { "CD", 0x4 },
4523         },
4524 };
4525
4526 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4527  * headphone jack and the internal CD lines since these are the only pins at
4528  * which audio can appear.  For flexibility, also allow the option of
4529  * recording the mixer output on the second ADC (ADC0 doesn't have a
4530  * connection to the mixer output).
4531  */
4532 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4533         {
4534                 .num_items = 3,
4535                 .items = {
4536                         { "Mic/Line", 0x0 },
4537                         { "CD", 0x4 },
4538                         { "Headphone", 0x2 },
4539                 },
4540         },
4541         {
4542                 .num_items = 4,
4543                 .items = {
4544                         { "Mic/Line", 0x0 },
4545                         { "CD", 0x4 },
4546                         { "Headphone", 0x2 },
4547                         { "Mixer", 0x5 },
4548                 },
4549         },
4550
4551 };
4552
4553 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4554  * the Fujitsu S702x, but jacks are marked differently.
4555  */
4556 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4557         {
4558                 .num_items = 4,
4559                 .items = {
4560                         { "Mic", 0x0 },
4561                         { "Line", 0x2 },
4562                         { "CD", 0x4 },
4563                         { "Headphone", 0x5 },
4564                 },
4565         },
4566         {
4567                 .num_items = 5,
4568                 .items = {
4569                         { "Mic", 0x0 },
4570                         { "Line", 0x2 },
4571                         { "CD", 0x4 },
4572                         { "Headphone", 0x6 },
4573                         { "Mixer", 0x5 },
4574                 },
4575         },
4576 };
4577
4578 /* Maxdata Favorit 100XS */
4579 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
4580         {
4581                 .num_items = 2,
4582                 .items = {
4583                         { "Line/Mic", 0x0 },
4584                         { "CD", 0x4 },
4585                 },
4586         },
4587         {
4588                 .num_items = 3,
4589                 .items = {
4590                         { "Line/Mic", 0x0 },
4591                         { "CD", 0x4 },
4592                         { "Mixer", 0x5 },
4593                 },
4594         },
4595 };
4596
4597 /*
4598  * This is just place-holder, so there's something for alc_build_pcms to look
4599  * at when it calculates the maximum number of channels. ALC260 has no mixer
4600  * element which allows changing the channel mode, so the verb list is
4601  * never used.
4602  */
4603 static struct hda_channel_mode alc260_modes[1] = {
4604         { 2, NULL },
4605 };
4606
4607
4608 /* Mixer combinations
4609  *
4610  * basic: base_output + input + pc_beep + capture
4611  * HP: base_output + input + capture_alt
4612  * HP_3013: hp_3013 + input + capture
4613  * fujitsu: fujitsu + capture
4614  * acer: acer + capture
4615  */
4616
4617 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4618         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4619         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4620         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4621         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4622         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4623         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4624         { } /* end */
4625 };
4626
4627 static struct snd_kcontrol_new alc260_input_mixer[] = {
4628         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4629         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4630         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4631         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4632         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4633         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4634         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4635         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4636         { } /* end */
4637 };
4638
4639 /* update HP, line and mono out pins according to the master switch */
4640 static void alc260_hp_master_update(struct hda_codec *codec,
4641                                     hda_nid_t hp, hda_nid_t line,
4642                                     hda_nid_t mono)
4643 {
4644         struct alc_spec *spec = codec->spec;
4645         unsigned int val = spec->master_sw ? PIN_HP : 0;
4646         /* change HP and line-out pins */
4647         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4648                             val);
4649         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4650                             val);
4651         /* mono (speaker) depending on the HP jack sense */
4652         val = (val && !spec->jack_present) ? PIN_OUT : 0;
4653         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4654                             val);
4655 }
4656
4657 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4658                                    struct snd_ctl_elem_value *ucontrol)
4659 {
4660         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4661         struct alc_spec *spec = codec->spec;
4662         *ucontrol->value.integer.value = spec->master_sw;
4663         return 0;
4664 }
4665
4666 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4667                                    struct snd_ctl_elem_value *ucontrol)
4668 {
4669         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4670         struct alc_spec *spec = codec->spec;
4671         int val = !!*ucontrol->value.integer.value;
4672         hda_nid_t hp, line, mono;
4673
4674         if (val == spec->master_sw)
4675                 return 0;
4676         spec->master_sw = val;
4677         hp = (kcontrol->private_value >> 16) & 0xff;
4678         line = (kcontrol->private_value >> 8) & 0xff;
4679         mono = kcontrol->private_value & 0xff;
4680         alc260_hp_master_update(codec, hp, line, mono);
4681         return 1;
4682 }
4683
4684 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4685         {
4686                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4687                 .name = "Master Playback Switch",
4688                 .info = snd_ctl_boolean_mono_info,
4689                 .get = alc260_hp_master_sw_get,
4690                 .put = alc260_hp_master_sw_put,
4691                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4692         },
4693         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4694         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4695         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4696         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4697         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4698                               HDA_OUTPUT),
4699         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4700         { } /* end */
4701 };
4702
4703 static struct hda_verb alc260_hp_unsol_verbs[] = {
4704         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4705         {},
4706 };
4707
4708 static void alc260_hp_automute(struct hda_codec *codec)
4709 {
4710         struct alc_spec *spec = codec->spec;
4711         unsigned int present;
4712
4713         present = snd_hda_codec_read(codec, 0x10, 0,
4714                                      AC_VERB_GET_PIN_SENSE, 0);
4715         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4716         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4717 }
4718
4719 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4720 {
4721         if ((res >> 26) == ALC880_HP_EVENT)
4722                 alc260_hp_automute(codec);
4723 }
4724
4725 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4726         {
4727                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4728                 .name = "Master Playback Switch",
4729                 .info = snd_ctl_boolean_mono_info,
4730                 .get = alc260_hp_master_sw_get,
4731                 .put = alc260_hp_master_sw_put,
4732                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
4733         },
4734         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4735         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4736         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4737         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4738         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4739         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4740         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4741         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4742         { } /* end */
4743 };
4744
4745 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4746         .ops = &snd_hda_bind_vol,
4747         .values = {
4748                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4749                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4750                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4751                 0
4752         },
4753 };
4754
4755 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4756         .ops = &snd_hda_bind_sw,
4757         .values = {
4758                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4759                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4760                 0
4761         },
4762 };
4763
4764 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4765         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4766         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4767         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4768         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4769         { } /* end */
4770 };
4771
4772 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4773         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4774         {},
4775 };
4776
4777 static void alc260_hp_3013_automute(struct hda_codec *codec)
4778 {
4779         struct alc_spec *spec = codec->spec;
4780         unsigned int present;
4781
4782         present = snd_hda_codec_read(codec, 0x15, 0,
4783                                      AC_VERB_GET_PIN_SENSE, 0);
4784         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4785         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
4786 }
4787
4788 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4789                                        unsigned int res)
4790 {
4791         if ((res >> 26) == ALC880_HP_EVENT)
4792                 alc260_hp_3013_automute(codec);
4793 }
4794
4795 static void alc260_hp_3012_automute(struct hda_codec *codec)
4796 {
4797         unsigned int present, bits;
4798
4799         present = snd_hda_codec_read(codec, 0x10, 0,
4800                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4801
4802         bits = present ? 0 : PIN_OUT;
4803         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4804                             bits);
4805         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4806                             bits);
4807         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4808                             bits);
4809 }
4810
4811 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4812                                        unsigned int res)
4813 {
4814         if ((res >> 26) == ALC880_HP_EVENT)
4815                 alc260_hp_3012_automute(codec);
4816 }
4817
4818 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
4819  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
4820  */
4821 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4822         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4823         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4824         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4825         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4826         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4827         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4828         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4829         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4830         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4831         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4832         { } /* end */
4833 };
4834
4835 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
4836  * versions of the ALC260 don't act on requests to enable mic bias from NID
4837  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
4838  * datasheet doesn't mention this restriction.  At this stage it's not clear
4839  * whether this behaviour is intentional or is a hardware bug in chip
4840  * revisions available in early 2006.  Therefore for now allow the
4841  * "Headphone Jack Mode" control to span all choices, but if it turns out
4842  * that the lack of mic bias for this NID is intentional we could change the
4843  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4844  *
4845  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4846  * don't appear to make the mic bias available from the "line" jack, even
4847  * though the NID used for this jack (0x14) can supply it.  The theory is
4848  * that perhaps Acer have included blocking capacitors between the ALC260
4849  * and the output jack.  If this turns out to be the case for all such
4850  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4851  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4852  *
4853  * The C20x Tablet series have a mono internal speaker which is controlled
4854  * via the chip's Mono sum widget and pin complex, so include the necessary
4855  * controls for such models.  On models without a "mono speaker" the control
4856  * won't do anything.
4857  */
4858 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4859         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4860         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4861         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4862         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4863                               HDA_OUTPUT),
4864         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4865                            HDA_INPUT),
4866         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4867         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4868         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4869         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4870         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4871         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4872         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4873         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4874         { } /* end */
4875 };
4876
4877 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
4878  */
4879 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
4880         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4881         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4882         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4883         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4884         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4885         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4886         { } /* end */
4887 };
4888
4889 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4890  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
4891  */
4892 static struct snd_kcontrol_new alc260_will_mixer[] = {
4893         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4894         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4895         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4896         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4897         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4898         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4899         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4900         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4901         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4902         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4903         { } /* end */
4904 };
4905
4906 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4907  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4908  */
4909 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4910         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4911         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4912         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4913         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4914         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4915         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4916         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4917         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4918         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4919         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4920         { } /* end */
4921 };
4922
4923 /*
4924  * initialization verbs
4925  */
4926 static struct hda_verb alc260_init_verbs[] = {
4927         /* Line In pin widget for input */
4928         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4929         /* CD pin widget for input */
4930         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4931         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4932         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4933         /* Mic2 (front panel) pin widget for input and vref at 80% */
4934         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4935         /* LINE-2 is used for line-out in rear */
4936         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4937         /* select line-out */
4938         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4939         /* LINE-OUT pin */
4940         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4941         /* enable HP */
4942         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4943         /* enable Mono */
4944         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4945         /* mute capture amp left and right */
4946         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4947         /* set connection select to line in (default select for this ADC) */
4948         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4949         /* mute capture amp left and right */
4950         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4951         /* set connection select to line in (default select for this ADC) */
4952         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4953         /* set vol=0 Line-Out mixer amp left and right */
4954         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4955         /* unmute pin widget amp left and right (no gain on this amp) */
4956         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4957         /* set vol=0 HP mixer amp left and right */
4958         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4959         /* unmute pin widget amp left and right (no gain on this amp) */
4960         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4961         /* set vol=0 Mono mixer amp left and right */
4962         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4963         /* unmute pin widget amp left and right (no gain on this amp) */
4964         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4965         /* unmute LINE-2 out pin */
4966         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4967         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4968          * Line In 2 = 0x03
4969          */
4970         /* mute analog inputs */
4971         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4972         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4973         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4974         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4975         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4976         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4977         /* mute Front out path */
4978         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4979         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4980         /* mute Headphone out path */
4981         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4982         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4983         /* mute Mono out path */
4984         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4985         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4986         { }
4987 };
4988
4989 #if 0 /* should be identical with alc260_init_verbs? */
4990 static struct hda_verb alc260_hp_init_verbs[] = {
4991         /* Headphone and output */
4992         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4993         /* mono output */
4994         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4995         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4996         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4997         /* Mic2 (front panel) pin widget for input and vref at 80% */
4998         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4999         /* Line In pin widget for input */
5000         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5001         /* Line-2 pin widget for output */
5002         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5003         /* CD pin widget for input */
5004         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5005         /* unmute amp left and right */
5006         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5007         /* set connection select to line in (default select for this ADC) */
5008         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5009         /* unmute Line-Out mixer amp left and right (volume = 0) */
5010         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5011         /* mute pin widget amp left and right (no gain on this amp) */
5012         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5013         /* unmute HP mixer amp left and right (volume = 0) */
5014         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5015         /* mute pin widget amp left and right (no gain on this amp) */
5016         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5017         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5018          * Line In 2 = 0x03
5019          */
5020         /* mute analog inputs */
5021         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5022         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5023         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5024         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5025         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5026         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5027         /* Unmute Front out path */
5028         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5029         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5030         /* Unmute Headphone out path */
5031         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5032         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5033         /* Unmute Mono out path */
5034         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5035         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5036         { }
5037 };
5038 #endif
5039
5040 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5041         /* Line out and output */
5042         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5043         /* mono output */
5044         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5045         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5046         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5047         /* Mic2 (front panel) pin widget for input and vref at 80% */
5048         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5049         /* Line In pin widget for input */
5050         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5051         /* Headphone pin widget for output */
5052         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5053         /* CD pin widget for input */
5054         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5055         /* unmute amp left and right */
5056         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5057         /* set connection select to line in (default select for this ADC) */
5058         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5059         /* unmute Line-Out mixer amp left and right (volume = 0) */
5060         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5061         /* mute pin widget amp left and right (no gain on this amp) */
5062         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5063         /* unmute HP mixer amp left and right (volume = 0) */
5064         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5065         /* mute pin widget amp left and right (no gain on this amp) */
5066         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5067         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5068          * Line In 2 = 0x03
5069          */
5070         /* mute analog inputs */
5071         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5072         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5073         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5074         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5075         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5076         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5077         /* Unmute Front out path */
5078         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5079         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5080         /* Unmute Headphone out path */
5081         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5082         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5083         /* Unmute Mono out path */
5084         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5085         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5086         { }
5087 };
5088
5089 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5090  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5091  * audio = 0x16, internal speaker = 0x10.
5092  */
5093 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5094         /* Disable all GPIOs */
5095         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5096         /* Internal speaker is connected to headphone pin */
5097         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5098         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5099         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5100         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5101         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5102         /* Ensure all other unused pins are disabled and muted. */
5103         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5104         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5105         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5106         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5107         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5108         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5109         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5110         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5111
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 Line1 pin widget takes its input from the OUT1 sum bus
5117          * when acting as an output.
5118          */
5119         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5120
5121         /* Start with output sum widgets muted and their output gains at min */
5122         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5123         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5124         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5125         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5126         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5127         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5128         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5129         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5130         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5131
5132         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5133         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5134         /* Unmute Line1 pin widget output buffer since it starts as an output.
5135          * If the pin mode is changed by the user the pin mode control will
5136          * take care of enabling the pin's input/output buffers as needed.
5137          * Therefore there's no need to enable the input buffer at this
5138          * stage.
5139          */
5140         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5141         /* Unmute input buffer of pin widget used for Line-in (no equiv
5142          * mixer ctrl)
5143          */
5144         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5145
5146         /* Mute capture amp left and right */
5147         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5148         /* Set ADC connection select to match default mixer setting - line
5149          * in (on mic1 pin)
5150          */
5151         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5152
5153         /* Do the same for the second ADC: mute capture input amp and
5154          * set ADC connection to line in (on mic1 pin)
5155          */
5156         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5157         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5158
5159         /* Mute all inputs to mixer widget (even unconnected ones) */
5160         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5161         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5162         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5163         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5164         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5165         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5166         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5167         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5168
5169         { }
5170 };
5171
5172 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5173  * similar laptops (adapted from Fujitsu init verbs).
5174  */
5175 static struct hda_verb alc260_acer_init_verbs[] = {
5176         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5177          * the headphone jack.  Turn this on and rely on the standard mute
5178          * methods whenever the user wants to turn these outputs off.
5179          */
5180         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5181         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5182         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5183         /* Internal speaker/Headphone jack is connected to Line-out pin */
5184         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5185         /* Internal microphone/Mic jack is connected to Mic1 pin */
5186         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5187         /* Line In jack is connected to Line1 pin */
5188         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5189         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5190         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5191         /* Ensure all other unused pins are disabled and muted. */
5192         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5193         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5194         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5195         {0x13, 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 mono pin widget amp output (no equiv mixer ctrl) */
5224         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5225         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5226          * inputs. If the pin mode is changed by the user the pin mode control
5227          * will take care of enabling the pin's input/output buffers as needed.
5228          * Therefore there's no need to enable the input buffer at this
5229          * stage.
5230          */
5231         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5232         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5233
5234         /* Mute capture amp left and right */
5235         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5236         /* Set ADC connection select to match default mixer setting - mic
5237          * (on mic1 pin)
5238          */
5239         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5240
5241         /* Do similar with the second ADC: mute capture input amp and
5242          * set ADC connection to mic to match ALSA's default state.
5243          */
5244         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5245         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5246
5247         /* Mute all inputs to mixer widget (even unconnected ones) */
5248         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5249         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5250         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5251         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5252         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5253         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5254         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5255         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5256
5257         { }
5258 };
5259
5260 /* Initialisation sequence for Maxdata Favorit 100XS
5261  * (adapted from Acer init verbs).
5262  */
5263 static struct hda_verb alc260_favorit100_init_verbs[] = {
5264         /* GPIO 0 enables the output jack.
5265          * Turn this on and rely on the standard mute
5266          * methods whenever the user wants to turn these outputs off.
5267          */
5268         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5269         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5270         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5271         /* Line/Mic input jack is connected to Mic1 pin */
5272         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5273         /* Ensure all other unused pins are disabled and muted. */
5274         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5275         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5276         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5277         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5278         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5279         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5280         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5281         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5282         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5283         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5284         /* Disable digital (SPDIF) pins */
5285         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5286         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5287
5288         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5289          * bus when acting as outputs.
5290          */
5291         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5292         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5293
5294         /* Start with output sum widgets muted and their output gains at min */
5295         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5296         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5297         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5298         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5299         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5300         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5301         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5302         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5303         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5304
5305         /* Unmute Line-out pin widget amp left and right
5306          * (no equiv mixer ctrl)
5307          */
5308         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5309         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5310          * inputs. If the pin mode is changed by the user the pin mode control
5311          * will take care of enabling the pin's input/output buffers as needed.
5312          * Therefore there's no need to enable the input buffer at this
5313          * stage.
5314          */
5315         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5316
5317         /* Mute capture amp left and right */
5318         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5319         /* Set ADC connection select to match default mixer setting - mic
5320          * (on mic1 pin)
5321          */
5322         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5323
5324         /* Do similar with the second ADC: mute capture input amp and
5325          * set ADC connection to mic to match ALSA's default state.
5326          */
5327         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5328         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5329
5330         /* Mute all inputs to mixer widget (even unconnected ones) */
5331         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5332         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5333         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5334         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5335         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5336         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5337         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5338         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5339
5340         { }
5341 };
5342
5343 static struct hda_verb alc260_will_verbs[] = {
5344         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5345         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5346         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5347         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5348         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5349         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5350         {}
5351 };
5352
5353 static struct hda_verb alc260_replacer_672v_verbs[] = {
5354         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5355         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5356         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5357
5358         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5359         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5360         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5361
5362         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5363         {}
5364 };
5365
5366 /* toggle speaker-output according to the hp-jack state */
5367 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5368 {
5369         unsigned int present;
5370
5371         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5372         present = snd_hda_codec_read(codec, 0x0f, 0,
5373                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5374         if (present) {
5375                 snd_hda_codec_write_cache(codec, 0x01, 0,
5376                                           AC_VERB_SET_GPIO_DATA, 1);
5377                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5378                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5379                                           PIN_HP);
5380         } else {
5381                 snd_hda_codec_write_cache(codec, 0x01, 0,
5382                                           AC_VERB_SET_GPIO_DATA, 0);
5383                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5384                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5385                                           PIN_OUT);
5386         }
5387 }
5388
5389 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5390                                        unsigned int res)
5391 {
5392         if ((res >> 26) == ALC880_HP_EVENT)
5393                 alc260_replacer_672v_automute(codec);
5394 }
5395
5396 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5397         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5398         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5399         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5400         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5401         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5402         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5403         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5404         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5405         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5406         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5407         {}
5408 };
5409
5410 /* Test configuration for debugging, modelled after the ALC880 test
5411  * configuration.
5412  */
5413 #ifdef CONFIG_SND_DEBUG
5414 static hda_nid_t alc260_test_dac_nids[1] = {
5415         0x02,
5416 };
5417 static hda_nid_t alc260_test_adc_nids[2] = {
5418         0x04, 0x05,
5419 };
5420 /* For testing the ALC260, each input MUX needs its own definition since
5421  * the signal assignments are different.  This assumes that the first ADC
5422  * is NID 0x04.
5423  */
5424 static struct hda_input_mux alc260_test_capture_sources[2] = {
5425         {
5426                 .num_items = 7,
5427                 .items = {
5428                         { "MIC1 pin", 0x0 },
5429                         { "MIC2 pin", 0x1 },
5430                         { "LINE1 pin", 0x2 },
5431                         { "LINE2 pin", 0x3 },
5432                         { "CD pin", 0x4 },
5433                         { "LINE-OUT pin", 0x5 },
5434                         { "HP-OUT pin", 0x6 },
5435                 },
5436         },
5437         {
5438                 .num_items = 8,
5439                 .items = {
5440                         { "MIC1 pin", 0x0 },
5441                         { "MIC2 pin", 0x1 },
5442                         { "LINE1 pin", 0x2 },
5443                         { "LINE2 pin", 0x3 },
5444                         { "CD pin", 0x4 },
5445                         { "Mixer", 0x5 },
5446                         { "LINE-OUT pin", 0x6 },
5447                         { "HP-OUT pin", 0x7 },
5448                 },
5449         },
5450 };
5451 static struct snd_kcontrol_new alc260_test_mixer[] = {
5452         /* Output driver widgets */
5453         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5454         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5455         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5456         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5457         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5458         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5459
5460         /* Modes for retasking pin widgets
5461          * Note: the ALC260 doesn't seem to act on requests to enable mic
5462          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5463          * mention this restriction.  At this stage it's not clear whether
5464          * this behaviour is intentional or is a hardware bug in chip
5465          * revisions available at least up until early 2006.  Therefore for
5466          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5467          * choices, but if it turns out that the lack of mic bias for these
5468          * NIDs is intentional we could change their modes from
5469          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5470          */
5471         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5472         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5473         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5474         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5475         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5476         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5477
5478         /* Loopback mixer controls */
5479         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5480         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5481         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5482         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5483         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5484         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5485         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5486         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5487         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5488         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5489         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5490         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5491         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5492         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5493
5494         /* Controls for GPIO pins, assuming they are configured as outputs */
5495         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5496         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5497         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5498         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5499
5500         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5501          * is ambigious as to which NID is which; testing on laptops which
5502          * make this output available should provide clarification.
5503          */
5504         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5505         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5506
5507         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5508          * this output to turn on an external amplifier.
5509          */
5510         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5511         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5512
5513         { } /* end */
5514 };
5515 static struct hda_verb alc260_test_init_verbs[] = {
5516         /* Enable all GPIOs as outputs with an initial value of 0 */
5517         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5518         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5519         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5520
5521         /* Enable retasking pins as output, initially without power amp */
5522         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5523         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5524         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5525         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5526         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5527         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5528
5529         /* Disable digital (SPDIF) pins initially, but users can enable
5530          * them via a mixer switch.  In the case of SPDIF-out, this initverb
5531          * payload also sets the generation to 0, output to be in "consumer"
5532          * PCM format, copyright asserted, no pre-emphasis and no validity
5533          * control.
5534          */
5535         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5536         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5537
5538         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5539          * OUT1 sum bus when acting as an output.
5540          */
5541         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5542         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5543         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5544         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5545
5546         /* Start with output sum widgets muted and their output gains at min */
5547         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5548         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5549         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5550         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5551         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5552         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5553         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5554         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5555         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5556
5557         /* Unmute retasking pin widget output buffers since the default
5558          * state appears to be output.  As the pin mode is changed by the
5559          * user the pin mode control will take care of enabling the pin's
5560          * input/output buffers as needed.
5561          */
5562         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5563         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5564         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5565         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5566         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5567         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5568         /* Also unmute the mono-out pin widget */
5569         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5570
5571         /* Mute capture amp left and right */
5572         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5573         /* Set ADC connection select to match default mixer setting (mic1
5574          * pin)
5575          */
5576         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5577
5578         /* Do the same for the second ADC: mute capture input amp and
5579          * set ADC connection to mic1 pin
5580          */
5581         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5582         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5583
5584         /* Mute all inputs to mixer widget (even unconnected ones) */
5585         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5586         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5587         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5588         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5589         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5590         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5591         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5592         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5593
5594         { }
5595 };
5596 #endif
5597
5598 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
5599 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
5600
5601 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
5602 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
5603
5604 /*
5605  * for BIOS auto-configuration
5606  */
5607
5608 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5609                                         const char *pfx, int *vol_bits)
5610 {
5611         hda_nid_t nid_vol;
5612         unsigned long vol_val, sw_val;
5613         char name[32];
5614         int err;
5615
5616         if (nid >= 0x0f && nid < 0x11) {
5617                 nid_vol = nid - 0x7;
5618                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5619                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5620         } else if (nid == 0x11) {
5621                 nid_vol = nid - 0x7;
5622                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5623                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5624         } else if (nid >= 0x12 && nid <= 0x15) {
5625                 nid_vol = 0x08;
5626                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5627                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5628         } else
5629                 return 0; /* N/A */
5630
5631         if (!(*vol_bits & (1 << nid_vol))) {
5632                 /* first control for the volume widget */
5633                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5634                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5635                 if (err < 0)
5636                         return err;
5637                 *vol_bits |= (1 << nid_vol);
5638         }
5639         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5640         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5641         if (err < 0)
5642                 return err;
5643         return 1;
5644 }
5645
5646 /* add playback controls from the parsed DAC table */
5647 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5648                                              const struct auto_pin_cfg *cfg)
5649 {
5650         hda_nid_t nid;
5651         int err;
5652         int vols = 0;
5653
5654         spec->multiout.num_dacs = 1;
5655         spec->multiout.dac_nids = spec->private_dac_nids;
5656         spec->multiout.dac_nids[0] = 0x02;
5657
5658         nid = cfg->line_out_pins[0];
5659         if (nid) {
5660                 err = alc260_add_playback_controls(spec, nid, "Front", &vols);
5661                 if (err < 0)
5662                         return err;
5663         }
5664
5665         nid = cfg->speaker_pins[0];
5666         if (nid) {
5667                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
5668                 if (err < 0)
5669                         return err;
5670         }
5671
5672         nid = cfg->hp_pins[0];
5673         if (nid) {
5674                 err = alc260_add_playback_controls(spec, nid, "Headphone",
5675                                                    &vols);
5676                 if (err < 0)
5677                         return err;
5678         }
5679         return 0;
5680 }
5681
5682 /* create playback/capture controls for input pins */
5683 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5684                                                 const struct auto_pin_cfg *cfg)
5685 {
5686         struct hda_input_mux *imux = &spec->private_imux[0];
5687         int i, err, idx;
5688
5689         for (i = 0; i < AUTO_PIN_LAST; i++) {
5690                 if (cfg->input_pins[i] >= 0x12) {
5691                         idx = cfg->input_pins[i] - 0x12;
5692                         err = new_analog_input(spec, cfg->input_pins[i],
5693                                                auto_pin_cfg_labels[i], idx,
5694                                                0x07);
5695                         if (err < 0)
5696                                 return err;
5697                         imux->items[imux->num_items].label =
5698                                 auto_pin_cfg_labels[i];
5699                         imux->items[imux->num_items].index = idx;
5700                         imux->num_items++;
5701                 }
5702                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5703                         idx = cfg->input_pins[i] - 0x09;
5704                         err = new_analog_input(spec, cfg->input_pins[i],
5705                                                auto_pin_cfg_labels[i], idx,
5706                                                0x07);
5707                         if (err < 0)
5708                                 return err;
5709                         imux->items[imux->num_items].label =
5710                                 auto_pin_cfg_labels[i];
5711                         imux->items[imux->num_items].index = idx;
5712                         imux->num_items++;
5713                 }
5714         }
5715         return 0;
5716 }
5717
5718 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5719                                               hda_nid_t nid, int pin_type,
5720                                               int sel_idx)
5721 {
5722         alc_set_pin_output(codec, nid, pin_type);
5723         /* need the manual connection? */
5724         if (nid >= 0x12) {
5725                 int idx = nid - 0x12;
5726                 snd_hda_codec_write(codec, idx + 0x0b, 0,
5727                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
5728         }
5729 }
5730
5731 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5732 {
5733         struct alc_spec *spec = codec->spec;
5734         hda_nid_t nid;
5735
5736         nid = spec->autocfg.line_out_pins[0];
5737         if (nid) {
5738                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5739                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5740         }
5741
5742         nid = spec->autocfg.speaker_pins[0];
5743         if (nid)
5744                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5745
5746         nid = spec->autocfg.hp_pins[0];
5747         if (nid)
5748                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5749 }
5750
5751 #define ALC260_PIN_CD_NID               0x16
5752 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5753 {
5754         struct alc_spec *spec = codec->spec;
5755         int i;
5756
5757         for (i = 0; i < AUTO_PIN_LAST; i++) {
5758                 hda_nid_t nid = spec->autocfg.input_pins[i];
5759                 if (nid >= 0x12) {
5760                         alc_set_input_pin(codec, nid, i);
5761                         if (nid != ALC260_PIN_CD_NID &&
5762                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5763                                 snd_hda_codec_write(codec, nid, 0,
5764                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5765                                                     AMP_OUT_MUTE);
5766                 }
5767         }
5768 }
5769
5770 /*
5771  * generic initialization of ADC, input mixers and output mixers
5772  */
5773 static struct hda_verb alc260_volume_init_verbs[] = {
5774         /*
5775          * Unmute ADC0-1 and set the default input to mic-in
5776          */
5777         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5778         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5779         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5780         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5781
5782         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5783          * mixer widget
5784          * Note: PASD motherboards uses the Line In 2 as the input for
5785          * front panel mic (mic 2)
5786          */
5787         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5788         /* mute analog inputs */
5789         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5790         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5791         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5792         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5793         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5794
5795         /*
5796          * Set up output mixers (0x08 - 0x0a)
5797          */
5798         /* set vol=0 to output mixers */
5799         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5800         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5801         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5802         /* set up input amps for analog loopback */
5803         /* Amp Indices: DAC = 0, mixer = 1 */
5804         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5805         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5806         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5807         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5808         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5809         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5810
5811         { }
5812 };
5813
5814 static int alc260_parse_auto_config(struct hda_codec *codec)
5815 {
5816         struct alc_spec *spec = codec->spec;
5817         int err;
5818         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5819
5820         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5821                                            alc260_ignore);
5822         if (err < 0)
5823                 return err;
5824         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5825         if (err < 0)
5826                 return err;
5827         if (!spec->kctls.list)
5828                 return 0; /* can't find valid BIOS pin config */
5829         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5830         if (err < 0)
5831                 return err;
5832
5833         spec->multiout.max_channels = 2;
5834
5835         if (spec->autocfg.dig_outs)
5836                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5837         if (spec->kctls.list)
5838                 add_mixer(spec, spec->kctls.list);
5839
5840         add_verb(spec, alc260_volume_init_verbs);
5841
5842         spec->num_mux_defs = 1;
5843         spec->input_mux = &spec->private_imux[0];
5844
5845         alc_ssid_check(codec, 0x10, 0x15, 0x0f);
5846
5847         return 1;
5848 }
5849
5850 /* additional initialization for auto-configuration model */
5851 static void alc260_auto_init(struct hda_codec *codec)
5852 {
5853         struct alc_spec *spec = codec->spec;
5854         alc260_auto_init_multi_out(codec);
5855         alc260_auto_init_analog_input(codec);
5856         if (spec->unsol_event)
5857                 alc_inithook(codec);
5858 }
5859
5860 #ifdef CONFIG_SND_HDA_POWER_SAVE
5861 static struct hda_amp_list alc260_loopbacks[] = {
5862         { 0x07, HDA_INPUT, 0 },
5863         { 0x07, HDA_INPUT, 1 },
5864         { 0x07, HDA_INPUT, 2 },
5865         { 0x07, HDA_INPUT, 3 },
5866         { 0x07, HDA_INPUT, 4 },
5867         { } /* end */
5868 };
5869 #endif
5870
5871 /*
5872  * ALC260 configurations
5873  */
5874 static const char *alc260_models[ALC260_MODEL_LAST] = {
5875         [ALC260_BASIC]          = "basic",
5876         [ALC260_HP]             = "hp",
5877         [ALC260_HP_3013]        = "hp-3013",
5878         [ALC260_HP_DC7600]      = "hp-dc7600",
5879         [ALC260_FUJITSU_S702X]  = "fujitsu",
5880         [ALC260_ACER]           = "acer",
5881         [ALC260_WILL]           = "will",
5882         [ALC260_REPLACER_672V]  = "replacer",
5883         [ALC260_FAVORIT100]     = "favorit100",
5884 #ifdef CONFIG_SND_DEBUG
5885         [ALC260_TEST]           = "test",
5886 #endif
5887         [ALC260_AUTO]           = "auto",
5888 };
5889
5890 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5891         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5892         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5893         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
5894         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5895         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5896         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5897         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
5898         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
5899         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5900         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5901         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5902         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5903         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5904         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5905         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5906         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5907         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5908         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5909         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5910         {}
5911 };
5912
5913 static struct alc_config_preset alc260_presets[] = {
5914         [ALC260_BASIC] = {
5915                 .mixers = { alc260_base_output_mixer,
5916                             alc260_input_mixer },
5917                 .init_verbs = { alc260_init_verbs },
5918                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5919                 .dac_nids = alc260_dac_nids,
5920                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5921                 .adc_nids = alc260_adc_nids,
5922                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5923                 .channel_mode = alc260_modes,
5924                 .input_mux = &alc260_capture_source,
5925         },
5926         [ALC260_HP] = {
5927                 .mixers = { alc260_hp_output_mixer,
5928                             alc260_input_mixer },
5929                 .init_verbs = { alc260_init_verbs,
5930                                 alc260_hp_unsol_verbs },
5931                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5932                 .dac_nids = alc260_dac_nids,
5933                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5934                 .adc_nids = alc260_adc_nids_alt,
5935                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5936                 .channel_mode = alc260_modes,
5937                 .input_mux = &alc260_capture_source,
5938                 .unsol_event = alc260_hp_unsol_event,
5939                 .init_hook = alc260_hp_automute,
5940         },
5941         [ALC260_HP_DC7600] = {
5942                 .mixers = { alc260_hp_dc7600_mixer,
5943                             alc260_input_mixer },
5944                 .init_verbs = { alc260_init_verbs,
5945                                 alc260_hp_dc7600_verbs },
5946                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5947                 .dac_nids = alc260_dac_nids,
5948                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5949                 .adc_nids = alc260_adc_nids_alt,
5950                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5951                 .channel_mode = alc260_modes,
5952                 .input_mux = &alc260_capture_source,
5953                 .unsol_event = alc260_hp_3012_unsol_event,
5954                 .init_hook = alc260_hp_3012_automute,
5955         },
5956         [ALC260_HP_3013] = {
5957                 .mixers = { alc260_hp_3013_mixer,
5958                             alc260_input_mixer },
5959                 .init_verbs = { alc260_hp_3013_init_verbs,
5960                                 alc260_hp_3013_unsol_verbs },
5961                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5962                 .dac_nids = alc260_dac_nids,
5963                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5964                 .adc_nids = alc260_adc_nids_alt,
5965                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5966                 .channel_mode = alc260_modes,
5967                 .input_mux = &alc260_capture_source,
5968                 .unsol_event = alc260_hp_3013_unsol_event,
5969                 .init_hook = alc260_hp_3013_automute,
5970         },
5971         [ALC260_FUJITSU_S702X] = {
5972                 .mixers = { alc260_fujitsu_mixer },
5973                 .init_verbs = { alc260_fujitsu_init_verbs },
5974                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5975                 .dac_nids = alc260_dac_nids,
5976                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5977                 .adc_nids = alc260_dual_adc_nids,
5978                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5979                 .channel_mode = alc260_modes,
5980                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5981                 .input_mux = alc260_fujitsu_capture_sources,
5982         },
5983         [ALC260_ACER] = {
5984                 .mixers = { alc260_acer_mixer },
5985                 .init_verbs = { alc260_acer_init_verbs },
5986                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5987                 .dac_nids = alc260_dac_nids,
5988                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5989                 .adc_nids = alc260_dual_adc_nids,
5990                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5991                 .channel_mode = alc260_modes,
5992                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5993                 .input_mux = alc260_acer_capture_sources,
5994         },
5995         [ALC260_FAVORIT100] = {
5996                 .mixers = { alc260_favorit100_mixer },
5997                 .init_verbs = { alc260_favorit100_init_verbs },
5998                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5999                 .dac_nids = alc260_dac_nids,
6000                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6001                 .adc_nids = alc260_dual_adc_nids,
6002                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6003                 .channel_mode = alc260_modes,
6004                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6005                 .input_mux = alc260_favorit100_capture_sources,
6006         },
6007         [ALC260_WILL] = {
6008                 .mixers = { alc260_will_mixer },
6009                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
6010                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6011                 .dac_nids = alc260_dac_nids,
6012                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6013                 .adc_nids = alc260_adc_nids,
6014                 .dig_out_nid = ALC260_DIGOUT_NID,
6015                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6016                 .channel_mode = alc260_modes,
6017                 .input_mux = &alc260_capture_source,
6018         },
6019         [ALC260_REPLACER_672V] = {
6020                 .mixers = { alc260_replacer_672v_mixer },
6021                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6022                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6023                 .dac_nids = alc260_dac_nids,
6024                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6025                 .adc_nids = alc260_adc_nids,
6026                 .dig_out_nid = ALC260_DIGOUT_NID,
6027                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6028                 .channel_mode = alc260_modes,
6029                 .input_mux = &alc260_capture_source,
6030                 .unsol_event = alc260_replacer_672v_unsol_event,
6031                 .init_hook = alc260_replacer_672v_automute,
6032         },
6033 #ifdef CONFIG_SND_DEBUG
6034         [ALC260_TEST] = {
6035                 .mixers = { alc260_test_mixer },
6036                 .init_verbs = { alc260_test_init_verbs },
6037                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6038                 .dac_nids = alc260_test_dac_nids,
6039                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6040                 .adc_nids = alc260_test_adc_nids,
6041                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6042                 .channel_mode = alc260_modes,
6043                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6044                 .input_mux = alc260_test_capture_sources,
6045         },
6046 #endif
6047 };
6048
6049 static int patch_alc260(struct hda_codec *codec)
6050 {
6051         struct alc_spec *spec;
6052         int err, board_config;
6053
6054         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6055         if (spec == NULL)
6056                 return -ENOMEM;
6057
6058         codec->spec = spec;
6059
6060         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6061                                                   alc260_models,
6062                                                   alc260_cfg_tbl);
6063         if (board_config < 0) {
6064                 snd_printd(KERN_INFO "hda_codec: Unknown model for %s, "
6065                            "trying auto-probe from BIOS...\n",
6066                            codec->chip_name);
6067                 board_config = ALC260_AUTO;
6068         }
6069
6070         if (board_config == ALC260_AUTO) {
6071                 /* automatic parse from the BIOS config */
6072                 err = alc260_parse_auto_config(codec);
6073                 if (err < 0) {
6074                         alc_free(codec);
6075                         return err;
6076                 } else if (!err) {
6077                         printk(KERN_INFO
6078                                "hda_codec: Cannot set up configuration "
6079                                "from BIOS.  Using base mode...\n");
6080                         board_config = ALC260_BASIC;
6081                 }
6082         }
6083
6084         err = snd_hda_attach_beep_device(codec, 0x1);
6085         if (err < 0) {
6086                 alc_free(codec);
6087                 return err;
6088         }
6089
6090         if (board_config != ALC260_AUTO)
6091                 setup_preset(spec, &alc260_presets[board_config]);
6092
6093         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6094         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6095
6096         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6097         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6098
6099         if (!spec->adc_nids && spec->input_mux) {
6100                 /* check whether NID 0x04 is valid */
6101                 unsigned int wcap = get_wcaps(codec, 0x04);
6102                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6103                 /* get type */
6104                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6105                         spec->adc_nids = alc260_adc_nids_alt;
6106                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6107                 } else {
6108                         spec->adc_nids = alc260_adc_nids;
6109                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6110                 }
6111         }
6112         set_capture_mixer(spec);
6113         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6114
6115         spec->vmaster_nid = 0x08;
6116
6117         codec->patch_ops = alc_patch_ops;
6118         if (board_config == ALC260_AUTO)
6119                 spec->init_hook = alc260_auto_init;
6120 #ifdef CONFIG_SND_HDA_POWER_SAVE
6121         if (!spec->loopback.amplist)
6122                 spec->loopback.amplist = alc260_loopbacks;
6123 #endif
6124         codec->proc_widget_hook = print_realtek_coef;
6125
6126         return 0;
6127 }
6128
6129
6130 /*
6131  * ALC882 support
6132  *
6133  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6134  * configuration.  Each pin widget can choose any input DACs and a mixer.
6135  * Each ADC is connected from a mixer of all inputs.  This makes possible
6136  * 6-channel independent captures.
6137  *
6138  * In addition, an independent DAC for the multi-playback (not used in this
6139  * driver yet).
6140  */
6141 #define ALC882_DIGOUT_NID       0x06
6142 #define ALC882_DIGIN_NID        0x0a
6143
6144 static struct hda_channel_mode alc882_ch_modes[1] = {
6145         { 8, NULL }
6146 };
6147
6148 static hda_nid_t alc882_dac_nids[4] = {
6149         /* front, rear, clfe, rear_surr */
6150         0x02, 0x03, 0x04, 0x05
6151 };
6152
6153 /* identical with ALC880 */
6154 #define alc882_adc_nids         alc880_adc_nids
6155 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6156
6157 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6158 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6159
6160 /* input MUX */
6161 /* FIXME: should be a matrix-type input source selection */
6162
6163 static struct hda_input_mux alc882_capture_source = {
6164         .num_items = 4,
6165         .items = {
6166                 { "Mic", 0x0 },
6167                 { "Front Mic", 0x1 },
6168                 { "Line", 0x2 },
6169                 { "CD", 0x4 },
6170         },
6171 };
6172
6173 static struct hda_input_mux mb5_capture_source = {
6174         .num_items = 3,
6175         .items = {
6176                 { "Mic", 0x1 },
6177                 { "Line", 0x2 },
6178                 { "CD", 0x4 },
6179         },
6180 };
6181
6182 /*
6183  * 2ch mode
6184  */
6185 static struct hda_verb alc882_3ST_ch2_init[] = {
6186         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6187         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6188         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6189         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6190         { } /* end */
6191 };
6192
6193 /*
6194  * 6ch mode
6195  */
6196 static struct hda_verb alc882_3ST_ch6_init[] = {
6197         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6198         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6199         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6200         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6201         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6202         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6203         { } /* end */
6204 };
6205
6206 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
6207         { 2, alc882_3ST_ch2_init },
6208         { 6, alc882_3ST_ch6_init },
6209 };
6210
6211 /*
6212  * 6ch mode
6213  */
6214 static struct hda_verb alc882_sixstack_ch6_init[] = {
6215         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6216         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6217         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6218         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6219         { } /* end */
6220 };
6221
6222 /*
6223  * 8ch mode
6224  */
6225 static struct hda_verb alc882_sixstack_ch8_init[] = {
6226         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6227         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6228         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6229         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6230         { } /* end */
6231 };
6232
6233 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6234         { 6, alc882_sixstack_ch6_init },
6235         { 8, alc882_sixstack_ch8_init },
6236 };
6237
6238 /*
6239  * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
6240  */
6241
6242 /*
6243  * 2ch mode
6244  */
6245 static struct hda_verb alc885_mbp_ch2_init[] = {
6246         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6247         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6248         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6249         { } /* end */
6250 };
6251
6252 /*
6253  * 6ch mode
6254  */
6255 static struct hda_verb alc885_mbp_ch6_init[] = {
6256         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6257         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6258         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6259         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6260         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6261         { } /* end */
6262 };
6263
6264 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
6265         { 2, alc885_mbp_ch2_init },
6266         { 6, alc885_mbp_ch6_init },
6267 };
6268
6269 /*
6270  * 2ch
6271  * Speakers/Woofer/HP = Front
6272  * LineIn = Input
6273  */
6274 static struct hda_verb alc885_mb5_ch2_init[] = {
6275         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6276         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6277         { } /* end */
6278 };
6279
6280 /*
6281  * 6ch mode
6282  * Speakers/HP = Front
6283  * Woofer = LFE
6284  * LineIn = Surround
6285  */
6286 static struct hda_verb alc885_mb5_ch6_init[] = {
6287         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6288         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6289         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6290         { } /* end */
6291 };
6292
6293 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
6294         { 2, alc885_mb5_ch2_init },
6295         { 6, alc885_mb5_ch6_init },
6296 };
6297
6298 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6299  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6300  */
6301 static struct snd_kcontrol_new alc882_base_mixer[] = {
6302         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6303         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6304         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6305         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6306         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6307         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6308         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6309         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6310         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6311         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6312         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6313         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6314         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6315         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6316         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6317         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6318         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6319         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6320         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6321         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6322         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6323         { } /* end */
6324 };
6325
6326 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
6327         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6328         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6329         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
6330         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6331         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6332         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6333         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
6334         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
6335         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
6336         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
6337         { } /* end */
6338 };
6339
6340 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
6341         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6342         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6343         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6344         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
6345         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
6346         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
6347         HDA_CODEC_VOLUME("HP Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
6348         HDA_BIND_MUTE   ("HP Playback Switch", 0x0f, 0x02, HDA_INPUT),
6349         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6350         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6351         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
6352         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
6353         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
6354         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
6355         { } /* end */
6356 };
6357
6358 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
6359         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6360         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6361         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6362         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6363         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6364         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6365         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6366         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6367         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6368         { } /* end */
6369 };
6370
6371 static struct snd_kcontrol_new alc882_targa_mixer[] = {
6372         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6373         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6374         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6375         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6376         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6377         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6378         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6379         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6380         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6381         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6382         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6383         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6384         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6385         { } /* end */
6386 };
6387
6388 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
6389  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
6390  */
6391 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
6392         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6393         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6394         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6395         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
6396         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6397         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6398         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6399         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6400         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
6401         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
6402         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6403         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6404         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6405         { } /* end */
6406 };
6407
6408 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
6409         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6410         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6411         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6412         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6413         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6414         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6415         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6416         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6417         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6418         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6419         { } /* end */
6420 };
6421
6422 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
6423         {
6424                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6425                 .name = "Channel Mode",
6426                 .info = alc_ch_mode_info,
6427                 .get = alc_ch_mode_get,
6428                 .put = alc_ch_mode_put,
6429         },
6430         { } /* end */
6431 };
6432
6433 static struct hda_verb alc882_init_verbs[] = {
6434         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6435         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6436         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6437         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6438         /* Rear mixer */
6439         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6440         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6441         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6442         /* CLFE mixer */
6443         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6444         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6445         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6446         /* Side mixer */
6447         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6448         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6449         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6450
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         /* Rear Pin: output 1 (0x0d) */
6456         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6457         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6458         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6459         /* CLFE Pin: output 2 (0x0e) */
6460         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6461         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6462         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
6463         /* Side Pin: output 3 (0x0f) */
6464         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6465         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6466         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
6467         /* Mic (rear) pin: input vref at 80% */
6468         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6469         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6470         /* Front Mic pin: input vref at 80% */
6471         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6472         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6473         /* Line In pin: input */
6474         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6475         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6476         /* Line-2 In: Headphone output (output 0 - 0x0c) */
6477         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6478         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6479         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
6480         /* CD pin widget for input */
6481         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6482
6483         /* FIXME: use matrix-type input source selection */
6484         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6485         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6486         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6487         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6488         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6489         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6490         /* Input mixer2 */
6491         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6492         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6493         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6494         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6495         /* Input mixer3 */
6496         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6497         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6498         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6499         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6500         /* ADC1: mute amp left and right */
6501         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6502         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6503         /* ADC2: mute amp left and right */
6504         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6505         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6506         /* ADC3: mute amp left and right */
6507         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6508         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6509
6510         { }
6511 };
6512
6513 static struct hda_verb alc882_eapd_verbs[] = {
6514         /* change to EAPD mode */
6515         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6516         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
6517         { }
6518 };
6519
6520 /* Mac Pro test */
6521 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
6522         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6523         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6524         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
6525         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
6526         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
6527         /* FIXME: this looks suspicious...
6528         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
6529         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
6530         */
6531         { } /* end */
6532 };
6533
6534 static struct hda_verb alc882_macpro_init_verbs[] = {
6535         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6536         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6537         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6538         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6539         /* Front Pin: output 0 (0x0c) */
6540         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6541         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6542         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6543         /* Front Mic pin: input vref at 80% */
6544         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6545         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6546         /* Speaker:  output */
6547         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6548         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6549         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
6550         /* Headphone output (output 0 - 0x0c) */
6551         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6552         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6553         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6554
6555         /* FIXME: use matrix-type input source selection */
6556         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6557         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6558         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6559         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6560         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6561         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6562         /* Input mixer2 */
6563         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6564         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6565         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6566         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6567         /* Input mixer3 */
6568         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6569         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6570         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6571         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6572         /* ADC1: mute amp left and right */
6573         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6574         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6575         /* ADC2: mute amp left and right */
6576         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6577         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6578         /* ADC3: mute amp left and right */
6579         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6580         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6581
6582         { }
6583 };
6584
6585 /* Macbook 5,1 */
6586 static struct hda_verb alc885_mb5_init_verbs[] = {
6587         /* DACs */
6588         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6589         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6590         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6591         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6592         /* Front mixer */
6593         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6594         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6595         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6596         /* Surround mixer */
6597         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6598         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6599         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6600         /* LFE mixer */
6601         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6602         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6603         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6604         /* HP mixer */
6605         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6606         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6607         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6608         /* Front Pin (0x0c) */
6609         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
6610         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6611         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6612         /* LFE Pin (0x0e) */
6613         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
6614         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6615         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
6616         /* HP Pin (0x0f) */
6617         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6618         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6619         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
6620         /* Front Mic pin: input vref at 80% */
6621         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6622         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6623         /* Line In pin */
6624         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6625         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6626
6627         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6628         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6629         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6630         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6631         { }
6632 };
6633
6634 /* Macbook Pro rev3 */
6635 static struct hda_verb alc885_mbp3_init_verbs[] = {
6636         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6637         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6638         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6639         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6640         /* Rear mixer */
6641         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6642         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6643         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6644         /* Front Pin: output 0 (0x0c) */
6645         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6646         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6647         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6648         /* HP Pin: output 0 (0x0d) */
6649         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
6650         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6651         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6652         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6653         /* Mic (rear) pin: input vref at 80% */
6654         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6655         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6656         /* Front Mic pin: input vref at 80% */
6657         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6658         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6659         /* Line In pin: use output 1 when in LineOut mode */
6660         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6661         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6662         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
6663
6664         /* FIXME: use matrix-type input source selection */
6665         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6666         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6667         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6668         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6669         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6670         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6671         /* Input mixer2 */
6672         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6673         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6674         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6675         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6676         /* Input mixer3 */
6677         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6678         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6679         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6680         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6681         /* ADC1: mute amp left and right */
6682         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6683         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6684         /* ADC2: mute amp left and right */
6685         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6686         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6687         /* ADC3: mute amp left and right */
6688         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6689         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6690
6691         { }
6692 };
6693
6694 /* iMac 24 mixer. */
6695 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
6696         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6697         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
6698         { } /* end */
6699 };
6700
6701 /* iMac 24 init verbs. */
6702 static struct hda_verb alc885_imac24_init_verbs[] = {
6703         /* Internal speakers: output 0 (0x0c) */
6704         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6705         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6706         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6707         /* Internal speakers: output 0 (0x0c) */
6708         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6709         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6710         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
6711         /* Headphone: output 0 (0x0c) */
6712         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6713         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6714         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6715         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6716         /* Front Mic: input vref at 80% */
6717         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6718         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6719         { }
6720 };
6721
6722 /* Toggle speaker-output according to the hp-jack state */
6723 static void alc885_imac24_automute_init_hook(struct hda_codec *codec)
6724 {
6725         struct alc_spec *spec = codec->spec;
6726
6727         spec->autocfg.hp_pins[0] = 0x14;
6728         spec->autocfg.speaker_pins[0] = 0x18;
6729         spec->autocfg.speaker_pins[1] = 0x1a;
6730         alc_automute_amp(codec);
6731 }
6732
6733 static void alc885_mbp3_init_hook(struct hda_codec *codec)
6734 {
6735         struct alc_spec *spec = codec->spec;
6736
6737         spec->autocfg.hp_pins[0] = 0x15;
6738         spec->autocfg.speaker_pins[0] = 0x14;
6739         alc_automute_amp(codec);
6740 }
6741
6742
6743 static struct hda_verb alc882_targa_verbs[] = {
6744         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6745         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6746
6747         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6748         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6749
6750         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6751         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6752         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6753
6754         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6755         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6756         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
6757         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
6758         { } /* end */
6759 };
6760
6761 /* toggle speaker-output according to the hp-jack state */
6762 static void alc882_targa_automute(struct hda_codec *codec)
6763 {
6764         struct alc_spec *spec = codec->spec;
6765         alc_automute_amp(codec);
6766         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
6767                                   spec->jack_present ? 1 : 3);
6768 }
6769
6770 static void alc882_targa_init_hook(struct hda_codec *codec)
6771 {
6772         struct alc_spec *spec = codec->spec;
6773
6774         spec->autocfg.hp_pins[0] = 0x14;
6775         spec->autocfg.speaker_pins[0] = 0x1b;
6776         alc882_targa_automute(codec);
6777 }
6778
6779 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
6780 {
6781         if ((res >> 26) == ALC880_HP_EVENT)
6782                 alc882_targa_automute(codec);
6783 }
6784
6785 static struct hda_verb alc882_asus_a7j_verbs[] = {
6786         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6787         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6788
6789         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6790         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6791         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6792
6793         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6794         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6795         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6796
6797         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6798         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6799         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6800         { } /* end */
6801 };
6802
6803 static struct hda_verb alc882_asus_a7m_verbs[] = {
6804         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6805         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6806
6807         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6808         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6809         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6810
6811         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6812         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6813         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6814
6815         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6816         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6817         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6818         { } /* end */
6819 };
6820
6821 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
6822 {
6823         unsigned int gpiostate, gpiomask, gpiodir;
6824
6825         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
6826                                        AC_VERB_GET_GPIO_DATA, 0);
6827
6828         if (!muted)
6829                 gpiostate |= (1 << pin);
6830         else
6831                 gpiostate &= ~(1 << pin);
6832
6833         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
6834                                       AC_VERB_GET_GPIO_MASK, 0);
6835         gpiomask |= (1 << pin);
6836
6837         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
6838                                      AC_VERB_GET_GPIO_DIRECTION, 0);
6839         gpiodir |= (1 << pin);
6840
6841
6842         snd_hda_codec_write(codec, codec->afg, 0,
6843                             AC_VERB_SET_GPIO_MASK, gpiomask);
6844         snd_hda_codec_write(codec, codec->afg, 0,
6845                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
6846
6847         msleep(1);
6848
6849         snd_hda_codec_write(codec, codec->afg, 0,
6850                             AC_VERB_SET_GPIO_DATA, gpiostate);
6851 }
6852
6853 /* set up GPIO at initialization */
6854 static void alc885_macpro_init_hook(struct hda_codec *codec)
6855 {
6856         alc882_gpio_mute(codec, 0, 0);
6857         alc882_gpio_mute(codec, 1, 0);
6858 }
6859
6860 /* set up GPIO and update auto-muting at initialization */
6861 static void alc885_imac24_init_hook(struct hda_codec *codec)
6862 {
6863         alc885_macpro_init_hook(codec);
6864         alc885_imac24_automute_init_hook(codec);
6865 }
6866
6867 /*
6868  * generic initialization of ADC, input mixers and output mixers
6869  */
6870 static struct hda_verb alc882_auto_init_verbs[] = {
6871         /*
6872          * Unmute ADC0-2 and set the default input to mic-in
6873          */
6874         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6875         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6876         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6877         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6878         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6879         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6880
6881         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6882          * mixer widget
6883          * Note: PASD motherboards uses the Line In 2 as the input for
6884          * front panel mic (mic 2)
6885          */
6886         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6887         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6888         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6889         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6890         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6891         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6892
6893         /*
6894          * Set up output mixers (0x0c - 0x0f)
6895          */
6896         /* set vol=0 to output mixers */
6897         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6898         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6899         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6900         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6901         /* set up input amps for analog loopback */
6902         /* Amp Indices: DAC = 0, mixer = 1 */
6903         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6904         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6905         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6906         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6907         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6908         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6909         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6910         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6911         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6912         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6913
6914         /* FIXME: use matrix-type input source selection */
6915         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6916         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6917         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6918         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6919         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6920         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6921         /* Input mixer2 */
6922         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6923         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6924         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6925         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6926         /* Input mixer3 */
6927         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6928         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6929         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6930         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6931
6932         { }
6933 };
6934
6935 #ifdef CONFIG_SND_HDA_POWER_SAVE
6936 #define alc882_loopbacks        alc880_loopbacks
6937 #endif
6938
6939 /* pcm configuration: identiacal with ALC880 */
6940 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
6941 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
6942 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
6943 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
6944
6945 /*
6946  * configuration and preset
6947  */
6948 static const char *alc882_models[ALC882_MODEL_LAST] = {
6949         [ALC882_3ST_DIG]        = "3stack-dig",
6950         [ALC882_6ST_DIG]        = "6stack-dig",
6951         [ALC882_ARIMA]          = "arima",
6952         [ALC882_W2JC]           = "w2jc",
6953         [ALC882_TARGA]          = "targa",
6954         [ALC882_ASUS_A7J]       = "asus-a7j",
6955         [ALC882_ASUS_A7M]       = "asus-a7m",
6956         [ALC885_MACPRO]         = "macpro",
6957         [ALC885_MB5]            = "mb5",
6958         [ALC885_MBP3]           = "mbp3",
6959         [ALC885_IMAC24]         = "imac24",
6960         [ALC882_AUTO]           = "auto",
6961 };
6962
6963 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6964         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6965         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6966         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6967         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6968         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6969         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6970         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6971         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6972         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6973         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
6974         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6975         SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6976         {}
6977 };
6978
6979 static struct alc_config_preset alc882_presets[] = {
6980         [ALC882_3ST_DIG] = {
6981                 .mixers = { alc882_base_mixer },
6982                 .init_verbs = { alc882_init_verbs },
6983                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6984                 .dac_nids = alc882_dac_nids,
6985                 .dig_out_nid = ALC882_DIGOUT_NID,
6986                 .dig_in_nid = ALC882_DIGIN_NID,
6987                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6988                 .channel_mode = alc882_ch_modes,
6989                 .need_dac_fix = 1,
6990                 .input_mux = &alc882_capture_source,
6991         },
6992         [ALC882_6ST_DIG] = {
6993                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6994                 .init_verbs = { alc882_init_verbs },
6995                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6996                 .dac_nids = alc882_dac_nids,
6997                 .dig_out_nid = ALC882_DIGOUT_NID,
6998                 .dig_in_nid = ALC882_DIGIN_NID,
6999                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
7000                 .channel_mode = alc882_sixstack_modes,
7001                 .input_mux = &alc882_capture_source,
7002         },
7003         [ALC882_ARIMA] = {
7004                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
7005                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
7006                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
7007                 .dac_nids = alc882_dac_nids,
7008                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
7009                 .channel_mode = alc882_sixstack_modes,
7010                 .input_mux = &alc882_capture_source,
7011         },
7012         [ALC882_W2JC] = {
7013                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
7014                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
7015                                 alc880_gpio1_init_verbs },
7016                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
7017                 .dac_nids = alc882_dac_nids,
7018                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
7019                 .channel_mode = alc880_threestack_modes,
7020                 .need_dac_fix = 1,
7021                 .input_mux = &alc882_capture_source,
7022                 .dig_out_nid = ALC882_DIGOUT_NID,
7023         },
7024         [ALC885_MBP3] = {
7025                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
7026                 .init_verbs = { alc885_mbp3_init_verbs,
7027                                 alc880_gpio1_init_verbs },
7028                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
7029                 .dac_nids = alc882_dac_nids,
7030                 .channel_mode = alc885_mbp_6ch_modes,
7031                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
7032                 .input_mux = &alc882_capture_source,
7033                 .dig_out_nid = ALC882_DIGOUT_NID,
7034                 .dig_in_nid = ALC882_DIGIN_NID,
7035                 .unsol_event = alc_automute_amp_unsol_event,
7036                 .init_hook = alc885_mbp3_init_hook,
7037         },
7038         [ALC885_MB5] = {
7039                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
7040                 .init_verbs = { alc885_mb5_init_verbs,
7041                                 alc880_gpio1_init_verbs },
7042                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
7043                 .dac_nids = alc882_dac_nids,
7044                 .channel_mode = alc885_mb5_6ch_modes,
7045                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
7046                 .input_mux = &mb5_capture_source,
7047                 .dig_out_nid = ALC882_DIGOUT_NID,
7048                 .dig_in_nid = ALC882_DIGIN_NID,
7049         },
7050         [ALC885_MACPRO] = {
7051                 .mixers = { alc882_macpro_mixer },
7052                 .init_verbs = { alc882_macpro_init_verbs },
7053                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
7054                 .dac_nids = alc882_dac_nids,
7055                 .dig_out_nid = ALC882_DIGOUT_NID,
7056                 .dig_in_nid = ALC882_DIGIN_NID,
7057                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
7058                 .channel_mode = alc882_ch_modes,
7059                 .input_mux = &alc882_capture_source,
7060                 .init_hook = alc885_macpro_init_hook,
7061         },
7062         [ALC885_IMAC24] = {
7063                 .mixers = { alc885_imac24_mixer },
7064                 .init_verbs = { alc885_imac24_init_verbs },
7065                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
7066                 .dac_nids = alc882_dac_nids,
7067                 .dig_out_nid = ALC882_DIGOUT_NID,
7068                 .dig_in_nid = ALC882_DIGIN_NID,
7069                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
7070                 .channel_mode = alc882_ch_modes,
7071                 .input_mux = &alc882_capture_source,
7072                 .unsol_event = alc_automute_amp_unsol_event,
7073                 .init_hook = alc885_imac24_init_hook,
7074         },
7075         [ALC882_TARGA] = {
7076                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
7077                 .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
7078                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
7079                 .dac_nids = alc882_dac_nids,
7080                 .dig_out_nid = ALC882_DIGOUT_NID,
7081                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
7082                 .adc_nids = alc882_adc_nids,
7083                 .capsrc_nids = alc882_capsrc_nids,
7084                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
7085                 .channel_mode = alc882_3ST_6ch_modes,
7086                 .need_dac_fix = 1,
7087                 .input_mux = &alc882_capture_source,
7088                 .unsol_event = alc882_targa_unsol_event,
7089                 .init_hook = alc882_targa_init_hook,
7090         },
7091         [ALC882_ASUS_A7J] = {
7092                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
7093                 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
7094                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
7095                 .dac_nids = alc882_dac_nids,
7096                 .dig_out_nid = ALC882_DIGOUT_NID,
7097                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
7098                 .adc_nids = alc882_adc_nids,
7099                 .capsrc_nids = alc882_capsrc_nids,
7100                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
7101                 .channel_mode = alc882_3ST_6ch_modes,
7102                 .need_dac_fix = 1,
7103                 .input_mux = &alc882_capture_source,
7104         },
7105         [ALC882_ASUS_A7M] = {
7106                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
7107                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
7108                                 alc880_gpio1_init_verbs,
7109                                 alc882_asus_a7m_verbs },
7110                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
7111                 .dac_nids = alc882_dac_nids,
7112                 .dig_out_nid = ALC882_DIGOUT_NID,
7113                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
7114                 .channel_mode = alc880_threestack_modes,
7115                 .need_dac_fix = 1,
7116                 .input_mux = &alc882_capture_source,
7117         },
7118 };
7119
7120
7121 /*
7122  * Pin config fixes
7123  */
7124 enum {
7125         PINFIX_ABIT_AW9D_MAX
7126 };
7127
7128 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
7129         { 0x15, 0x01080104 }, /* side */
7130         { 0x16, 0x01011012 }, /* rear */
7131         { 0x17, 0x01016011 }, /* clfe */
7132         { }
7133 };
7134
7135 static const struct alc_pincfg *alc882_pin_fixes[] = {
7136         [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
7137 };
7138
7139 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
7140         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
7141         {}
7142 };
7143
7144 /*
7145  * BIOS auto configuration
7146  */
7147 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
7148                                               hda_nid_t nid, int pin_type,
7149                                               int dac_idx)
7150 {
7151         /* set as output */
7152         struct alc_spec *spec = codec->spec;
7153         int idx;
7154
7155         alc_set_pin_output(codec, nid, pin_type);
7156         if (spec->multiout.dac_nids[dac_idx] == 0x25)
7157                 idx = 4;
7158         else
7159                 idx = spec->multiout.dac_nids[dac_idx] - 2;
7160         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
7161
7162 }
7163
7164 static void alc882_auto_init_multi_out(struct hda_codec *codec)
7165 {
7166         struct alc_spec *spec = codec->spec;
7167         int i;
7168
7169         for (i = 0; i <= HDA_SIDE; i++) {
7170                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
7171                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
7172                 if (nid)
7173                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
7174                                                           i);
7175         }
7176 }
7177
7178 static void alc882_auto_init_hp_out(struct hda_codec *codec)
7179 {
7180         struct alc_spec *spec = codec->spec;
7181         hda_nid_t pin;
7182
7183         pin = spec->autocfg.hp_pins[0];
7184         if (pin) /* connect to front */
7185                 /* use dac 0 */
7186                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
7187         pin = spec->autocfg.speaker_pins[0];
7188         if (pin)
7189                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
7190 }
7191
7192 #define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
7193 #define ALC882_PIN_CD_NID               ALC880_PIN_CD_NID
7194
7195 static void alc882_auto_init_analog_input(struct hda_codec *codec)
7196 {
7197         struct alc_spec *spec = codec->spec;
7198         int i;
7199
7200         for (i = 0; i < AUTO_PIN_LAST; i++) {
7201                 hda_nid_t nid = spec->autocfg.input_pins[i];
7202                 if (!nid)
7203                         continue;
7204                 alc_set_input_pin(codec, nid, AUTO_PIN_FRONT_MIC /*i*/);
7205                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
7206                         snd_hda_codec_write(codec, nid, 0,
7207                                             AC_VERB_SET_AMP_GAIN_MUTE,
7208                                             AMP_OUT_MUTE);
7209         }
7210 }
7211
7212 static void alc882_auto_init_input_src(struct hda_codec *codec)
7213 {
7214         struct alc_spec *spec = codec->spec;
7215         int c;
7216
7217         for (c = 0; c < spec->num_adc_nids; c++) {
7218                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
7219                 hda_nid_t nid = spec->capsrc_nids[c];
7220                 unsigned int mux_idx;
7221                 const struct hda_input_mux *imux;
7222                 int conns, mute, idx, item;
7223
7224                 conns = snd_hda_get_connections(codec, nid, conn_list,
7225                                                 ARRAY_SIZE(conn_list));
7226                 if (conns < 0)
7227                         continue;
7228                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
7229                 imux = &spec->input_mux[mux_idx];
7230                 for (idx = 0; idx < conns; idx++) {
7231                         /* if the current connection is the selected one,
7232                          * unmute it as default - otherwise mute it
7233                          */
7234                         mute = AMP_IN_MUTE(idx);
7235                         for (item = 0; item < imux->num_items; item++) {
7236                                 if (imux->items[item].index == idx) {
7237                                         if (spec->cur_mux[c] == item)
7238                                                 mute = AMP_IN_UNMUTE(idx);
7239                                         break;
7240                                 }
7241                         }
7242                         /* check if we have a selector or mixer
7243                          * we could check for the widget type instead, but
7244                          * just check for Amp-In presence (in case of mixer
7245                          * without amp-in there is something wrong, this
7246                          * function shouldn't be used or capsrc nid is wrong)
7247                          */
7248                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
7249                                 snd_hda_codec_write(codec, nid, 0,
7250                                                     AC_VERB_SET_AMP_GAIN_MUTE,
7251                                                     mute);
7252                         else if (mute != AMP_IN_MUTE(idx))
7253                                 snd_hda_codec_write(codec, nid, 0,
7254                                                     AC_VERB_SET_CONNECT_SEL,
7255                                                     idx);
7256                 }
7257         }
7258 }
7259
7260 /* add mic boosts if needed */
7261 static int alc_auto_add_mic_boost(struct hda_codec *codec)
7262 {
7263         struct alc_spec *spec = codec->spec;
7264         int err;
7265         hda_nid_t nid;
7266
7267         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
7268         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
7269                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
7270                                   "Mic Boost",
7271                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
7272                 if (err < 0)
7273                         return err;
7274         }
7275         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
7276         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
7277                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
7278                                   "Front Mic Boost",
7279                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
7280                 if (err < 0)
7281                         return err;
7282         }
7283         return 0;
7284 }
7285
7286 /* almost identical with ALC880 parser... */
7287 static int alc882_parse_auto_config(struct hda_codec *codec)
7288 {
7289         struct alc_spec *spec = codec->spec;
7290         int err = alc880_parse_auto_config(codec);
7291
7292         if (err < 0)
7293                 return err;
7294         else if (!err)
7295                 return 0; /* no config found */
7296
7297         err = alc_auto_add_mic_boost(codec);
7298         if (err < 0)
7299                 return err;
7300
7301         /* hack - override the init verbs */
7302         spec->init_verbs[0] = alc882_auto_init_verbs;
7303
7304         return 1; /* config found */
7305 }
7306
7307 /* additional initialization for auto-configuration model */
7308 static void alc882_auto_init(struct hda_codec *codec)
7309 {
7310         struct alc_spec *spec = codec->spec;
7311         alc882_auto_init_multi_out(codec);
7312         alc882_auto_init_hp_out(codec);
7313         alc882_auto_init_analog_input(codec);
7314         alc882_auto_init_input_src(codec);
7315         if (spec->unsol_event)
7316                 alc_inithook(codec);
7317 }
7318
7319 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
7320
7321 static int patch_alc882(struct hda_codec *codec)
7322 {
7323         struct alc_spec *spec;
7324         int err, board_config;
7325
7326         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7327         if (spec == NULL)
7328                 return -ENOMEM;
7329
7330         codec->spec = spec;
7331
7332         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
7333                                                   alc882_models,
7334                                                   alc882_cfg_tbl);
7335
7336         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
7337                 /* Pick up systems that don't supply PCI SSID */
7338                 switch (codec->subsystem_id) {
7339                 case 0x106b0c00: /* Mac Pro */
7340                         board_config = ALC885_MACPRO;
7341                         break;
7342                 case 0x106b1000: /* iMac 24 */
7343                 case 0x106b2800: /* AppleTV */
7344                 case 0x106b3e00: /* iMac 24 Aluminium */
7345                         board_config = ALC885_IMAC24;
7346                         break;
7347                 case 0x106b00a0: /* MacBookPro3,1 - Another revision */
7348                 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
7349                 case 0x106b00a4: /* MacbookPro4,1 */
7350                 case 0x106b2c00: /* Macbook Pro rev3 */
7351                 /* Macbook 3.1 (0x106b3600) is handled by patch_alc883() */
7352                 case 0x106b3800: /* MacbookPro4,1 - latter revision */
7353                         board_config = ALC885_MBP3;
7354                         break;
7355                 case 0x106b3f00: /* Macbook 5,1 */
7356                 case 0x106b4000: /* Macbook Pro 5,1 - FIXME: HP jack sense
7357                                   *   seems not working, so apparently
7358                                   *   no perfect solution yet
7359                                   */
7360                         board_config = ALC885_MB5;
7361                         break;
7362                 default:
7363                         /* ALC889A is handled better as ALC888-compatible */
7364                         if (codec->revision_id == 0x100101 ||
7365                             codec->revision_id == 0x100103) {
7366                                 alc_free(codec);
7367                                 return patch_alc883(codec);
7368                         }
7369                         printk(KERN_INFO "hda_codec: Unknown model for %s, "
7370                                "trying auto-probe from BIOS...\n",
7371                                codec->chip_name);
7372                         board_config = ALC882_AUTO;
7373                 }
7374         }
7375
7376         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
7377
7378         if (board_config == ALC882_AUTO) {
7379                 /* automatic parse from the BIOS config */
7380                 err = alc882_parse_auto_config(codec);
7381                 if (err < 0) {
7382                         alc_free(codec);
7383                         return err;
7384                 } else if (!err) {
7385                         printk(KERN_INFO
7386                                "hda_codec: Cannot set up configuration "
7387                                "from BIOS.  Using base mode...\n");
7388                         board_config = ALC882_3ST_DIG;
7389                 }
7390         }
7391
7392         err = snd_hda_attach_beep_device(codec, 0x1);
7393         if (err < 0) {
7394                 alc_free(codec);
7395                 return err;
7396         }
7397
7398         if (board_config != ALC882_AUTO)
7399                 setup_preset(spec, &alc882_presets[board_config]);
7400
7401         spec->stream_analog_playback = &alc882_pcm_analog_playback;
7402         spec->stream_analog_capture = &alc882_pcm_analog_capture;
7403         /* FIXME: setup DAC5 */
7404         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
7405         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
7406
7407         spec->stream_digital_playback = &alc882_pcm_digital_playback;
7408         spec->stream_digital_capture = &alc882_pcm_digital_capture;
7409
7410         spec->capture_style = CAPT_MIX; /* matrix-style capture */
7411         if (!spec->adc_nids && spec->input_mux) {
7412                 /* check whether NID 0x07 is valid */
7413                 unsigned int wcap = get_wcaps(codec, 0x07);
7414                 /* get type */
7415                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
7416                 if (wcap != AC_WID_AUD_IN) {
7417                         spec->adc_nids = alc882_adc_nids_alt;
7418                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
7419                         spec->capsrc_nids = alc882_capsrc_nids_alt;
7420                 } else {
7421                         spec->adc_nids = alc882_adc_nids;
7422                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
7423                         spec->capsrc_nids = alc882_capsrc_nids;
7424                 }
7425         }
7426         set_capture_mixer(spec);
7427         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
7428
7429         spec->vmaster_nid = 0x0c;
7430
7431         codec->patch_ops = alc_patch_ops;
7432         if (board_config == ALC882_AUTO)
7433                 spec->init_hook = alc882_auto_init;
7434 #ifdef CONFIG_SND_HDA_POWER_SAVE
7435         if (!spec->loopback.amplist)
7436                 spec->loopback.amplist = alc882_loopbacks;
7437 #endif
7438         codec->proc_widget_hook = print_realtek_coef;
7439
7440         return 0;
7441 }
7442
7443 /*
7444  * ALC883 support
7445  *
7446  * ALC883 is almost identical with ALC880 but has cleaner and more flexible
7447  * configuration.  Each pin widget can choose any input DACs and a mixer.
7448  * Each ADC is connected from a mixer of all inputs.  This makes possible
7449  * 6-channel independent captures.
7450  *
7451  * In addition, an independent DAC for the multi-playback (not used in this
7452  * driver yet).
7453  */
7454 #define ALC883_DIGOUT_NID       0x06
7455 #define ALC883_DIGIN_NID        0x0a
7456
7457 #define ALC1200_DIGOUT_NID      0x10
7458
7459 static hda_nid_t alc883_dac_nids[4] = {
7460         /* front, rear, clfe, rear_surr */
7461         0x02, 0x03, 0x04, 0x05
7462 };
7463
7464 static hda_nid_t alc883_adc_nids[2] = {
7465         /* ADC1-2 */
7466         0x08, 0x09,
7467 };
7468
7469 static hda_nid_t alc883_adc_nids_alt[1] = {
7470         /* ADC1 */
7471         0x08,
7472 };
7473
7474 static hda_nid_t alc883_adc_nids_rev[2] = {
7475         /* ADC2-1 */
7476         0x09, 0x08
7477 };
7478
7479 #define alc889_adc_nids         alc880_adc_nids
7480
7481 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
7482
7483 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7484
7485 #define alc889_capsrc_nids      alc882_capsrc_nids
7486
7487 /* input MUX */
7488 /* FIXME: should be a matrix-type input source selection */
7489
7490 static struct hda_input_mux alc883_capture_source = {
7491         .num_items = 4,
7492         .items = {
7493                 { "Mic", 0x0 },
7494                 { "Front Mic", 0x1 },
7495                 { "Line", 0x2 },
7496                 { "CD", 0x4 },
7497         },
7498 };
7499
7500 static struct hda_input_mux alc883_3stack_6ch_intel = {
7501         .num_items = 4,
7502         .items = {
7503                 { "Mic", 0x1 },
7504                 { "Front Mic", 0x0 },
7505                 { "Line", 0x2 },
7506                 { "CD", 0x4 },
7507         },
7508 };
7509
7510 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7511         .num_items = 2,
7512         .items = {
7513                 { "Mic", 0x1 },
7514                 { "Line", 0x2 },
7515         },
7516 };
7517
7518 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7519         .num_items = 4,
7520         .items = {
7521                 { "Mic", 0x0 },
7522                 { "iMic", 0x1 },
7523                 { "Line", 0x2 },
7524                 { "CD", 0x4 },
7525         },
7526 };
7527
7528 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7529         .num_items = 2,
7530         .items = {
7531                 { "Mic", 0x0 },
7532                 { "Int Mic", 0x1 },
7533         },
7534 };
7535
7536 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7537         .num_items = 3,
7538         .items = {
7539                 { "Mic", 0x0 },
7540                 { "Front Mic", 0x1 },
7541                 { "Line", 0x4 },
7542         },
7543 };
7544
7545 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7546         .num_items = 2,
7547         .items = {
7548                 { "Mic", 0x0 },
7549                 { "Line", 0x2 },
7550         },
7551 };
7552
7553 static struct hda_input_mux alc889A_mb31_capture_source = {
7554         .num_items = 2,
7555         .items = {
7556                 { "Mic", 0x0 },
7557                 /* Front Mic (0x01) unused */
7558                 { "Line", 0x2 },
7559                 /* Line 2 (0x03) unused */
7560                 /* CD (0x04) unsused? */
7561         },
7562 };
7563
7564 /*
7565  * 2ch mode
7566  */
7567 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7568         { 2, NULL }
7569 };
7570
7571 /*
7572  * 2ch mode
7573  */
7574 static struct hda_verb alc883_3ST_ch2_init[] = {
7575         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7576         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7577         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7578         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7579         { } /* end */
7580 };
7581
7582 /*
7583  * 4ch mode
7584  */
7585 static struct hda_verb alc883_3ST_ch4_init[] = {
7586         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7587         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7588         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7589         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7590         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7591         { } /* end */
7592 };
7593
7594 /*
7595  * 6ch mode
7596  */
7597 static struct hda_verb alc883_3ST_ch6_init[] = {
7598         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7599         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7600         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7601         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7602         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7603         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7604         { } /* end */
7605 };
7606
7607 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
7608         { 2, alc883_3ST_ch2_init },
7609         { 4, alc883_3ST_ch4_init },
7610         { 6, alc883_3ST_ch6_init },
7611 };
7612
7613 /*
7614  * 2ch mode
7615  */
7616 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7617         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7618         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7619         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7620         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7621         { } /* end */
7622 };
7623
7624 /*
7625  * 4ch mode
7626  */
7627 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7628         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7629         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7630         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7631         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7632         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7633         { } /* end */
7634 };
7635
7636 /*
7637  * 6ch mode
7638  */
7639 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7640         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7641         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7642         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7643         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7644         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7645         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7646         { } /* end */
7647 };
7648
7649 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7650         { 2, alc883_3ST_ch2_intel_init },
7651         { 4, alc883_3ST_ch4_intel_init },
7652         { 6, alc883_3ST_ch6_intel_init },
7653 };
7654
7655 /*
7656  * 6ch mode
7657  */
7658 static struct hda_verb alc883_sixstack_ch6_init[] = {
7659         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7660         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7661         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7662         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7663         { } /* end */
7664 };
7665
7666 /*
7667  * 8ch mode
7668  */
7669 static struct hda_verb alc883_sixstack_ch8_init[] = {
7670         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7671         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7672         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7673         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7674         { } /* end */
7675 };
7676
7677 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7678         { 6, alc883_sixstack_ch6_init },
7679         { 8, alc883_sixstack_ch8_init },
7680 };
7681
7682 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
7683 static struct hda_verb alc889A_mb31_ch2_init[] = {
7684         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7685         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7686         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7687         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7688         { } /* end */
7689 };
7690
7691 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
7692 static struct hda_verb alc889A_mb31_ch4_init[] = {
7693         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7694         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7695         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7696         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7697         { } /* end */
7698 };
7699
7700 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
7701 static struct hda_verb alc889A_mb31_ch5_init[] = {
7702         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
7703         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7704         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7705         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7706         { } /* end */
7707 };
7708
7709 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
7710 static struct hda_verb alc889A_mb31_ch6_init[] = {
7711         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
7712         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
7713         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7714         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7715         { } /* end */
7716 };
7717
7718 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
7719         { 2, alc889A_mb31_ch2_init },
7720         { 4, alc889A_mb31_ch4_init },
7721         { 5, alc889A_mb31_ch5_init },
7722         { 6, alc889A_mb31_ch6_init },
7723 };
7724
7725 static struct hda_verb alc883_medion_eapd_verbs[] = {
7726         /* eanable EAPD on medion laptop */
7727         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7728         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7729         { }
7730 };
7731
7732 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7733  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7734  */
7735
7736 static struct snd_kcontrol_new alc883_base_mixer[] = {
7737         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7738         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7739         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7740         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7741         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7742         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7743         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7744         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7745         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7746         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7747         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7748         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7749         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7750         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7751         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7752         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7753         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7754         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7755         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7756         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7757         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7758         { } /* end */
7759 };
7760
7761 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7762         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7763         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7764         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7765         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7766         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7767         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7768         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7769         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7770         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7771         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7772         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7773         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7774         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7775         { } /* end */
7776 };
7777
7778 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7779         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7780         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7781         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7782         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7783         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7784         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7785         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7786         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7787         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7788         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7789         { } /* end */
7790 };
7791
7792 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7793         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7794         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7795         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7796         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7797         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7798         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7799         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7800         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7801         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7802         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7803         { } /* end */
7804 };
7805
7806 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7807         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7808         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7809         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7810         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7811         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7812         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7813         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7814         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7815         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7816         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7817         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7818         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7819         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7820         { } /* end */
7821 };
7822
7823 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7824         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7825         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7826         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7827         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7828         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7829         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7830         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7831         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7832         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7833         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7834         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7835         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7836         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7837         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7838         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7839         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7840         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7841         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7842         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7843         { } /* end */
7844 };
7845
7846 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7847         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7848         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7849         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7850         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7851         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7852                               HDA_OUTPUT),
7853         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7854         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7855         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7856         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7857         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7858         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7859         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7860         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7861         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7862         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7863         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7864         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7865         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7866         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7867         { } /* end */
7868 };
7869
7870 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7871         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7872         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7873         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7874         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7875         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7876         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7877         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7878         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7879         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7880         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7881         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7882         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7883         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7884         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7885         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7886         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7887         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7888         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7889         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7890         { } /* end */
7891 };
7892
7893 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7894         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7895         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7896         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7897         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7898         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7899         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7900         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7901         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7902         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7903         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7904         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7905         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7906         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7907         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7908         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7909         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7910         { } /* end */
7911 };
7912
7913 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7914         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7915         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7916         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7917         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7918         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7919         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7920         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7921         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7922         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7923         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7924         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7925         { } /* end */
7926 };
7927
7928 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7929         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7930         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7931         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7932         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7933         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7934         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7935         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7936         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7937         { } /* end */
7938 };
7939
7940 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7941         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7942         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7943         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7944         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7945         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7946         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7947         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7948         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7949         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7950         { } /* end */
7951 };
7952
7953 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7954         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7955         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7956         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7957         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7958         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7959         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7960         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7961         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7962         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7963         { } /* end */
7964 };
7965
7966 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7967         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7968         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7969         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7970         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7971         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7972         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7973         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7974         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7975         { } /* end */
7976 };
7977
7978 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7979         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7980         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7981         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7982         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7983         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7984                                                 0x0d, 1, 0x0, HDA_OUTPUT),
7985         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7986         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7987         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7988         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7989         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7990         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7991         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7992         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7993         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7994         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7995         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7996         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7997         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7998         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7999         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8000         { } /* end */
8001 };
8002
8003 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
8004         /* Output mixers */
8005         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8006         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8007         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8008         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8009         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
8010                 HDA_OUTPUT),
8011         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
8012         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
8013         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
8014         /* Output switches */
8015         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
8016         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
8017         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
8018         /* Boost mixers */
8019         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
8020         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
8021         /* Input mixers */
8022         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8023         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8024         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8025         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8026         { } /* end */
8027 };
8028
8029 static struct hda_bind_ctls alc883_bind_cap_vol = {
8030         .ops = &snd_hda_bind_vol,
8031         .values = {
8032                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8033                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8034                 0
8035         },
8036 };
8037
8038 static struct hda_bind_ctls alc883_bind_cap_switch = {
8039         .ops = &snd_hda_bind_sw,
8040         .values = {
8041                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8042                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8043                 0
8044         },
8045 };
8046
8047 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
8048         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8049         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8050         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8051         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8052         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8053         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8054         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8055         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8056         { } /* end */
8057 };
8058
8059 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
8060         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
8061         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
8062         {
8063                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8064                 /* .name = "Capture Source", */
8065                 .name = "Input Source",
8066                 .count = 1,
8067                 .info = alc_mux_enum_info,
8068                 .get = alc_mux_enum_get,
8069                 .put = alc_mux_enum_put,
8070         },
8071         { } /* end */
8072 };
8073
8074 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
8075         {
8076                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8077                 .name = "Channel Mode",
8078                 .info = alc_ch_mode_info,
8079                 .get = alc_ch_mode_get,
8080                 .put = alc_ch_mode_put,
8081         },
8082         { } /* end */
8083 };
8084
8085 static struct hda_verb alc883_init_verbs[] = {
8086         /* ADC1: mute amp left and right */
8087         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8088         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8089         /* ADC2: mute amp left and right */
8090         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8091         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8092         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8093         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8094         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8095         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8096         /* Rear mixer */
8097         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8098         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8099         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8100         /* CLFE mixer */
8101         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8102         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8103         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8104         /* Side mixer */
8105         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8106         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8107         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8108
8109         /* mute analog input loopbacks */
8110         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8111         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8112         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8113         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8114         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8115
8116         /* Front Pin: output 0 (0x0c) */
8117         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8118         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8119         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8120         /* Rear Pin: output 1 (0x0d) */
8121         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8122         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8123         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8124         /* CLFE Pin: output 2 (0x0e) */
8125         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8126         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8127         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8128         /* Side Pin: output 3 (0x0f) */
8129         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8130         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8131         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8132         /* Mic (rear) pin: input vref at 80% */
8133         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8134         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8135         /* Front Mic pin: input vref at 80% */
8136         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8137         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8138         /* Line In pin: input */
8139         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8140         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8141         /* Line-2 In: Headphone output (output 0 - 0x0c) */
8142         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8143         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8144         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8145         /* CD pin widget for input */
8146         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8147
8148         /* FIXME: use matrix-type input source selection */
8149         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8150         /* Input mixer2 */
8151         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8152         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8153         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8154         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8155         /* Input mixer3 */
8156         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8157         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8158         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8159         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8160         { }
8161 };
8162
8163 /* toggle speaker-output according to the hp-jack state */
8164 static void alc883_mitac_init_hook(struct hda_codec *codec)
8165 {
8166         struct alc_spec *spec = codec->spec;
8167
8168         spec->autocfg.hp_pins[0] = 0x15;
8169         spec->autocfg.speaker_pins[0] = 0x14;
8170         spec->autocfg.speaker_pins[1] = 0x17;
8171         alc_automute_amp(codec);
8172 }
8173
8174 /* auto-toggle front mic */
8175 /*
8176 static void alc883_mitac_mic_automute(struct hda_codec *codec)
8177 {
8178         unsigned int present;
8179         unsigned char bits;
8180
8181         present = snd_hda_codec_read(codec, 0x18, 0,
8182                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8183         bits = present ? HDA_AMP_MUTE : 0;
8184         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
8185 }
8186 */
8187
8188 static struct hda_verb alc883_mitac_verbs[] = {
8189         /* HP */
8190         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8191         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8192         /* Subwoofer */
8193         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8194         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8195
8196         /* enable unsolicited event */
8197         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8198         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8199
8200         { } /* end */
8201 };
8202
8203 static struct hda_verb alc883_clevo_m720_verbs[] = {
8204         /* HP */
8205         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8206         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8207         /* Int speaker */
8208         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
8209         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8210
8211         /* enable unsolicited event */
8212         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8213         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8214
8215         { } /* end */
8216 };
8217
8218 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8219         /* HP */
8220         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8221         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8222         /* Subwoofer */
8223         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8224         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8225
8226         /* enable unsolicited event */
8227         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8228
8229         { } /* end */
8230 };
8231
8232 static struct hda_verb alc883_tagra_verbs[] = {
8233         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8234         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8235
8236         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8237         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8238
8239         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8240         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8241         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8242
8243         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8244         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
8245         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
8246         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
8247
8248         { } /* end */
8249 };
8250
8251 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8252         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8253         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8254         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8255         { } /* end */
8256 };
8257
8258 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8259         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8260         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8261         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8262         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8263         { } /* end */
8264 };
8265
8266 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8267         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8268         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8269         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8270         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8271         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8272         { } /* end */
8273 };
8274
8275 static struct hda_verb alc883_haier_w66_verbs[] = {
8276         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8277         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8278
8279         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8280
8281         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8282         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8283         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8284         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8285         { } /* end */
8286 };
8287
8288 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8289         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8290         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8291         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8292         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8293         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8294         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8295         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8296         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8297         { } /* end */
8298 };
8299
8300 static struct hda_verb alc888_6st_dell_verbs[] = {
8301         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8302         { }
8303 };
8304
8305 static void alc888_3st_hp_init_hook(struct hda_codec *codec)
8306 {
8307         struct alc_spec *spec = codec->spec;
8308
8309         spec->autocfg.hp_pins[0] = 0x1b;
8310         spec->autocfg.speaker_pins[0] = 0x14;
8311         spec->autocfg.speaker_pins[1] = 0x16;
8312         spec->autocfg.speaker_pins[2] = 0x18;
8313         alc_automute_amp(codec);
8314 }
8315
8316 static struct hda_verb alc888_3st_hp_verbs[] = {
8317         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8318         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8319         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8320         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8321         { } /* end */
8322 };
8323
8324 /*
8325  * 2ch mode
8326  */
8327 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8328         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8329         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8330         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8331         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8332         { } /* end */
8333 };
8334
8335 /*
8336  * 4ch mode
8337  */
8338 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8339         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8340         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8341         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8342         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8343         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8344         { } /* end */
8345 };
8346
8347 /*
8348  * 6ch mode
8349  */
8350 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8351         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8352         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8353         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8354         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8355         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8356         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8357         { } /* end */
8358 };
8359
8360 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8361         { 2, alc888_3st_hp_2ch_init },
8362         { 4, alc888_3st_hp_4ch_init },
8363         { 6, alc888_3st_hp_6ch_init },
8364 };
8365
8366 /* toggle front-jack and RCA according to the hp-jack state */
8367 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8368 {
8369         unsigned int present;
8370
8371         present = snd_hda_codec_read(codec, 0x1b, 0,
8372                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8373         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8374                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8375         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8376                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8377 }
8378
8379 /* toggle RCA according to the front-jack state */
8380 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8381 {
8382         unsigned int present;
8383
8384         present = snd_hda_codec_read(codec, 0x14, 0,
8385                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8386         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8387                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8388 }
8389
8390 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8391                                              unsigned int res)
8392 {
8393         if ((res >> 26) == ALC880_HP_EVENT)
8394                 alc888_lenovo_ms7195_front_automute(codec);
8395         if ((res >> 26) == ALC880_FRONT_EVENT)
8396                 alc888_lenovo_ms7195_rca_automute(codec);
8397 }
8398
8399 static struct hda_verb alc883_medion_md2_verbs[] = {
8400         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8401         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8402
8403         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8404
8405         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8406         { } /* end */
8407 };
8408
8409 /* toggle speaker-output according to the hp-jack state */
8410 static void alc883_medion_md2_init_hook(struct hda_codec *codec)
8411 {
8412         struct alc_spec *spec = codec->spec;
8413
8414         spec->autocfg.hp_pins[0] = 0x14;
8415         spec->autocfg.speaker_pins[0] = 0x15;
8416         alc_automute_amp(codec);
8417 }
8418
8419 /* toggle speaker-output according to the hp-jack state */
8420 #define alc883_tagra_init_hook          alc882_targa_init_hook
8421 #define alc883_tagra_unsol_event        alc882_targa_unsol_event
8422
8423 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8424 {
8425         unsigned int present;
8426
8427         present = snd_hda_codec_read(codec, 0x18, 0,
8428                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8429         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8430                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8431 }
8432
8433 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8434 {
8435         struct alc_spec *spec = codec->spec;
8436
8437         spec->autocfg.hp_pins[0] = 0x15;
8438         spec->autocfg.speaker_pins[0] = 0x14;
8439         alc_automute_amp(codec);
8440         alc883_clevo_m720_mic_automute(codec);
8441 }
8442
8443 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8444                                            unsigned int res)
8445 {
8446         switch (res >> 26) {
8447         case ALC880_MIC_EVENT:
8448                 alc883_clevo_m720_mic_automute(codec);
8449                 break;
8450         default:
8451                 alc_automute_amp_unsol_event(codec, res);
8452                 break;
8453         }
8454 }
8455
8456 /* toggle speaker-output according to the hp-jack state */
8457 static void alc883_2ch_fujitsu_pi2515_init_hook(struct hda_codec *codec)
8458 {
8459         struct alc_spec *spec = codec->spec;
8460
8461         spec->autocfg.hp_pins[0] = 0x14;
8462         spec->autocfg.speaker_pins[0] = 0x15;
8463         alc_automute_amp(codec);
8464 }
8465
8466 static void alc883_haier_w66_init_hook(struct hda_codec *codec)
8467 {
8468         struct alc_spec *spec = codec->spec;
8469
8470         spec->autocfg.hp_pins[0] = 0x1b;
8471         spec->autocfg.speaker_pins[0] = 0x14;
8472         alc_automute_amp(codec);
8473 }
8474
8475 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8476 {
8477         unsigned int present;
8478         unsigned char bits;
8479
8480         present = snd_hda_codec_read(codec, 0x14, 0,
8481                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8482         bits = present ? HDA_AMP_MUTE : 0;
8483         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8484                                  HDA_AMP_MUTE, bits);
8485 }
8486
8487 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8488 {
8489         unsigned int present;
8490         unsigned char bits;
8491
8492         present = snd_hda_codec_read(codec, 0x1b, 0,
8493                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8494         bits = present ? HDA_AMP_MUTE : 0;
8495         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8496                                  HDA_AMP_MUTE, bits);
8497         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8498                                  HDA_AMP_MUTE, bits);
8499 }
8500
8501 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8502                                            unsigned int res)
8503 {
8504         if ((res >> 26) == ALC880_HP_EVENT)
8505                 alc883_lenovo_101e_all_automute(codec);
8506         if ((res >> 26) == ALC880_FRONT_EVENT)
8507                 alc883_lenovo_101e_ispeaker_automute(codec);
8508 }
8509
8510 /* toggle speaker-output according to the hp-jack state */
8511 static void alc883_acer_aspire_init_hook(struct hda_codec *codec)
8512 {
8513         struct alc_spec *spec = codec->spec;
8514
8515         spec->autocfg.hp_pins[0] = 0x14;
8516         spec->autocfg.speaker_pins[0] = 0x15;
8517         spec->autocfg.speaker_pins[1] = 0x16;
8518         alc_automute_amp(codec);
8519 }
8520
8521 static struct hda_verb alc883_acer_eapd_verbs[] = {
8522         /* HP Pin: output 0 (0x0c) */
8523         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8524         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8525         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8526         /* Front Pin: output 0 (0x0c) */
8527         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8528         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8529         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8530         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8531         /* eanable EAPD on medion laptop */
8532         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8533         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8534         /* enable unsolicited event */
8535         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8536         { }
8537 };
8538
8539 static void alc888_6st_dell_init_hook(struct hda_codec *codec)
8540 {
8541         struct alc_spec *spec = codec->spec;
8542
8543         spec->autocfg.hp_pins[0] = 0x1b;
8544         spec->autocfg.speaker_pins[0] = 0x14;
8545         spec->autocfg.speaker_pins[1] = 0x15;
8546         spec->autocfg.speaker_pins[2] = 0x16;
8547         spec->autocfg.speaker_pins[3] = 0x17;
8548         alc_automute_amp(codec);
8549 }
8550
8551 static void alc888_lenovo_sky_init_hook(struct hda_codec *codec)
8552 {
8553         struct alc_spec *spec = codec->spec;
8554
8555         spec->autocfg.hp_pins[0] = 0x1b;
8556         spec->autocfg.speaker_pins[0] = 0x14;
8557         spec->autocfg.speaker_pins[1] = 0x15;
8558         spec->autocfg.speaker_pins[2] = 0x16;
8559         spec->autocfg.speaker_pins[3] = 0x17;
8560         spec->autocfg.speaker_pins[4] = 0x1a;
8561         alc_automute_amp(codec);
8562 }
8563
8564 /*
8565  * generic initialization of ADC, input mixers and output mixers
8566  */
8567 static struct hda_verb alc883_auto_init_verbs[] = {
8568         /*
8569          * Unmute ADC0-2 and set the default input to mic-in
8570          */
8571         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8572         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8573         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8574         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8575
8576         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8577          * mixer widget
8578          * Note: PASD motherboards uses the Line In 2 as the input for
8579          * front panel mic (mic 2)
8580          */
8581         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8582         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8583         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8584         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8585         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8586         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8587
8588         /*
8589          * Set up output mixers (0x0c - 0x0f)
8590          */
8591         /* set vol=0 to output mixers */
8592         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8593         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8594         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8595         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8596         /* set up input amps for analog loopback */
8597         /* Amp Indices: DAC = 0, mixer = 1 */
8598         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8599         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8600         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8601         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8602         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8603         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8604         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8605         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8606         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8607         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8608
8609         /* FIXME: use matrix-type input source selection */
8610         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8611         /* Input mixer1 */
8612         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8613         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8614         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8615         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8616         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8617         /* Input mixer2 */
8618         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8619         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8620         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8621         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8622         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8623
8624         { }
8625 };
8626
8627 static struct hda_verb alc888_asus_m90v_verbs[] = {
8628         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8629         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8630         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8631         /* enable unsolicited event */
8632         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8633         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8634         { } /* end */
8635 };
8636
8637 static void alc883_nb_mic_automute(struct hda_codec *codec)
8638 {
8639         unsigned int present;
8640
8641         present = snd_hda_codec_read(codec, 0x18, 0,
8642                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8643         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8644                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8645         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8646                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8647 }
8648
8649 static void alc883_M90V_init_hook(struct hda_codec *codec)
8650 {
8651         struct alc_spec *spec = codec->spec;
8652
8653         spec->autocfg.hp_pins[0] = 0x1b;
8654         spec->autocfg.speaker_pins[0] = 0x14;
8655         spec->autocfg.speaker_pins[1] = 0x15;
8656         spec->autocfg.speaker_pins[2] = 0x16;
8657         alc_automute_pin(codec);
8658 }
8659
8660 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8661                                            unsigned int res)
8662 {
8663         switch (res >> 26) {
8664         case ALC880_MIC_EVENT:
8665                 alc883_nb_mic_automute(codec);
8666                 break;
8667         default:
8668                 alc_sku_unsol_event(codec, res);
8669                 break;
8670         }
8671 }
8672
8673 static void alc883_mode2_inithook(struct hda_codec *codec)
8674 {
8675         alc883_M90V_init_hook(codec);
8676         alc883_nb_mic_automute(codec);
8677 }
8678
8679 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8680         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8681         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8682         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8683         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8684         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8685         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8686         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8687         /* enable unsolicited event */
8688         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8689         { } /* end */
8690 };
8691
8692 static void alc883_eee1601_inithook(struct hda_codec *codec)
8693 {
8694         struct alc_spec *spec = codec->spec;
8695
8696         spec->autocfg.hp_pins[0] = 0x14;
8697         spec->autocfg.speaker_pins[0] = 0x1b;
8698         alc_automute_pin(codec);
8699 }
8700
8701 static struct hda_verb alc889A_mb31_verbs[] = {
8702         /* Init rear pin (used as headphone output) */
8703         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
8704         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
8705         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8706         /* Init line pin (used as output in 4ch and 6ch mode) */
8707         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
8708         /* Init line 2 pin (used as headphone out by default) */
8709         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
8710         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
8711         { } /* end */
8712 };
8713
8714 /* Mute speakers according to the headphone jack state */
8715 static void alc889A_mb31_automute(struct hda_codec *codec)
8716 {
8717         unsigned int present;
8718
8719         /* Mute only in 2ch or 4ch mode */
8720         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
8721             == 0x00) {
8722                 present = snd_hda_codec_read(codec, 0x15, 0,
8723                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
8724                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
8725                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8726                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8727                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8728         }
8729 }
8730
8731 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
8732 {
8733         if ((res >> 26) == ALC880_HP_EVENT)
8734                 alc889A_mb31_automute(codec);
8735 }
8736
8737 #ifdef CONFIG_SND_HDA_POWER_SAVE
8738 #define alc883_loopbacks        alc880_loopbacks
8739 #endif
8740
8741 /* pcm configuration: identiacal with ALC880 */
8742 #define alc883_pcm_analog_playback      alc880_pcm_analog_playback
8743 #define alc883_pcm_analog_capture       alc880_pcm_analog_capture
8744 #define alc883_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
8745 #define alc883_pcm_digital_playback     alc880_pcm_digital_playback
8746 #define alc883_pcm_digital_capture      alc880_pcm_digital_capture
8747
8748 /*
8749  * configuration and preset
8750  */
8751 static const char *alc883_models[ALC883_MODEL_LAST] = {
8752         [ALC883_3ST_2ch_DIG]    = "3stack-dig",
8753         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8754         [ALC883_3ST_6ch]        = "3stack-6ch",
8755         [ALC883_6ST_DIG]        = "6stack-dig",
8756         [ALC883_TARGA_DIG]      = "targa-dig",
8757         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8758         [ALC883_ACER]           = "acer",
8759         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8760         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8761         [ALC883_MEDION]         = "medion",
8762         [ALC883_MEDION_MD2]     = "medion-md2",
8763         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8764         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8765         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8766         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8767         [ALC888_LENOVO_SKY] = "lenovo-sky",
8768         [ALC883_HAIER_W66]      = "haier-w66",
8769         [ALC888_3ST_HP]         = "3stack-hp",
8770         [ALC888_6ST_DELL]       = "6stack-dell",
8771         [ALC883_MITAC]          = "mitac",
8772         [ALC883_CLEVO_M720]     = "clevo-m720",
8773         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8774         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8775         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8776         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8777         [ALC889A_MB31]          = "mb31",
8778         [ALC883_AUTO]           = "auto",
8779 };
8780
8781 static struct snd_pci_quirk alc883_cfg_tbl[] = {
8782         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
8783         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8784         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8785         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
8786         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8787         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8788         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8789         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8790                 ALC888_ACER_ASPIRE_4930G),
8791         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8792                 ALC888_ACER_ASPIRE_4930G),
8793         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC883_AUTO),
8794         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC883_AUTO),
8795         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8796                 ALC888_ACER_ASPIRE_4930G),
8797         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8798                 ALC888_ACER_ASPIRE_4930G),
8799         /* default Acer -- disabled as it causes more problems.
8800          *    model=auto should work fine now
8801          */
8802         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
8803         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8804         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8805         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8806         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8807         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8808         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8809         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
8810         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8811         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8812         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8813         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8814         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8815         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8816         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
8817         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8818         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8819         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8820         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8821         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8822         SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
8823         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8824         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8825         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8826         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8827         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8828         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8829         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8830         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8831         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8832         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8833         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8834         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8835         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8836         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8837         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8838         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8839         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8840         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8841         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8842         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8843         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8844         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8845         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8846         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8847         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8848         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8849         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
8850         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8851         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8852         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
8853                       ALC883_FUJITSU_PI2515),
8854         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
8855                 ALC888_FUJITSU_XA3530),
8856         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8857         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8858         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8859         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8860         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8861         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8862         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
8863         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8864         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8865         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8866         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8867         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
8868         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL),
8869         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8870         {}
8871 };
8872
8873 static hda_nid_t alc883_slave_dig_outs[] = {
8874         ALC1200_DIGOUT_NID, 0,
8875 };
8876
8877 static hda_nid_t alc1200_slave_dig_outs[] = {
8878         ALC883_DIGOUT_NID, 0,
8879 };
8880
8881 static struct alc_config_preset alc883_presets[] = {
8882         [ALC883_3ST_2ch_DIG] = {
8883                 .mixers = { alc883_3ST_2ch_mixer },
8884                 .init_verbs = { alc883_init_verbs },
8885                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8886                 .dac_nids = alc883_dac_nids,
8887                 .dig_out_nid = ALC883_DIGOUT_NID,
8888                 .dig_in_nid = ALC883_DIGIN_NID,
8889                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8890                 .channel_mode = alc883_3ST_2ch_modes,
8891                 .input_mux = &alc883_capture_source,
8892         },
8893         [ALC883_3ST_6ch_DIG] = {
8894                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8895                 .init_verbs = { alc883_init_verbs },
8896                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8897                 .dac_nids = alc883_dac_nids,
8898                 .dig_out_nid = ALC883_DIGOUT_NID,
8899                 .dig_in_nid = ALC883_DIGIN_NID,
8900                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8901                 .channel_mode = alc883_3ST_6ch_modes,
8902                 .need_dac_fix = 1,
8903                 .input_mux = &alc883_capture_source,
8904         },
8905         [ALC883_3ST_6ch] = {
8906                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8907                 .init_verbs = { alc883_init_verbs },
8908                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8909                 .dac_nids = alc883_dac_nids,
8910                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8911                 .channel_mode = alc883_3ST_6ch_modes,
8912                 .need_dac_fix = 1,
8913                 .input_mux = &alc883_capture_source,
8914         },
8915         [ALC883_3ST_6ch_INTEL] = {
8916                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8917                 .init_verbs = { alc883_init_verbs },
8918                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8919                 .dac_nids = alc883_dac_nids,
8920                 .dig_out_nid = ALC883_DIGOUT_NID,
8921                 .dig_in_nid = ALC883_DIGIN_NID,
8922                 .slave_dig_outs = alc883_slave_dig_outs,
8923                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8924                 .channel_mode = alc883_3ST_6ch_intel_modes,
8925                 .need_dac_fix = 1,
8926                 .input_mux = &alc883_3stack_6ch_intel,
8927         },
8928         [ALC883_6ST_DIG] = {
8929                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8930                 .init_verbs = { alc883_init_verbs },
8931                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8932                 .dac_nids = alc883_dac_nids,
8933                 .dig_out_nid = ALC883_DIGOUT_NID,
8934                 .dig_in_nid = ALC883_DIGIN_NID,
8935                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8936                 .channel_mode = alc883_sixstack_modes,
8937                 .input_mux = &alc883_capture_source,
8938         },
8939         [ALC883_TARGA_DIG] = {
8940                 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8941                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8942                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8943                 .dac_nids = alc883_dac_nids,
8944                 .dig_out_nid = ALC883_DIGOUT_NID,
8945                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8946                 .channel_mode = alc883_3ST_6ch_modes,
8947                 .need_dac_fix = 1,
8948                 .input_mux = &alc883_capture_source,
8949                 .unsol_event = alc883_tagra_unsol_event,
8950                 .init_hook = alc883_tagra_init_hook,
8951         },
8952         [ALC883_TARGA_2ch_DIG] = {
8953                 .mixers = { alc883_tagra_2ch_mixer},
8954                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8955                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8956                 .dac_nids = alc883_dac_nids,
8957                 .adc_nids = alc883_adc_nids_alt,
8958                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8959                 .dig_out_nid = ALC883_DIGOUT_NID,
8960                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8961                 .channel_mode = alc883_3ST_2ch_modes,
8962                 .input_mux = &alc883_capture_source,
8963                 .unsol_event = alc883_tagra_unsol_event,
8964                 .init_hook = alc883_tagra_init_hook,
8965         },
8966         [ALC883_ACER] = {
8967                 .mixers = { alc883_base_mixer },
8968                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8969                  * and the headphone jack.  Turn this on and rely on the
8970                  * standard mute methods whenever the user wants to turn
8971                  * these outputs off.
8972                  */
8973                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8974                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8975                 .dac_nids = alc883_dac_nids,
8976                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8977                 .channel_mode = alc883_3ST_2ch_modes,
8978                 .input_mux = &alc883_capture_source,
8979         },
8980         [ALC883_ACER_ASPIRE] = {
8981                 .mixers = { alc883_acer_aspire_mixer },
8982                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8983                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8984                 .dac_nids = alc883_dac_nids,
8985                 .dig_out_nid = ALC883_DIGOUT_NID,
8986                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8987                 .channel_mode = alc883_3ST_2ch_modes,
8988                 .input_mux = &alc883_capture_source,
8989                 .unsol_event = alc_automute_amp_unsol_event,
8990                 .init_hook = alc883_acer_aspire_init_hook,
8991         },
8992         [ALC888_ACER_ASPIRE_4930G] = {
8993                 .mixers = { alc888_base_mixer,
8994                                 alc883_chmode_mixer },
8995                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
8996                                 alc888_acer_aspire_4930g_verbs },
8997                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8998                 .dac_nids = alc883_dac_nids,
8999                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9000                 .adc_nids = alc883_adc_nids_rev,
9001                 .capsrc_nids = alc883_capsrc_nids_rev,
9002                 .dig_out_nid = ALC883_DIGOUT_NID,
9003                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9004                 .channel_mode = alc883_3ST_6ch_modes,
9005                 .need_dac_fix = 1,
9006                 .num_mux_defs =
9007                         ARRAY_SIZE(alc888_2_capture_sources),
9008                 .input_mux = alc888_2_capture_sources,
9009                 .unsol_event = alc_automute_amp_unsol_event,
9010                 .init_hook = alc888_acer_aspire_4930g_init_hook,
9011         },
9012         [ALC883_MEDION] = {
9013                 .mixers = { alc883_fivestack_mixer,
9014                             alc883_chmode_mixer },
9015                 .init_verbs = { alc883_init_verbs,
9016                                 alc883_medion_eapd_verbs },
9017                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9018                 .dac_nids = alc883_dac_nids,
9019                 .adc_nids = alc883_adc_nids_alt,
9020                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9021                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9022                 .channel_mode = alc883_sixstack_modes,
9023                 .input_mux = &alc883_capture_source,
9024         },
9025         [ALC883_MEDION_MD2] = {
9026                 .mixers = { alc883_medion_md2_mixer},
9027                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
9028                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9029                 .dac_nids = alc883_dac_nids,
9030                 .dig_out_nid = ALC883_DIGOUT_NID,
9031                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9032                 .channel_mode = alc883_3ST_2ch_modes,
9033                 .input_mux = &alc883_capture_source,
9034                 .unsol_event = alc_automute_amp_unsol_event,
9035                 .init_hook = alc883_medion_md2_init_hook,
9036         },
9037         [ALC883_LAPTOP_EAPD] = {
9038                 .mixers = { alc883_base_mixer },
9039                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
9040                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9041                 .dac_nids = alc883_dac_nids,
9042                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9043                 .channel_mode = alc883_3ST_2ch_modes,
9044                 .input_mux = &alc883_capture_source,
9045         },
9046         [ALC883_CLEVO_M720] = {
9047                 .mixers = { alc883_clevo_m720_mixer },
9048                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
9049                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9050                 .dac_nids = alc883_dac_nids,
9051                 .dig_out_nid = ALC883_DIGOUT_NID,
9052                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9053                 .channel_mode = alc883_3ST_2ch_modes,
9054                 .input_mux = &alc883_capture_source,
9055                 .unsol_event = alc883_clevo_m720_unsol_event,
9056                 .init_hook = alc883_clevo_m720_init_hook,
9057         },
9058         [ALC883_LENOVO_101E_2ch] = {
9059                 .mixers = { alc883_lenovo_101e_2ch_mixer},
9060                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
9061                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9062                 .dac_nids = alc883_dac_nids,
9063                 .adc_nids = alc883_adc_nids_alt,
9064                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9065                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9066                 .channel_mode = alc883_3ST_2ch_modes,
9067                 .input_mux = &alc883_lenovo_101e_capture_source,
9068                 .unsol_event = alc883_lenovo_101e_unsol_event,
9069                 .init_hook = alc883_lenovo_101e_all_automute,
9070         },
9071         [ALC883_LENOVO_NB0763] = {
9072                 .mixers = { alc883_lenovo_nb0763_mixer },
9073                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
9074                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9075                 .dac_nids = alc883_dac_nids,
9076                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9077                 .channel_mode = alc883_3ST_2ch_modes,
9078                 .need_dac_fix = 1,
9079                 .input_mux = &alc883_lenovo_nb0763_capture_source,
9080                 .unsol_event = alc_automute_amp_unsol_event,
9081                 .init_hook = alc883_medion_md2_init_hook,
9082         },
9083         [ALC888_LENOVO_MS7195_DIG] = {
9084                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9085                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
9086                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9087                 .dac_nids = alc883_dac_nids,
9088                 .dig_out_nid = ALC883_DIGOUT_NID,
9089                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9090                 .channel_mode = alc883_3ST_6ch_modes,
9091                 .need_dac_fix = 1,
9092                 .input_mux = &alc883_capture_source,
9093                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
9094                 .init_hook = alc888_lenovo_ms7195_front_automute,
9095         },
9096         [ALC883_HAIER_W66] = {
9097                 .mixers = { alc883_tagra_2ch_mixer},
9098                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
9099                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9100                 .dac_nids = alc883_dac_nids,
9101                 .dig_out_nid = ALC883_DIGOUT_NID,
9102                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9103                 .channel_mode = alc883_3ST_2ch_modes,
9104                 .input_mux = &alc883_capture_source,
9105                 .unsol_event = alc_automute_amp_unsol_event,
9106                 .init_hook = alc883_haier_w66_init_hook,
9107         },
9108         [ALC888_3ST_HP] = {
9109                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9110                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9111                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9112                 .dac_nids = alc883_dac_nids,
9113                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9114                 .channel_mode = alc888_3st_hp_modes,
9115                 .need_dac_fix = 1,
9116                 .input_mux = &alc883_capture_source,
9117                 .unsol_event = alc_automute_amp_unsol_event,
9118                 .init_hook = alc888_3st_hp_init_hook,
9119         },
9120         [ALC888_6ST_DELL] = {
9121                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9122                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9123                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9124                 .dac_nids = alc883_dac_nids,
9125                 .dig_out_nid = ALC883_DIGOUT_NID,
9126                 .dig_in_nid = ALC883_DIGIN_NID,
9127                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9128                 .channel_mode = alc883_sixstack_modes,
9129                 .input_mux = &alc883_capture_source,
9130                 .unsol_event = alc_automute_amp_unsol_event,
9131                 .init_hook = alc888_6st_dell_init_hook,
9132         },
9133         [ALC883_MITAC] = {
9134                 .mixers = { alc883_mitac_mixer },
9135                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9136                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9137                 .dac_nids = alc883_dac_nids,
9138                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9139                 .channel_mode = alc883_3ST_2ch_modes,
9140                 .input_mux = &alc883_capture_source,
9141                 .unsol_event = alc_automute_amp_unsol_event,
9142                 .init_hook = alc883_mitac_init_hook,
9143         },
9144         [ALC883_FUJITSU_PI2515] = {
9145                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9146                 .init_verbs = { alc883_init_verbs,
9147                                 alc883_2ch_fujitsu_pi2515_verbs},
9148                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9149                 .dac_nids = alc883_dac_nids,
9150                 .dig_out_nid = ALC883_DIGOUT_NID,
9151                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9152                 .channel_mode = alc883_3ST_2ch_modes,
9153                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9154                 .unsol_event = alc_automute_amp_unsol_event,
9155                 .init_hook = alc883_2ch_fujitsu_pi2515_init_hook,
9156         },
9157         [ALC888_FUJITSU_XA3530] = {
9158                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
9159                 .init_verbs = { alc883_init_verbs,
9160                         alc888_fujitsu_xa3530_verbs },
9161                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9162                 .dac_nids = alc883_dac_nids,
9163                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9164                 .adc_nids = alc883_adc_nids_rev,
9165                 .capsrc_nids = alc883_capsrc_nids_rev,
9166                 .dig_out_nid = ALC883_DIGOUT_NID,
9167                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9168                 .channel_mode = alc888_4ST_8ch_intel_modes,
9169                 .num_mux_defs =
9170                         ARRAY_SIZE(alc888_2_capture_sources),
9171                 .input_mux = alc888_2_capture_sources,
9172                 .unsol_event = alc_automute_amp_unsol_event,
9173                 .init_hook = alc888_fujitsu_xa3530_init_hook,
9174         },
9175         [ALC888_LENOVO_SKY] = {
9176                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9177                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9178                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9179                 .dac_nids = alc883_dac_nids,
9180                 .dig_out_nid = ALC883_DIGOUT_NID,
9181                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9182                 .channel_mode = alc883_sixstack_modes,
9183                 .need_dac_fix = 1,
9184                 .input_mux = &alc883_lenovo_sky_capture_source,
9185                 .unsol_event = alc_automute_amp_unsol_event,
9186                 .init_hook = alc888_lenovo_sky_init_hook,
9187         },
9188         [ALC888_ASUS_M90V] = {
9189                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9190                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9191                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9192                 .dac_nids = alc883_dac_nids,
9193                 .dig_out_nid = ALC883_DIGOUT_NID,
9194                 .dig_in_nid = ALC883_DIGIN_NID,
9195                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9196                 .channel_mode = alc883_3ST_6ch_modes,
9197                 .need_dac_fix = 1,
9198                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9199                 .unsol_event = alc883_mode2_unsol_event,
9200                 .init_hook = alc883_mode2_inithook,
9201         },
9202         [ALC888_ASUS_EEE1601] = {
9203                 .mixers = { alc883_asus_eee1601_mixer },
9204                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
9205                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9206                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9207                 .dac_nids = alc883_dac_nids,
9208                 .dig_out_nid = ALC883_DIGOUT_NID,
9209                 .dig_in_nid = ALC883_DIGIN_NID,
9210                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9211                 .channel_mode = alc883_3ST_2ch_modes,
9212                 .need_dac_fix = 1,
9213                 .input_mux = &alc883_asus_eee1601_capture_source,
9214                 .unsol_event = alc_sku_unsol_event,
9215                 .init_hook = alc883_eee1601_inithook,
9216         },
9217         [ALC1200_ASUS_P5Q] = {
9218                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9219                 .init_verbs = { alc883_init_verbs },
9220                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9221                 .dac_nids = alc883_dac_nids,
9222                 .dig_out_nid = ALC1200_DIGOUT_NID,
9223                 .dig_in_nid = ALC883_DIGIN_NID,
9224                 .slave_dig_outs = alc1200_slave_dig_outs,
9225                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9226                 .channel_mode = alc883_sixstack_modes,
9227                 .input_mux = &alc883_capture_source,
9228         },
9229         [ALC889A_MB31] = {
9230                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
9231                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
9232                         alc880_gpio1_init_verbs },
9233                 .adc_nids = alc883_adc_nids,
9234                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
9235                 .dac_nids = alc883_dac_nids,
9236                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9237                 .channel_mode = alc889A_mb31_6ch_modes,
9238                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
9239                 .input_mux = &alc889A_mb31_capture_source,
9240                 .dig_out_nid = ALC883_DIGOUT_NID,
9241                 .unsol_event = alc889A_mb31_unsol_event,
9242                 .init_hook = alc889A_mb31_automute,
9243         },
9244 };
9245
9246
9247 /*
9248  * BIOS auto configuration
9249  */
9250 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
9251                                               hda_nid_t nid, int pin_type,
9252                                               int dac_idx)
9253 {
9254         /* set as output */
9255         struct alc_spec *spec = codec->spec;
9256         int idx;
9257
9258         alc_set_pin_output(codec, nid, pin_type);
9259         if (spec->multiout.dac_nids[dac_idx] == 0x25)
9260                 idx = 4;
9261         else
9262                 idx = spec->multiout.dac_nids[dac_idx] - 2;
9263         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9264
9265 }
9266
9267 static void alc883_auto_init_multi_out(struct hda_codec *codec)
9268 {
9269         struct alc_spec *spec = codec->spec;
9270         int i;
9271
9272         for (i = 0; i <= HDA_SIDE; i++) {
9273                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9274                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
9275                 if (nid)
9276                         alc883_auto_set_output_and_unmute(codec, nid, pin_type,
9277                                                           i);
9278         }
9279 }
9280
9281 static void alc883_auto_init_hp_out(struct hda_codec *codec)
9282 {
9283         struct alc_spec *spec = codec->spec;
9284         hda_nid_t pin;
9285
9286         pin = spec->autocfg.hp_pins[0];
9287         if (pin) /* connect to front */
9288                 /* use dac 0 */
9289                 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9290         pin = spec->autocfg.speaker_pins[0];
9291         if (pin)
9292                 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9293 }
9294
9295 #define alc883_is_input_pin(nid)        alc880_is_input_pin(nid)
9296 #define ALC883_PIN_CD_NID               ALC880_PIN_CD_NID
9297
9298 static void alc883_auto_init_analog_input(struct hda_codec *codec)
9299 {
9300         struct alc_spec *spec = codec->spec;
9301         int i;
9302
9303         for (i = 0; i < AUTO_PIN_LAST; i++) {
9304                 hda_nid_t nid = spec->autocfg.input_pins[i];
9305                 if (alc883_is_input_pin(nid)) {
9306                         alc_set_input_pin(codec, nid, i);
9307                         if (nid != ALC883_PIN_CD_NID &&
9308                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
9309                                 snd_hda_codec_write(codec, nid, 0,
9310                                                     AC_VERB_SET_AMP_GAIN_MUTE,
9311                                                     AMP_OUT_MUTE);
9312                 }
9313         }
9314 }
9315
9316 #define alc883_auto_init_input_src      alc882_auto_init_input_src
9317
9318 /* almost identical with ALC880 parser... */
9319 static int alc883_parse_auto_config(struct hda_codec *codec)
9320 {
9321         struct alc_spec *spec = codec->spec;
9322         int err = alc880_parse_auto_config(codec);
9323         struct auto_pin_cfg *cfg = &spec->autocfg;
9324         int i;
9325
9326         if (err < 0)
9327                 return err;
9328         else if (!err)
9329                 return 0; /* no config found */
9330
9331         err = alc_auto_add_mic_boost(codec);
9332         if (err < 0)
9333                 return err;
9334
9335         /* hack - override the init verbs */
9336         spec->init_verbs[0] = alc883_auto_init_verbs;
9337
9338         /* setup input_mux for ALC889 */
9339         if (codec->vendor_id == 0x10ec0889) {
9340                 /* digital-mic input pin is excluded in alc880_auto_create..()
9341                  * because it's under 0x18
9342                  */
9343                 if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
9344                     cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
9345                         struct hda_input_mux *imux = &spec->private_imux[0];
9346                         for (i = 1; i < 3; i++)
9347                                 memcpy(&spec->private_imux[i],
9348                                        &spec->private_imux[0],
9349                                        sizeof(spec->private_imux[0]));
9350                         imux->items[imux->num_items].label = "Int DMic";
9351                         imux->items[imux->num_items].index = 0x0b;
9352                         imux->num_items++;
9353                         spec->num_mux_defs = 3;
9354                         spec->input_mux = spec->private_imux;
9355                 }
9356         }
9357
9358         return 1; /* config found */
9359 }
9360
9361 /* additional initialization for auto-configuration model */
9362 static void alc883_auto_init(struct hda_codec *codec)
9363 {
9364         struct alc_spec *spec = codec->spec;
9365         alc883_auto_init_multi_out(codec);
9366         alc883_auto_init_hp_out(codec);
9367         alc883_auto_init_analog_input(codec);
9368         alc883_auto_init_input_src(codec);
9369         if (spec->unsol_event)
9370                 alc_inithook(codec);
9371 }
9372
9373 static int patch_alc883(struct hda_codec *codec)
9374 {
9375         struct alc_spec *spec;
9376         int err, board_config;
9377
9378         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9379         if (spec == NULL)
9380                 return -ENOMEM;
9381
9382         codec->spec = spec;
9383
9384         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9385
9386         board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
9387                                                   alc883_models,
9388                                                   alc883_cfg_tbl);
9389         if (board_config < 0 || board_config >= ALC883_MODEL_LAST) {
9390                 /* Pick up systems that don't supply PCI SSID */
9391                 switch (codec->subsystem_id) {
9392                 case 0x106b3600: /* Macbook 3.1 */
9393                         board_config = ALC889A_MB31;
9394                         break;
9395                 default:
9396                         printk(KERN_INFO
9397                                 "hda_codec: Unknown model for %s, trying "
9398                                 "auto-probe from BIOS...\n", codec->chip_name);
9399                         board_config = ALC883_AUTO;
9400                 }
9401         }
9402
9403         if (board_config == ALC883_AUTO) {
9404                 /* automatic parse from the BIOS config */
9405                 err = alc883_parse_auto_config(codec);
9406                 if (err < 0) {
9407                         alc_free(codec);
9408                         return err;
9409                 } else if (!err) {
9410                         printk(KERN_INFO
9411                                "hda_codec: Cannot set up configuration "
9412                                "from BIOS.  Using base mode...\n");
9413                         board_config = ALC883_3ST_2ch_DIG;
9414                 }
9415         }
9416
9417         err = snd_hda_attach_beep_device(codec, 0x1);
9418         if (err < 0) {
9419                 alc_free(codec);
9420                 return err;
9421         }
9422
9423         if (board_config != ALC883_AUTO)
9424                 setup_preset(spec, &alc883_presets[board_config]);
9425
9426         switch (codec->vendor_id) {
9427         case 0x10ec0888:
9428                 if (!spec->num_adc_nids) {
9429                         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9430                         spec->adc_nids = alc883_adc_nids;
9431                 }
9432                 if (!spec->capsrc_nids)
9433                         spec->capsrc_nids = alc883_capsrc_nids;
9434                 spec->capture_style = CAPT_MIX; /* matrix-style capture */
9435                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
9436                 break;
9437         case 0x10ec0889:
9438                 if (!spec->num_adc_nids) {
9439                         spec->num_adc_nids = ARRAY_SIZE(alc889_adc_nids);
9440                         spec->adc_nids = alc889_adc_nids;
9441                 }
9442                 if (!spec->capsrc_nids)
9443                         spec->capsrc_nids = alc889_capsrc_nids;
9444                 spec->capture_style = CAPT_1MUX_MIX; /* 1mux/Nmix-style
9445                                                         capture */
9446                 break;
9447         default:
9448                 if (!spec->num_adc_nids) {
9449                         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9450                         spec->adc_nids = alc883_adc_nids;
9451                 }
9452                 if (!spec->capsrc_nids)
9453                         spec->capsrc_nids = alc883_capsrc_nids;
9454                 spec->capture_style = CAPT_MIX; /* matrix-style capture */
9455                 break;
9456         }
9457
9458         spec->stream_analog_playback = &alc883_pcm_analog_playback;
9459         spec->stream_analog_capture = &alc883_pcm_analog_capture;
9460         spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
9461
9462         spec->stream_digital_playback = &alc883_pcm_digital_playback;
9463         spec->stream_digital_capture = &alc883_pcm_digital_capture;
9464
9465         if (!spec->cap_mixer)
9466                 set_capture_mixer(spec);
9467         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9468
9469         spec->vmaster_nid = 0x0c;
9470
9471         codec->patch_ops = alc_patch_ops;
9472         if (board_config == ALC883_AUTO)
9473                 spec->init_hook = alc883_auto_init;
9474
9475 #ifdef CONFIG_SND_HDA_POWER_SAVE
9476         if (!spec->loopback.amplist)
9477                 spec->loopback.amplist = alc883_loopbacks;
9478 #endif
9479         codec->proc_widget_hook = print_realtek_coef;
9480
9481         return 0;
9482 }
9483
9484 /*
9485  * ALC262 support
9486  */
9487
9488 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
9489 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
9490
9491 #define alc262_dac_nids         alc260_dac_nids
9492 #define alc262_adc_nids         alc882_adc_nids
9493 #define alc262_adc_nids_alt     alc882_adc_nids_alt
9494 #define alc262_capsrc_nids      alc882_capsrc_nids
9495 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
9496
9497 #define alc262_modes            alc260_modes
9498 #define alc262_capture_source   alc882_capture_source
9499
9500 static hda_nid_t alc262_dmic_adc_nids[1] = {
9501         /* ADC0 */
9502         0x09
9503 };
9504
9505 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
9506
9507 static struct snd_kcontrol_new alc262_base_mixer[] = {
9508         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9509         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9510         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9511         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9512         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9513         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9514         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9515         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9516         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9517         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9518         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9519         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9520         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
9521         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9522         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9523         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
9524         { } /* end */
9525 };
9526
9527 /* update HP, line and mono-out pins according to the master switch */
9528 static void alc262_hp_master_update(struct hda_codec *codec)
9529 {
9530         struct alc_spec *spec = codec->spec;
9531         int val = spec->master_sw;
9532
9533         /* HP & line-out */
9534         snd_hda_codec_write_cache(codec, 0x1b, 0,
9535                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9536                                   val ? PIN_HP : 0);
9537         snd_hda_codec_write_cache(codec, 0x15, 0,
9538                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9539                                   val ? PIN_HP : 0);
9540         /* mono (speaker) depending on the HP jack sense */
9541         val = val && !spec->jack_present;
9542         snd_hda_codec_write_cache(codec, 0x16, 0,
9543                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9544                                   val ? PIN_OUT : 0);
9545 }
9546
9547 static void alc262_hp_bpc_automute(struct hda_codec *codec)
9548 {
9549         struct alc_spec *spec = codec->spec;
9550         unsigned int presence;
9551         presence = snd_hda_codec_read(codec, 0x1b, 0,
9552                                       AC_VERB_GET_PIN_SENSE, 0);
9553         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9554         alc262_hp_master_update(codec);
9555 }
9556
9557 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
9558 {
9559         if ((res >> 26) != ALC880_HP_EVENT)
9560                 return;
9561         alc262_hp_bpc_automute(codec);
9562 }
9563
9564 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
9565 {
9566         struct alc_spec *spec = codec->spec;
9567         unsigned int presence;
9568         presence = snd_hda_codec_read(codec, 0x15, 0,
9569                                       AC_VERB_GET_PIN_SENSE, 0);
9570         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9571         alc262_hp_master_update(codec);
9572 }
9573
9574 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
9575                                            unsigned int res)
9576 {
9577         if ((res >> 26) != ALC880_HP_EVENT)
9578                 return;
9579         alc262_hp_wildwest_automute(codec);
9580 }
9581
9582 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
9583
9584 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9585                                    struct snd_ctl_elem_value *ucontrol)
9586 {
9587         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9588         struct alc_spec *spec = codec->spec;
9589         int val = !!*ucontrol->value.integer.value;
9590
9591         if (val == spec->master_sw)
9592                 return 0;
9593         spec->master_sw = val;
9594         alc262_hp_master_update(codec);
9595         return 1;
9596 }
9597
9598 #define ALC262_HP_MASTER_SWITCH                                 \
9599         {                                                       \
9600                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
9601                 .name = "Master Playback Switch",               \
9602                 .info = snd_ctl_boolean_mono_info,              \
9603                 .get = alc262_hp_master_sw_get,                 \
9604                 .put = alc262_hp_master_sw_put,                 \
9605         }
9606
9607 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9608         ALC262_HP_MASTER_SWITCH,
9609         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9610         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9611         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9612         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9613                               HDA_OUTPUT),
9614         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9615                             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("Mic Boost", 0x18, 0, HDA_INPUT),
9619         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9620         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9621         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9622         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9623         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9624         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9625         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9626         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9627         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9628         { } /* end */
9629 };
9630
9631 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9632         ALC262_HP_MASTER_SWITCH,
9633         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9634         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9635         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9636         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9637         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9638                               HDA_OUTPUT),
9639         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9640                             HDA_OUTPUT),
9641         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9642         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9643         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9644         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9645         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9646         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9647         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9648         { } /* end */
9649 };
9650
9651 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9652         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9653         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9654         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9655         { } /* end */
9656 };
9657
9658 /* mute/unmute internal speaker according to the hp jack and mute state */
9659 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9660 {
9661         struct alc_spec *spec = codec->spec;
9662
9663         spec->autocfg.hp_pins[0] = 0x15;
9664         spec->autocfg.speaker_pins[0] = 0x0c; /* HACK: not actually a pin */
9665         alc_automute_amp(codec);
9666 }
9667
9668 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9669         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9670         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9671         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9672         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9673         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9674         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9675         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9676         { } /* end */
9677 };
9678
9679 static struct hda_verb alc262_hp_t5735_verbs[] = {
9680         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9681         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9682
9683         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9684         { }
9685 };
9686
9687 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9688         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9689         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9690         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9691         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9692         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9693         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9694         { } /* end */
9695 };
9696
9697 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9698         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9699         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9700         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9701         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9702         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9703         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9704         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9705         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9706         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9707         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9708         {}
9709 };
9710
9711 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9712         .num_items = 1,
9713         .items = {
9714                 { "Line", 0x1 },
9715         },
9716 };
9717
9718 /* bind hp and internal speaker mute (with plug check) as master switch */
9719 static void alc262_hippo_master_update(struct hda_codec *codec)
9720 {
9721         struct alc_spec *spec = codec->spec;
9722         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
9723         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
9724         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
9725         unsigned int mute;
9726
9727         /* HP */
9728         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
9729         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
9730                                  HDA_AMP_MUTE, mute);
9731         /* mute internal speaker per jack sense */
9732         if (spec->jack_present)
9733                 mute = HDA_AMP_MUTE;
9734         if (line_nid)
9735                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
9736                                          HDA_AMP_MUTE, mute);
9737         if (speaker_nid && speaker_nid != line_nid)
9738                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
9739                                          HDA_AMP_MUTE, mute);
9740 }
9741
9742 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
9743
9744 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
9745                                       struct snd_ctl_elem_value *ucontrol)
9746 {
9747         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9748         struct alc_spec *spec = codec->spec;
9749         int val = !!*ucontrol->value.integer.value;
9750
9751         if (val == spec->master_sw)
9752                 return 0;
9753         spec->master_sw = val;
9754         alc262_hippo_master_update(codec);
9755         return 1;
9756 }
9757
9758 #define ALC262_HIPPO_MASTER_SWITCH                              \
9759         {                                                       \
9760                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
9761                 .name = "Master Playback Switch",               \
9762                 .info = snd_ctl_boolean_mono_info,              \
9763                 .get = alc262_hippo_master_sw_get,              \
9764                 .put = alc262_hippo_master_sw_put,              \
9765         }
9766
9767 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
9768         ALC262_HIPPO_MASTER_SWITCH,
9769         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9770         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9771         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9772         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9773         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9774         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9775         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9776         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9777         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9778         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9779         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9780         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9781         { } /* end */
9782 };
9783
9784 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
9785         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9786         ALC262_HIPPO_MASTER_SWITCH,
9787         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9788         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9789         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9790         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9791         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9792         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9793         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9794         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9795         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9796         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9797         { } /* end */
9798 };
9799
9800 /* mute/unmute internal speaker according to the hp jack and mute state */
9801 static void alc262_hippo_automute(struct hda_codec *codec)
9802 {
9803         struct alc_spec *spec = codec->spec;
9804         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
9805         unsigned int present;
9806
9807         /* need to execute and sync at first */
9808         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
9809         present = snd_hda_codec_read(codec, hp_nid, 0,
9810                                      AC_VERB_GET_PIN_SENSE, 0);
9811         spec->jack_present = (present & 0x80000000) != 0;
9812         alc262_hippo_master_update(codec);
9813 }
9814
9815 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
9816 {
9817         if ((res >> 26) != ALC880_HP_EVENT)
9818                 return;
9819         alc262_hippo_automute(codec);
9820 }
9821
9822 static void alc262_hippo_init_hook(struct hda_codec *codec)
9823 {
9824         struct alc_spec *spec = codec->spec;
9825
9826         spec->autocfg.hp_pins[0] = 0x15;
9827         spec->autocfg.speaker_pins[0] = 0x14;
9828         alc262_hippo_automute(codec);
9829 }
9830
9831 static void alc262_hippo1_init_hook(struct hda_codec *codec)
9832 {
9833         struct alc_spec *spec = codec->spec;
9834
9835         spec->autocfg.hp_pins[0] = 0x1b;
9836         spec->autocfg.speaker_pins[0] = 0x14;
9837         alc262_hippo_automute(codec);
9838 }
9839
9840
9841 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9842         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9843         ALC262_HIPPO_MASTER_SWITCH,
9844         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9845         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9846         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9847         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9848         { } /* end */
9849 };
9850
9851 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9852         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9853         ALC262_HIPPO_MASTER_SWITCH,
9854         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9855         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9856         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9857         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9858         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9859         { } /* end */
9860 };
9861
9862 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
9863         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9864         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9865         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
9866         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
9867         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9868         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9869         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9870         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9871         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9872         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9873         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9874         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9875         { } /* end */
9876 };
9877
9878 static struct hda_verb alc262_tyan_verbs[] = {
9879         /* Headphone automute */
9880         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9881         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9882         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9883
9884         /* P11 AUX_IN, white 4-pin connector */
9885         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9886         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
9887         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
9888         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
9889
9890         {}
9891 };
9892
9893 /* unsolicited event for HP jack sensing */
9894 static void alc262_tyan_init_hook(struct hda_codec *codec)
9895 {
9896         struct alc_spec *spec = codec->spec;
9897
9898         spec->autocfg.hp_pins[0] = 0x1b;
9899         spec->autocfg.speaker_pins[0] = 0x15;
9900         alc_automute_amp(codec);
9901 }
9902
9903
9904 #define alc262_capture_mixer            alc882_capture_mixer
9905 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
9906
9907 /*
9908  * generic initialization of ADC, input mixers and output mixers
9909  */
9910 static struct hda_verb alc262_init_verbs[] = {
9911         /*
9912          * Unmute ADC0-2 and set the default input to mic-in
9913          */
9914         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9915         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9916         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9917         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9918         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9919         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9920
9921         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9922          * mixer widget
9923          * Note: PASD motherboards uses the Line In 2 as the input for
9924          * front panel mic (mic 2)
9925          */
9926         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9927         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9928         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9929         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9930         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9931         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9932
9933         /*
9934          * Set up output mixers (0x0c - 0x0e)
9935          */
9936         /* set vol=0 to output mixers */
9937         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9938         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9939         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9940         /* set up input amps for analog loopback */
9941         /* Amp Indices: DAC = 0, mixer = 1 */
9942         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9943         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9944         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9945         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9946         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9947         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9948
9949         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9950         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9951         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9952         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9953         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9954         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9955
9956         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9957         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9958         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9959         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9960         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9961
9962         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9963         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9964
9965         /* FIXME: use matrix-type input source selection */
9966         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9967         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9968         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9969         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9970         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9971         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9972         /* Input mixer2 */
9973         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9974         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9975         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9976         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9977         /* Input mixer3 */
9978         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9979         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9980         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9981         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9982
9983         { }
9984 };
9985
9986 static struct hda_verb alc262_eapd_verbs[] = {
9987         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9988         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9989         { }
9990 };
9991
9992 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9993         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9994         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9995         {}
9996 };
9997
9998 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9999         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10000         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10001         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10002
10003         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10004         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10005         {}
10006 };
10007
10008 static struct hda_verb alc262_sony_unsol_verbs[] = {
10009         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10010         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10011         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
10012
10013         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10014         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10015         {}
10016 };
10017
10018 static struct hda_input_mux alc262_dmic_capture_source = {
10019         .num_items = 2,
10020         .items = {
10021                 { "Int DMic", 0x9 },
10022                 { "Mic", 0x0 },
10023         },
10024 };
10025
10026 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
10027         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10028         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10029         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10030         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10031         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10032         { } /* end */
10033 };
10034
10035 static struct hda_verb alc262_toshiba_s06_verbs[] = {
10036         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10037         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10038         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10039         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10040         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
10041         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10042         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10043         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10044         {}
10045 };
10046
10047 static void alc262_dmic_automute(struct hda_codec *codec)
10048 {
10049         unsigned int present;
10050
10051         present = snd_hda_codec_read(codec, 0x18, 0,
10052                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
10053         snd_hda_codec_write(codec, 0x22, 0,
10054                                 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
10055 }
10056
10057
10058 /* unsolicited event for HP jack sensing */
10059 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
10060                                        unsigned int res)
10061 {
10062         if ((res >> 26) == ALC880_MIC_EVENT)
10063                 alc262_dmic_automute(codec);
10064         else
10065                 alc_sku_unsol_event(codec, res);
10066 }
10067
10068 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
10069 {
10070         struct alc_spec *spec = codec->spec;
10071
10072         spec->autocfg.hp_pins[0] = 0x15;
10073         spec->autocfg.speaker_pins[0] = 0x14;
10074         alc_automute_pin(codec);
10075         alc262_dmic_automute(codec);
10076 }
10077
10078 /*
10079  * nec model
10080  *  0x15 = headphone
10081  *  0x16 = internal speaker
10082  *  0x18 = external mic
10083  */
10084
10085 static struct snd_kcontrol_new alc262_nec_mixer[] = {
10086         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
10087         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
10088
10089         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10090         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10091         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10092
10093         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10094         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10095         { } /* end */
10096 };
10097
10098 static struct hda_verb alc262_nec_verbs[] = {
10099         /* Unmute Speaker */
10100         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10101
10102         /* Headphone */
10103         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10104         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10105
10106         /* External mic to headphone */
10107         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10108         /* External mic to speaker */
10109         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10110         {}
10111 };
10112
10113 /*
10114  * fujitsu model
10115  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10116  *  0x1b = port replicator headphone out
10117  */
10118
10119 #define ALC_HP_EVENT    0x37
10120
10121 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10122         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10123         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10124         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10125         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10126         {}
10127 };
10128
10129 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10130         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10131         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10132         {}
10133 };
10134
10135 static struct hda_input_mux alc262_fujitsu_capture_source = {
10136         .num_items = 3,
10137         .items = {
10138                 { "Mic", 0x0 },
10139                 { "Int Mic", 0x1 },
10140                 { "CD", 0x4 },
10141         },
10142 };
10143
10144 static struct hda_input_mux alc262_HP_capture_source = {
10145         .num_items = 5,
10146         .items = {
10147                 { "Mic", 0x0 },
10148                 { "Front Mic", 0x1 },
10149                 { "Line", 0x2 },
10150                 { "CD", 0x4 },
10151                 { "AUX IN", 0x6 },
10152         },
10153 };
10154
10155 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10156         .num_items = 4,
10157         .items = {
10158                 { "Mic", 0x0 },
10159                 { "Front Mic", 0x2 },
10160                 { "Line", 0x1 },
10161                 { "CD", 0x4 },
10162         },
10163 };
10164
10165 /* mute/unmute internal speaker according to the hp jacks and mute state */
10166 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10167 {
10168         struct alc_spec *spec = codec->spec;
10169         unsigned int mute;
10170
10171         if (force || !spec->sense_updated) {
10172                 unsigned int present;
10173                 /* need to execute and sync at first */
10174                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
10175                 /* check laptop HP jack */
10176                 present = snd_hda_codec_read(codec, 0x14, 0,
10177                                              AC_VERB_GET_PIN_SENSE, 0);
10178                 /* need to execute and sync at first */
10179                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10180                 /* check docking HP jack */
10181                 present |= snd_hda_codec_read(codec, 0x1b, 0,
10182                                               AC_VERB_GET_PIN_SENSE, 0);
10183                 if (present & AC_PINSENSE_PRESENCE)
10184                         spec->jack_present = 1;
10185                 else
10186                         spec->jack_present = 0;
10187                 spec->sense_updated = 1;
10188         }
10189         /* unmute internal speaker only if both HPs are unplugged and
10190          * master switch is on
10191          */
10192         if (spec->jack_present)
10193                 mute = HDA_AMP_MUTE;
10194         else
10195                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10196         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10197                                  HDA_AMP_MUTE, mute);
10198 }
10199
10200 /* unsolicited event for HP jack sensing */
10201 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10202                                        unsigned int res)
10203 {
10204         if ((res >> 26) != ALC_HP_EVENT)
10205                 return;
10206         alc262_fujitsu_automute(codec, 1);
10207 }
10208
10209 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10210 {
10211         alc262_fujitsu_automute(codec, 1);
10212 }
10213
10214 /* bind volumes of both NID 0x0c and 0x0d */
10215 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10216         .ops = &snd_hda_bind_vol,
10217         .values = {
10218                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10219                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10220                 0
10221         },
10222 };
10223
10224 /* mute/unmute internal speaker according to the hp jack and mute state */
10225 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10226 {
10227         struct alc_spec *spec = codec->spec;
10228         unsigned int mute;
10229
10230         if (force || !spec->sense_updated) {
10231                 unsigned int present_int_hp;
10232                 /* need to execute and sync at first */
10233                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10234                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
10235                                         AC_VERB_GET_PIN_SENSE, 0);
10236                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
10237                 spec->sense_updated = 1;
10238         }
10239         if (spec->jack_present) {
10240                 /* mute internal speaker */
10241                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10242                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10243                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10244                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10245         } else {
10246                 /* unmute internal speaker if necessary */
10247                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10248                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10249                                          HDA_AMP_MUTE, mute);
10250                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10251                                          HDA_AMP_MUTE, mute);
10252         }
10253 }
10254
10255 /* unsolicited event for HP jack sensing */
10256 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10257                                        unsigned int res)
10258 {
10259         if ((res >> 26) != ALC_HP_EVENT)
10260                 return;
10261         alc262_lenovo_3000_automute(codec, 1);
10262 }
10263
10264 /* bind hp and internal speaker mute (with plug check) */
10265 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10266                                          struct snd_ctl_elem_value *ucontrol)
10267 {
10268         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10269         long *valp = ucontrol->value.integer.value;
10270         int change;
10271
10272         change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10273                                                  HDA_AMP_MUTE,
10274                                                  valp ? 0 : HDA_AMP_MUTE);
10275         change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10276                                                  HDA_AMP_MUTE,
10277                                                  valp ? 0 : HDA_AMP_MUTE);
10278
10279         if (change)
10280                 alc262_fujitsu_automute(codec, 0);
10281         return change;
10282 }
10283
10284 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10285         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10286         {
10287                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10288                 .name = "Master Playback Switch",
10289                 .info = snd_hda_mixer_amp_switch_info,
10290                 .get = snd_hda_mixer_amp_switch_get,
10291                 .put = alc262_fujitsu_master_sw_put,
10292                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10293         },
10294         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10295         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10296         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10297         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10298         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10299         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10300         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10301         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10302         { } /* end */
10303 };
10304
10305 /* bind hp and internal speaker mute (with plug check) */
10306 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10307                                          struct snd_ctl_elem_value *ucontrol)
10308 {
10309         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10310         long *valp = ucontrol->value.integer.value;
10311         int change;
10312
10313         change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10314                                                  HDA_AMP_MUTE,
10315                                                  valp ? 0 : HDA_AMP_MUTE);
10316
10317         if (change)
10318                 alc262_lenovo_3000_automute(codec, 0);
10319         return change;
10320 }
10321
10322 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10323         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10324         {
10325                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10326                 .name = "Master Playback Switch",
10327                 .info = snd_hda_mixer_amp_switch_info,
10328                 .get = snd_hda_mixer_amp_switch_get,
10329                 .put = alc262_lenovo_3000_master_sw_put,
10330                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10331         },
10332         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10333         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10334         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10335         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10336         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10337         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10338         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10339         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10340         { } /* end */
10341 };
10342
10343 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10344         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10345         ALC262_HIPPO_MASTER_SWITCH,
10346         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10347         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10348         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10349         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10350         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10351         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10352         { } /* end */
10353 };
10354
10355 /* additional init verbs for Benq laptops */
10356 static struct hda_verb alc262_EAPD_verbs[] = {
10357         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10358         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10359         {}
10360 };
10361
10362 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10363         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10364         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10365
10366         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10367         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10368         {}
10369 };
10370
10371 /* Samsung Q1 Ultra Vista model setup */
10372 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10373         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10374         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10375         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10376         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10377         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10378         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10379         { } /* end */
10380 };
10381
10382 static struct hda_verb alc262_ultra_verbs[] = {
10383         /* output mixer */
10384         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10385         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10386         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10387         /* speaker */
10388         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10389         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10390         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10391         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10392         /* HP */
10393         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10394         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10395         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10396         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10397         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10398         /* internal mic */
10399         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10400         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10401         /* ADC, choose mic */
10402         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10403         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10404         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10405         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10406         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10407         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10408         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10409         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10410         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10411         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
10412         {}
10413 };
10414
10415 /* mute/unmute internal speaker according to the hp jack and mute state */
10416 static void alc262_ultra_automute(struct hda_codec *codec)
10417 {
10418         struct alc_spec *spec = codec->spec;
10419         unsigned int mute;
10420
10421         mute = 0;
10422         /* auto-mute only when HP is used as HP */
10423         if (!spec->cur_mux[0]) {
10424                 unsigned int present;
10425                 /* need to execute and sync at first */
10426                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
10427                 present = snd_hda_codec_read(codec, 0x15, 0,
10428                                              AC_VERB_GET_PIN_SENSE, 0);
10429                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
10430                 if (spec->jack_present)
10431                         mute = HDA_AMP_MUTE;
10432         }
10433         /* mute/unmute internal speaker */
10434         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10435                                  HDA_AMP_MUTE, mute);
10436         /* mute/unmute HP */
10437         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10438                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
10439 }
10440
10441 /* unsolicited event for HP jack sensing */
10442 static void alc262_ultra_unsol_event(struct hda_codec *codec,
10443                                        unsigned int res)
10444 {
10445         if ((res >> 26) != ALC880_HP_EVENT)
10446                 return;
10447         alc262_ultra_automute(codec);
10448 }
10449
10450 static struct hda_input_mux alc262_ultra_capture_source = {
10451         .num_items = 2,
10452         .items = {
10453                 { "Mic", 0x1 },
10454                 { "Headphone", 0x7 },
10455         },
10456 };
10457
10458 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
10459                                      struct snd_ctl_elem_value *ucontrol)
10460 {
10461         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10462         struct alc_spec *spec = codec->spec;
10463         int ret;
10464
10465         ret = alc_mux_enum_put(kcontrol, ucontrol);
10466         if (!ret)
10467                 return 0;
10468         /* reprogram the HP pin as mic or HP according to the input source */
10469         snd_hda_codec_write_cache(codec, 0x15, 0,
10470                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10471                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
10472         alc262_ultra_automute(codec); /* mute/unmute HP */
10473         return ret;
10474 }
10475
10476 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
10477         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10478         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10479         {
10480                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10481                 .name = "Capture Source",
10482                 .info = alc_mux_enum_info,
10483                 .get = alc_mux_enum_get,
10484                 .put = alc262_ultra_mux_enum_put,
10485         },
10486         { } /* end */
10487 };
10488
10489 /* add playback controls from the parsed DAC table */
10490 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
10491                                              const struct auto_pin_cfg *cfg)
10492 {
10493         hda_nid_t nid;
10494         int err;
10495
10496         spec->multiout.num_dacs = 1;    /* only use one dac */
10497         spec->multiout.dac_nids = spec->private_dac_nids;
10498         spec->multiout.dac_nids[0] = 2;
10499
10500         nid = cfg->line_out_pins[0];
10501         if (nid) {
10502                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10503                                   "Front Playback Volume",
10504                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
10505                 if (err < 0)
10506                         return err;
10507                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10508                                   "Front Playback Switch",
10509                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10510                 if (err < 0)
10511                         return err;
10512         }
10513
10514         nid = cfg->speaker_pins[0];
10515         if (nid) {
10516                 if (nid == 0x16) {
10517                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10518                                           "Speaker Playback Volume",
10519                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10520                                                               HDA_OUTPUT));
10521                         if (err < 0)
10522                                 return err;
10523                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10524                                           "Speaker Playback Switch",
10525                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10526                                                               HDA_OUTPUT));
10527                         if (err < 0)
10528                                 return err;
10529                 } else {
10530                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10531                                           "Speaker Playback Switch",
10532                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10533                                                               HDA_OUTPUT));
10534                         if (err < 0)
10535                                 return err;
10536                 }
10537         }
10538         nid = cfg->hp_pins[0];
10539         if (nid) {
10540                 /* spec->multiout.hp_nid = 2; */
10541                 if (nid == 0x16) {
10542                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10543                                           "Headphone Playback Volume",
10544                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10545                                                               HDA_OUTPUT));
10546                         if (err < 0)
10547                                 return err;
10548                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10549                                           "Headphone Playback Switch",
10550                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10551                                                               HDA_OUTPUT));
10552                         if (err < 0)
10553                                 return err;
10554                 } else {
10555                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10556                                           "Headphone Playback Switch",
10557                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10558                                                               HDA_OUTPUT));
10559                         if (err < 0)
10560                                 return err;
10561                 }
10562         }
10563         return 0;
10564 }
10565
10566 /* identical with ALC880 */
10567 #define alc262_auto_create_analog_input_ctls \
10568         alc880_auto_create_analog_input_ctls
10569
10570 /*
10571  * generic initialization of ADC, input mixers and output mixers
10572  */
10573 static struct hda_verb alc262_volume_init_verbs[] = {
10574         /*
10575          * Unmute ADC0-2 and set the default input to mic-in
10576          */
10577         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10578         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10579         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10580         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10581         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10582         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10583
10584         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10585          * mixer widget
10586          * Note: PASD motherboards uses the Line In 2 as the input for
10587          * front panel mic (mic 2)
10588          */
10589         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10590         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10591         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10592         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10593         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10594         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10595
10596         /*
10597          * Set up output mixers (0x0c - 0x0f)
10598          */
10599         /* set vol=0 to output mixers */
10600         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10601         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10602         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10603
10604         /* set up input amps for analog loopback */
10605         /* Amp Indices: DAC = 0, mixer = 1 */
10606         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10607         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10608         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10609         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10610         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10611         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10612
10613         /* FIXME: use matrix-type input source selection */
10614         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10615         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10616         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10617         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10618         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10619         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10620         /* Input mixer2 */
10621         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10622         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10623         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10624         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10625         /* Input mixer3 */
10626         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10627         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10628         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10629         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10630
10631         { }
10632 };
10633
10634 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10635         /*
10636          * Unmute ADC0-2 and set the default input to mic-in
10637          */
10638         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10639         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10640         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10641         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10642         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10643         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10644
10645         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10646          * mixer widget
10647          * Note: PASD motherboards uses the Line In 2 as the input for
10648          * front panel mic (mic 2)
10649          */
10650         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10651         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10652         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10653         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10654         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10655         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10656         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10657         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10658
10659         /*
10660          * Set up output mixers (0x0c - 0x0e)
10661          */
10662         /* set vol=0 to output mixers */
10663         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10664         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10665         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10666
10667         /* set up input amps for analog loopback */
10668         /* Amp Indices: DAC = 0, mixer = 1 */
10669         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10670         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10671         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10672         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10673         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10674         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10675
10676         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10677         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10678         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10679
10680         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10681         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10682
10683         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10684         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10685
10686         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10687         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10688         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10689         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10690         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10691
10692         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10693         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10694         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10695         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10696         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10697         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10698
10699
10700         /* FIXME: use matrix-type input source selection */
10701         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
10702         /* Input mixer1: only unmute Mic */
10703         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10704         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
10705         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10706         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10707         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10708         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
10709         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
10710         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
10711         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
10712         /* Input mixer2 */
10713         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10714         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
10715         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10716         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10717         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10718         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
10719         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
10720         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
10721         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
10722         /* Input mixer3 */
10723         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10724         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
10725         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10726         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10727         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10728         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
10729         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
10730         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
10731         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
10732
10733         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10734
10735         { }
10736 };
10737
10738 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10739         /*
10740          * Unmute ADC0-2 and set the default input to mic-in
10741          */
10742         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10743         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10744         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10745         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10746         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10747         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10748
10749         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10750          * mixer widget
10751          * Note: PASD motherboards uses the Line In 2 as the input for front
10752          * panel mic (mic 2)
10753          */
10754         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10755         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10756         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10757         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10758         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10759         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10760         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10761         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10762         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10763         /*
10764          * Set up output mixers (0x0c - 0x0e)
10765          */
10766         /* set vol=0 to output mixers */
10767         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10768         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10769         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10770
10771         /* set up input amps for analog loopback */
10772         /* Amp Indices: DAC = 0, mixer = 1 */
10773         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10774         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10775         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10776         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10777         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10778         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10779
10780
10781         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
10782         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
10783         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
10784         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
10785         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10786         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
10787         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
10788
10789         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10790         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10791
10792         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10793         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10794
10795         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10796         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10797         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10798         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10799         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10800         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10801
10802         /* FIXME: use matrix-type input source selection */
10803         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10804         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10805         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10806         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10807         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10808         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10809         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10810         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
10811         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10812         /* Input mixer2 */
10813         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10814         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10815         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10816         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10817         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10818         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10819         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10820         /* Input mixer3 */
10821         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10822         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10823         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10824         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10825         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10826         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10827         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10828
10829         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10830
10831         { }
10832 };
10833
10834 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10835
10836         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
10837         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10838         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10839
10840         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
10841         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10842         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10843         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10844
10845         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
10846         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10847         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10848         {}
10849 };
10850
10851
10852 #ifdef CONFIG_SND_HDA_POWER_SAVE
10853 #define alc262_loopbacks        alc880_loopbacks
10854 #endif
10855
10856 /* pcm configuration: identiacal with ALC880 */
10857 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
10858 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
10859 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
10860 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
10861
10862 /*
10863  * BIOS auto configuration
10864  */
10865 static int alc262_parse_auto_config(struct hda_codec *codec)
10866 {
10867         struct alc_spec *spec = codec->spec;
10868         int err;
10869         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10870
10871         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10872                                            alc262_ignore);
10873         if (err < 0)
10874                 return err;
10875         if (!spec->autocfg.line_outs) {
10876                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
10877                         spec->multiout.max_channels = 2;
10878                         spec->no_analog = 1;
10879                         goto dig_only;
10880                 }
10881                 return 0; /* can't find valid BIOS pin config */
10882         }
10883         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10884         if (err < 0)
10885                 return err;
10886         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10887         if (err < 0)
10888                 return err;
10889
10890         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10891
10892  dig_only:
10893         if (spec->autocfg.dig_outs) {
10894                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10895                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
10896         }
10897         if (spec->autocfg.dig_in_pin)
10898                 spec->dig_in_nid = ALC262_DIGIN_NID;
10899
10900         if (spec->kctls.list)
10901                 add_mixer(spec, spec->kctls.list);
10902
10903         add_verb(spec, alc262_volume_init_verbs);
10904         spec->num_mux_defs = 1;
10905         spec->input_mux = &spec->private_imux[0];
10906
10907         err = alc_auto_add_mic_boost(codec);
10908         if (err < 0)
10909                 return err;
10910
10911         alc_ssid_check(codec, 0x15, 0x14, 0x1b);
10912
10913         return 1;
10914 }
10915
10916 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
10917 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
10918 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
10919 #define alc262_auto_init_input_src      alc882_auto_init_input_src
10920
10921
10922 /* init callback for auto-configuration model -- overriding the default init */
10923 static void alc262_auto_init(struct hda_codec *codec)
10924 {
10925         struct alc_spec *spec = codec->spec;
10926         alc262_auto_init_multi_out(codec);
10927         alc262_auto_init_hp_out(codec);
10928         alc262_auto_init_analog_input(codec);
10929         alc262_auto_init_input_src(codec);
10930         if (spec->unsol_event)
10931                 alc_inithook(codec);
10932 }
10933
10934 /*
10935  * configuration and preset
10936  */
10937 static const char *alc262_models[ALC262_MODEL_LAST] = {
10938         [ALC262_BASIC]          = "basic",
10939         [ALC262_HIPPO]          = "hippo",
10940         [ALC262_HIPPO_1]        = "hippo_1",
10941         [ALC262_FUJITSU]        = "fujitsu",
10942         [ALC262_HP_BPC]         = "hp-bpc",
10943         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10944         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
10945         [ALC262_HP_RP5700]      = "hp-rp5700",
10946         [ALC262_BENQ_ED8]       = "benq",
10947         [ALC262_BENQ_T31]       = "benq-t31",
10948         [ALC262_SONY_ASSAMD]    = "sony-assamd",
10949         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
10950         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
10951         [ALC262_ULTRA]          = "ultra",
10952         [ALC262_LENOVO_3000]    = "lenovo-3000",
10953         [ALC262_NEC]            = "nec",
10954         [ALC262_TYAN]           = "tyan",
10955         [ALC262_AUTO]           = "auto",
10956 };
10957
10958 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10959         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10960         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10961         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
10962                            ALC262_HP_BPC),
10963         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
10964                            ALC262_HP_BPC),
10965         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
10966                            ALC262_HP_BPC),
10967         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10968         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10969         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10970         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10971         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10972         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10973         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10974         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10975         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10976         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10977         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10978         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10979                       ALC262_HP_TC_T5735),
10980         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10981         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10982         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10983         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10984         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
10985         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
10986                            ALC262_SONY_ASSAMD),
10987         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10988                       ALC262_TOSHIBA_RX1),
10989         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
10990         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10991         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10992         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
10993         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
10994                            ALC262_ULTRA),
10995         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
10996         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10997         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10998         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10999         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
11000         {}
11001 };
11002
11003 static struct alc_config_preset alc262_presets[] = {
11004         [ALC262_BASIC] = {
11005                 .mixers = { alc262_base_mixer },
11006                 .init_verbs = { alc262_init_verbs },
11007                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11008                 .dac_nids = alc262_dac_nids,
11009                 .hp_nid = 0x03,
11010                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11011                 .channel_mode = alc262_modes,
11012                 .input_mux = &alc262_capture_source,
11013         },
11014         [ALC262_HIPPO] = {
11015                 .mixers = { alc262_hippo_mixer },
11016                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
11017                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11018                 .dac_nids = alc262_dac_nids,
11019                 .hp_nid = 0x03,
11020                 .dig_out_nid = ALC262_DIGOUT_NID,
11021                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11022                 .channel_mode = alc262_modes,
11023                 .input_mux = &alc262_capture_source,
11024                 .unsol_event = alc262_hippo_unsol_event,
11025                 .init_hook = alc262_hippo_init_hook,
11026         },
11027         [ALC262_HIPPO_1] = {
11028                 .mixers = { alc262_hippo1_mixer },
11029                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
11030                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11031                 .dac_nids = alc262_dac_nids,
11032                 .hp_nid = 0x02,
11033                 .dig_out_nid = ALC262_DIGOUT_NID,
11034                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11035                 .channel_mode = alc262_modes,
11036                 .input_mux = &alc262_capture_source,
11037                 .unsol_event = alc262_hippo_unsol_event,
11038                 .init_hook = alc262_hippo1_init_hook,
11039         },
11040         [ALC262_FUJITSU] = {
11041                 .mixers = { alc262_fujitsu_mixer },
11042                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11043                                 alc262_fujitsu_unsol_verbs },
11044                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11045                 .dac_nids = alc262_dac_nids,
11046                 .hp_nid = 0x03,
11047                 .dig_out_nid = ALC262_DIGOUT_NID,
11048                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11049                 .channel_mode = alc262_modes,
11050                 .input_mux = &alc262_fujitsu_capture_source,
11051                 .unsol_event = alc262_fujitsu_unsol_event,
11052                 .init_hook = alc262_fujitsu_init_hook,
11053         },
11054         [ALC262_HP_BPC] = {
11055                 .mixers = { alc262_HP_BPC_mixer },
11056                 .init_verbs = { alc262_HP_BPC_init_verbs },
11057                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11058                 .dac_nids = alc262_dac_nids,
11059                 .hp_nid = 0x03,
11060                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11061                 .channel_mode = alc262_modes,
11062                 .input_mux = &alc262_HP_capture_source,
11063                 .unsol_event = alc262_hp_bpc_unsol_event,
11064                 .init_hook = alc262_hp_bpc_automute,
11065         },
11066         [ALC262_HP_BPC_D7000_WF] = {
11067                 .mixers = { alc262_HP_BPC_WildWest_mixer },
11068                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11069                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11070                 .dac_nids = alc262_dac_nids,
11071                 .hp_nid = 0x03,
11072                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11073                 .channel_mode = alc262_modes,
11074                 .input_mux = &alc262_HP_D7000_capture_source,
11075                 .unsol_event = alc262_hp_wildwest_unsol_event,
11076                 .init_hook = alc262_hp_wildwest_automute,
11077         },
11078         [ALC262_HP_BPC_D7000_WL] = {
11079                 .mixers = { alc262_HP_BPC_WildWest_mixer,
11080                             alc262_HP_BPC_WildWest_option_mixer },
11081                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11082                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11083                 .dac_nids = alc262_dac_nids,
11084                 .hp_nid = 0x03,
11085                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11086                 .channel_mode = alc262_modes,
11087                 .input_mux = &alc262_HP_D7000_capture_source,
11088                 .unsol_event = alc262_hp_wildwest_unsol_event,
11089                 .init_hook = alc262_hp_wildwest_automute,
11090         },
11091         [ALC262_HP_TC_T5735] = {
11092                 .mixers = { alc262_hp_t5735_mixer },
11093                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
11094                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11095                 .dac_nids = alc262_dac_nids,
11096                 .hp_nid = 0x03,
11097                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11098                 .channel_mode = alc262_modes,
11099                 .input_mux = &alc262_capture_source,
11100                 .unsol_event = alc_automute_amp_unsol_event,
11101                 .init_hook = alc262_hp_t5735_init_hook,
11102         },
11103         [ALC262_HP_RP5700] = {
11104                 .mixers = { alc262_hp_rp5700_mixer },
11105                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11106                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11107                 .dac_nids = alc262_dac_nids,
11108                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11109                 .channel_mode = alc262_modes,
11110                 .input_mux = &alc262_hp_rp5700_capture_source,
11111         },
11112         [ALC262_BENQ_ED8] = {
11113                 .mixers = { alc262_base_mixer },
11114                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11115                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11116                 .dac_nids = alc262_dac_nids,
11117                 .hp_nid = 0x03,
11118                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11119                 .channel_mode = alc262_modes,
11120                 .input_mux = &alc262_capture_source,
11121         },
11122         [ALC262_SONY_ASSAMD] = {
11123                 .mixers = { alc262_sony_mixer },
11124                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11125                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11126                 .dac_nids = alc262_dac_nids,
11127                 .hp_nid = 0x02,
11128                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11129                 .channel_mode = alc262_modes,
11130                 .input_mux = &alc262_capture_source,
11131                 .unsol_event = alc262_hippo_unsol_event,
11132                 .init_hook = alc262_hippo_init_hook,
11133         },
11134         [ALC262_BENQ_T31] = {
11135                 .mixers = { alc262_benq_t31_mixer },
11136                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
11137                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11138                 .dac_nids = alc262_dac_nids,
11139                 .hp_nid = 0x03,
11140                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11141                 .channel_mode = alc262_modes,
11142                 .input_mux = &alc262_capture_source,
11143                 .unsol_event = alc262_hippo_unsol_event,
11144                 .init_hook = alc262_hippo_init_hook,
11145         },
11146         [ALC262_ULTRA] = {
11147                 .mixers = { alc262_ultra_mixer },
11148                 .cap_mixer = alc262_ultra_capture_mixer,
11149                 .init_verbs = { alc262_ultra_verbs },
11150                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11151                 .dac_nids = alc262_dac_nids,
11152                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11153                 .channel_mode = alc262_modes,
11154                 .input_mux = &alc262_ultra_capture_source,
11155                 .adc_nids = alc262_adc_nids, /* ADC0 */
11156                 .capsrc_nids = alc262_capsrc_nids,
11157                 .num_adc_nids = 1, /* single ADC */
11158                 .unsol_event = alc262_ultra_unsol_event,
11159                 .init_hook = alc262_ultra_automute,
11160         },
11161         [ALC262_LENOVO_3000] = {
11162                 .mixers = { alc262_lenovo_3000_mixer },
11163                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11164                                 alc262_lenovo_3000_unsol_verbs },
11165                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11166                 .dac_nids = alc262_dac_nids,
11167                 .hp_nid = 0x03,
11168                 .dig_out_nid = ALC262_DIGOUT_NID,
11169                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11170                 .channel_mode = alc262_modes,
11171                 .input_mux = &alc262_fujitsu_capture_source,
11172                 .unsol_event = alc262_lenovo_3000_unsol_event,
11173         },
11174         [ALC262_NEC] = {
11175                 .mixers = { alc262_nec_mixer },
11176                 .init_verbs = { alc262_nec_verbs },
11177                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11178                 .dac_nids = alc262_dac_nids,
11179                 .hp_nid = 0x03,
11180                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11181                 .channel_mode = alc262_modes,
11182                 .input_mux = &alc262_capture_source,
11183         },
11184         [ALC262_TOSHIBA_S06] = {
11185                 .mixers = { alc262_toshiba_s06_mixer },
11186                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11187                                                         alc262_eapd_verbs },
11188                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11189                 .capsrc_nids = alc262_dmic_capsrc_nids,
11190                 .dac_nids = alc262_dac_nids,
11191                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11192                 .dig_out_nid = ALC262_DIGOUT_NID,
11193                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11194                 .channel_mode = alc262_modes,
11195                 .input_mux = &alc262_dmic_capture_source,
11196                 .unsol_event = alc262_toshiba_s06_unsol_event,
11197                 .init_hook = alc262_toshiba_s06_init_hook,
11198         },
11199         [ALC262_TOSHIBA_RX1] = {
11200                 .mixers = { alc262_toshiba_rx1_mixer },
11201                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11202                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11203                 .dac_nids = alc262_dac_nids,
11204                 .hp_nid = 0x03,
11205                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11206                 .channel_mode = alc262_modes,
11207                 .input_mux = &alc262_capture_source,
11208                 .unsol_event = alc262_hippo_unsol_event,
11209                 .init_hook = alc262_hippo_init_hook,
11210         },
11211         [ALC262_TYAN] = {
11212                 .mixers = { alc262_tyan_mixer },
11213                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11214                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11215                 .dac_nids = alc262_dac_nids,
11216                 .hp_nid = 0x02,
11217                 .dig_out_nid = ALC262_DIGOUT_NID,
11218                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11219                 .channel_mode = alc262_modes,
11220                 .input_mux = &alc262_capture_source,
11221                 .unsol_event = alc_automute_amp_unsol_event,
11222                 .init_hook = alc262_tyan_init_hook,
11223         },
11224 };
11225
11226 static int patch_alc262(struct hda_codec *codec)
11227 {
11228         struct alc_spec *spec;
11229         int board_config;
11230         int err;
11231
11232         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11233         if (spec == NULL)
11234                 return -ENOMEM;
11235
11236         codec->spec = spec;
11237 #if 0
11238         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11239          * under-run
11240          */
11241         {
11242         int tmp;
11243         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11244         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11245         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11246         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11247         }
11248 #endif
11249
11250         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11251
11252         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11253                                                   alc262_models,
11254                                                   alc262_cfg_tbl);
11255
11256         if (board_config < 0) {
11257                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
11258                        "trying auto-probe from BIOS...\n", codec->chip_name);
11259                 board_config = ALC262_AUTO;
11260         }
11261
11262         if (board_config == ALC262_AUTO) {
11263                 /* automatic parse from the BIOS config */
11264                 err = alc262_parse_auto_config(codec);
11265                 if (err < 0) {
11266                         alc_free(codec);
11267                         return err;
11268                 } else if (!err) {
11269                         printk(KERN_INFO
11270                                "hda_codec: Cannot set up configuration "
11271                                "from BIOS.  Using base mode...\n");
11272                         board_config = ALC262_BASIC;
11273                 }
11274         }
11275
11276         if (!spec->no_analog) {
11277                 err = snd_hda_attach_beep_device(codec, 0x1);
11278                 if (err < 0) {
11279                         alc_free(codec);
11280                         return err;
11281                 }
11282         }
11283
11284         if (board_config != ALC262_AUTO)
11285                 setup_preset(spec, &alc262_presets[board_config]);
11286
11287         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11288         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11289
11290         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11291         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11292
11293         spec->capture_style = CAPT_MIX;
11294         if (!spec->adc_nids && spec->input_mux) {
11295                 /* check whether NID 0x07 is valid */
11296                 unsigned int wcap = get_wcaps(codec, 0x07);
11297
11298                 /* get type */
11299                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11300                 if (wcap != AC_WID_AUD_IN) {
11301                         spec->adc_nids = alc262_adc_nids_alt;
11302                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
11303                         spec->capsrc_nids = alc262_capsrc_nids_alt;
11304                 } else {
11305                         spec->adc_nids = alc262_adc_nids;
11306                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
11307                         spec->capsrc_nids = alc262_capsrc_nids;
11308                 }
11309         }
11310         if (!spec->cap_mixer && !spec->no_analog)
11311                 set_capture_mixer(spec);
11312         if (!spec->no_analog)
11313                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11314
11315         spec->vmaster_nid = 0x0c;
11316
11317         codec->patch_ops = alc_patch_ops;
11318         if (board_config == ALC262_AUTO)
11319                 spec->init_hook = alc262_auto_init;
11320 #ifdef CONFIG_SND_HDA_POWER_SAVE
11321         if (!spec->loopback.amplist)
11322                 spec->loopback.amplist = alc262_loopbacks;
11323 #endif
11324         codec->proc_widget_hook = print_realtek_coef;
11325
11326         return 0;
11327 }
11328
11329 /*
11330  *  ALC268 channel source setting (2 channel)
11331  */
11332 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
11333 #define alc268_modes            alc260_modes
11334
11335 static hda_nid_t alc268_dac_nids[2] = {
11336         /* front, hp */
11337         0x02, 0x03
11338 };
11339
11340 static hda_nid_t alc268_adc_nids[2] = {
11341         /* ADC0-1 */
11342         0x08, 0x07
11343 };
11344
11345 static hda_nid_t alc268_adc_nids_alt[1] = {
11346         /* ADC0 */
11347         0x08
11348 };
11349
11350 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11351
11352 static struct snd_kcontrol_new alc268_base_mixer[] = {
11353         /* output mixer control */
11354         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11355         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11356         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11357         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11358         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11359         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11360         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11361         { }
11362 };
11363
11364 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
11365         /* output mixer control */
11366         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11367         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11368         ALC262_HIPPO_MASTER_SWITCH,
11369         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11370         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11371         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11372         { }
11373 };
11374
11375 /* bind Beep switches of both NID 0x0f and 0x10 */
11376 static struct hda_bind_ctls alc268_bind_beep_sw = {
11377         .ops = &snd_hda_bind_sw,
11378         .values = {
11379                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
11380                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
11381                 0
11382         },
11383 };
11384
11385 static struct snd_kcontrol_new alc268_beep_mixer[] = {
11386         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
11387         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
11388         { }
11389 };
11390
11391 static struct hda_verb alc268_eapd_verbs[] = {
11392         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11393         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11394         { }
11395 };
11396
11397 /* Toshiba specific */
11398 static struct hda_verb alc268_toshiba_verbs[] = {
11399         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11400         { } /* end */
11401 };
11402
11403 static struct hda_input_mux alc268_acer_lc_capture_source = {
11404         .num_items = 2,
11405         .items = {
11406                 { "i-Mic", 0x6 },
11407                 { "E-Mic", 0x0 },
11408         },
11409 };
11410
11411 /* Acer specific */
11412 /* bind volumes of both NID 0x02 and 0x03 */
11413 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
11414         .ops = &snd_hda_bind_vol,
11415         .values = {
11416                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11417                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11418                 0
11419         },
11420 };
11421
11422 /* mute/unmute internal speaker according to the hp jack and mute state */
11423 static void alc268_acer_automute(struct hda_codec *codec, int force)
11424 {
11425         struct alc_spec *spec = codec->spec;
11426         unsigned int mute;
11427
11428         if (force || !spec->sense_updated) {
11429                 unsigned int present;
11430                 present = snd_hda_codec_read(codec, 0x14, 0,
11431                                          AC_VERB_GET_PIN_SENSE, 0);
11432                 spec->jack_present = (present & 0x80000000) != 0;
11433                 spec->sense_updated = 1;
11434         }
11435         if (spec->jack_present)
11436                 mute = HDA_AMP_MUTE; /* mute internal speaker */
11437         else /* unmute internal speaker if necessary */
11438                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11439         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11440                                  HDA_AMP_MUTE, mute);
11441 }
11442
11443
11444 /* bind hp and internal speaker mute (with plug check) */
11445 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
11446                                      struct snd_ctl_elem_value *ucontrol)
11447 {
11448         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11449         long *valp = ucontrol->value.integer.value;
11450         int change;
11451
11452         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
11453                                           HDA_AMP_MUTE,
11454                                           valp[0] ? 0 : HDA_AMP_MUTE);
11455         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
11456                                            HDA_AMP_MUTE,
11457                                            valp[1] ? 0 : HDA_AMP_MUTE);
11458         if (change)
11459                 alc268_acer_automute(codec, 0);
11460         return change;
11461 }
11462
11463 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
11464         /* output mixer control */
11465         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11466         {
11467                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11468                 .name = "Master Playback Switch",
11469                 .info = snd_hda_mixer_amp_switch_info,
11470                 .get = snd_hda_mixer_amp_switch_get,
11471                 .put = alc268_acer_master_sw_put,
11472                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11473         },
11474         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
11475         { }
11476 };
11477
11478 static struct snd_kcontrol_new alc268_acer_mixer[] = {
11479         /* output mixer control */
11480         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11481         {
11482                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11483                 .name = "Master Playback Switch",
11484                 .info = snd_hda_mixer_amp_switch_info,
11485                 .get = snd_hda_mixer_amp_switch_get,
11486                 .put = alc268_acer_master_sw_put,
11487                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11488         },
11489         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11490         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11491         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11492         { }
11493 };
11494
11495 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
11496         /* output mixer control */
11497         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11498         {
11499                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11500                 .name = "Master Playback Switch",
11501                 .info = snd_hda_mixer_amp_switch_info,
11502                 .get = snd_hda_mixer_amp_switch_get,
11503                 .put = alc268_acer_master_sw_put,
11504                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11505         },
11506         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11507         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11508         { }
11509 };
11510
11511 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
11512         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11513         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11514         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11515         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11516         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
11517         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
11518         { }
11519 };
11520
11521 static struct hda_verb alc268_acer_verbs[] = {
11522         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
11523         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11524         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11525         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11526         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11527         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11528         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11529         { }
11530 };
11531
11532 /* unsolicited event for HP jack sensing */
11533 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
11534 #define alc268_toshiba_init_hook        alc262_hippo_init_hook
11535
11536 static void alc268_acer_unsol_event(struct hda_codec *codec,
11537                                        unsigned int res)
11538 {
11539         if ((res >> 26) != ALC880_HP_EVENT)
11540                 return;
11541         alc268_acer_automute(codec, 1);
11542 }
11543
11544 static void alc268_acer_init_hook(struct hda_codec *codec)
11545 {
11546         alc268_acer_automute(codec, 1);
11547 }
11548
11549 /* toggle speaker-output according to the hp-jack state */
11550 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
11551 {
11552         unsigned int present;
11553         unsigned char bits;
11554
11555         present = snd_hda_codec_read(codec, 0x15, 0,
11556                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11557         bits = present ? AMP_IN_MUTE(0) : 0;
11558         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
11559                                 AMP_IN_MUTE(0), bits);
11560         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
11561                                 AMP_IN_MUTE(0), bits);
11562 }
11563
11564
11565 static void alc268_acer_mic_automute(struct hda_codec *codec)
11566 {
11567         unsigned int present;
11568
11569         present = snd_hda_codec_read(codec, 0x18, 0,
11570                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11571         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11572                             present ? 0x0 : 0x6);
11573 }
11574
11575 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
11576                                     unsigned int res)
11577 {
11578         if ((res >> 26) == ALC880_HP_EVENT)
11579                 alc268_aspire_one_speaker_automute(codec);
11580         if ((res >> 26) == ALC880_MIC_EVENT)
11581                 alc268_acer_mic_automute(codec);
11582 }
11583
11584 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
11585 {
11586         alc268_aspire_one_speaker_automute(codec);
11587         alc268_acer_mic_automute(codec);
11588 }
11589
11590 static struct snd_kcontrol_new alc268_dell_mixer[] = {
11591         /* output mixer control */
11592         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11593         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11594         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11595         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11596         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11597         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11598         { }
11599 };
11600
11601 static struct hda_verb alc268_dell_verbs[] = {
11602         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11603         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11604         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11605         { }
11606 };
11607
11608 /* mute/unmute internal speaker according to the hp jack and mute state */
11609 static void alc268_dell_init_hook(struct hda_codec *codec)
11610 {
11611         struct alc_spec *spec = codec->spec;
11612
11613         spec->autocfg.hp_pins[0] = 0x15;
11614         spec->autocfg.speaker_pins[0] = 0x14;
11615         alc_automute_pin(codec);
11616 }
11617
11618 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
11619         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11620         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11621         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11622         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11623         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11624         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
11625         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
11626         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11627         { }
11628 };
11629
11630 static struct hda_verb alc267_quanta_il1_verbs[] = {
11631         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11632         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11633         { }
11634 };
11635
11636 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11637 {
11638         unsigned int present;
11639
11640         present = snd_hda_codec_read(codec, 0x18, 0,
11641                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11642         snd_hda_codec_write(codec, 0x23, 0,
11643                             AC_VERB_SET_CONNECT_SEL,
11644                             present ? 0x00 : 0x01);
11645 }
11646
11647 static void alc267_quanta_il1_init_hook(struct hda_codec *codec)
11648 {
11649         struct alc_spec *spec = codec->spec;
11650
11651         spec->autocfg.hp_pins[0] = 0x15;
11652         spec->autocfg.speaker_pins[0] = 0x14;
11653         alc_automute_pin(codec);
11654         alc267_quanta_il1_mic_automute(codec);
11655 }
11656
11657 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11658                                            unsigned int res)
11659 {
11660         switch (res >> 26) {
11661         case ALC880_MIC_EVENT:
11662                 alc267_quanta_il1_mic_automute(codec);
11663                 break;
11664         default:
11665                 alc_sku_unsol_event(codec, res);
11666                 break;
11667         }
11668 }
11669
11670 /*
11671  * generic initialization of ADC, input mixers and output mixers
11672  */
11673 static struct hda_verb alc268_base_init_verbs[] = {
11674         /* Unmute DAC0-1 and set vol = 0 */
11675         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11676         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11677
11678         /*
11679          * Set up output mixers (0x0c - 0x0e)
11680          */
11681         /* set vol=0 to output mixers */
11682         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11683         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11684
11685         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11686         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11687
11688         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11689         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11690         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11691         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11692         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11693         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11694         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11695         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11696
11697         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11698         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11699         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11700         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11701         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11702
11703         /* set PCBEEP vol = 0, mute connections */
11704         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11705         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11706         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11707
11708         /* Unmute Selector 23h,24h and set the default input to mic-in */
11709
11710         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11711         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11712         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11713         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11714
11715         { }
11716 };
11717
11718 /*
11719  * generic initialization of ADC, input mixers and output mixers
11720  */
11721 static struct hda_verb alc268_volume_init_verbs[] = {
11722         /* set output DAC */
11723         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11724         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11725
11726         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11727         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11728         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11729         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11730         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11731
11732         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11733         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11734         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11735
11736         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11737         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11738
11739         /* set PCBEEP vol = 0, mute connections */
11740         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11741         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11742         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11743
11744         { }
11745 };
11746
11747 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11748         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11749         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11750         {
11751                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11752                 /* The multiple "Capture Source" controls confuse alsamixer
11753                  * So call somewhat different..
11754                  */
11755                 /* .name = "Capture Source", */
11756                 .name = "Input Source",
11757                 .count = 1,
11758                 .info = alc_mux_enum_info,
11759                 .get = alc_mux_enum_get,
11760                 .put = alc_mux_enum_put,
11761         },
11762         { } /* end */
11763 };
11764
11765 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11766         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11767         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11768         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11769         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11770         {
11771                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11772                 /* The multiple "Capture Source" controls confuse alsamixer
11773                  * So call somewhat different..
11774                  */
11775                 /* .name = "Capture Source", */
11776                 .name = "Input Source",
11777                 .count = 2,
11778                 .info = alc_mux_enum_info,
11779                 .get = alc_mux_enum_get,
11780                 .put = alc_mux_enum_put,
11781         },
11782         { } /* end */
11783 };
11784
11785 static struct hda_input_mux alc268_capture_source = {
11786         .num_items = 4,
11787         .items = {
11788                 { "Mic", 0x0 },
11789                 { "Front Mic", 0x1 },
11790                 { "Line", 0x2 },
11791                 { "CD", 0x3 },
11792         },
11793 };
11794
11795 static struct hda_input_mux alc268_acer_capture_source = {
11796         .num_items = 3,
11797         .items = {
11798                 { "Mic", 0x0 },
11799                 { "Internal Mic", 0x1 },
11800                 { "Line", 0x2 },
11801         },
11802 };
11803
11804 static struct hda_input_mux alc268_acer_dmic_capture_source = {
11805         .num_items = 3,
11806         .items = {
11807                 { "Mic", 0x0 },
11808                 { "Internal Mic", 0x6 },
11809                 { "Line", 0x2 },
11810         },
11811 };
11812
11813 #ifdef CONFIG_SND_DEBUG
11814 static struct snd_kcontrol_new alc268_test_mixer[] = {
11815         /* Volume widgets */
11816         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11817         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11818         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11819         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11820         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11821         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11822         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11823         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11824         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11825         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11826         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11827         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11828         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11829         /* The below appears problematic on some hardwares */
11830         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11831         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11832         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11833         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11834         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11835
11836         /* Modes for retasking pin widgets */
11837         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11838         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11839         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11840         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11841
11842         /* Controls for GPIO pins, assuming they are configured as outputs */
11843         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11844         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11845         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11846         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11847
11848         /* Switches to allow the digital SPDIF output pin to be enabled.
11849          * The ALC268 does not have an SPDIF input.
11850          */
11851         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11852
11853         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
11854          * this output to turn on an external amplifier.
11855          */
11856         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11857         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11858
11859         { } /* end */
11860 };
11861 #endif
11862
11863 /* create input playback/capture controls for the given pin */
11864 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11865                                     const char *ctlname, int idx)
11866 {
11867         char name[32];
11868         int err;
11869
11870         sprintf(name, "%s Playback Volume", ctlname);
11871         if (nid == 0x14) {
11872                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11873                                   HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
11874                                                       HDA_OUTPUT));
11875                 if (err < 0)
11876                         return err;
11877         } else if (nid == 0x15) {
11878                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11879                                   HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
11880                                                       HDA_OUTPUT));
11881                 if (err < 0)
11882                         return err;
11883         } else
11884                 return -1;
11885         sprintf(name, "%s Playback Switch", ctlname);
11886         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11887                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11888         if (err < 0)
11889                 return err;
11890         return 0;
11891 }
11892
11893 /* add playback controls from the parsed DAC table */
11894 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11895                                              const struct auto_pin_cfg *cfg)
11896 {
11897         hda_nid_t nid;
11898         int err;
11899
11900         spec->multiout.num_dacs = 2;    /* only use one dac */
11901         spec->multiout.dac_nids = spec->private_dac_nids;
11902         spec->multiout.dac_nids[0] = 2;
11903         spec->multiout.dac_nids[1] = 3;
11904
11905         nid = cfg->line_out_pins[0];
11906         if (nid)
11907                 alc268_new_analog_output(spec, nid, "Front", 0);
11908
11909         nid = cfg->speaker_pins[0];
11910         if (nid == 0x1d) {
11911                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11912                                   "Speaker Playback Volume",
11913                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11914                 if (err < 0)
11915                         return err;
11916         }
11917         nid = cfg->hp_pins[0];
11918         if (nid)
11919                 alc268_new_analog_output(spec, nid, "Headphone", 0);
11920
11921         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11922         if (nid == 0x16) {
11923                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11924                                   "Mono Playback Switch",
11925                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
11926                 if (err < 0)
11927                         return err;
11928         }
11929         return 0;
11930 }
11931
11932 /* create playback/capture controls for input pins */
11933 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11934                                                 const struct auto_pin_cfg *cfg)
11935 {
11936         struct hda_input_mux *imux = &spec->private_imux[0];
11937         int i, idx1;
11938
11939         for (i = 0; i < AUTO_PIN_LAST; i++) {
11940                 switch(cfg->input_pins[i]) {
11941                 case 0x18:
11942                         idx1 = 0;       /* Mic 1 */
11943                         break;
11944                 case 0x19:
11945                         idx1 = 1;       /* Mic 2 */
11946                         break;
11947                 case 0x1a:
11948                         idx1 = 2;       /* Line In */
11949                         break;
11950                 case 0x1c:
11951                         idx1 = 3;       /* CD */
11952                         break;
11953                 case 0x12:
11954                 case 0x13:
11955                         idx1 = 6;       /* digital mics */
11956                         break;
11957                 default:
11958                         continue;
11959                 }
11960                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11961                 imux->items[imux->num_items].index = idx1;
11962                 imux->num_items++;
11963         }
11964         return 0;
11965 }
11966
11967 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11968 {
11969         struct alc_spec *spec = codec->spec;
11970         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11971         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11972         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11973         unsigned int    dac_vol1, dac_vol2;
11974
11975         if (speaker_nid) {
11976                 snd_hda_codec_write(codec, speaker_nid, 0,
11977                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11978                 snd_hda_codec_write(codec, 0x0f, 0,
11979                                     AC_VERB_SET_AMP_GAIN_MUTE,
11980                                     AMP_IN_UNMUTE(1));
11981                 snd_hda_codec_write(codec, 0x10, 0,
11982                                     AC_VERB_SET_AMP_GAIN_MUTE,
11983                                     AMP_IN_UNMUTE(1));
11984         } else {
11985                 snd_hda_codec_write(codec, 0x0f, 0,
11986                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11987                 snd_hda_codec_write(codec, 0x10, 0,
11988                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11989         }
11990
11991         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
11992         if (line_nid == 0x14)
11993                 dac_vol2 = AMP_OUT_ZERO;
11994         else if (line_nid == 0x15)
11995                 dac_vol1 = AMP_OUT_ZERO;
11996         if (hp_nid == 0x14)
11997                 dac_vol2 = AMP_OUT_ZERO;
11998         else if (hp_nid == 0x15)
11999                 dac_vol1 = AMP_OUT_ZERO;
12000         if (line_nid != 0x16 || hp_nid != 0x16 ||
12001             spec->autocfg.line_out_pins[1] != 0x16 ||
12002             spec->autocfg.line_out_pins[2] != 0x16)
12003                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
12004
12005         snd_hda_codec_write(codec, 0x02, 0,
12006                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
12007         snd_hda_codec_write(codec, 0x03, 0,
12008                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
12009 }
12010
12011 /* pcm configuration: identiacal with ALC880 */
12012 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
12013 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
12014 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
12015 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
12016
12017 /*
12018  * BIOS auto configuration
12019  */
12020 static int alc268_parse_auto_config(struct hda_codec *codec)
12021 {
12022         struct alc_spec *spec = codec->spec;
12023         int err;
12024         static hda_nid_t alc268_ignore[] = { 0 };
12025
12026         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12027                                            alc268_ignore);
12028         if (err < 0)
12029                 return err;
12030         if (!spec->autocfg.line_outs) {
12031                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12032                         spec->multiout.max_channels = 2;
12033                         spec->no_analog = 1;
12034                         goto dig_only;
12035                 }
12036                 return 0; /* can't find valid BIOS pin config */
12037         }
12038         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
12039         if (err < 0)
12040                 return err;
12041         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
12042         if (err < 0)
12043                 return err;
12044
12045         spec->multiout.max_channels = 2;
12046
12047  dig_only:
12048         /* digital only support output */
12049         if (spec->autocfg.dig_outs) {
12050                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
12051                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
12052         }
12053         if (spec->kctls.list)
12054                 add_mixer(spec, spec->kctls.list);
12055
12056         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
12057                 add_mixer(spec, alc268_beep_mixer);
12058
12059         add_verb(spec, alc268_volume_init_verbs);
12060         spec->num_mux_defs = 1;
12061         spec->input_mux = &spec->private_imux[0];
12062
12063         err = alc_auto_add_mic_boost(codec);
12064         if (err < 0)
12065                 return err;
12066
12067         return 1;
12068 }
12069
12070 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
12071 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
12072 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
12073
12074 /* init callback for auto-configuration model -- overriding the default init */
12075 static void alc268_auto_init(struct hda_codec *codec)
12076 {
12077         struct alc_spec *spec = codec->spec;
12078         alc268_auto_init_multi_out(codec);
12079         alc268_auto_init_hp_out(codec);
12080         alc268_auto_init_mono_speaker_out(codec);
12081         alc268_auto_init_analog_input(codec);
12082         if (spec->unsol_event)
12083                 alc_inithook(codec);
12084 }
12085
12086 /*
12087  * configuration and preset
12088  */
12089 static const char *alc268_models[ALC268_MODEL_LAST] = {
12090         [ALC267_QUANTA_IL1]     = "quanta-il1",
12091         [ALC268_3ST]            = "3stack",
12092         [ALC268_TOSHIBA]        = "toshiba",
12093         [ALC268_ACER]           = "acer",
12094         [ALC268_ACER_DMIC]      = "acer-dmic",
12095         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
12096         [ALC268_DELL]           = "dell",
12097         [ALC268_ZEPTO]          = "zepto",
12098 #ifdef CONFIG_SND_DEBUG
12099         [ALC268_TEST]           = "test",
12100 #endif
12101         [ALC268_AUTO]           = "auto",
12102 };
12103
12104 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12105         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12106         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12107         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12108         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12109         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12110         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12111                                                 ALC268_ACER_ASPIRE_ONE),
12112         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12113         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
12114         SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
12115         SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
12116         SND_PCI_QUIRK(0x103c, 0x30f1, "HP TX25xx series", ALC268_TOSHIBA),
12117         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12118         SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
12119         SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
12120         SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
12121         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12122         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12123         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12124         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12125         {}
12126 };
12127
12128 static struct alc_config_preset alc268_presets[] = {
12129         [ALC267_QUANTA_IL1] = {
12130                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
12131                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12132                                 alc267_quanta_il1_verbs },
12133                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12134                 .dac_nids = alc268_dac_nids,
12135                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12136                 .adc_nids = alc268_adc_nids_alt,
12137                 .hp_nid = 0x03,
12138                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12139                 .channel_mode = alc268_modes,
12140                 .input_mux = &alc268_capture_source,
12141                 .unsol_event = alc267_quanta_il1_unsol_event,
12142                 .init_hook = alc267_quanta_il1_init_hook,
12143         },
12144         [ALC268_3ST] = {
12145                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12146                             alc268_beep_mixer },
12147                 .init_verbs = { alc268_base_init_verbs },
12148                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12149                 .dac_nids = alc268_dac_nids,
12150                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12151                 .adc_nids = alc268_adc_nids_alt,
12152                 .capsrc_nids = alc268_capsrc_nids,
12153                 .hp_nid = 0x03,
12154                 .dig_out_nid = ALC268_DIGOUT_NID,
12155                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12156                 .channel_mode = alc268_modes,
12157                 .input_mux = &alc268_capture_source,
12158         },
12159         [ALC268_TOSHIBA] = {
12160                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
12161                             alc268_beep_mixer },
12162                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12163                                 alc268_toshiba_verbs },
12164                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12165                 .dac_nids = alc268_dac_nids,
12166                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12167                 .adc_nids = alc268_adc_nids_alt,
12168                 .capsrc_nids = alc268_capsrc_nids,
12169                 .hp_nid = 0x03,
12170                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12171                 .channel_mode = alc268_modes,
12172                 .input_mux = &alc268_capture_source,
12173                 .unsol_event = alc268_toshiba_unsol_event,
12174                 .init_hook = alc268_toshiba_init_hook,
12175         },
12176         [ALC268_ACER] = {
12177                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12178                             alc268_beep_mixer },
12179                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12180                                 alc268_acer_verbs },
12181                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12182                 .dac_nids = alc268_dac_nids,
12183                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12184                 .adc_nids = alc268_adc_nids_alt,
12185                 .capsrc_nids = alc268_capsrc_nids,
12186                 .hp_nid = 0x02,
12187                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12188                 .channel_mode = alc268_modes,
12189                 .input_mux = &alc268_acer_capture_source,
12190                 .unsol_event = alc268_acer_unsol_event,
12191                 .init_hook = alc268_acer_init_hook,
12192         },
12193         [ALC268_ACER_DMIC] = {
12194                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12195                             alc268_beep_mixer },
12196                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12197                                 alc268_acer_verbs },
12198                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12199                 .dac_nids = alc268_dac_nids,
12200                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12201                 .adc_nids = alc268_adc_nids_alt,
12202                 .capsrc_nids = alc268_capsrc_nids,
12203                 .hp_nid = 0x02,
12204                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12205                 .channel_mode = alc268_modes,
12206                 .input_mux = &alc268_acer_dmic_capture_source,
12207                 .unsol_event = alc268_acer_unsol_event,
12208                 .init_hook = alc268_acer_init_hook,
12209         },
12210         [ALC268_ACER_ASPIRE_ONE] = {
12211                 .mixers = { alc268_acer_aspire_one_mixer,
12212                             alc268_beep_mixer,
12213                             alc268_capture_alt_mixer },
12214                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12215                                 alc268_acer_aspire_one_verbs },
12216                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12217                 .dac_nids = alc268_dac_nids,
12218                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12219                 .adc_nids = alc268_adc_nids_alt,
12220                 .capsrc_nids = alc268_capsrc_nids,
12221                 .hp_nid = 0x03,
12222                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12223                 .channel_mode = alc268_modes,
12224                 .input_mux = &alc268_acer_lc_capture_source,
12225                 .unsol_event = alc268_acer_lc_unsol_event,
12226                 .init_hook = alc268_acer_lc_init_hook,
12227         },
12228         [ALC268_DELL] = {
12229                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
12230                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12231                                 alc268_dell_verbs },
12232                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12233                 .dac_nids = alc268_dac_nids,
12234                 .hp_nid = 0x02,
12235                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12236                 .channel_mode = alc268_modes,
12237                 .unsol_event = alc_sku_unsol_event,
12238                 .init_hook = alc268_dell_init_hook,
12239                 .input_mux = &alc268_capture_source,
12240         },
12241         [ALC268_ZEPTO] = {
12242                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12243                             alc268_beep_mixer },
12244                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12245                                 alc268_toshiba_verbs },
12246                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12247                 .dac_nids = alc268_dac_nids,
12248                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12249                 .adc_nids = alc268_adc_nids_alt,
12250                 .capsrc_nids = alc268_capsrc_nids,
12251                 .hp_nid = 0x03,
12252                 .dig_out_nid = ALC268_DIGOUT_NID,
12253                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12254                 .channel_mode = alc268_modes,
12255                 .input_mux = &alc268_capture_source,
12256                 .unsol_event = alc268_toshiba_unsol_event,
12257                 .init_hook = alc268_toshiba_init_hook
12258         },
12259 #ifdef CONFIG_SND_DEBUG
12260         [ALC268_TEST] = {
12261                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
12262                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12263                                 alc268_volume_init_verbs },
12264                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12265                 .dac_nids = alc268_dac_nids,
12266                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12267                 .adc_nids = alc268_adc_nids_alt,
12268                 .capsrc_nids = alc268_capsrc_nids,
12269                 .hp_nid = 0x03,
12270                 .dig_out_nid = ALC268_DIGOUT_NID,
12271                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12272                 .channel_mode = alc268_modes,
12273                 .input_mux = &alc268_capture_source,
12274         },
12275 #endif
12276 };
12277
12278 static int patch_alc268(struct hda_codec *codec)
12279 {
12280         struct alc_spec *spec;
12281         int board_config;
12282         int i, has_beep, err;
12283
12284         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12285         if (spec == NULL)
12286                 return -ENOMEM;
12287
12288         codec->spec = spec;
12289
12290         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12291                                                   alc268_models,
12292                                                   alc268_cfg_tbl);
12293
12294         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12295                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
12296                        "trying auto-probe from BIOS...\n", codec->chip_name);
12297                 board_config = ALC268_AUTO;
12298         }
12299
12300         if (board_config == ALC268_AUTO) {
12301                 /* automatic parse from the BIOS config */
12302                 err = alc268_parse_auto_config(codec);
12303                 if (err < 0) {
12304                         alc_free(codec);
12305                         return err;
12306                 } else if (!err) {
12307                         printk(KERN_INFO
12308                                "hda_codec: Cannot set up configuration "
12309                                "from BIOS.  Using base mode...\n");
12310                         board_config = ALC268_3ST;
12311                 }
12312         }
12313
12314         if (board_config != ALC268_AUTO)
12315                 setup_preset(spec, &alc268_presets[board_config]);
12316
12317         spec->stream_analog_playback = &alc268_pcm_analog_playback;
12318         spec->stream_analog_capture = &alc268_pcm_analog_capture;
12319         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12320
12321         spec->stream_digital_playback = &alc268_pcm_digital_playback;
12322
12323         has_beep = 0;
12324         for (i = 0; i < spec->num_mixers; i++) {
12325                 if (spec->mixers[i] == alc268_beep_mixer) {
12326                         has_beep = 1;
12327                         break;
12328                 }
12329         }
12330
12331         if (has_beep) {
12332                 err = snd_hda_attach_beep_device(codec, 0x1);
12333                 if (err < 0) {
12334                         alc_free(codec);
12335                         return err;
12336                 }
12337                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12338                         /* override the amp caps for beep generator */
12339                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12340                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12341                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12342                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12343                                           (0 << AC_AMPCAP_MUTE_SHIFT));
12344         }
12345
12346         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12347                 /* check whether NID 0x07 is valid */
12348                 unsigned int wcap = get_wcaps(codec, 0x07);
12349                 int i;
12350
12351                 /* get type */
12352                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
12353                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
12354                         spec->adc_nids = alc268_adc_nids_alt;
12355                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
12356                         add_mixer(spec, alc268_capture_alt_mixer);
12357                 } else {
12358                         spec->adc_nids = alc268_adc_nids;
12359                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
12360                         add_mixer(spec, alc268_capture_mixer);
12361                 }
12362                 spec->capsrc_nids = alc268_capsrc_nids;
12363                 /* set default input source */
12364                 for (i = 0; i < spec->num_adc_nids; i++)
12365                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
12366                                 0, AC_VERB_SET_CONNECT_SEL,
12367                                 spec->input_mux->items[0].index);
12368         }
12369
12370         spec->vmaster_nid = 0x02;
12371
12372         codec->patch_ops = alc_patch_ops;
12373         if (board_config == ALC268_AUTO)
12374                 spec->init_hook = alc268_auto_init;
12375
12376         codec->proc_widget_hook = print_realtek_coef;
12377
12378         return 0;
12379 }
12380
12381 /*
12382  *  ALC269 channel source setting (2 channel)
12383  */
12384 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
12385
12386 #define alc269_dac_nids         alc260_dac_nids
12387
12388 static hda_nid_t alc269_adc_nids[1] = {
12389         /* ADC1 */
12390         0x08,
12391 };
12392
12393 static hda_nid_t alc269_capsrc_nids[1] = {
12394         0x23,
12395 };
12396
12397 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
12398  *       not a mux!
12399  */
12400
12401 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
12402         .num_items = 2,
12403         .items = {
12404                 { "i-Mic", 0x5 },
12405                 { "e-Mic", 0x0 },
12406         },
12407 };
12408
12409 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
12410         .num_items = 2,
12411         .items = {
12412                 { "i-Mic", 0x1 },
12413                 { "e-Mic", 0x0 },
12414         },
12415 };
12416
12417 #define alc269_modes            alc260_modes
12418 #define alc269_capture_source   alc880_lg_lw_capture_source
12419
12420 static struct snd_kcontrol_new alc269_base_mixer[] = {
12421         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12422         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12423         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12424         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12425         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12426         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12427         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12428         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12429         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12430         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12431         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12432         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
12433         { } /* end */
12434 };
12435
12436 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
12437         /* output mixer control */
12438         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12439         {
12440                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12441                 .name = "Master Playback Switch",
12442                 .info = snd_hda_mixer_amp_switch_info,
12443                 .get = snd_hda_mixer_amp_switch_get,
12444                 .put = alc268_acer_master_sw_put,
12445                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12446         },
12447         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12448         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12449         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12450         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12451         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12452         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12453         { }
12454 };
12455
12456 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
12457         /* output mixer control */
12458         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12459         {
12460                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12461                 .name = "Master Playback Switch",
12462                 .info = snd_hda_mixer_amp_switch_info,
12463                 .get = snd_hda_mixer_amp_switch_get,
12464                 .put = alc268_acer_master_sw_put,
12465                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12466         },
12467         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12468         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12469         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12470         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12471         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12472         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12473         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
12474         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
12475         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
12476         { }
12477 };
12478
12479 /* bind volumes of both NID 0x0c and 0x0d */
12480 static struct hda_bind_ctls alc269_epc_bind_vol = {
12481         .ops = &snd_hda_bind_vol,
12482         .values = {
12483                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12484                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12485                 0
12486         },
12487 };
12488
12489 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
12490         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12491         HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
12492         HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12493         { } /* end */
12494 };
12495
12496 /* capture mixer elements */
12497 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
12498         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12499         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12500         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12501         { } /* end */
12502 };
12503
12504 /* FSC amilo */
12505 static struct snd_kcontrol_new alc269_fujitsu_mixer[] = {
12506         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12507         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12508         HDA_BIND_VOL("PCM Playback Volume", &alc269_epc_bind_vol),
12509         { } /* end */
12510 };
12511
12512 static struct hda_verb alc269_quanta_fl1_verbs[] = {
12513         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12514         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12515         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12516         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12517         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12518         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12519         { }
12520 };
12521
12522 static struct hda_verb alc269_lifebook_verbs[] = {
12523         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12524         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
12525         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12526         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12527         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12528         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12529         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12530         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12531         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12532         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12533         { }
12534 };
12535
12536 /* toggle speaker-output according to the hp-jack state */
12537 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
12538 {
12539         unsigned int present;
12540         unsigned char bits;
12541
12542         present = snd_hda_codec_read(codec, 0x15, 0,
12543                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12544         bits = present ? AMP_IN_MUTE(0) : 0;
12545         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12546                         AMP_IN_MUTE(0), bits);
12547         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12548                         AMP_IN_MUTE(0), bits);
12549
12550         snd_hda_codec_write(codec, 0x20, 0,
12551                         AC_VERB_SET_COEF_INDEX, 0x0c);
12552         snd_hda_codec_write(codec, 0x20, 0,
12553                         AC_VERB_SET_PROC_COEF, 0x680);
12554
12555         snd_hda_codec_write(codec, 0x20, 0,
12556                         AC_VERB_SET_COEF_INDEX, 0x0c);
12557         snd_hda_codec_write(codec, 0x20, 0,
12558                         AC_VERB_SET_PROC_COEF, 0x480);
12559 }
12560
12561 /* toggle speaker-output according to the hp-jacks state */
12562 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
12563 {
12564         unsigned int present;
12565         unsigned char bits;
12566
12567         /* Check laptop headphone socket */
12568         present = snd_hda_codec_read(codec, 0x15, 0,
12569                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12570
12571         /* Check port replicator headphone socket */
12572         present |= snd_hda_codec_read(codec, 0x1a, 0,
12573                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12574
12575         bits = present ? AMP_IN_MUTE(0) : 0;
12576         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12577                         AMP_IN_MUTE(0), bits);
12578         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12579                         AMP_IN_MUTE(0), bits);
12580
12581         snd_hda_codec_write(codec, 0x20, 0,
12582                         AC_VERB_SET_COEF_INDEX, 0x0c);
12583         snd_hda_codec_write(codec, 0x20, 0,
12584                         AC_VERB_SET_PROC_COEF, 0x680);
12585
12586         snd_hda_codec_write(codec, 0x20, 0,
12587                         AC_VERB_SET_COEF_INDEX, 0x0c);
12588         snd_hda_codec_write(codec, 0x20, 0,
12589                         AC_VERB_SET_PROC_COEF, 0x480);
12590 }
12591
12592 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
12593 {
12594         unsigned int present;
12595
12596         present = snd_hda_codec_read(codec, 0x18, 0,
12597                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12598         snd_hda_codec_write(codec, 0x23, 0,
12599                             AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
12600 }
12601
12602 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
12603 {
12604         unsigned int present_laptop;
12605         unsigned int present_dock;
12606
12607         present_laptop = snd_hda_codec_read(codec, 0x18, 0,
12608                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12609
12610         present_dock = snd_hda_codec_read(codec, 0x1b, 0,
12611                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12612
12613         /* Laptop mic port overrides dock mic port, design decision */
12614         if (present_dock)
12615                 snd_hda_codec_write(codec, 0x23, 0,
12616                                 AC_VERB_SET_CONNECT_SEL, 0x3);
12617         if (present_laptop)
12618                 snd_hda_codec_write(codec, 0x23, 0,
12619                                 AC_VERB_SET_CONNECT_SEL, 0x0);
12620         if (!present_dock && !present_laptop)
12621                 snd_hda_codec_write(codec, 0x23, 0,
12622                                 AC_VERB_SET_CONNECT_SEL, 0x1);
12623 }
12624
12625 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
12626                                     unsigned int res)
12627 {
12628         if ((res >> 26) == ALC880_HP_EVENT)
12629                 alc269_quanta_fl1_speaker_automute(codec);
12630         if ((res >> 26) == ALC880_MIC_EVENT)
12631                 alc269_quanta_fl1_mic_automute(codec);
12632 }
12633
12634 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
12635                                         unsigned int res)
12636 {
12637         if ((res >> 26) == ALC880_HP_EVENT)
12638                 alc269_lifebook_speaker_automute(codec);
12639         if ((res >> 26) == ALC880_MIC_EVENT)
12640                 alc269_lifebook_mic_autoswitch(codec);
12641 }
12642
12643 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
12644 {
12645         alc269_quanta_fl1_speaker_automute(codec);
12646         alc269_quanta_fl1_mic_automute(codec);
12647 }
12648
12649 static void alc269_lifebook_init_hook(struct hda_codec *codec)
12650 {
12651         alc269_lifebook_speaker_automute(codec);
12652         alc269_lifebook_mic_autoswitch(codec);
12653 }
12654
12655 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
12656         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12657         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
12658         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12659         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
12660         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12661         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12662         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12663         {}
12664 };
12665
12666 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
12667         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12668         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
12669         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12670         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
12671         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12672         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12673         {}
12674 };
12675
12676 /* toggle speaker-output according to the hp-jack state */
12677 static void alc269_speaker_automute(struct hda_codec *codec)
12678 {
12679         unsigned int present;
12680         unsigned char bits;
12681
12682         present = snd_hda_codec_read(codec, 0x15, 0,
12683                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12684         bits = present ? AMP_IN_MUTE(0) : 0;
12685         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12686                                 AMP_IN_MUTE(0), bits);
12687         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12688                                 AMP_IN_MUTE(0), bits);
12689 }
12690
12691 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
12692 {
12693         unsigned int present;
12694
12695         present = snd_hda_codec_read(codec, 0x18, 0,
12696                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12697         snd_hda_codec_write(codec, 0x23, 0,
12698                                 AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
12699 }
12700
12701 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
12702 {
12703         unsigned int present;
12704
12705         present = snd_hda_codec_read(codec, 0x18, 0,
12706                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12707         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12708                                 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
12709         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12710                                 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
12711 }
12712
12713 /* unsolicited event for HP jack sensing */
12714 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
12715                                      unsigned int res)
12716 {
12717         if ((res >> 26) == ALC880_HP_EVENT)
12718                 alc269_speaker_automute(codec);
12719
12720         if ((res >> 26) == ALC880_MIC_EVENT)
12721                 alc269_eeepc_dmic_automute(codec);
12722 }
12723
12724 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
12725 {
12726         alc269_speaker_automute(codec);
12727         alc269_eeepc_dmic_automute(codec);
12728 }
12729
12730 /* unsolicited event for HP jack sensing */
12731 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
12732                                      unsigned int res)
12733 {
12734         if ((res >> 26) == ALC880_HP_EVENT)
12735                 alc269_speaker_automute(codec);
12736
12737         if ((res >> 26) == ALC880_MIC_EVENT)
12738                 alc269_eeepc_amic_automute(codec);
12739 }
12740
12741 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12742 {
12743         alc269_speaker_automute(codec);
12744         alc269_eeepc_amic_automute(codec);
12745 }
12746
12747 /*
12748  * generic initialization of ADC, input mixers and output mixers
12749  */
12750 static struct hda_verb alc269_init_verbs[] = {
12751         /*
12752          * Unmute ADC0 and set the default input to mic-in
12753          */
12754         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12755
12756         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12757          * analog-loopback mixer widget
12758          * Note: PASD motherboards uses the Line In 2 as the input for
12759          * front panel mic (mic 2)
12760          */
12761         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12762         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12763         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12764         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12765         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12766         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12767
12768         /*
12769          * Set up output mixers (0x0c - 0x0e)
12770          */
12771         /* set vol=0 to output mixers */
12772         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12773         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12774
12775         /* set up input amps for analog loopback */
12776         /* Amp Indices: DAC = 0, mixer = 1 */
12777         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12778         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12779         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12780         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12781         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12782         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12783
12784         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12785         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12786         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12787         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12788         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12789         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12790         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12791
12792         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12793         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12794         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12795         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12796         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12797         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12798         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12799
12800         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12801         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12802
12803         /* FIXME: use matrix-type input source selection */
12804         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12805         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12806         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12807         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12808         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12809         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12810
12811         /* set EAPD */
12812         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12813         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12814         { }
12815 };
12816
12817 /* add playback controls from the parsed DAC table */
12818 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12819                                              const struct auto_pin_cfg *cfg)
12820 {
12821         hda_nid_t nid;
12822         int err;
12823
12824         spec->multiout.num_dacs = 1;    /* only use one dac */
12825         spec->multiout.dac_nids = spec->private_dac_nids;
12826         spec->multiout.dac_nids[0] = 2;
12827
12828         nid = cfg->line_out_pins[0];
12829         if (nid) {
12830                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12831                                   "Front Playback Volume",
12832                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12833                 if (err < 0)
12834                         return err;
12835                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12836                                   "Front Playback Switch",
12837                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12838                 if (err < 0)
12839                         return err;
12840         }
12841
12842         nid = cfg->speaker_pins[0];
12843         if (nid) {
12844                 if (!cfg->line_out_pins[0]) {
12845                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12846                                           "Speaker Playback Volume",
12847                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12848                                                               HDA_OUTPUT));
12849                         if (err < 0)
12850                                 return err;
12851                 }
12852                 if (nid == 0x16) {
12853                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12854                                           "Speaker Playback Switch",
12855                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12856                                                               HDA_OUTPUT));
12857                         if (err < 0)
12858                                 return err;
12859                 } else {
12860                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12861                                           "Speaker Playback Switch",
12862                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12863                                                               HDA_OUTPUT));
12864                         if (err < 0)
12865                                 return err;
12866                 }
12867         }
12868         nid = cfg->hp_pins[0];
12869         if (nid) {
12870                 /* spec->multiout.hp_nid = 2; */
12871                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12872                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12873                                           "Headphone Playback Volume",
12874                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12875                                                               HDA_OUTPUT));
12876                         if (err < 0)
12877                                 return err;
12878                 }
12879                 if (nid == 0x16) {
12880                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12881                                           "Headphone Playback Switch",
12882                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12883                                                               HDA_OUTPUT));
12884                         if (err < 0)
12885                                 return err;
12886                 } else {
12887                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12888                                           "Headphone Playback Switch",
12889                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12890                                                               HDA_OUTPUT));
12891                         if (err < 0)
12892                                 return err;
12893                 }
12894         }
12895         return 0;
12896 }
12897
12898 static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec,
12899                                                 const struct auto_pin_cfg *cfg)
12900 {
12901         int err;
12902
12903         err = alc880_auto_create_analog_input_ctls(spec, cfg);
12904         if (err < 0)
12905                 return err;
12906         /* digital-mic input pin is excluded in alc880_auto_create..()
12907          * because it's under 0x18
12908          */
12909         if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
12910             cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
12911                 struct hda_input_mux *imux = &spec->private_imux[0];
12912                 imux->items[imux->num_items].label = "Int Mic";
12913                 imux->items[imux->num_items].index = 0x05;
12914                 imux->num_items++;
12915         }
12916         return 0;
12917 }
12918
12919 #ifdef CONFIG_SND_HDA_POWER_SAVE
12920 #define alc269_loopbacks        alc880_loopbacks
12921 #endif
12922
12923 /* pcm configuration: identiacal with ALC880 */
12924 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
12925 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
12926 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
12927 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
12928
12929 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
12930         .substreams = 1,
12931         .channels_min = 2,
12932         .channels_max = 8,
12933         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
12934         /* NID is set in alc_build_pcms */
12935         .ops = {
12936                 .open = alc880_playback_pcm_open,
12937                 .prepare = alc880_playback_pcm_prepare,
12938                 .cleanup = alc880_playback_pcm_cleanup
12939         },
12940 };
12941
12942 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
12943         .substreams = 1,
12944         .channels_min = 2,
12945         .channels_max = 2,
12946         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
12947         /* NID is set in alc_build_pcms */
12948 };
12949
12950 /*
12951  * BIOS auto configuration
12952  */
12953 static int alc269_parse_auto_config(struct hda_codec *codec)
12954 {
12955         struct alc_spec *spec = codec->spec;
12956         int err;
12957         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12958
12959         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12960                                            alc269_ignore);
12961         if (err < 0)
12962                 return err;
12963
12964         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12965         if (err < 0)
12966                 return err;
12967         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12968         if (err < 0)
12969                 return err;
12970
12971         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12972
12973         if (spec->autocfg.dig_outs)
12974                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12975
12976         if (spec->kctls.list)
12977                 add_mixer(spec, spec->kctls.list);
12978
12979         add_verb(spec, alc269_init_verbs);
12980         spec->num_mux_defs = 1;
12981         spec->input_mux = &spec->private_imux[0];
12982         /* set default input source */
12983         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12984                                   0, AC_VERB_SET_CONNECT_SEL,
12985                                   spec->input_mux->items[0].index);
12986
12987         err = alc_auto_add_mic_boost(codec);
12988         if (err < 0)
12989                 return err;
12990
12991         if (!spec->cap_mixer && !spec->no_analog)
12992                 set_capture_mixer(spec);
12993
12994         return 1;
12995 }
12996
12997 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
12998 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
12999 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
13000
13001
13002 /* init callback for auto-configuration model -- overriding the default init */
13003 static void alc269_auto_init(struct hda_codec *codec)
13004 {
13005         struct alc_spec *spec = codec->spec;
13006         alc269_auto_init_multi_out(codec);
13007         alc269_auto_init_hp_out(codec);
13008         alc269_auto_init_analog_input(codec);
13009         if (spec->unsol_event)
13010                 alc_inithook(codec);
13011 }
13012
13013 /*
13014  * configuration and preset
13015  */
13016 static const char *alc269_models[ALC269_MODEL_LAST] = {
13017         [ALC269_BASIC]                  = "basic",
13018         [ALC269_QUANTA_FL1]             = "quanta",
13019         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
13020         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
13021         [ALC269_FUJITSU]                = "fujitsu",
13022         [ALC269_LIFEBOOK]               = "lifebook"
13023 };
13024
13025 static struct snd_pci_quirk alc269_cfg_tbl[] = {
13026         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
13027         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
13028                       ALC269_ASUS_EEEPC_P703),
13029         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_ASUS_EEEPC_P703),
13030         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_ASUS_EEEPC_P703),
13031         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_ASUS_EEEPC_P703),
13032         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_ASUS_EEEPC_P703),
13033         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_ASUS_EEEPC_P703),
13034         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_ASUS_EEEPC_P703),
13035         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
13036                       ALC269_ASUS_EEEPC_P901),
13037         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
13038                       ALC269_ASUS_EEEPC_P901),
13039         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_ASUS_EEEPC_P901),
13040         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
13041         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
13042         {}
13043 };
13044
13045 static struct alc_config_preset alc269_presets[] = {
13046         [ALC269_BASIC] = {
13047                 .mixers = { alc269_base_mixer },
13048                 .init_verbs = { alc269_init_verbs },
13049                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13050                 .dac_nids = alc269_dac_nids,
13051                 .hp_nid = 0x03,
13052                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13053                 .channel_mode = alc269_modes,
13054                 .input_mux = &alc269_capture_source,
13055         },
13056         [ALC269_QUANTA_FL1] = {
13057                 .mixers = { alc269_quanta_fl1_mixer },
13058                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
13059                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13060                 .dac_nids = alc269_dac_nids,
13061                 .hp_nid = 0x03,
13062                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13063                 .channel_mode = alc269_modes,
13064                 .input_mux = &alc269_capture_source,
13065                 .unsol_event = alc269_quanta_fl1_unsol_event,
13066                 .init_hook = alc269_quanta_fl1_init_hook,
13067         },
13068         [ALC269_ASUS_EEEPC_P703] = {
13069                 .mixers = { alc269_eeepc_mixer },
13070                 .cap_mixer = alc269_epc_capture_mixer,
13071                 .init_verbs = { alc269_init_verbs,
13072                                 alc269_eeepc_amic_init_verbs },
13073                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13074                 .dac_nids = alc269_dac_nids,
13075                 .hp_nid = 0x03,
13076                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13077                 .channel_mode = alc269_modes,
13078                 .input_mux = &alc269_eeepc_amic_capture_source,
13079                 .unsol_event = alc269_eeepc_amic_unsol_event,
13080                 .init_hook = alc269_eeepc_amic_inithook,
13081         },
13082         [ALC269_ASUS_EEEPC_P901] = {
13083                 .mixers = { alc269_eeepc_mixer },
13084                 .cap_mixer = alc269_epc_capture_mixer,
13085                 .init_verbs = { alc269_init_verbs,
13086                                 alc269_eeepc_dmic_init_verbs },
13087                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13088                 .dac_nids = alc269_dac_nids,
13089                 .hp_nid = 0x03,
13090                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13091                 .channel_mode = alc269_modes,
13092                 .input_mux = &alc269_eeepc_dmic_capture_source,
13093                 .unsol_event = alc269_eeepc_dmic_unsol_event,
13094                 .init_hook = alc269_eeepc_dmic_inithook,
13095         },
13096         [ALC269_FUJITSU] = {
13097                 .mixers = { alc269_fujitsu_mixer },
13098                 .cap_mixer = alc269_epc_capture_mixer,
13099                 .init_verbs = { alc269_init_verbs,
13100                                 alc269_eeepc_dmic_init_verbs },
13101                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13102                 .dac_nids = alc269_dac_nids,
13103                 .hp_nid = 0x03,
13104                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13105                 .channel_mode = alc269_modes,
13106                 .input_mux = &alc269_eeepc_dmic_capture_source,
13107                 .unsol_event = alc269_eeepc_dmic_unsol_event,
13108                 .init_hook = alc269_eeepc_dmic_inithook,
13109         },
13110         [ALC269_LIFEBOOK] = {
13111                 .mixers = { alc269_lifebook_mixer },
13112                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13113                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13114                 .dac_nids = alc269_dac_nids,
13115                 .hp_nid = 0x03,
13116                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13117                 .channel_mode = alc269_modes,
13118                 .input_mux = &alc269_capture_source,
13119                 .unsol_event = alc269_lifebook_unsol_event,
13120                 .init_hook = alc269_lifebook_init_hook,
13121         },
13122 };
13123
13124 static int patch_alc269(struct hda_codec *codec)
13125 {
13126         struct alc_spec *spec;
13127         int board_config;
13128         int err;
13129
13130         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13131         if (spec == NULL)
13132                 return -ENOMEM;
13133
13134         codec->spec = spec;
13135
13136         alc_fix_pll_init(codec, 0x20, 0x04, 15);
13137
13138         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13139                                                   alc269_models,
13140                                                   alc269_cfg_tbl);
13141
13142         if (board_config < 0) {
13143                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
13144                        "trying auto-probe from BIOS...\n", codec->chip_name);
13145                 board_config = ALC269_AUTO;
13146         }
13147
13148         if (board_config == ALC269_AUTO) {
13149                 /* automatic parse from the BIOS config */
13150                 err = alc269_parse_auto_config(codec);
13151                 if (err < 0) {
13152                         alc_free(codec);
13153                         return err;
13154                 } else if (!err) {
13155                         printk(KERN_INFO
13156                                "hda_codec: Cannot set up configuration "
13157                                "from BIOS.  Using base mode...\n");
13158                         board_config = ALC269_BASIC;
13159                 }
13160         }
13161
13162         err = snd_hda_attach_beep_device(codec, 0x1);
13163         if (err < 0) {
13164                 alc_free(codec);
13165                 return err;
13166         }
13167
13168         if (board_config != ALC269_AUTO)
13169                 setup_preset(spec, &alc269_presets[board_config]);
13170
13171         if (codec->subsystem_id == 0x17aa3bf8) {
13172                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
13173                  * fix the sample rate of analog I/O to 44.1kHz
13174                  */
13175                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
13176                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
13177         } else {
13178                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
13179                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
13180         }
13181         spec->stream_digital_playback = &alc269_pcm_digital_playback;
13182         spec->stream_digital_capture = &alc269_pcm_digital_capture;
13183
13184         spec->adc_nids = alc269_adc_nids;
13185         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13186         spec->capsrc_nids = alc269_capsrc_nids;
13187         if (!spec->cap_mixer)
13188                 set_capture_mixer(spec);
13189         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13190
13191         codec->patch_ops = alc_patch_ops;
13192         if (board_config == ALC269_AUTO)
13193                 spec->init_hook = alc269_auto_init;
13194 #ifdef CONFIG_SND_HDA_POWER_SAVE
13195         if (!spec->loopback.amplist)
13196                 spec->loopback.amplist = alc269_loopbacks;
13197 #endif
13198         codec->proc_widget_hook = print_realtek_coef;
13199
13200         return 0;
13201 }
13202
13203 /*
13204  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13205  */
13206
13207 /*
13208  * set the path ways for 2 channel output
13209  * need to set the codec line out and mic 1 pin widgets to inputs
13210  */
13211 static struct hda_verb alc861_threestack_ch2_init[] = {
13212         /* set pin widget 1Ah (line in) for input */
13213         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13214         /* set pin widget 18h (mic1/2) for input, for mic also enable
13215          * the vref
13216          */
13217         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13218
13219         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13220 #if 0
13221         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13222         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13223 #endif
13224         { } /* end */
13225 };
13226 /*
13227  * 6ch mode
13228  * need to set the codec line out and mic 1 pin widgets to outputs
13229  */
13230 static struct hda_verb alc861_threestack_ch6_init[] = {
13231         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13232         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13233         /* set pin widget 18h (mic1) for output (CLFE)*/
13234         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13235
13236         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13237         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13238
13239         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13240 #if 0
13241         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13242         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13243 #endif
13244         { } /* end */
13245 };
13246
13247 static struct hda_channel_mode alc861_threestack_modes[2] = {
13248         { 2, alc861_threestack_ch2_init },
13249         { 6, alc861_threestack_ch6_init },
13250 };
13251 /* Set mic1 as input and unmute the mixer */
13252 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13253         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13254         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13255         { } /* end */
13256 };
13257 /* Set mic1 as output and mute mixer */
13258 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13259         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13260         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13261         { } /* end */
13262 };
13263
13264 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13265         { 2, alc861_uniwill_m31_ch2_init },
13266         { 4, alc861_uniwill_m31_ch4_init },
13267 };
13268
13269 /* Set mic1 and line-in as input and unmute the mixer */
13270 static struct hda_verb alc861_asus_ch2_init[] = {
13271         /* set pin widget 1Ah (line in) for input */
13272         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13273         /* set pin widget 18h (mic1/2) for input, for mic also enable
13274          * the vref
13275          */
13276         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13277
13278         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13279 #if 0
13280         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13281         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13282 #endif
13283         { } /* end */
13284 };
13285 /* Set mic1 nad line-in as output and mute mixer */
13286 static struct hda_verb alc861_asus_ch6_init[] = {
13287         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13288         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13289         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13290         /* set pin widget 18h (mic1) for output (CLFE)*/
13291         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13292         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13293         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13294         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13295
13296         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13297 #if 0
13298         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13299         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13300 #endif
13301         { } /* end */
13302 };
13303
13304 static struct hda_channel_mode alc861_asus_modes[2] = {
13305         { 2, alc861_asus_ch2_init },
13306         { 6, alc861_asus_ch6_init },
13307 };
13308
13309 /* patch-ALC861 */
13310
13311 static struct snd_kcontrol_new alc861_base_mixer[] = {
13312         /* output mixer control */
13313         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13314         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13315         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13316         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13317         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13318
13319         /*Input mixer control */
13320         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13321            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13322         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13323         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13324         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13325         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13326         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13327         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13328         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13329         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13330
13331         { } /* end */
13332 };
13333
13334 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13335         /* output mixer control */
13336         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13337         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13338         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13339         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13340         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13341
13342         /* Input mixer control */
13343         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13344            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13345         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13346         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13347         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13348         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13349         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13350         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13351         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13352         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13353
13354         {
13355                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13356                 .name = "Channel Mode",
13357                 .info = alc_ch_mode_info,
13358                 .get = alc_ch_mode_get,
13359                 .put = alc_ch_mode_put,
13360                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13361         },
13362         { } /* end */
13363 };
13364
13365 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13366         /* output mixer control */
13367         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13368         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13369         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13370
13371         { } /* end */
13372 };
13373
13374 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13375         /* output mixer control */
13376         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13377         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13378         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13379         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13380         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13381
13382         /* Input mixer control */
13383         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13384            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13385         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13386         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13387         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13388         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13389         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13390         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13391         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13392         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13393
13394         {
13395                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13396                 .name = "Channel Mode",
13397                 .info = alc_ch_mode_info,
13398                 .get = alc_ch_mode_get,
13399                 .put = alc_ch_mode_put,
13400                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13401         },
13402         { } /* end */
13403 };
13404
13405 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13406         /* output mixer control */
13407         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13408         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13409         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13410         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13411         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13412
13413         /* Input mixer control */
13414         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13415         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13416         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13417         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13418         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13419         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13420         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13421         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13422         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13423         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13424
13425         {
13426                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13427                 .name = "Channel Mode",
13428                 .info = alc_ch_mode_info,
13429                 .get = alc_ch_mode_get,
13430                 .put = alc_ch_mode_put,
13431                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13432         },
13433         { }
13434 };
13435
13436 /* additional mixer */
13437 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13438         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13439         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13440         { }
13441 };
13442
13443 /*
13444  * generic initialization of ADC, input mixers and output mixers
13445  */
13446 static struct hda_verb alc861_base_init_verbs[] = {
13447         /*
13448          * Unmute ADC0 and set the default input to mic-in
13449          */
13450         /* port-A for surround (rear panel) */
13451         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13452         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
13453         /* port-B for mic-in (rear panel) with vref */
13454         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13455         /* port-C for line-in (rear panel) */
13456         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13457         /* port-D for Front */
13458         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13459         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13460         /* port-E for HP out (front panel) */
13461         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13462         /* route front PCM to HP */
13463         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13464         /* port-F for mic-in (front panel) with vref */
13465         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13466         /* port-G for CLFE (rear panel) */
13467         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13468         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13469         /* port-H for side (rear panel) */
13470         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13471         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
13472         /* CD-in */
13473         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13474         /* route front mic to ADC1*/
13475         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13476         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13477
13478         /* Unmute DAC0~3 & spdif out*/
13479         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13480         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13481         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13482         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13483         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13484
13485         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13486         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13487         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13488         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13489         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13490
13491         /* Unmute Stereo Mixer 15 */
13492         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13493         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13494         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13495         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13496
13497         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13498         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13499         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13500         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13501         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13502         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13503         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13504         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13505         /* hp used DAC 3 (Front) */
13506         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13507         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13508
13509         { }
13510 };
13511
13512 static struct hda_verb alc861_threestack_init_verbs[] = {
13513         /*
13514          * Unmute ADC0 and set the default input to mic-in
13515          */
13516         /* port-A for surround (rear panel) */
13517         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13518         /* port-B for mic-in (rear panel) with vref */
13519         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13520         /* port-C for line-in (rear panel) */
13521         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13522         /* port-D for Front */
13523         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13524         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13525         /* port-E for HP out (front panel) */
13526         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13527         /* route front PCM to HP */
13528         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13529         /* port-F for mic-in (front panel) with vref */
13530         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13531         /* port-G for CLFE (rear panel) */
13532         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13533         /* port-H for side (rear panel) */
13534         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13535         /* CD-in */
13536         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13537         /* route front mic to ADC1*/
13538         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13539         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13540         /* Unmute DAC0~3 & spdif out*/
13541         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13542         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13543         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13544         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13545         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13546
13547         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13548         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13549         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13550         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13551         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13552
13553         /* Unmute Stereo Mixer 15 */
13554         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13555         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13556         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13557         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13558
13559         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13560         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13561         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13562         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13563         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13564         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13565         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13566         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13567         /* hp used DAC 3 (Front) */
13568         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13569         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13570         { }
13571 };
13572
13573 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
13574         /*
13575          * Unmute ADC0 and set the default input to mic-in
13576          */
13577         /* port-A for surround (rear panel) */
13578         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13579         /* port-B for mic-in (rear panel) with vref */
13580         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13581         /* port-C for line-in (rear panel) */
13582         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13583         /* port-D for Front */
13584         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13585         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13586         /* port-E for HP out (front panel) */
13587         /* this has to be set to VREF80 */
13588         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13589         /* route front PCM to HP */
13590         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13591         /* port-F for mic-in (front panel) with vref */
13592         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13593         /* port-G for CLFE (rear panel) */
13594         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13595         /* port-H for side (rear panel) */
13596         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13597         /* CD-in */
13598         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13599         /* route front mic to ADC1*/
13600         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13601         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13602         /* Unmute DAC0~3 & spdif out*/
13603         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13604         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13605         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13606         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13607         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13608
13609         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13610         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13611         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13612         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13613         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13614
13615         /* Unmute Stereo Mixer 15 */
13616         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13617         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13618         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13619         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13620
13621         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13622         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13623         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13624         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13625         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13626         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13627         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13628         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13629         /* hp used DAC 3 (Front) */
13630         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13631         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13632         { }
13633 };
13634
13635 static struct hda_verb alc861_asus_init_verbs[] = {
13636         /*
13637          * Unmute ADC0 and set the default input to mic-in
13638          */
13639         /* port-A for surround (rear panel)
13640          * according to codec#0 this is the HP jack
13641          */
13642         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
13643         /* route front PCM to HP */
13644         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
13645         /* port-B for mic-in (rear panel) with vref */
13646         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13647         /* port-C for line-in (rear panel) */
13648         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13649         /* port-D for Front */
13650         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13651         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13652         /* port-E for HP out (front panel) */
13653         /* this has to be set to VREF80 */
13654         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13655         /* route front PCM to HP */
13656         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13657         /* port-F for mic-in (front panel) with vref */
13658         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13659         /* port-G for CLFE (rear panel) */
13660         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13661         /* port-H for side (rear panel) */
13662         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13663         /* CD-in */
13664         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13665         /* route front mic to ADC1*/
13666         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13667         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13668         /* Unmute DAC0~3 & spdif out*/
13669         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13670         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13671         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13672         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13673         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13674         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13675         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13676         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13677         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13678         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13679
13680         /* Unmute Stereo Mixer 15 */
13681         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13682         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13683         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13684         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13685
13686         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13687         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13688         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13689         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13690         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13691         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13692         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13693         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13694         /* hp used DAC 3 (Front) */
13695         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13696         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13697         { }
13698 };
13699
13700 /* additional init verbs for ASUS laptops */
13701 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
13702         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
13703         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
13704         { }
13705 };
13706
13707 /*
13708  * generic initialization of ADC, input mixers and output mixers
13709  */
13710 static struct hda_verb alc861_auto_init_verbs[] = {
13711         /*
13712          * Unmute ADC0 and set the default input to mic-in
13713          */
13714         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
13715         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13716
13717         /* Unmute DAC0~3 & spdif out*/
13718         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13719         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13720         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13721         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13722         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13723
13724         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13725         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13726         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13727         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13728         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13729
13730         /* Unmute Stereo Mixer 15 */
13731         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13732         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13733         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13734         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
13735
13736         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13737         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13738         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13739         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13740         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13741         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13742         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13743         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13744
13745         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13746         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13747         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13748         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13749         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13750         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13751         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13752         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13753
13754         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
13755
13756         { }
13757 };
13758
13759 static struct hda_verb alc861_toshiba_init_verbs[] = {
13760         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13761
13762         { }
13763 };
13764
13765 /* toggle speaker-output according to the hp-jack state */
13766 static void alc861_toshiba_automute(struct hda_codec *codec)
13767 {
13768         unsigned int present;
13769
13770         present = snd_hda_codec_read(codec, 0x0f, 0,
13771                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13772         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13773                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13774         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13775                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13776 }
13777
13778 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13779                                        unsigned int res)
13780 {
13781         if ((res >> 26) == ALC880_HP_EVENT)
13782                 alc861_toshiba_automute(codec);
13783 }
13784
13785 /* pcm configuration: identiacal with ALC880 */
13786 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
13787 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
13788 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
13789 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
13790
13791
13792 #define ALC861_DIGOUT_NID       0x07
13793
13794 static struct hda_channel_mode alc861_8ch_modes[1] = {
13795         { 8, NULL }
13796 };
13797
13798 static hda_nid_t alc861_dac_nids[4] = {
13799         /* front, surround, clfe, side */
13800         0x03, 0x06, 0x05, 0x04
13801 };
13802
13803 static hda_nid_t alc660_dac_nids[3] = {
13804         /* front, clfe, surround */
13805         0x03, 0x05, 0x06
13806 };
13807
13808 static hda_nid_t alc861_adc_nids[1] = {
13809         /* ADC0-2 */
13810         0x08,
13811 };
13812
13813 static struct hda_input_mux alc861_capture_source = {
13814         .num_items = 5,
13815         .items = {
13816                 { "Mic", 0x0 },
13817                 { "Front Mic", 0x3 },
13818                 { "Line", 0x1 },
13819                 { "CD", 0x4 },
13820                 { "Mixer", 0x5 },
13821         },
13822 };
13823
13824 /* fill in the dac_nids table from the parsed pin configuration */
13825 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13826                                      const struct auto_pin_cfg *cfg)
13827 {
13828         int i;
13829         hda_nid_t nid;
13830
13831         spec->multiout.dac_nids = spec->private_dac_nids;
13832         for (i = 0; i < cfg->line_outs; i++) {
13833                 nid = cfg->line_out_pins[i];
13834                 if (nid) {
13835                         if (i >= ARRAY_SIZE(alc861_dac_nids))
13836                                 continue;
13837                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13838                 }
13839         }
13840         spec->multiout.num_dacs = cfg->line_outs;
13841         return 0;
13842 }
13843
13844 /* add playback controls from the parsed DAC table */
13845 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13846                                              const struct auto_pin_cfg *cfg)
13847 {
13848         char name[32];
13849         static const char *chname[4] = {
13850                 "Front", "Surround", NULL /*CLFE*/, "Side"
13851         };
13852         hda_nid_t nid;
13853         int i, idx, err;
13854
13855         for (i = 0; i < cfg->line_outs; i++) {
13856                 nid = spec->multiout.dac_nids[i];
13857                 if (!nid)
13858                         continue;
13859                 if (nid == 0x05) {
13860                         /* Center/LFE */
13861                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13862                                           "Center Playback Switch",
13863                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13864                                                               HDA_OUTPUT));
13865                         if (err < 0)
13866                                 return err;
13867                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13868                                           "LFE Playback Switch",
13869                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13870                                                               HDA_OUTPUT));
13871                         if (err < 0)
13872                                 return err;
13873                 } else {
13874                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13875                              idx++)
13876                                 if (nid == alc861_dac_nids[idx])
13877                                         break;
13878                         sprintf(name, "%s Playback Switch", chname[idx]);
13879                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13880                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13881                                                               HDA_OUTPUT));
13882                         if (err < 0)
13883                                 return err;
13884                 }
13885         }
13886         return 0;
13887 }
13888
13889 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13890 {
13891         int err;
13892         hda_nid_t nid;
13893
13894         if (!pin)
13895                 return 0;
13896
13897         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13898                 nid = 0x03;
13899                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13900                                   "Headphone Playback Switch",
13901                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13902                 if (err < 0)
13903                         return err;
13904                 spec->multiout.hp_nid = nid;
13905         }
13906         return 0;
13907 }
13908
13909 /* create playback/capture controls for input pins */
13910 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13911                                                 const struct auto_pin_cfg *cfg)
13912 {
13913         struct hda_input_mux *imux = &spec->private_imux[0];
13914         int i, err, idx, idx1;
13915
13916         for (i = 0; i < AUTO_PIN_LAST; i++) {
13917                 switch (cfg->input_pins[i]) {
13918                 case 0x0c:
13919                         idx1 = 1;
13920                         idx = 2;        /* Line In */
13921                         break;
13922                 case 0x0f:
13923                         idx1 = 2;
13924                         idx = 2;        /* Line In */
13925                         break;
13926                 case 0x0d:
13927                         idx1 = 0;
13928                         idx = 1;        /* Mic In */
13929                         break;
13930                 case 0x10:
13931                         idx1 = 3;
13932                         idx = 1;        /* Mic In */
13933                         break;
13934                 case 0x11:
13935                         idx1 = 4;
13936                         idx = 0;        /* CD */
13937                         break;
13938                 default:
13939                         continue;
13940                 }
13941
13942                 err = new_analog_input(spec, cfg->input_pins[i],
13943                                        auto_pin_cfg_labels[i], idx, 0x15);
13944                 if (err < 0)
13945                         return err;
13946
13947                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13948                 imux->items[imux->num_items].index = idx1;
13949                 imux->num_items++;
13950         }
13951         return 0;
13952 }
13953
13954 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13955                                               hda_nid_t nid,
13956                                               int pin_type, int dac_idx)
13957 {
13958         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13959                             pin_type);
13960         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13961                             AMP_OUT_UNMUTE);
13962 }
13963
13964 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13965 {
13966         struct alc_spec *spec = codec->spec;
13967         int i;
13968
13969         for (i = 0; i < spec->autocfg.line_outs; i++) {
13970                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13971                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13972                 if (nid)
13973                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13974                                                           spec->multiout.dac_nids[i]);
13975         }
13976 }
13977
13978 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13979 {
13980         struct alc_spec *spec = codec->spec;
13981         hda_nid_t pin;
13982
13983         pin = spec->autocfg.hp_pins[0];
13984         if (pin) /* connect to front */
13985                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13986                                                   spec->multiout.dac_nids[0]);
13987         pin = spec->autocfg.speaker_pins[0];
13988         if (pin)
13989                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13990 }
13991
13992 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13993 {
13994         struct alc_spec *spec = codec->spec;
13995         int i;
13996
13997         for (i = 0; i < AUTO_PIN_LAST; i++) {
13998                 hda_nid_t nid = spec->autocfg.input_pins[i];
13999                 if (nid >= 0x0c && nid <= 0x11)
14000                         alc_set_input_pin(codec, nid, i);
14001         }
14002 }
14003
14004 /* parse the BIOS configuration and set up the alc_spec */
14005 /* return 1 if successful, 0 if the proper config is not found,
14006  * or a negative error code
14007  */
14008 static int alc861_parse_auto_config(struct hda_codec *codec)
14009 {
14010         struct alc_spec *spec = codec->spec;
14011         int err;
14012         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
14013
14014         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14015                                            alc861_ignore);
14016         if (err < 0)
14017                 return err;
14018         if (!spec->autocfg.line_outs)
14019                 return 0; /* can't find valid BIOS pin config */
14020
14021         err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
14022         if (err < 0)
14023                 return err;
14024         err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
14025         if (err < 0)
14026                 return err;
14027         err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
14028         if (err < 0)
14029                 return err;
14030         err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
14031         if (err < 0)
14032                 return err;
14033
14034         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14035
14036         if (spec->autocfg.dig_outs)
14037                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
14038
14039         if (spec->kctls.list)
14040                 add_mixer(spec, spec->kctls.list);
14041
14042         add_verb(spec, alc861_auto_init_verbs);
14043
14044         spec->num_mux_defs = 1;
14045         spec->input_mux = &spec->private_imux[0];
14046
14047         spec->adc_nids = alc861_adc_nids;
14048         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
14049         set_capture_mixer(spec);
14050
14051         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b);
14052
14053         return 1;
14054 }
14055
14056 /* additional initialization for auto-configuration model */
14057 static void alc861_auto_init(struct hda_codec *codec)
14058 {
14059         struct alc_spec *spec = codec->spec;
14060         alc861_auto_init_multi_out(codec);
14061         alc861_auto_init_hp_out(codec);
14062         alc861_auto_init_analog_input(codec);
14063         if (spec->unsol_event)
14064                 alc_inithook(codec);
14065 }
14066
14067 #ifdef CONFIG_SND_HDA_POWER_SAVE
14068 static struct hda_amp_list alc861_loopbacks[] = {
14069         { 0x15, HDA_INPUT, 0 },
14070         { 0x15, HDA_INPUT, 1 },
14071         { 0x15, HDA_INPUT, 2 },
14072         { 0x15, HDA_INPUT, 3 },
14073         { } /* end */
14074 };
14075 #endif
14076
14077
14078 /*
14079  * configuration and preset
14080  */
14081 static const char *alc861_models[ALC861_MODEL_LAST] = {
14082         [ALC861_3ST]            = "3stack",
14083         [ALC660_3ST]            = "3stack-660",
14084         [ALC861_3ST_DIG]        = "3stack-dig",
14085         [ALC861_6ST_DIG]        = "6stack-dig",
14086         [ALC861_UNIWILL_M31]    = "uniwill-m31",
14087         [ALC861_TOSHIBA]        = "toshiba",
14088         [ALC861_ASUS]           = "asus",
14089         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
14090         [ALC861_AUTO]           = "auto",
14091 };
14092
14093 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14094         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14095         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14096         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14097         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14098         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14099         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14100         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14101         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14102          *        Any other models that need this preset?
14103          */
14104         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14105         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14106         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14107         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14108         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14109         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14110         /* FIXME: the below seems conflict */
14111         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14112         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14113         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14114         {}
14115 };
14116
14117 static struct alc_config_preset alc861_presets[] = {
14118         [ALC861_3ST] = {
14119                 .mixers = { alc861_3ST_mixer },
14120                 .init_verbs = { alc861_threestack_init_verbs },
14121                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14122                 .dac_nids = alc861_dac_nids,
14123                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14124                 .channel_mode = alc861_threestack_modes,
14125                 .need_dac_fix = 1,
14126                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14127                 .adc_nids = alc861_adc_nids,
14128                 .input_mux = &alc861_capture_source,
14129         },
14130         [ALC861_3ST_DIG] = {
14131                 .mixers = { alc861_base_mixer },
14132                 .init_verbs = { alc861_threestack_init_verbs },
14133                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14134                 .dac_nids = alc861_dac_nids,
14135                 .dig_out_nid = ALC861_DIGOUT_NID,
14136                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14137                 .channel_mode = alc861_threestack_modes,
14138                 .need_dac_fix = 1,
14139                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14140                 .adc_nids = alc861_adc_nids,
14141                 .input_mux = &alc861_capture_source,
14142         },
14143         [ALC861_6ST_DIG] = {
14144                 .mixers = { alc861_base_mixer },
14145                 .init_verbs = { alc861_base_init_verbs },
14146                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14147                 .dac_nids = alc861_dac_nids,
14148                 .dig_out_nid = ALC861_DIGOUT_NID,
14149                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14150                 .channel_mode = alc861_8ch_modes,
14151                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14152                 .adc_nids = alc861_adc_nids,
14153                 .input_mux = &alc861_capture_source,
14154         },
14155         [ALC660_3ST] = {
14156                 .mixers = { alc861_3ST_mixer },
14157                 .init_verbs = { alc861_threestack_init_verbs },
14158                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
14159                 .dac_nids = alc660_dac_nids,
14160                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14161                 .channel_mode = alc861_threestack_modes,
14162                 .need_dac_fix = 1,
14163                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14164                 .adc_nids = alc861_adc_nids,
14165                 .input_mux = &alc861_capture_source,
14166         },
14167         [ALC861_UNIWILL_M31] = {
14168                 .mixers = { alc861_uniwill_m31_mixer },
14169                 .init_verbs = { alc861_uniwill_m31_init_verbs },
14170                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14171                 .dac_nids = alc861_dac_nids,
14172                 .dig_out_nid = ALC861_DIGOUT_NID,
14173                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14174                 .channel_mode = alc861_uniwill_m31_modes,
14175                 .need_dac_fix = 1,
14176                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14177                 .adc_nids = alc861_adc_nids,
14178                 .input_mux = &alc861_capture_source,
14179         },
14180         [ALC861_TOSHIBA] = {
14181                 .mixers = { alc861_toshiba_mixer },
14182                 .init_verbs = { alc861_base_init_verbs,
14183                                 alc861_toshiba_init_verbs },
14184                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14185                 .dac_nids = alc861_dac_nids,
14186                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14187                 .channel_mode = alc883_3ST_2ch_modes,
14188                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14189                 .adc_nids = alc861_adc_nids,
14190                 .input_mux = &alc861_capture_source,
14191                 .unsol_event = alc861_toshiba_unsol_event,
14192                 .init_hook = alc861_toshiba_automute,
14193         },
14194         [ALC861_ASUS] = {
14195                 .mixers = { alc861_asus_mixer },
14196                 .init_verbs = { alc861_asus_init_verbs },
14197                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14198                 .dac_nids = alc861_dac_nids,
14199                 .dig_out_nid = ALC861_DIGOUT_NID,
14200                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14201                 .channel_mode = alc861_asus_modes,
14202                 .need_dac_fix = 1,
14203                 .hp_nid = 0x06,
14204                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14205                 .adc_nids = alc861_adc_nids,
14206                 .input_mux = &alc861_capture_source,
14207         },
14208         [ALC861_ASUS_LAPTOP] = {
14209                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14210                 .init_verbs = { alc861_asus_init_verbs,
14211                                 alc861_asus_laptop_init_verbs },
14212                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14213                 .dac_nids = alc861_dac_nids,
14214                 .dig_out_nid = ALC861_DIGOUT_NID,
14215                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14216                 .channel_mode = alc883_3ST_2ch_modes,
14217                 .need_dac_fix = 1,
14218                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14219                 .adc_nids = alc861_adc_nids,
14220                 .input_mux = &alc861_capture_source,
14221         },
14222 };
14223
14224
14225 static int patch_alc861(struct hda_codec *codec)
14226 {
14227         struct alc_spec *spec;
14228         int board_config;
14229         int err;
14230
14231         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14232         if (spec == NULL)
14233                 return -ENOMEM;
14234
14235         codec->spec = spec;
14236
14237         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14238                                                   alc861_models,
14239                                                   alc861_cfg_tbl);
14240
14241         if (board_config < 0) {
14242                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
14243                        "trying auto-probe from BIOS...\n", codec->chip_name);
14244                 board_config = ALC861_AUTO;
14245         }
14246
14247         if (board_config == ALC861_AUTO) {
14248                 /* automatic parse from the BIOS config */
14249                 err = alc861_parse_auto_config(codec);
14250                 if (err < 0) {
14251                         alc_free(codec);
14252                         return err;
14253                 } else if (!err) {
14254                         printk(KERN_INFO
14255                                "hda_codec: Cannot set up configuration "
14256                                "from BIOS.  Using base mode...\n");
14257                    board_config = ALC861_3ST_DIG;
14258                 }
14259         }
14260
14261         err = snd_hda_attach_beep_device(codec, 0x23);
14262         if (err < 0) {
14263                 alc_free(codec);
14264                 return err;
14265         }
14266
14267         if (board_config != ALC861_AUTO)
14268                 setup_preset(spec, &alc861_presets[board_config]);
14269
14270         spec->stream_analog_playback = &alc861_pcm_analog_playback;
14271         spec->stream_analog_capture = &alc861_pcm_analog_capture;
14272
14273         spec->stream_digital_playback = &alc861_pcm_digital_playback;
14274         spec->stream_digital_capture = &alc861_pcm_digital_capture;
14275
14276         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14277
14278         spec->vmaster_nid = 0x03;
14279
14280         codec->patch_ops = alc_patch_ops;
14281         if (board_config == ALC861_AUTO)
14282                 spec->init_hook = alc861_auto_init;
14283 #ifdef CONFIG_SND_HDA_POWER_SAVE
14284         if (!spec->loopback.amplist)
14285                 spec->loopback.amplist = alc861_loopbacks;
14286 #endif
14287         codec->proc_widget_hook = print_realtek_coef;
14288
14289         return 0;
14290 }
14291
14292 /*
14293  * ALC861-VD support
14294  *
14295  * Based on ALC882
14296  *
14297  * In addition, an independent DAC
14298  */
14299 #define ALC861VD_DIGOUT_NID     0x06
14300
14301 static hda_nid_t alc861vd_dac_nids[4] = {
14302         /* front, surr, clfe, side surr */
14303         0x02, 0x03, 0x04, 0x05
14304 };
14305
14306 /* dac_nids for ALC660vd are in a different order - according to
14307  * Realtek's driver.
14308  * This should probably tesult in a different mixer for 6stack models
14309  * of ALC660vd codecs, but for now there is only 3stack mixer
14310  * - and it is the same as in 861vd.
14311  * adc_nids in ALC660vd are (is) the same as in 861vd
14312  */
14313 static hda_nid_t alc660vd_dac_nids[3] = {
14314         /* front, rear, clfe, rear_surr */
14315         0x02, 0x04, 0x03
14316 };
14317
14318 static hda_nid_t alc861vd_adc_nids[1] = {
14319         /* ADC0 */
14320         0x09,
14321 };
14322
14323 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14324
14325 /* input MUX */
14326 /* FIXME: should be a matrix-type input source selection */
14327 static struct hda_input_mux alc861vd_capture_source = {
14328         .num_items = 4,
14329         .items = {
14330                 { "Mic", 0x0 },
14331                 { "Front Mic", 0x1 },
14332                 { "Line", 0x2 },
14333                 { "CD", 0x4 },
14334         },
14335 };
14336
14337 static struct hda_input_mux alc861vd_dallas_capture_source = {
14338         .num_items = 2,
14339         .items = {
14340                 { "Ext Mic", 0x0 },
14341                 { "Int Mic", 0x1 },
14342         },
14343 };
14344
14345 static struct hda_input_mux alc861vd_hp_capture_source = {
14346         .num_items = 2,
14347         .items = {
14348                 { "Front Mic", 0x0 },
14349                 { "ATAPI Mic", 0x1 },
14350         },
14351 };
14352
14353 /*
14354  * 2ch mode
14355  */
14356 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14357         { 2, NULL }
14358 };
14359
14360 /*
14361  * 6ch mode
14362  */
14363 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14364         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14365         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14366         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14367         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14368         { } /* end */
14369 };
14370
14371 /*
14372  * 8ch mode
14373  */
14374 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14375         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14376         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14377         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14378         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14379         { } /* end */
14380 };
14381
14382 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14383         { 6, alc861vd_6stack_ch6_init },
14384         { 8, alc861vd_6stack_ch8_init },
14385 };
14386
14387 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14388         {
14389                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14390                 .name = "Channel Mode",
14391                 .info = alc_ch_mode_info,
14392                 .get = alc_ch_mode_get,
14393                 .put = alc_ch_mode_put,
14394         },
14395         { } /* end */
14396 };
14397
14398 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14399  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14400  */
14401 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14402         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14403         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14404
14405         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14406         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14407
14408         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14409                                 HDA_OUTPUT),
14410         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14411                                 HDA_OUTPUT),
14412         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14413         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14414
14415         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14416         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14417
14418         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14419
14420         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14421         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14422         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14423
14424         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14425         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14426         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14427
14428         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14429         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14430
14431         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14432         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14433
14434         { } /* end */
14435 };
14436
14437 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
14438         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14439         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14440
14441         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14442
14443         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14444         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14445         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14446
14447         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14448         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14449         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14450
14451         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14452         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14453
14454         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14455         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14456
14457         { } /* end */
14458 };
14459
14460 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
14461         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14462         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
14463         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14464
14465         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14466
14467         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14468         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14469         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14470
14471         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14472         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14473         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14474
14475         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14476         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14477
14478         { } /* end */
14479 };
14480
14481 /* Pin assignment: Speaker=0x14, HP = 0x15,
14482  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
14483  */
14484 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
14485         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14486         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
14487         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14488         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14489         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
14490         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14491         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14492         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
14493         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14494         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14495         { } /* end */
14496 };
14497
14498 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
14499  *                 Front Mic=0x18, ATAPI Mic = 0x19,
14500  */
14501 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
14502         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14503         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14504         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14505         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14506         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14507         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14508         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14509         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14510
14511         { } /* end */
14512 };
14513
14514 /*
14515  * generic initialization of ADC, input mixers and output mixers
14516  */
14517 static struct hda_verb alc861vd_volume_init_verbs[] = {
14518         /*
14519          * Unmute ADC0 and set the default input to mic-in
14520          */
14521         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14522         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14523
14524         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
14525          * the analog-loopback mixer widget
14526          */
14527         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14528         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14529         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14530         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14531         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14532         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14533
14534         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
14535         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14536         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14537         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14538         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14539
14540         /*
14541          * Set up output mixers (0x02 - 0x05)
14542          */
14543         /* set vol=0 to output mixers */
14544         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14545         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14546         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14547         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14548
14549         /* set up input amps for analog loopback */
14550         /* Amp Indices: DAC = 0, mixer = 1 */
14551         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14552         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14553         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14554         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14555         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14556         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14557         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14558         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14559
14560         { }
14561 };
14562
14563 /*
14564  * 3-stack pin configuration:
14565  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
14566  */
14567 static struct hda_verb alc861vd_3stack_init_verbs[] = {
14568         /*
14569          * Set pin mode and muting
14570          */
14571         /* set front pin widgets 0x14 for output */
14572         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14573         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14574         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14575
14576         /* Mic (rear) pin: input vref at 80% */
14577         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14578         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14579         /* Front Mic pin: input vref at 80% */
14580         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14581         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14582         /* Line In pin: input */
14583         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14584         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14585         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14586         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14587         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14588         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14589         /* CD pin widget for input */
14590         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14591
14592         { }
14593 };
14594
14595 /*
14596  * 6-stack pin configuration:
14597  */
14598 static struct hda_verb alc861vd_6stack_init_verbs[] = {
14599         /*
14600          * Set pin mode and muting
14601          */
14602         /* set front pin widgets 0x14 for output */
14603         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14604         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14605         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14606
14607         /* Rear Pin: output 1 (0x0d) */
14608         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14609         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14610         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14611         /* CLFE Pin: output 2 (0x0e) */
14612         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14613         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14614         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
14615         /* Side Pin: output 3 (0x0f) */
14616         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14617         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14618         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
14619
14620         /* Mic (rear) pin: input vref at 80% */
14621         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14622         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14623         /* Front Mic pin: input vref at 80% */
14624         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14625         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14626         /* Line In pin: input */
14627         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14628         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14629         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14630         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14631         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14632         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14633         /* CD pin widget for input */
14634         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14635
14636         { }
14637 };
14638
14639 static struct hda_verb alc861vd_eapd_verbs[] = {
14640         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14641         { }
14642 };
14643
14644 static struct hda_verb alc660vd_eapd_verbs[] = {
14645         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14646         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14647         { }
14648 };
14649
14650 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
14651         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14652         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14653         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
14654         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14655         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14656         {}
14657 };
14658
14659 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
14660 {
14661         unsigned int present;
14662         unsigned char bits;
14663
14664         present = snd_hda_codec_read(codec, 0x18, 0,
14665                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14666         bits = present ? HDA_AMP_MUTE : 0;
14667         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
14668                                  HDA_AMP_MUTE, bits);
14669 }
14670
14671 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
14672 {
14673         struct alc_spec *spec = codec->spec;
14674
14675         spec->autocfg.hp_pins[0] = 0x1b;
14676         spec->autocfg.speaker_pins[0] = 0x14;
14677         alc_automute_amp(codec);
14678         alc861vd_lenovo_mic_automute(codec);
14679 }
14680
14681 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
14682                                         unsigned int res)
14683 {
14684         switch (res >> 26) {
14685         case ALC880_MIC_EVENT:
14686                 alc861vd_lenovo_mic_automute(codec);
14687                 break;
14688         default:
14689                 alc_automute_amp_unsol_event(codec, res);
14690                 break;
14691         }
14692 }
14693
14694 static struct hda_verb alc861vd_dallas_verbs[] = {
14695         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14696         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14697         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14698         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14699
14700         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14701         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14702         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14703         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14704         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14705         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14706         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14707         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14708
14709         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14710         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14711         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14712         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14713         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14714         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14715         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14716         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14717
14718         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14719         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14720         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14721         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14722         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14723         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14724         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14725         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14726
14727         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14728         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14729         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14730         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14731
14732         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14733         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14734         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14735
14736         { } /* end */
14737 };
14738
14739 /* toggle speaker-output according to the hp-jack state */
14740 static void alc861vd_dallas_init_hook(struct hda_codec *codec)
14741 {
14742         struct alc_spec *spec = codec->spec;
14743
14744         spec->autocfg.hp_pins[0] = 0x15;
14745         spec->autocfg.speaker_pins[0] = 0x14;
14746         alc_automute_amp(codec);
14747 }
14748
14749 #ifdef CONFIG_SND_HDA_POWER_SAVE
14750 #define alc861vd_loopbacks      alc880_loopbacks
14751 #endif
14752
14753 /* pcm configuration: identiacal with ALC880 */
14754 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
14755 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
14756 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
14757 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
14758
14759 /*
14760  * configuration and preset
14761  */
14762 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14763         [ALC660VD_3ST]          = "3stack-660",
14764         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
14765         [ALC660VD_ASUS_V1S]     = "asus-v1s",
14766         [ALC861VD_3ST]          = "3stack",
14767         [ALC861VD_3ST_DIG]      = "3stack-digout",
14768         [ALC861VD_6ST_DIG]      = "6stack-digout",
14769         [ALC861VD_LENOVO]       = "lenovo",
14770         [ALC861VD_DALLAS]       = "dallas",
14771         [ALC861VD_HP]           = "hp",
14772         [ALC861VD_AUTO]         = "auto",
14773 };
14774
14775 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14776         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14777         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14778         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14779         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14780         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
14781         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14782         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14783         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14784         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14785         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14786         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14787         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14788         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14789         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
14790         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14791         {}
14792 };
14793
14794 static struct alc_config_preset alc861vd_presets[] = {
14795         [ALC660VD_3ST] = {
14796                 .mixers = { alc861vd_3st_mixer },
14797                 .init_verbs = { alc861vd_volume_init_verbs,
14798                                  alc861vd_3stack_init_verbs },
14799                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14800                 .dac_nids = alc660vd_dac_nids,
14801                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14802                 .channel_mode = alc861vd_3stack_2ch_modes,
14803                 .input_mux = &alc861vd_capture_source,
14804         },
14805         [ALC660VD_3ST_DIG] = {
14806                 .mixers = { alc861vd_3st_mixer },
14807                 .init_verbs = { alc861vd_volume_init_verbs,
14808                                  alc861vd_3stack_init_verbs },
14809                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14810                 .dac_nids = alc660vd_dac_nids,
14811                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14812                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14813                 .channel_mode = alc861vd_3stack_2ch_modes,
14814                 .input_mux = &alc861vd_capture_source,
14815         },
14816         [ALC861VD_3ST] = {
14817                 .mixers = { alc861vd_3st_mixer },
14818                 .init_verbs = { alc861vd_volume_init_verbs,
14819                                  alc861vd_3stack_init_verbs },
14820                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14821                 .dac_nids = alc861vd_dac_nids,
14822                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14823                 .channel_mode = alc861vd_3stack_2ch_modes,
14824                 .input_mux = &alc861vd_capture_source,
14825         },
14826         [ALC861VD_3ST_DIG] = {
14827                 .mixers = { alc861vd_3st_mixer },
14828                 .init_verbs = { alc861vd_volume_init_verbs,
14829                                  alc861vd_3stack_init_verbs },
14830                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14831                 .dac_nids = alc861vd_dac_nids,
14832                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14833                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14834                 .channel_mode = alc861vd_3stack_2ch_modes,
14835                 .input_mux = &alc861vd_capture_source,
14836         },
14837         [ALC861VD_6ST_DIG] = {
14838                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14839                 .init_verbs = { alc861vd_volume_init_verbs,
14840                                 alc861vd_6stack_init_verbs },
14841                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14842                 .dac_nids = alc861vd_dac_nids,
14843                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14844                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14845                 .channel_mode = alc861vd_6stack_modes,
14846                 .input_mux = &alc861vd_capture_source,
14847         },
14848         [ALC861VD_LENOVO] = {
14849                 .mixers = { alc861vd_lenovo_mixer },
14850                 .init_verbs = { alc861vd_volume_init_verbs,
14851                                 alc861vd_3stack_init_verbs,
14852                                 alc861vd_eapd_verbs,
14853                                 alc861vd_lenovo_unsol_verbs },
14854                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14855                 .dac_nids = alc660vd_dac_nids,
14856                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14857                 .channel_mode = alc861vd_3stack_2ch_modes,
14858                 .input_mux = &alc861vd_capture_source,
14859                 .unsol_event = alc861vd_lenovo_unsol_event,
14860                 .init_hook = alc861vd_lenovo_init_hook,
14861         },
14862         [ALC861VD_DALLAS] = {
14863                 .mixers = { alc861vd_dallas_mixer },
14864                 .init_verbs = { alc861vd_dallas_verbs },
14865                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14866                 .dac_nids = alc861vd_dac_nids,
14867                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14868                 .channel_mode = alc861vd_3stack_2ch_modes,
14869                 .input_mux = &alc861vd_dallas_capture_source,
14870                 .unsol_event = alc_automute_amp_unsol_event,
14871                 .init_hook = alc861vd_dallas_init_hook,
14872         },
14873         [ALC861VD_HP] = {
14874                 .mixers = { alc861vd_hp_mixer },
14875                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14876                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14877                 .dac_nids = alc861vd_dac_nids,
14878                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14879                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14880                 .channel_mode = alc861vd_3stack_2ch_modes,
14881                 .input_mux = &alc861vd_hp_capture_source,
14882                 .unsol_event = alc_automute_amp_unsol_event,
14883                 .init_hook = alc861vd_dallas_init_hook,
14884         },
14885         [ALC660VD_ASUS_V1S] = {
14886                 .mixers = { alc861vd_lenovo_mixer },
14887                 .init_verbs = { alc861vd_volume_init_verbs,
14888                                 alc861vd_3stack_init_verbs,
14889                                 alc861vd_eapd_verbs,
14890                                 alc861vd_lenovo_unsol_verbs },
14891                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14892                 .dac_nids = alc660vd_dac_nids,
14893                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14894                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14895                 .channel_mode = alc861vd_3stack_2ch_modes,
14896                 .input_mux = &alc861vd_capture_source,
14897                 .unsol_event = alc861vd_lenovo_unsol_event,
14898                 .init_hook = alc861vd_lenovo_init_hook,
14899         },
14900 };
14901
14902 /*
14903  * BIOS auto configuration
14904  */
14905 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14906                                 hda_nid_t nid, int pin_type, int dac_idx)
14907 {
14908         alc_set_pin_output(codec, nid, pin_type);
14909 }
14910
14911 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14912 {
14913         struct alc_spec *spec = codec->spec;
14914         int i;
14915
14916         for (i = 0; i <= HDA_SIDE; i++) {
14917                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14918                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14919                 if (nid)
14920                         alc861vd_auto_set_output_and_unmute(codec, nid,
14921                                                             pin_type, i);
14922         }
14923 }
14924
14925
14926 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14927 {
14928         struct alc_spec *spec = codec->spec;
14929         hda_nid_t pin;
14930
14931         pin = spec->autocfg.hp_pins[0];
14932         if (pin) /* connect to front and  use dac 0 */
14933                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14934         pin = spec->autocfg.speaker_pins[0];
14935         if (pin)
14936                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14937 }
14938
14939 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
14940 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
14941
14942 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14943 {
14944         struct alc_spec *spec = codec->spec;
14945         int i;
14946
14947         for (i = 0; i < AUTO_PIN_LAST; i++) {
14948                 hda_nid_t nid = spec->autocfg.input_pins[i];
14949                 if (alc861vd_is_input_pin(nid)) {
14950                         alc_set_input_pin(codec, nid, i);
14951                         if (nid != ALC861VD_PIN_CD_NID &&
14952                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
14953                                 snd_hda_codec_write(codec, nid, 0,
14954                                                 AC_VERB_SET_AMP_GAIN_MUTE,
14955                                                 AMP_OUT_MUTE);
14956                 }
14957         }
14958 }
14959
14960 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
14961
14962 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
14963 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
14964
14965 /* add playback controls from the parsed DAC table */
14966 /* Based on ALC880 version. But ALC861VD has separate,
14967  * different NIDs for mute/unmute switch and volume control */
14968 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14969                                              const struct auto_pin_cfg *cfg)
14970 {
14971         char name[32];
14972         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14973         hda_nid_t nid_v, nid_s;
14974         int i, err;
14975
14976         for (i = 0; i < cfg->line_outs; i++) {
14977                 if (!spec->multiout.dac_nids[i])
14978                         continue;
14979                 nid_v = alc861vd_idx_to_mixer_vol(
14980                                 alc880_dac_to_idx(
14981                                         spec->multiout.dac_nids[i]));
14982                 nid_s = alc861vd_idx_to_mixer_switch(
14983                                 alc880_dac_to_idx(
14984                                         spec->multiout.dac_nids[i]));
14985
14986                 if (i == 2) {
14987                         /* Center/LFE */
14988                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14989                                           "Center Playback Volume",
14990                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14991                                                               HDA_OUTPUT));
14992                         if (err < 0)
14993                                 return err;
14994                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14995                                           "LFE Playback Volume",
14996                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14997                                                               HDA_OUTPUT));
14998                         if (err < 0)
14999                                 return err;
15000                         err = add_control(spec, ALC_CTL_BIND_MUTE,
15001                                           "Center Playback Switch",
15002                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
15003                                                               HDA_INPUT));
15004                         if (err < 0)
15005                                 return err;
15006                         err = add_control(spec, ALC_CTL_BIND_MUTE,
15007                                           "LFE Playback Switch",
15008                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
15009                                                               HDA_INPUT));
15010                         if (err < 0)
15011                                 return err;
15012                 } else {
15013                         sprintf(name, "%s Playback Volume", chname[i]);
15014                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
15015                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
15016                                                               HDA_OUTPUT));
15017                         if (err < 0)
15018                                 return err;
15019                         sprintf(name, "%s Playback Switch", chname[i]);
15020                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
15021                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
15022                                                               HDA_INPUT));
15023                         if (err < 0)
15024                                 return err;
15025                 }
15026         }
15027         return 0;
15028 }
15029
15030 /* add playback controls for speaker and HP outputs */
15031 /* Based on ALC880 version. But ALC861VD has separate,
15032  * different NIDs for mute/unmute switch and volume control */
15033 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
15034                                         hda_nid_t pin, const char *pfx)
15035 {
15036         hda_nid_t nid_v, nid_s;
15037         int err;
15038         char name[32];
15039
15040         if (!pin)
15041                 return 0;
15042
15043         if (alc880_is_fixed_pin(pin)) {
15044                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
15045                 /* specify the DAC as the extra output */
15046                 if (!spec->multiout.hp_nid)
15047                         spec->multiout.hp_nid = nid_v;
15048                 else
15049                         spec->multiout.extra_out_nid[0] = nid_v;
15050                 /* control HP volume/switch on the output mixer amp */
15051                 nid_v = alc861vd_idx_to_mixer_vol(
15052                                 alc880_fixed_pin_idx(pin));
15053                 nid_s = alc861vd_idx_to_mixer_switch(
15054                                 alc880_fixed_pin_idx(pin));
15055
15056                 sprintf(name, "%s Playback Volume", pfx);
15057                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
15058                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
15059                 if (err < 0)
15060                         return err;
15061                 sprintf(name, "%s Playback Switch", pfx);
15062                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
15063                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
15064                 if (err < 0)
15065                         return err;
15066         } else if (alc880_is_multi_pin(pin)) {
15067                 /* set manual connection */
15068                 /* we have only a switch on HP-out PIN */
15069                 sprintf(name, "%s Playback Switch", pfx);
15070                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
15071                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15072                 if (err < 0)
15073                         return err;
15074         }
15075         return 0;
15076 }
15077
15078 /* parse the BIOS configuration and set up the alc_spec
15079  * return 1 if successful, 0 if the proper config is not found,
15080  * or a negative error code
15081  * Based on ALC880 version - had to change it to override
15082  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15083 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15084 {
15085         struct alc_spec *spec = codec->spec;
15086         int err;
15087         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15088
15089         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15090                                            alc861vd_ignore);
15091         if (err < 0)
15092                 return err;
15093         if (!spec->autocfg.line_outs)
15094                 return 0; /* can't find valid BIOS pin config */
15095
15096         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15097         if (err < 0)
15098                 return err;
15099         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15100         if (err < 0)
15101                 return err;
15102         err = alc861vd_auto_create_extra_out(spec,
15103                                              spec->autocfg.speaker_pins[0],
15104                                              "Speaker");
15105         if (err < 0)
15106                 return err;
15107         err = alc861vd_auto_create_extra_out(spec,
15108                                              spec->autocfg.hp_pins[0],
15109                                              "Headphone");
15110         if (err < 0)
15111                 return err;
15112         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
15113         if (err < 0)
15114                 return err;
15115
15116         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15117
15118         if (spec->autocfg.dig_outs)
15119                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15120
15121         if (spec->kctls.list)
15122                 add_mixer(spec, spec->kctls.list);
15123
15124         add_verb(spec, alc861vd_volume_init_verbs);
15125
15126         spec->num_mux_defs = 1;
15127         spec->input_mux = &spec->private_imux[0];
15128
15129         err = alc_auto_add_mic_boost(codec);
15130         if (err < 0)
15131                 return err;
15132
15133         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
15134
15135         return 1;
15136 }
15137
15138 /* additional initialization for auto-configuration model */
15139 static void alc861vd_auto_init(struct hda_codec *codec)
15140 {
15141         struct alc_spec *spec = codec->spec;
15142         alc861vd_auto_init_multi_out(codec);
15143         alc861vd_auto_init_hp_out(codec);
15144         alc861vd_auto_init_analog_input(codec);
15145         alc861vd_auto_init_input_src(codec);
15146         if (spec->unsol_event)
15147                 alc_inithook(codec);
15148 }
15149
15150 static int patch_alc861vd(struct hda_codec *codec)
15151 {
15152         struct alc_spec *spec;
15153         int err, board_config;
15154
15155         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15156         if (spec == NULL)
15157                 return -ENOMEM;
15158
15159         codec->spec = spec;
15160
15161         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15162                                                   alc861vd_models,
15163                                                   alc861vd_cfg_tbl);
15164
15165         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15166                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
15167                        "trying auto-probe from BIOS...\n", codec->chip_name);
15168                 board_config = ALC861VD_AUTO;
15169         }
15170
15171         if (board_config == ALC861VD_AUTO) {
15172                 /* automatic parse from the BIOS config */
15173                 err = alc861vd_parse_auto_config(codec);
15174                 if (err < 0) {
15175                         alc_free(codec);
15176                         return err;
15177                 } else if (!err) {
15178                         printk(KERN_INFO
15179                                "hda_codec: Cannot set up configuration "
15180                                "from BIOS.  Using base mode...\n");
15181                         board_config = ALC861VD_3ST;
15182                 }
15183         }
15184
15185         err = snd_hda_attach_beep_device(codec, 0x23);
15186         if (err < 0) {
15187                 alc_free(codec);
15188                 return err;
15189         }
15190
15191         if (board_config != ALC861VD_AUTO)
15192                 setup_preset(spec, &alc861vd_presets[board_config]);
15193
15194         if (codec->vendor_id == 0x10ec0660) {
15195                 /* always turn on EAPD */
15196                 add_verb(spec, alc660vd_eapd_verbs);
15197         }
15198
15199         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15200         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15201
15202         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15203         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15204
15205         spec->adc_nids = alc861vd_adc_nids;
15206         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15207         spec->capsrc_nids = alc861vd_capsrc_nids;
15208         spec->capture_style = CAPT_MIX;
15209
15210         set_capture_mixer(spec);
15211         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15212
15213         spec->vmaster_nid = 0x02;
15214
15215         codec->patch_ops = alc_patch_ops;
15216
15217         if (board_config == ALC861VD_AUTO)
15218                 spec->init_hook = alc861vd_auto_init;
15219 #ifdef CONFIG_SND_HDA_POWER_SAVE
15220         if (!spec->loopback.amplist)
15221                 spec->loopback.amplist = alc861vd_loopbacks;
15222 #endif
15223         codec->proc_widget_hook = print_realtek_coef;
15224
15225         return 0;
15226 }
15227
15228 /*
15229  * ALC662 support
15230  *
15231  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15232  * configuration.  Each pin widget can choose any input DACs and a mixer.
15233  * Each ADC is connected from a mixer of all inputs.  This makes possible
15234  * 6-channel independent captures.
15235  *
15236  * In addition, an independent DAC for the multi-playback (not used in this
15237  * driver yet).
15238  */
15239 #define ALC662_DIGOUT_NID       0x06
15240 #define ALC662_DIGIN_NID        0x0a
15241
15242 static hda_nid_t alc662_dac_nids[4] = {
15243         /* front, rear, clfe, rear_surr */
15244         0x02, 0x03, 0x04
15245 };
15246
15247 static hda_nid_t alc272_dac_nids[2] = {
15248         0x02, 0x03
15249 };
15250
15251 static hda_nid_t alc662_adc_nids[1] = {
15252         /* ADC1-2 */
15253         0x09,
15254 };
15255
15256 static hda_nid_t alc272_adc_nids[1] = {
15257         /* ADC1-2 */
15258         0x08,
15259 };
15260
15261 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
15262 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
15263
15264
15265 /* input MUX */
15266 /* FIXME: should be a matrix-type input source selection */
15267 static struct hda_input_mux alc662_capture_source = {
15268         .num_items = 4,
15269         .items = {
15270                 { "Mic", 0x0 },
15271                 { "Front Mic", 0x1 },
15272                 { "Line", 0x2 },
15273                 { "CD", 0x4 },
15274         },
15275 };
15276
15277 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15278         .num_items = 2,
15279         .items = {
15280                 { "Mic", 0x1 },
15281                 { "Line", 0x2 },
15282         },
15283 };
15284
15285 static struct hda_input_mux alc662_eeepc_capture_source = {
15286         .num_items = 2,
15287         .items = {
15288                 { "i-Mic", 0x1 },
15289                 { "e-Mic", 0x0 },
15290         },
15291 };
15292
15293 static struct hda_input_mux alc663_capture_source = {
15294         .num_items = 3,
15295         .items = {
15296                 { "Mic", 0x0 },
15297                 { "Front Mic", 0x1 },
15298                 { "Line", 0x2 },
15299         },
15300 };
15301
15302 static struct hda_input_mux alc663_m51va_capture_source = {
15303         .num_items = 2,
15304         .items = {
15305                 { "Ext-Mic", 0x0 },
15306                 { "D-Mic", 0x9 },
15307         },
15308 };
15309
15310 #if 1 /* set to 0 for testing other input sources below */
15311 static struct hda_input_mux alc272_nc10_capture_source = {
15312         .num_items = 2,
15313         .items = {
15314                 { "Autoselect Mic", 0x0 },
15315                 { "Internal Mic", 0x1 },
15316         },
15317 };
15318 #else
15319 static struct hda_input_mux alc272_nc10_capture_source = {
15320         .num_items = 16,
15321         .items = {
15322                 { "Autoselect Mic", 0x0 },
15323                 { "Internal Mic", 0x1 },
15324                 { "In-0x02", 0x2 },
15325                 { "In-0x03", 0x3 },
15326                 { "In-0x04", 0x4 },
15327                 { "In-0x05", 0x5 },
15328                 { "In-0x06", 0x6 },
15329                 { "In-0x07", 0x7 },
15330                 { "In-0x08", 0x8 },
15331                 { "In-0x09", 0x9 },
15332                 { "In-0x0a", 0x0a },
15333                 { "In-0x0b", 0x0b },
15334                 { "In-0x0c", 0x0c },
15335                 { "In-0x0d", 0x0d },
15336                 { "In-0x0e", 0x0e },
15337                 { "In-0x0f", 0x0f },
15338         },
15339 };
15340 #endif
15341
15342 /*
15343  * 2ch mode
15344  */
15345 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15346         { 2, NULL }
15347 };
15348
15349 /*
15350  * 2ch mode
15351  */
15352 static struct hda_verb alc662_3ST_ch2_init[] = {
15353         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15354         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15355         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15356         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15357         { } /* end */
15358 };
15359
15360 /*
15361  * 6ch mode
15362  */
15363 static struct hda_verb alc662_3ST_ch6_init[] = {
15364         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15365         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15366         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15367         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15368         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15369         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15370         { } /* end */
15371 };
15372
15373 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15374         { 2, alc662_3ST_ch2_init },
15375         { 6, alc662_3ST_ch6_init },
15376 };
15377
15378 /*
15379  * 2ch mode
15380  */
15381 static struct hda_verb alc662_sixstack_ch6_init[] = {
15382         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15383         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15384         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15385         { } /* end */
15386 };
15387
15388 /*
15389  * 6ch mode
15390  */
15391 static struct hda_verb alc662_sixstack_ch8_init[] = {
15392         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15393         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15394         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15395         { } /* end */
15396 };
15397
15398 static struct hda_channel_mode alc662_5stack_modes[2] = {
15399         { 2, alc662_sixstack_ch6_init },
15400         { 6, alc662_sixstack_ch8_init },
15401 };
15402
15403 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15404  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15405  */
15406
15407 static struct snd_kcontrol_new alc662_base_mixer[] = {
15408         /* output mixer control */
15409         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
15410         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15411         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
15412         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15413         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15414         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15415         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15416         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15417         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15418
15419         /*Input mixer control */
15420         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
15421         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
15422         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
15423         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
15424         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
15425         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
15426         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
15427         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
15428         { } /* end */
15429 };
15430
15431 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
15432         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15433         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15434         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15435         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15436         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15437         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15438         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15439         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15440         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15441         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15442         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15443         { } /* end */
15444 };
15445
15446 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
15447         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15448         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15449         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15450         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15451         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15452         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15453         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15454         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15455         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15456         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15457         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15458         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15459         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15460         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15461         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15462         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15463         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15464         { } /* end */
15465 };
15466
15467 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
15468         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15469         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
15470         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15471         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
15472         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15473         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15474         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15475         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15476         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15477         { } /* end */
15478 };
15479
15480 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
15481         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15482         ALC262_HIPPO_MASTER_SWITCH,
15483
15484         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
15485         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15486         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15487
15488         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15489         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15490         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15491         { } /* end */
15492 };
15493
15494 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
15495         ALC262_HIPPO_MASTER_SWITCH,
15496         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15497         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15498         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15499         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15500         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
15501         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15502         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15503         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15504         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15505         { } /* end */
15506 };
15507
15508 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
15509         .ops = &snd_hda_bind_vol,
15510         .values = {
15511                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15512                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
15513                 0
15514         },
15515 };
15516
15517 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
15518         .ops = &snd_hda_bind_sw,
15519         .values = {
15520                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15521                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15522                 0
15523         },
15524 };
15525
15526 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
15527         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15528         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
15529         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15530         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15531         { } /* end */
15532 };
15533
15534 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
15535         .ops = &snd_hda_bind_sw,
15536         .values = {
15537                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15538                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15539                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15540                 0
15541         },
15542 };
15543
15544 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
15545         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15546         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
15547         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15548         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15549         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15550         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15551
15552         { } /* end */
15553 };
15554
15555 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
15556         .ops = &snd_hda_bind_sw,
15557         .values = {
15558                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15559                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15560                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15561                 0
15562         },
15563 };
15564
15565 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
15566         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15567         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
15568         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15569         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15570         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15571         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15572         { } /* end */
15573 };
15574
15575 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
15576         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15577         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15578         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15579         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15580         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15581         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15582         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15583         { } /* end */
15584 };
15585
15586 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
15587         .ops = &snd_hda_bind_vol,
15588         .values = {
15589                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15590                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
15591                 0
15592         },
15593 };
15594
15595 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
15596         .ops = &snd_hda_bind_sw,
15597         .values = {
15598                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15599                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
15600                 0
15601         },
15602 };
15603
15604 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
15605         HDA_BIND_VOL("Master Playback Volume",
15606                                 &alc663_asus_two_bind_master_vol),
15607         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15608         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15609         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15610         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15611         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15612         { } /* end */
15613 };
15614
15615 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
15616         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15617         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15618         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15619         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15620         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15621         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15622         { } /* end */
15623 };
15624
15625 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
15626         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15627         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15628         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15629         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15630         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15631
15632         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15633         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15634         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15635         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15636         { } /* end */
15637 };
15638
15639 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
15640         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15641         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15642         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15643
15644         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15645         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15646         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15647         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15648         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15649         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15650         { } /* end */
15651 };
15652
15653 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
15654         {
15655                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15656                 .name = "Channel Mode",
15657                 .info = alc_ch_mode_info,
15658                 .get = alc_ch_mode_get,
15659                 .put = alc_ch_mode_put,
15660         },
15661         { } /* end */
15662 };
15663
15664 static struct hda_verb alc662_init_verbs[] = {
15665         /* ADC: mute amp left and right */
15666         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15667         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15668         /* Front mixer: unmute input/output amp left and right (volume = 0) */
15669
15670         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15671         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15672         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15673         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15674         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15675
15676         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15677         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15678         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15679         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15680         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15681         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15682
15683         /* Front Pin: output 0 (0x0c) */
15684         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15685         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15686
15687         /* Rear Pin: output 1 (0x0d) */
15688         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15689         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15690
15691         /* CLFE Pin: output 2 (0x0e) */
15692         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15693         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15694
15695         /* Mic (rear) pin: input vref at 80% */
15696         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15697         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15698         /* Front Mic pin: input vref at 80% */
15699         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15700         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15701         /* Line In pin: input */
15702         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15703         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15704         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15705         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15706         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15707         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15708         /* CD pin widget for input */
15709         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15710
15711         /* FIXME: use matrix-type input source selection */
15712         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15713         /* Input mixer */
15714         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15715         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15716
15717         /* always trun on EAPD */
15718         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15719         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15720
15721         { }
15722 };
15723
15724 static struct hda_verb alc662_sue_init_verbs[] = {
15725         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15726         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15727         {}
15728 };
15729
15730 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
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 /* Set Unsolicited Event*/
15737 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15738         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15739         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15740         {}
15741 };
15742
15743 /*
15744  * generic initialization of ADC, input mixers and output mixers
15745  */
15746 static struct hda_verb alc662_auto_init_verbs[] = {
15747         /*
15748          * Unmute ADC and set the default input to mic-in
15749          */
15750         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15751         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15752
15753         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15754          * mixer widget
15755          * Note: PASD motherboards uses the Line In 2 as the input for front
15756          * panel mic (mic 2)
15757          */
15758         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15759         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15760         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15761         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15762         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15763         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15764
15765         /*
15766          * Set up output mixers (0x0c - 0x0f)
15767          */
15768         /* set vol=0 to output mixers */
15769         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15770         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15771         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15772
15773         /* set up input amps for analog loopback */
15774         /* Amp Indices: DAC = 0, mixer = 1 */
15775         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15776         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15777         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15778         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15779         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15780         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15781
15782
15783         /* FIXME: use matrix-type input source selection */
15784         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15785         /* Input mixer */
15786         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15787         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15788         { }
15789 };
15790
15791 /* additional verbs for ALC663 */
15792 static struct hda_verb alc663_auto_init_verbs[] = {
15793         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15794         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15795         { }
15796 };
15797
15798 static struct hda_verb alc663_m51va_init_verbs[] = {
15799         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15800         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15801         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15802         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15803         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15804         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15805         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15806         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15807         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15808         {}
15809 };
15810
15811 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15812         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15813         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15814         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15815         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15816         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15817         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15818         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15819         {}
15820 };
15821
15822 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15823         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15824         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15825         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15826         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15827         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15828         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15829         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15830         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15831         {}
15832 };
15833
15834 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15835         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15836         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15837         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15838         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15839         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15840         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15841         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15842         {}
15843 };
15844
15845 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15846         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15847         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15848         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15849         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15850         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15851         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15852         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15853         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15854         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15855         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15856         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15857         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15858         {}
15859 };
15860
15861 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15862         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15863         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15864         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15865         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15866         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15867         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15868         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15869         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15870         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15871         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15872         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15873         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15874         {}
15875 };
15876
15877 static struct hda_verb alc663_g71v_init_verbs[] = {
15878         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15879         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15880         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15881
15882         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15883         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15884         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15885
15886         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15887         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15888         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15889         {}
15890 };
15891
15892 static struct hda_verb alc663_g50v_init_verbs[] = {
15893         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15894         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15895         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15896
15897         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15898         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15899         {}
15900 };
15901
15902 static struct hda_verb alc662_ecs_init_verbs[] = {
15903         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15904         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15905         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15906         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15907         {}
15908 };
15909
15910 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
15911         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15912         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15913         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15914         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15915         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15916         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15917         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15918         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15919         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15920         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15921         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15922         {}
15923 };
15924
15925 static struct hda_verb alc272_dell_init_verbs[] = {
15926         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15927         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15928         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15929         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15930         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15931         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15932         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15933         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15934         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15935         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15936         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15937         {}
15938 };
15939
15940 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15941         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15942         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15943         { } /* end */
15944 };
15945
15946 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
15947         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
15948         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
15949         { } /* end */
15950 };
15951
15952 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15953 {
15954         unsigned int present;
15955         unsigned char bits;
15956
15957         present = snd_hda_codec_read(codec, 0x14, 0,
15958                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15959         bits = present ? HDA_AMP_MUTE : 0;
15960         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15961                                  HDA_AMP_MUTE, bits);
15962 }
15963
15964 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15965 {
15966         unsigned int present;
15967         unsigned char bits;
15968
15969         present = snd_hda_codec_read(codec, 0x1b, 0,
15970                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15971         bits = present ? HDA_AMP_MUTE : 0;
15972         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15973                                  HDA_AMP_MUTE, bits);
15974         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15975                                  HDA_AMP_MUTE, bits);
15976 }
15977
15978 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15979                                            unsigned int res)
15980 {
15981         if ((res >> 26) == ALC880_HP_EVENT)
15982                 alc662_lenovo_101e_all_automute(codec);
15983         if ((res >> 26) == ALC880_FRONT_EVENT)
15984                 alc662_lenovo_101e_ispeaker_automute(codec);
15985 }
15986
15987 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15988 {
15989         unsigned int present;
15990
15991         present = snd_hda_codec_read(codec, 0x18, 0,
15992                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15993         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15994                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15995         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15996                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15997         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15998                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15999         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16000                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
16001 }
16002
16003 /* unsolicited event for HP jack sensing */
16004 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
16005                                      unsigned int res)
16006 {
16007         if ((res >> 26) == ALC880_MIC_EVENT)
16008                 alc662_eeepc_mic_automute(codec);
16009         else
16010                 alc262_hippo_unsol_event(codec, res);
16011 }
16012
16013 static void alc662_eeepc_inithook(struct hda_codec *codec)
16014 {
16015         alc262_hippo1_init_hook(codec);
16016         alc662_eeepc_mic_automute(codec);
16017 }
16018
16019 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
16020 {
16021         struct alc_spec *spec = codec->spec;
16022
16023         spec->autocfg.hp_pins[0] = 0x14;
16024         spec->autocfg.speaker_pins[0] = 0x1b;
16025         alc262_hippo_master_update(codec);
16026 }
16027
16028 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
16029 {
16030         unsigned int present;
16031         unsigned char bits;
16032
16033         present = snd_hda_codec_read(codec, 0x21, 0,
16034                         AC_VERB_GET_PIN_SENSE, 0)
16035                         & AC_PINSENSE_PRESENCE;
16036         bits = present ? HDA_AMP_MUTE : 0;
16037         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16038                                 AMP_IN_MUTE(0), bits);
16039         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16040                                 AMP_IN_MUTE(0), bits);
16041 }
16042
16043 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
16044 {
16045         unsigned int present;
16046         unsigned char bits;
16047
16048         present = snd_hda_codec_read(codec, 0x21, 0,
16049                         AC_VERB_GET_PIN_SENSE, 0)
16050                         & AC_PINSENSE_PRESENCE;
16051         bits = present ? HDA_AMP_MUTE : 0;
16052         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16053                                 AMP_IN_MUTE(0), bits);
16054         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16055                                 AMP_IN_MUTE(0), bits);
16056         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16057                                 AMP_IN_MUTE(0), bits);
16058         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16059                                 AMP_IN_MUTE(0), bits);
16060 }
16061
16062 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
16063 {
16064         unsigned int present;
16065         unsigned char bits;
16066
16067         present = snd_hda_codec_read(codec, 0x15, 0,
16068                         AC_VERB_GET_PIN_SENSE, 0)
16069                         & AC_PINSENSE_PRESENCE;
16070         bits = present ? HDA_AMP_MUTE : 0;
16071         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16072                                 AMP_IN_MUTE(0), bits);
16073         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16074                                 AMP_IN_MUTE(0), bits);
16075         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16076                                 AMP_IN_MUTE(0), bits);
16077         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16078                                 AMP_IN_MUTE(0), bits);
16079 }
16080
16081 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
16082 {
16083         unsigned int present;
16084         unsigned char bits;
16085
16086         present = snd_hda_codec_read(codec, 0x1b, 0,
16087                         AC_VERB_GET_PIN_SENSE, 0)
16088                         & AC_PINSENSE_PRESENCE;
16089         bits = present ? 0 : PIN_OUT;
16090         snd_hda_codec_write(codec, 0x14, 0,
16091                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
16092 }
16093
16094 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
16095 {
16096         unsigned int present1, present2;
16097
16098         present1 = snd_hda_codec_read(codec, 0x21, 0,
16099                         AC_VERB_GET_PIN_SENSE, 0)
16100                         & AC_PINSENSE_PRESENCE;
16101         present2 = snd_hda_codec_read(codec, 0x15, 0,
16102                         AC_VERB_GET_PIN_SENSE, 0)
16103                         & AC_PINSENSE_PRESENCE;
16104
16105         if (present1 || present2) {
16106                 snd_hda_codec_write_cache(codec, 0x14, 0,
16107                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16108         } else {
16109                 snd_hda_codec_write_cache(codec, 0x14, 0,
16110                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16111         }
16112 }
16113
16114 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16115 {
16116         unsigned int present1, present2;
16117
16118         present1 = snd_hda_codec_read(codec, 0x1b, 0,
16119                                 AC_VERB_GET_PIN_SENSE, 0)
16120                                 & AC_PINSENSE_PRESENCE;
16121         present2 = snd_hda_codec_read(codec, 0x15, 0,
16122                                 AC_VERB_GET_PIN_SENSE, 0)
16123                                 & AC_PINSENSE_PRESENCE;
16124
16125         if (present1 || present2) {
16126                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16127                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16128                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16129                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16130         } else {
16131                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16132                                 AMP_IN_MUTE(0), 0);
16133                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16134                                 AMP_IN_MUTE(0), 0);
16135         }
16136 }
16137
16138 static void alc663_m51va_mic_automute(struct hda_codec *codec)
16139 {
16140         unsigned int present;
16141
16142         present = snd_hda_codec_read(codec, 0x18, 0,
16143                         AC_VERB_GET_PIN_SENSE, 0)
16144                         & AC_PINSENSE_PRESENCE;
16145         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16146                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16147         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16148                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16149         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16150                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16151         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16152                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16153 }
16154
16155 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16156                                            unsigned int res)
16157 {
16158         switch (res >> 26) {
16159         case ALC880_HP_EVENT:
16160                 alc663_m51va_speaker_automute(codec);
16161                 break;
16162         case ALC880_MIC_EVENT:
16163                 alc663_m51va_mic_automute(codec);
16164                 break;
16165         }
16166 }
16167
16168 static void alc663_m51va_inithook(struct hda_codec *codec)
16169 {
16170         alc663_m51va_speaker_automute(codec);
16171         alc663_m51va_mic_automute(codec);
16172 }
16173
16174 /* ***************** Mode1 ******************************/
16175 static void alc663_mode1_unsol_event(struct hda_codec *codec,
16176                                            unsigned int res)
16177 {
16178         switch (res >> 26) {
16179         case ALC880_HP_EVENT:
16180                 alc663_m51va_speaker_automute(codec);
16181                 break;
16182         case ALC880_MIC_EVENT:
16183                 alc662_eeepc_mic_automute(codec);
16184                 break;
16185         }
16186 }
16187
16188 static void alc663_mode1_inithook(struct hda_codec *codec)
16189 {
16190         alc663_m51va_speaker_automute(codec);
16191         alc662_eeepc_mic_automute(codec);
16192 }
16193 /* ***************** Mode2 ******************************/
16194 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16195                                            unsigned int res)
16196 {
16197         switch (res >> 26) {
16198         case ALC880_HP_EVENT:
16199                 alc662_f5z_speaker_automute(codec);
16200                 break;
16201         case ALC880_MIC_EVENT:
16202                 alc662_eeepc_mic_automute(codec);
16203                 break;
16204         }
16205 }
16206
16207 static void alc662_mode2_inithook(struct hda_codec *codec)
16208 {
16209         alc662_f5z_speaker_automute(codec);
16210         alc662_eeepc_mic_automute(codec);
16211 }
16212 /* ***************** Mode3 ******************************/
16213 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16214                                            unsigned int res)
16215 {
16216         switch (res >> 26) {
16217         case ALC880_HP_EVENT:
16218                 alc663_two_hp_m1_speaker_automute(codec);
16219                 break;
16220         case ALC880_MIC_EVENT:
16221                 alc662_eeepc_mic_automute(codec);
16222                 break;
16223         }
16224 }
16225
16226 static void alc663_mode3_inithook(struct hda_codec *codec)
16227 {
16228         alc663_two_hp_m1_speaker_automute(codec);
16229         alc662_eeepc_mic_automute(codec);
16230 }
16231 /* ***************** Mode4 ******************************/
16232 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16233                                            unsigned int res)
16234 {
16235         switch (res >> 26) {
16236         case ALC880_HP_EVENT:
16237                 alc663_21jd_two_speaker_automute(codec);
16238                 break;
16239         case ALC880_MIC_EVENT:
16240                 alc662_eeepc_mic_automute(codec);
16241                 break;
16242         }
16243 }
16244
16245 static void alc663_mode4_inithook(struct hda_codec *codec)
16246 {
16247         alc663_21jd_two_speaker_automute(codec);
16248         alc662_eeepc_mic_automute(codec);
16249 }
16250 /* ***************** Mode5 ******************************/
16251 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16252                                            unsigned int res)
16253 {
16254         switch (res >> 26) {
16255         case ALC880_HP_EVENT:
16256                 alc663_15jd_two_speaker_automute(codec);
16257                 break;
16258         case ALC880_MIC_EVENT:
16259                 alc662_eeepc_mic_automute(codec);
16260                 break;
16261         }
16262 }
16263
16264 static void alc663_mode5_inithook(struct hda_codec *codec)
16265 {
16266         alc663_15jd_two_speaker_automute(codec);
16267         alc662_eeepc_mic_automute(codec);
16268 }
16269 /* ***************** Mode6 ******************************/
16270 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16271                                            unsigned int res)
16272 {
16273         switch (res >> 26) {
16274         case ALC880_HP_EVENT:
16275                 alc663_two_hp_m2_speaker_automute(codec);
16276                 break;
16277         case ALC880_MIC_EVENT:
16278                 alc662_eeepc_mic_automute(codec);
16279                 break;
16280         }
16281 }
16282
16283 static void alc663_mode6_inithook(struct hda_codec *codec)
16284 {
16285         alc663_two_hp_m2_speaker_automute(codec);
16286         alc662_eeepc_mic_automute(codec);
16287 }
16288
16289 static void alc663_g71v_hp_automute(struct hda_codec *codec)
16290 {
16291         unsigned int present;
16292         unsigned char bits;
16293
16294         present = snd_hda_codec_read(codec, 0x21, 0,
16295                                      AC_VERB_GET_PIN_SENSE, 0)
16296                 & AC_PINSENSE_PRESENCE;
16297         bits = present ? HDA_AMP_MUTE : 0;
16298         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16299                                  HDA_AMP_MUTE, bits);
16300         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16301                                  HDA_AMP_MUTE, bits);
16302 }
16303
16304 static void alc663_g71v_front_automute(struct hda_codec *codec)
16305 {
16306         unsigned int present;
16307         unsigned char bits;
16308
16309         present = snd_hda_codec_read(codec, 0x15, 0,
16310                                      AC_VERB_GET_PIN_SENSE, 0)
16311                 & AC_PINSENSE_PRESENCE;
16312         bits = present ? HDA_AMP_MUTE : 0;
16313         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16314                                  HDA_AMP_MUTE, bits);
16315 }
16316
16317 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16318                                            unsigned int res)
16319 {
16320         switch (res >> 26) {
16321         case ALC880_HP_EVENT:
16322                 alc663_g71v_hp_automute(codec);
16323                 break;
16324         case ALC880_FRONT_EVENT:
16325                 alc663_g71v_front_automute(codec);
16326                 break;
16327         case ALC880_MIC_EVENT:
16328                 alc662_eeepc_mic_automute(codec);
16329                 break;
16330         }
16331 }
16332
16333 static void alc663_g71v_inithook(struct hda_codec *codec)
16334 {
16335         alc663_g71v_front_automute(codec);
16336         alc663_g71v_hp_automute(codec);
16337         alc662_eeepc_mic_automute(codec);
16338 }
16339
16340 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16341                                            unsigned int res)
16342 {
16343         switch (res >> 26) {
16344         case ALC880_HP_EVENT:
16345                 alc663_m51va_speaker_automute(codec);
16346                 break;
16347         case ALC880_MIC_EVENT:
16348                 alc662_eeepc_mic_automute(codec);
16349                 break;
16350         }
16351 }
16352
16353 static void alc663_g50v_inithook(struct hda_codec *codec)
16354 {
16355         alc663_m51va_speaker_automute(codec);
16356         alc662_eeepc_mic_automute(codec);
16357 }
16358
16359 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16360         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16361         ALC262_HIPPO_MASTER_SWITCH,
16362
16363         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16364         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16365         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16366
16367         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16368         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16369         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16370         { } /* end */
16371 };
16372
16373 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
16374         /* Master Playback automatically created from Speaker and Headphone */
16375         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16376         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16377         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16378         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16379
16380         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16381         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16382         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
16383
16384         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16385         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16386         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
16387         { } /* end */
16388 };
16389
16390 #ifdef CONFIG_SND_HDA_POWER_SAVE
16391 #define alc662_loopbacks        alc880_loopbacks
16392 #endif
16393
16394
16395 /* pcm configuration: identiacal with ALC880 */
16396 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
16397 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
16398 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
16399 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
16400
16401 /*
16402  * configuration and preset
16403  */
16404 static const char *alc662_models[ALC662_MODEL_LAST] = {
16405         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
16406         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
16407         [ALC662_3ST_6ch]        = "3stack-6ch",
16408         [ALC662_5ST_DIG]        = "6stack-dig",
16409         [ALC662_LENOVO_101E]    = "lenovo-101e",
16410         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
16411         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
16412         [ALC662_ECS] = "ecs",
16413         [ALC663_ASUS_M51VA] = "m51va",
16414         [ALC663_ASUS_G71V] = "g71v",
16415         [ALC663_ASUS_H13] = "h13",
16416         [ALC663_ASUS_G50V] = "g50v",
16417         [ALC663_ASUS_MODE1] = "asus-mode1",
16418         [ALC662_ASUS_MODE2] = "asus-mode2",
16419         [ALC663_ASUS_MODE3] = "asus-mode3",
16420         [ALC663_ASUS_MODE4] = "asus-mode4",
16421         [ALC663_ASUS_MODE5] = "asus-mode5",
16422         [ALC663_ASUS_MODE6] = "asus-mode6",
16423         [ALC272_DELL]           = "dell",
16424         [ALC272_DELL_ZM1]       = "dell-zm1",
16425         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
16426         [ALC662_AUTO]           = "auto",
16427 };
16428
16429 static struct snd_pci_quirk alc662_cfg_tbl[] = {
16430         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
16431         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
16432         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
16433         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
16434         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
16435         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
16436         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
16437         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
16438         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
16439         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
16440         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
16441         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
16442         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
16443         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
16444         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
16445         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
16446         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
16447         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
16448         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
16449         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
16450         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
16451         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
16452         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
16453         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
16454         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
16455         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
16456         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
16457         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
16458         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
16459         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
16460         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
16461         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
16462         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
16463         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
16464         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
16465         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
16466         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
16467         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
16468         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
16469         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
16470         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
16471         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
16472         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
16473         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
16474         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
16475         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
16476         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
16477         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
16478         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
16479         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
16480         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
16481         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
16482                       ALC662_3ST_6ch_DIG),
16483         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
16484         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
16485                       ALC662_3ST_6ch_DIG),
16486         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
16487         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
16488         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
16489         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
16490                                         ALC662_3ST_6ch_DIG),
16491         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
16492                            ALC663_ASUS_H13),
16493         {}
16494 };
16495
16496 static struct alc_config_preset alc662_presets[] = {
16497         [ALC662_3ST_2ch_DIG] = {
16498                 .mixers = { alc662_3ST_2ch_mixer },
16499                 .init_verbs = { alc662_init_verbs },
16500                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16501                 .dac_nids = alc662_dac_nids,
16502                 .dig_out_nid = ALC662_DIGOUT_NID,
16503                 .dig_in_nid = ALC662_DIGIN_NID,
16504                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16505                 .channel_mode = alc662_3ST_2ch_modes,
16506                 .input_mux = &alc662_capture_source,
16507         },
16508         [ALC662_3ST_6ch_DIG] = {
16509                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16510                 .init_verbs = { alc662_init_verbs },
16511                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16512                 .dac_nids = alc662_dac_nids,
16513                 .dig_out_nid = ALC662_DIGOUT_NID,
16514                 .dig_in_nid = ALC662_DIGIN_NID,
16515                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16516                 .channel_mode = alc662_3ST_6ch_modes,
16517                 .need_dac_fix = 1,
16518                 .input_mux = &alc662_capture_source,
16519         },
16520         [ALC662_3ST_6ch] = {
16521                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16522                 .init_verbs = { alc662_init_verbs },
16523                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16524                 .dac_nids = alc662_dac_nids,
16525                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16526                 .channel_mode = alc662_3ST_6ch_modes,
16527                 .need_dac_fix = 1,
16528                 .input_mux = &alc662_capture_source,
16529         },
16530         [ALC662_5ST_DIG] = {
16531                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
16532                 .init_verbs = { alc662_init_verbs },
16533                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16534                 .dac_nids = alc662_dac_nids,
16535                 .dig_out_nid = ALC662_DIGOUT_NID,
16536                 .dig_in_nid = ALC662_DIGIN_NID,
16537                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
16538                 .channel_mode = alc662_5stack_modes,
16539                 .input_mux = &alc662_capture_source,
16540         },
16541         [ALC662_LENOVO_101E] = {
16542                 .mixers = { alc662_lenovo_101e_mixer },
16543                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
16544                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16545                 .dac_nids = alc662_dac_nids,
16546                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16547                 .channel_mode = alc662_3ST_2ch_modes,
16548                 .input_mux = &alc662_lenovo_101e_capture_source,
16549                 .unsol_event = alc662_lenovo_101e_unsol_event,
16550                 .init_hook = alc662_lenovo_101e_all_automute,
16551         },
16552         [ALC662_ASUS_EEEPC_P701] = {
16553                 .mixers = { alc662_eeepc_p701_mixer },
16554                 .init_verbs = { alc662_init_verbs,
16555                                 alc662_eeepc_sue_init_verbs },
16556                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16557                 .dac_nids = alc662_dac_nids,
16558                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16559                 .channel_mode = alc662_3ST_2ch_modes,
16560                 .input_mux = &alc662_eeepc_capture_source,
16561                 .unsol_event = alc662_eeepc_unsol_event,
16562                 .init_hook = alc662_eeepc_inithook,
16563         },
16564         [ALC662_ASUS_EEEPC_EP20] = {
16565                 .mixers = { alc662_eeepc_ep20_mixer,
16566                             alc662_chmode_mixer },
16567                 .init_verbs = { alc662_init_verbs,
16568                                 alc662_eeepc_ep20_sue_init_verbs },
16569                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16570                 .dac_nids = alc662_dac_nids,
16571                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16572                 .channel_mode = alc662_3ST_6ch_modes,
16573                 .input_mux = &alc662_lenovo_101e_capture_source,
16574                 .unsol_event = alc662_eeepc_unsol_event,
16575                 .init_hook = alc662_eeepc_ep20_inithook,
16576         },
16577         [ALC662_ECS] = {
16578                 .mixers = { alc662_ecs_mixer },
16579                 .init_verbs = { alc662_init_verbs,
16580                                 alc662_ecs_init_verbs },
16581                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16582                 .dac_nids = alc662_dac_nids,
16583                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16584                 .channel_mode = alc662_3ST_2ch_modes,
16585                 .input_mux = &alc662_eeepc_capture_source,
16586                 .unsol_event = alc662_eeepc_unsol_event,
16587                 .init_hook = alc662_eeepc_inithook,
16588         },
16589         [ALC663_ASUS_M51VA] = {
16590                 .mixers = { alc663_m51va_mixer },
16591                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16592                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16593                 .dac_nids = alc662_dac_nids,
16594                 .dig_out_nid = ALC662_DIGOUT_NID,
16595                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16596                 .channel_mode = alc662_3ST_2ch_modes,
16597                 .input_mux = &alc663_m51va_capture_source,
16598                 .unsol_event = alc663_m51va_unsol_event,
16599                 .init_hook = alc663_m51va_inithook,
16600         },
16601         [ALC663_ASUS_G71V] = {
16602                 .mixers = { alc663_g71v_mixer },
16603                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
16604                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16605                 .dac_nids = alc662_dac_nids,
16606                 .dig_out_nid = ALC662_DIGOUT_NID,
16607                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16608                 .channel_mode = alc662_3ST_2ch_modes,
16609                 .input_mux = &alc662_eeepc_capture_source,
16610                 .unsol_event = alc663_g71v_unsol_event,
16611                 .init_hook = alc663_g71v_inithook,
16612         },
16613         [ALC663_ASUS_H13] = {
16614                 .mixers = { alc663_m51va_mixer },
16615                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16616                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16617                 .dac_nids = alc662_dac_nids,
16618                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16619                 .channel_mode = alc662_3ST_2ch_modes,
16620                 .input_mux = &alc663_m51va_capture_source,
16621                 .unsol_event = alc663_m51va_unsol_event,
16622                 .init_hook = alc663_m51va_inithook,
16623         },
16624         [ALC663_ASUS_G50V] = {
16625                 .mixers = { alc663_g50v_mixer },
16626                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
16627                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16628                 .dac_nids = alc662_dac_nids,
16629                 .dig_out_nid = ALC662_DIGOUT_NID,
16630                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16631                 .channel_mode = alc662_3ST_6ch_modes,
16632                 .input_mux = &alc663_capture_source,
16633                 .unsol_event = alc663_g50v_unsol_event,
16634                 .init_hook = alc663_g50v_inithook,
16635         },
16636         [ALC663_ASUS_MODE1] = {
16637                 .mixers = { alc663_m51va_mixer },
16638                 .cap_mixer = alc662_auto_capture_mixer,
16639                 .init_verbs = { alc662_init_verbs,
16640                                 alc663_21jd_amic_init_verbs },
16641                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16642                 .hp_nid = 0x03,
16643                 .dac_nids = alc662_dac_nids,
16644                 .dig_out_nid = ALC662_DIGOUT_NID,
16645                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16646                 .channel_mode = alc662_3ST_2ch_modes,
16647                 .input_mux = &alc662_eeepc_capture_source,
16648                 .unsol_event = alc663_mode1_unsol_event,
16649                 .init_hook = alc663_mode1_inithook,
16650         },
16651         [ALC662_ASUS_MODE2] = {
16652                 .mixers = { alc662_1bjd_mixer },
16653                 .cap_mixer = alc662_auto_capture_mixer,
16654                 .init_verbs = { alc662_init_verbs,
16655                                 alc662_1bjd_amic_init_verbs },
16656                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16657                 .dac_nids = alc662_dac_nids,
16658                 .dig_out_nid = ALC662_DIGOUT_NID,
16659                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16660                 .channel_mode = alc662_3ST_2ch_modes,
16661                 .input_mux = &alc662_eeepc_capture_source,
16662                 .unsol_event = alc662_mode2_unsol_event,
16663                 .init_hook = alc662_mode2_inithook,
16664         },
16665         [ALC663_ASUS_MODE3] = {
16666                 .mixers = { alc663_two_hp_m1_mixer },
16667                 .cap_mixer = alc662_auto_capture_mixer,
16668                 .init_verbs = { alc662_init_verbs,
16669                                 alc663_two_hp_amic_m1_init_verbs },
16670                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16671                 .hp_nid = 0x03,
16672                 .dac_nids = alc662_dac_nids,
16673                 .dig_out_nid = ALC662_DIGOUT_NID,
16674                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16675                 .channel_mode = alc662_3ST_2ch_modes,
16676                 .input_mux = &alc662_eeepc_capture_source,
16677                 .unsol_event = alc663_mode3_unsol_event,
16678                 .init_hook = alc663_mode3_inithook,
16679         },
16680         [ALC663_ASUS_MODE4] = {
16681                 .mixers = { alc663_asus_21jd_clfe_mixer },
16682                 .cap_mixer = alc662_auto_capture_mixer,
16683                 .init_verbs = { alc662_init_verbs,
16684                                 alc663_21jd_amic_init_verbs},
16685                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16686                 .hp_nid = 0x03,
16687                 .dac_nids = alc662_dac_nids,
16688                 .dig_out_nid = ALC662_DIGOUT_NID,
16689                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16690                 .channel_mode = alc662_3ST_2ch_modes,
16691                 .input_mux = &alc662_eeepc_capture_source,
16692                 .unsol_event = alc663_mode4_unsol_event,
16693                 .init_hook = alc663_mode4_inithook,
16694         },
16695         [ALC663_ASUS_MODE5] = {
16696                 .mixers = { alc663_asus_15jd_clfe_mixer },
16697                 .cap_mixer = alc662_auto_capture_mixer,
16698                 .init_verbs = { alc662_init_verbs,
16699                                 alc663_15jd_amic_init_verbs },
16700                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16701                 .hp_nid = 0x03,
16702                 .dac_nids = alc662_dac_nids,
16703                 .dig_out_nid = ALC662_DIGOUT_NID,
16704                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16705                 .channel_mode = alc662_3ST_2ch_modes,
16706                 .input_mux = &alc662_eeepc_capture_source,
16707                 .unsol_event = alc663_mode5_unsol_event,
16708                 .init_hook = alc663_mode5_inithook,
16709         },
16710         [ALC663_ASUS_MODE6] = {
16711                 .mixers = { alc663_two_hp_m2_mixer },
16712                 .cap_mixer = alc662_auto_capture_mixer,
16713                 .init_verbs = { alc662_init_verbs,
16714                                 alc663_two_hp_amic_m2_init_verbs },
16715                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16716                 .hp_nid = 0x03,
16717                 .dac_nids = alc662_dac_nids,
16718                 .dig_out_nid = ALC662_DIGOUT_NID,
16719                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16720                 .channel_mode = alc662_3ST_2ch_modes,
16721                 .input_mux = &alc662_eeepc_capture_source,
16722                 .unsol_event = alc663_mode6_unsol_event,
16723                 .init_hook = alc663_mode6_inithook,
16724         },
16725         [ALC272_DELL] = {
16726                 .mixers = { alc663_m51va_mixer },
16727                 .cap_mixer = alc272_auto_capture_mixer,
16728                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
16729                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
16730                 .dac_nids = alc662_dac_nids,
16731                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16732                 .adc_nids = alc272_adc_nids,
16733                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
16734                 .capsrc_nids = alc272_capsrc_nids,
16735                 .channel_mode = alc662_3ST_2ch_modes,
16736                 .input_mux = &alc663_m51va_capture_source,
16737                 .unsol_event = alc663_m51va_unsol_event,
16738                 .init_hook = alc663_m51va_inithook,
16739         },
16740         [ALC272_DELL_ZM1] = {
16741                 .mixers = { alc663_m51va_mixer },
16742                 .cap_mixer = alc662_auto_capture_mixer,
16743                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
16744                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
16745                 .dac_nids = alc662_dac_nids,
16746                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16747                 .adc_nids = alc662_adc_nids,
16748                 .num_adc_nids = ARRAY_SIZE(alc662_adc_nids),
16749                 .capsrc_nids = alc662_capsrc_nids,
16750                 .channel_mode = alc662_3ST_2ch_modes,
16751                 .input_mux = &alc663_m51va_capture_source,
16752                 .unsol_event = alc663_m51va_unsol_event,
16753                 .init_hook = alc663_m51va_inithook,
16754         },
16755         [ALC272_SAMSUNG_NC10] = {
16756                 .mixers = { alc272_nc10_mixer },
16757                 .init_verbs = { alc662_init_verbs,
16758                                 alc663_21jd_amic_init_verbs },
16759                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
16760                 .dac_nids = alc272_dac_nids,
16761                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16762                 .channel_mode = alc662_3ST_2ch_modes,
16763                 .input_mux = &alc272_nc10_capture_source,
16764                 .unsol_event = alc663_mode4_unsol_event,
16765                 .init_hook = alc663_mode4_inithook,
16766         },
16767 };
16768
16769
16770 /*
16771  * BIOS auto configuration
16772  */
16773
16774 /* add playback controls from the parsed DAC table */
16775 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
16776                                              const struct auto_pin_cfg *cfg)
16777 {
16778         char name[32];
16779         static const char *chname[4] = {
16780                 "Front", "Surround", NULL /*CLFE*/, "Side"
16781         };
16782         hda_nid_t nid;
16783         int i, err;
16784
16785         for (i = 0; i < cfg->line_outs; i++) {
16786                 if (!spec->multiout.dac_nids[i])
16787                         continue;
16788                 nid = alc880_idx_to_dac(i);
16789                 if (i == 2) {
16790                         /* Center/LFE */
16791                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16792                                           "Center Playback Volume",
16793                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16794                                                               HDA_OUTPUT));
16795                         if (err < 0)
16796                                 return err;
16797                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16798                                           "LFE Playback Volume",
16799                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16800                                                               HDA_OUTPUT));
16801                         if (err < 0)
16802                                 return err;
16803                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16804                                           "Center Playback Switch",
16805                                           HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16806                                                               HDA_INPUT));
16807                         if (err < 0)
16808                                 return err;
16809                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16810                                           "LFE Playback Switch",
16811                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16812                                                               HDA_INPUT));
16813                         if (err < 0)
16814                                 return err;
16815                 } else {
16816                         sprintf(name, "%s Playback Volume", chname[i]);
16817                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16818                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16819                                                               HDA_OUTPUT));
16820                         if (err < 0)
16821                                 return err;
16822                         sprintf(name, "%s Playback Switch", chname[i]);
16823                         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16824                                 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16825                                                     3, 0, HDA_INPUT));
16826                         if (err < 0)
16827                                 return err;
16828                 }
16829         }
16830         return 0;
16831 }
16832
16833 /* add playback controls for speaker and HP outputs */
16834 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16835                                         const char *pfx)
16836 {
16837         hda_nid_t nid;
16838         int err;
16839         char name[32];
16840
16841         if (!pin)
16842                 return 0;
16843
16844         if (pin == 0x17) {
16845                 /* ALC663 has a mono output pin on 0x17 */
16846                 sprintf(name, "%s Playback Switch", pfx);
16847                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16848                                   HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16849                 return err;
16850         }
16851
16852         if (alc880_is_fixed_pin(pin)) {
16853                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16854                 /* printk(KERN_DEBUG "DAC nid=%x\n",nid); */
16855                 /* specify the DAC as the extra output */
16856                 if (!spec->multiout.hp_nid)
16857                         spec->multiout.hp_nid = nid;
16858                 else
16859                         spec->multiout.extra_out_nid[0] = nid;
16860                 /* control HP volume/switch on the output mixer amp */
16861                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16862                 sprintf(name, "%s Playback Volume", pfx);
16863                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16864                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16865                 if (err < 0)
16866                         return err;
16867                 sprintf(name, "%s Playback Switch", pfx);
16868                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16869                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16870                 if (err < 0)
16871                         return err;
16872         } else if (alc880_is_multi_pin(pin)) {
16873                 /* set manual connection */
16874                 /* we have only a switch on HP-out PIN */
16875                 sprintf(name, "%s Playback Switch", pfx);
16876                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16877                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16878                 if (err < 0)
16879                         return err;
16880         }
16881         return 0;
16882 }
16883
16884 /* return the index of the src widget from the connection list of the nid.
16885  * return -1 if not found
16886  */
16887 static int alc662_input_pin_idx(struct hda_codec *codec, hda_nid_t nid,
16888                                 hda_nid_t src)
16889 {
16890         hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
16891         int i, conns;
16892
16893         conns = snd_hda_get_connections(codec, nid, conn_list,
16894                                         ARRAY_SIZE(conn_list));
16895         if (conns < 0)
16896                 return -1;
16897         for (i = 0; i < conns; i++)
16898                 if (conn_list[i] == src)
16899                         return i;
16900         return -1;
16901 }
16902
16903 static int alc662_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
16904 {
16905         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
16906         return (pincap & AC_PINCAP_IN) != 0;
16907 }
16908
16909 /* create playback/capture controls for input pins */
16910 static int alc662_auto_create_analog_input_ctls(struct hda_codec *codec,
16911                                                 const struct auto_pin_cfg *cfg)
16912 {
16913         struct alc_spec *spec = codec->spec;
16914         struct hda_input_mux *imux = &spec->private_imux[0];
16915         int i, err, idx;
16916
16917         for (i = 0; i < AUTO_PIN_LAST; i++) {
16918                 if (alc662_is_input_pin(codec, cfg->input_pins[i])) {
16919                         idx = alc662_input_pin_idx(codec, 0x0b,
16920                                                    cfg->input_pins[i]);
16921                         if (idx >= 0) {
16922                                 err = new_analog_input(spec, cfg->input_pins[i],
16923                                                        auto_pin_cfg_labels[i],
16924                                                        idx, 0x0b);
16925                                 if (err < 0)
16926                                         return err;
16927                         }
16928                         idx = alc662_input_pin_idx(codec, 0x22,
16929                                                    cfg->input_pins[i]);
16930                         if (idx >= 0) {
16931                                 imux->items[imux->num_items].label =
16932                                         auto_pin_cfg_labels[i];
16933                                 imux->items[imux->num_items].index = idx;
16934                                 imux->num_items++;
16935                         }
16936                 }
16937         }
16938         return 0;
16939 }
16940
16941 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16942                                               hda_nid_t nid, int pin_type,
16943                                               int dac_idx)
16944 {
16945         alc_set_pin_output(codec, nid, pin_type);
16946         /* need the manual connection? */
16947         if (alc880_is_multi_pin(nid)) {
16948                 struct alc_spec *spec = codec->spec;
16949                 int idx = alc880_multi_pin_idx(nid);
16950                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16951                                     AC_VERB_SET_CONNECT_SEL,
16952                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16953         }
16954 }
16955
16956 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16957 {
16958         struct alc_spec *spec = codec->spec;
16959         int i;
16960
16961         for (i = 0; i <= HDA_SIDE; i++) {
16962                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16963                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16964                 if (nid)
16965                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16966                                                           i);
16967         }
16968 }
16969
16970 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16971 {
16972         struct alc_spec *spec = codec->spec;
16973         hda_nid_t pin;
16974
16975         pin = spec->autocfg.hp_pins[0];
16976         if (pin) /* connect to front */
16977                 /* use dac 0 */
16978                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16979         pin = spec->autocfg.speaker_pins[0];
16980         if (pin)
16981                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16982 }
16983
16984 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
16985
16986 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16987 {
16988         struct alc_spec *spec = codec->spec;
16989         int i;
16990
16991         for (i = 0; i < AUTO_PIN_LAST; i++) {
16992                 hda_nid_t nid = spec->autocfg.input_pins[i];
16993                 if (alc662_is_input_pin(codec, nid)) {
16994                         alc_set_input_pin(codec, nid, i);
16995                         if (nid != ALC662_PIN_CD_NID &&
16996                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16997                                 snd_hda_codec_write(codec, nid, 0,
16998                                                     AC_VERB_SET_AMP_GAIN_MUTE,
16999                                                     AMP_OUT_MUTE);
17000                 }
17001         }
17002 }
17003
17004 #define alc662_auto_init_input_src      alc882_auto_init_input_src
17005
17006 static int alc662_parse_auto_config(struct hda_codec *codec)
17007 {
17008         struct alc_spec *spec = codec->spec;
17009         int err;
17010         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
17011
17012         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17013                                            alc662_ignore);
17014         if (err < 0)
17015                 return err;
17016         if (!spec->autocfg.line_outs)
17017                 return 0; /* can't find valid BIOS pin config */
17018
17019         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17020         if (err < 0)
17021                 return err;
17022         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
17023         if (err < 0)
17024                 return err;
17025         err = alc662_auto_create_extra_out(spec,
17026                                            spec->autocfg.speaker_pins[0],
17027                                            "Speaker");
17028         if (err < 0)
17029                 return err;
17030         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
17031                                            "Headphone");
17032         if (err < 0)
17033                 return err;
17034         err = alc662_auto_create_analog_input_ctls(codec, &spec->autocfg);
17035         if (err < 0)
17036                 return err;
17037
17038         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17039
17040         if (spec->autocfg.dig_outs)
17041                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
17042
17043         if (spec->kctls.list)
17044                 add_mixer(spec, spec->kctls.list);
17045
17046         spec->num_mux_defs = 1;
17047         spec->input_mux = &spec->private_imux[0];
17048
17049         add_verb(spec, alc662_auto_init_verbs);
17050         if (codec->vendor_id == 0x10ec0663)
17051                 add_verb(spec, alc663_auto_init_verbs);
17052
17053         err = alc_auto_add_mic_boost(codec);
17054         if (err < 0)
17055                 return err;
17056
17057         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
17058
17059         return 1;
17060 }
17061
17062 /* additional initialization for auto-configuration model */
17063 static void alc662_auto_init(struct hda_codec *codec)
17064 {
17065         struct alc_spec *spec = codec->spec;
17066         alc662_auto_init_multi_out(codec);
17067         alc662_auto_init_hp_out(codec);
17068         alc662_auto_init_analog_input(codec);
17069         alc662_auto_init_input_src(codec);
17070         if (spec->unsol_event)
17071                 alc_inithook(codec);
17072 }
17073
17074 static int patch_alc662(struct hda_codec *codec)
17075 {
17076         struct alc_spec *spec;
17077         int err, board_config;
17078
17079         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17080         if (!spec)
17081                 return -ENOMEM;
17082
17083         codec->spec = spec;
17084
17085         alc_fix_pll_init(codec, 0x20, 0x04, 15);
17086
17087         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
17088                                                   alc662_models,
17089                                                   alc662_cfg_tbl);
17090         if (board_config < 0) {
17091                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
17092                        "trying auto-probe from BIOS...\n", codec->chip_name);
17093                 board_config = ALC662_AUTO;
17094         }
17095
17096         if (board_config == ALC662_AUTO) {
17097                 /* automatic parse from the BIOS config */
17098                 err = alc662_parse_auto_config(codec);
17099                 if (err < 0) {
17100                         alc_free(codec);
17101                         return err;
17102                 } else if (!err) {
17103                         printk(KERN_INFO
17104                                "hda_codec: Cannot set up configuration "
17105                                "from BIOS.  Using base mode...\n");
17106                         board_config = ALC662_3ST_2ch_DIG;
17107                 }
17108         }
17109
17110         err = snd_hda_attach_beep_device(codec, 0x1);
17111         if (err < 0) {
17112                 alc_free(codec);
17113                 return err;
17114         }
17115
17116         if (board_config != ALC662_AUTO)
17117                 setup_preset(spec, &alc662_presets[board_config]);
17118
17119         spec->stream_analog_playback = &alc662_pcm_analog_playback;
17120         spec->stream_analog_capture = &alc662_pcm_analog_capture;
17121
17122         spec->stream_digital_playback = &alc662_pcm_digital_playback;
17123         spec->stream_digital_capture = &alc662_pcm_digital_capture;
17124
17125         spec->adc_nids = alc662_adc_nids;
17126         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
17127         spec->capsrc_nids = alc662_capsrc_nids;
17128         spec->capture_style = CAPT_MIX;
17129
17130         if (!spec->cap_mixer)
17131                 set_capture_mixer(spec);
17132         if (codec->vendor_id == 0x10ec0662)
17133                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17134         else
17135                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
17136
17137         spec->vmaster_nid = 0x02;
17138
17139         codec->patch_ops = alc_patch_ops;
17140         if (board_config == ALC662_AUTO)
17141                 spec->init_hook = alc662_auto_init;
17142 #ifdef CONFIG_SND_HDA_POWER_SAVE
17143         if (!spec->loopback.amplist)
17144                 spec->loopback.amplist = alc662_loopbacks;
17145 #endif
17146         codec->proc_widget_hook = print_realtek_coef;
17147
17148         return 0;
17149 }
17150
17151 /*
17152  * patch entries
17153  */
17154 static struct hda_codec_preset snd_hda_preset_realtek[] = {
17155         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
17156         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
17157         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
17158         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
17159         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
17160         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
17161         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
17162           .patch = patch_alc861 },
17163         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
17164         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
17165         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
17166         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
17167           .patch = patch_alc883 },
17168         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
17169           .patch = patch_alc662 },
17170         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
17171         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
17172         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
17173         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
17174         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
17175           .patch = patch_alc882 }, /* should be patch_alc883() in future */
17176         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
17177           .patch = patch_alc882 }, /* should be patch_alc883() in future */
17178         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
17179         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
17180         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
17181           .patch = patch_alc883 },
17182         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
17183         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
17184         {} /* terminator */
17185 };
17186
17187 MODULE_ALIAS("snd-hda-codec-id:10ec*");
17188
17189 MODULE_LICENSE("GPL");
17190 MODULE_DESCRIPTION("Realtek HD-audio codec");
17191
17192 static struct hda_codec_preset_list realtek_list = {
17193         .preset = snd_hda_preset_realtek,
17194         .owner = THIS_MODULE,
17195 };
17196
17197 static int __init patch_realtek_init(void)
17198 {
17199         return snd_hda_add_codec_preset(&realtek_list);
17200 }
17201
17202 static void __exit patch_realtek_exit(void)
17203 {
17204         snd_hda_delete_codec_preset(&realtek_list);
17205 }
17206
17207 module_init(patch_realtek_init)
17208 module_exit(patch_realtek_exit)