SAFE public projects git trees. - safe/jmp/linux-2.6/blob - sound/pci/hda/patch_realtek.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for ALC 260/880/882 codecs
   5  *
   6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   7  *                    PeiSen Hou <pshou@realtek.com.tw>
   8  *                    Takashi Iwai <tiwai@suse.de>
   9  *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
  10  *
  11  *  This driver is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This driver is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/slab.h>
  29 #include <linux/pci.h>
  30 #include <sound/core.h>
  31 #include "hda_codec.h"
  32 #include "hda_local.h"
  33 #include "hda_beep.h"
  34
  35 #define ALC880_FRONT_EVENT              0x01
  36 #define ALC880_DCVOL_EVENT              0x02
  37 #define ALC880_HP_EVENT                 0x04
  38 #define ALC880_MIC_EVENT                0x08
  39
  40 /* ALC880 board config type */
  41 enum {
  42         ALC880_3ST,
  43         ALC880_3ST_DIG,
  44         ALC880_5ST,
  45         ALC880_5ST_DIG,
  46         ALC880_W810,
  47         ALC880_Z71V,
  48         ALC880_6ST,
  49         ALC880_6ST_DIG,
  50         ALC880_F1734,
  51         ALC880_ASUS,
  52         ALC880_ASUS_DIG,
  53         ALC880_ASUS_W1V,
  54         ALC880_ASUS_DIG2,
  55         ALC880_FUJITSU,
  56         ALC880_UNIWILL_DIG,
  57         ALC880_UNIWILL,
  58         ALC880_UNIWILL_P53,
  59         ALC880_CLEVO,
  60         ALC880_TCL_S700,
  61         ALC880_LG,
  62         ALC880_LG_LW,
  63         ALC880_MEDION_RIM,
  64 #ifdef CONFIG_SND_DEBUG
  65         ALC880_TEST,
  66 #endif
  67         ALC880_AUTO,
  68         ALC880_MODEL_LAST /* last tag */
  69 };
  70
  71 /* ALC260 models */
  72 enum {
  73         ALC260_BASIC,
  74         ALC260_HP,
  75         ALC260_HP_DC7600,
  76         ALC260_HP_3013,
  77         ALC260_FUJITSU_S702X,
  78         ALC260_ACER,
  79         ALC260_WILL,
  80         ALC260_REPLACER_672V,
  81         ALC260_FAVORIT100,
  82 #ifdef CONFIG_SND_DEBUG
  83         ALC260_TEST,
  84 #endif
  85         ALC260_AUTO,
  86         ALC260_MODEL_LAST /* last tag */
  87 };
  88
  89 /* ALC262 models */
  90 enum {
  91         ALC262_BASIC,
  92         ALC262_HIPPO,
  93         ALC262_HIPPO_1,
  94         ALC262_FUJITSU,
  95         ALC262_HP_BPC,
  96         ALC262_HP_BPC_D7000_WL,
  97         ALC262_HP_BPC_D7000_WF,
  98         ALC262_HP_TC_T5735,
  99         ALC262_HP_RP5700,
 100         ALC262_BENQ_ED8,
 101         ALC262_SONY_ASSAMD,
 102         ALC262_BENQ_T31,
 103         ALC262_ULTRA,
 104         ALC262_LENOVO_3000,
 105         ALC262_NEC,
 106         ALC262_TOSHIBA_S06,
 107         ALC262_TOSHIBA_RX1,
 108         ALC262_TYAN,
 109         ALC262_AUTO,
 110         ALC262_MODEL_LAST /* last tag */
 111 };
 112
 113 /* ALC268 models */
 114 enum {
 115         ALC267_QUANTA_IL1,
 116         ALC268_3ST,
 117         ALC268_TOSHIBA,
 118         ALC268_ACER,
 119         ALC268_ACER_DMIC,
 120         ALC268_ACER_ASPIRE_ONE,
 121         ALC268_DELL,
 122         ALC268_ZEPTO,
 123 #ifdef CONFIG_SND_DEBUG
 124         ALC268_TEST,
 125 #endif
 126         ALC268_AUTO,
 127         ALC268_MODEL_LAST /* last tag */
 128 };
 129
 130 /* ALC269 models */
 131 enum {
 132         ALC269_BASIC,
 133         ALC269_QUANTA_FL1,
 134         ALC269_ASUS_EEEPC_P703,
 135         ALC269_ASUS_EEEPC_P901,
 136         ALC269_FUJITSU,
 137         ALC269_LIFEBOOK,
 138         ALC269_AUTO,
 139         ALC269_MODEL_LAST /* last tag */
 140 };
 141
 142 /* ALC861 models */
 143 enum {
 144         ALC861_3ST,
 145         ALC660_3ST,
 146         ALC861_3ST_DIG,
 147         ALC861_6ST_DIG,
 148         ALC861_UNIWILL_M31,
 149         ALC861_TOSHIBA,
 150         ALC861_ASUS,
 151         ALC861_ASUS_LAPTOP,
 152         ALC861_AUTO,
 153         ALC861_MODEL_LAST,
 154 };
 155
 156 /* ALC861-VD models */
 157 enum {
 158         ALC660VD_3ST,
 159         ALC660VD_3ST_DIG,
 160         ALC660VD_ASUS_V1S,
 161         ALC861VD_3ST,
 162         ALC861VD_3ST_DIG,
 163         ALC861VD_6ST_DIG,
 164         ALC861VD_LENOVO,
 165         ALC861VD_DALLAS,
 166         ALC861VD_HP,
 167         ALC861VD_AUTO,
 168         ALC861VD_MODEL_LAST,
 169 };
 170
 171 /* ALC662 models */
 172 enum {
 173         ALC662_3ST_2ch_DIG,
 174         ALC662_3ST_6ch_DIG,
 175         ALC662_3ST_6ch,
 176         ALC662_5ST_DIG,
 177         ALC662_LENOVO_101E,
 178         ALC662_ASUS_EEEPC_P701,
 179         ALC662_ASUS_EEEPC_EP20,
 180         ALC663_ASUS_M51VA,
 181         ALC663_ASUS_G71V,
 182         ALC663_ASUS_H13,
 183         ALC663_ASUS_G50V,
 184         ALC662_ECS,
 185         ALC663_ASUS_MODE1,
 186         ALC662_ASUS_MODE2,
 187         ALC663_ASUS_MODE3,
 188         ALC663_ASUS_MODE4,
 189         ALC663_ASUS_MODE5,
 190         ALC663_ASUS_MODE6,
 191         ALC662_AUTO,
 192         ALC662_MODEL_LAST,
 193 };
 194
 195 /* ALC882 models */
 196 enum {
 197         ALC882_3ST_DIG,
 198         ALC882_6ST_DIG,
 199         ALC882_ARIMA,
 200         ALC882_W2JC,
 201         ALC882_TARGA,
 202         ALC882_ASUS_A7J,
 203         ALC882_ASUS_A7M,
 204         ALC885_MACPRO,
 205         ALC885_MBP3,
 206         ALC885_IMAC24,
 207         ALC882_AUTO,
 208         ALC882_MODEL_LAST,
 209 };
 210
 211 /* ALC883 models */
 212 enum {
 213         ALC883_3ST_2ch_DIG,
 214         ALC883_3ST_6ch_DIG,
 215         ALC883_3ST_6ch,
 216         ALC883_6ST_DIG,
 217         ALC883_TARGA_DIG,
 218         ALC883_TARGA_2ch_DIG,
 219         ALC883_ACER,
 220         ALC883_ACER_ASPIRE,
 221         ALC888_ACER_ASPIRE_4930G,
 222         ALC883_MEDION,
 223         ALC883_MEDION_MD2,
 224         ALC883_LAPTOP_EAPD,
 225         ALC883_LENOVO_101E_2ch,
 226         ALC883_LENOVO_NB0763,
 227         ALC888_LENOVO_MS7195_DIG,
 228         ALC888_LENOVO_SKY,
 229         ALC883_HAIER_W66,
 230         ALC888_3ST_HP,
 231         ALC888_6ST_DELL,
 232         ALC883_MITAC,
 233         ALC883_CLEVO_M720,
 234         ALC883_FUJITSU_PI2515,
 235         ALC888_FUJITSU_XA3530,
 236         ALC883_3ST_6ch_INTEL,
 237         ALC888_ASUS_M90V,
 238         ALC888_ASUS_EEE1601,
 239         ALC1200_ASUS_P5Q,
 240         ALC883_AUTO,
 241         ALC883_MODEL_LAST,
 242 };
 243
 244 /* styles of capture selection */
 245 enum {
 246         CAPT_MUX = 0,   /* only mux based */
 247         CAPT_MIX,       /* only mixer based */
 248         CAPT_1MUX_MIX,  /* first mux and other mixers */
 249 };
 250
 251 /* for GPIO Poll */
 252 #define GPIO_MASK       0x03
 253
 254 struct alc_spec {
 255         /* codec parameterization */
 256         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 257         unsigned int num_mixers;
 258         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 259         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 260
 261         const struct hda_verb *init_verbs[5];   /* initialization verbs
 262                                                  * don't forget NULL
 263                                                  * termination!
 264                                                  */
 265         unsigned int num_init_verbs;
 266
 267         char *stream_name_analog;       /* analog PCM stream */
 268         struct hda_pcm_stream *stream_analog_playback;
 269         struct hda_pcm_stream *stream_analog_capture;
 270         struct hda_pcm_stream *stream_analog_alt_playback;
 271         struct hda_pcm_stream *stream_analog_alt_capture;
 272
 273         char *stream_name_digital;      /* digital PCM stream */
 274         struct hda_pcm_stream *stream_digital_playback;
 275         struct hda_pcm_stream *stream_digital_capture;
 276
 277         /* playback */
 278         struct hda_multi_out multiout;  /* playback set-up
 279                                          * max_channels, dacs must be set
 280                                          * dig_out_nid and hp_nid are optional
 281                                          */
 282         hda_nid_t alt_dac_nid;
 283         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 284         int dig_out_type;
 285
 286         /* capture */
 287         unsigned int num_adc_nids;
 288         hda_nid_t *adc_nids;
 289         hda_nid_t *capsrc_nids;
 290         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 291         int capture_style;              /* capture style (CAPT_*) */
 292
 293         /* capture source */
 294         unsigned int num_mux_defs;
 295         const struct hda_input_mux *input_mux;
 296         unsigned int cur_mux[3];
 297
 298         /* channel model */
 299         const struct hda_channel_mode *channel_mode;
 300         int num_channel_mode;
 301         int need_dac_fix;
 302
 303         /* PCM information */
 304         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 305
 306         /* dynamic controls, init_verbs and input_mux */
 307         struct auto_pin_cfg autocfg;
 308         struct snd_array kctls;
 309         struct hda_input_mux private_imux[3];
 310         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 311
 312         /* hooks */
 313         void (*init_hook)(struct hda_codec *codec);
 314         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 315
 316         /* for pin sensing */
 317         unsigned int sense_updated: 1;
 318         unsigned int jack_present: 1;
 319         unsigned int master_sw: 1;
 320
 321         /* other flags */
 322         unsigned int no_analog :1; /* digital I/O only */
 323
 324         /* for virtual master */
 325         hda_nid_t vmaster_nid;
 326 #ifdef CONFIG_SND_HDA_POWER_SAVE
 327         struct hda_loopback_check loopback;
 328 #endif
 329
 330         /* for PLL fix */
 331         hda_nid_t pll_nid;
 332         unsigned int pll_coef_idx, pll_coef_bit;
 333 };
 334
 335 /*
 336  * configuration template - to be copied to the spec instance
 337  */
 338 struct alc_config_preset {
 339         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 340                                              * with spec
 341                                              */
 342         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 343         const struct hda_verb *init_verbs[5];
 344         unsigned int num_dacs;
 345         hda_nid_t *dac_nids;
 346         hda_nid_t dig_out_nid;          /* optional */
 347         hda_nid_t hp_nid;               /* optional */
 348         hda_nid_t *slave_dig_outs;
 349         unsigned int num_adc_nids;
 350         hda_nid_t *adc_nids;
 351         hda_nid_t *capsrc_nids;
 352         hda_nid_t dig_in_nid;
 353         unsigned int num_channel_mode;
 354         const struct hda_channel_mode *channel_mode;
 355         int need_dac_fix;
 356         unsigned int num_mux_defs;
 357         const struct hda_input_mux *input_mux;
 358         void (*unsol_event)(struct hda_codec *, unsigned int);
 359         void (*init_hook)(struct hda_codec *);
 360 #ifdef CONFIG_SND_HDA_POWER_SAVE
 361         struct hda_amp_list *loopbacks;
 362 #endif
 363 };
 364
 365
 366 /*
 367  * input MUX handling
 368  */
 369 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 370                              struct snd_ctl_elem_info *uinfo)
 371 {
 372         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 373         struct alc_spec *spec = codec->spec;
 374         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 375         if (mux_idx >= spec->num_mux_defs)
 376                 mux_idx = 0;
 377         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 378 }
 379
 380 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 381                             struct snd_ctl_elem_value *ucontrol)
 382 {
 383         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 384         struct alc_spec *spec = codec->spec;
 385         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 386
 387         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 388         return 0;
 389 }
 390
 391 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 392                             struct snd_ctl_elem_value *ucontrol)
 393 {
 394         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 395         struct alc_spec *spec = codec->spec;
 396         const struct hda_input_mux *imux;
 397         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 398         unsigned int mux_idx;
 399         hda_nid_t nid = spec->capsrc_nids ?
 400                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 401
 402         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 403         imux = &spec->input_mux[mux_idx];
 404
 405         if (spec->capture_style &&
 406             !(spec->capture_style == CAPT_1MUX_MIX && !adc_idx)) {
 407                 /* Matrix-mixer style (e.g. ALC882) */
 408                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 409                 unsigned int i, idx;
 410
 411                 idx = ucontrol->value.enumerated.item[0];
 412                 if (idx >= imux->num_items)
 413                         idx = imux->num_items - 1;
 414                 if (*cur_val == idx)
 415                         return 0;
 416                 for (i = 0; i < imux->num_items; i++) {
 417                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 418                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 419                                                  imux->items[i].index,
 420                                                  HDA_AMP_MUTE, v);
 421                 }
 422                 *cur_val = idx;
 423                 return 1;
 424         } else {
 425                 /* MUX style (e.g. ALC880) */
 426                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 427                                              &spec->cur_mux[adc_idx]);
 428         }
 429 }
 430
 431 /*
 432  * channel mode setting
 433  */
 434 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 435                             struct snd_ctl_elem_info *uinfo)
 436 {
 437         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 438         struct alc_spec *spec = codec->spec;
 439         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 440                                     spec->num_channel_mode);
 441 }
 442
 443 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 444                            struct snd_ctl_elem_value *ucontrol)
 445 {
 446         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 447         struct alc_spec *spec = codec->spec;
 448         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 449                                    spec->num_channel_mode,
 450                                    spec->multiout.max_channels);
 451 }
 452
 453 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 454                            struct snd_ctl_elem_value *ucontrol)
 455 {
 456         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 457         struct alc_spec *spec = codec->spec;
 458         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 459                                       spec->num_channel_mode,
 460                                       &spec->multiout.max_channels);
 461         if (err >= 0 && spec->need_dac_fix)
 462                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 463         return err;
 464 }
 465
 466 /*
 467  * Control the mode of pin widget settings via the mixer.  "pc" is used
 468  * instead of "%" to avoid consequences of accidently treating the % as
 469  * being part of a format specifier.  Maximum allowed length of a value is
 470  * 63 characters plus NULL terminator.
 471  *
 472  * Note: some retasking pin complexes seem to ignore requests for input
 473  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 474  * are requested.  Therefore order this list so that this behaviour will not
 475  * cause problems when mixer clients move through the enum sequentially.
 476  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 477  * March 2006.
 478  */
 479 static char *alc_pin_mode_names[] = {
 480         "Mic 50pc bias", "Mic 80pc bias",
 481         "Line in", "Line out", "Headphone out",
 482 };
 483 static unsigned char alc_pin_mode_values[] = {
 484         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 485 };
 486 /* The control can present all 5 options, or it can limit the options based
 487  * in the pin being assumed to be exclusively an input or an output pin.  In
 488  * addition, "input" pins may or may not process the mic bias option
 489  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 490  * accept requests for bias as of chip versions up to March 2006) and/or
 491  * wiring in the computer.
 492  */
 493 #define ALC_PIN_DIR_IN              0x00
 494 #define ALC_PIN_DIR_OUT             0x01
 495 #define ALC_PIN_DIR_INOUT           0x02
 496 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 497 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 498
 499 /* Info about the pin modes supported by the different pin direction modes.
 500  * For each direction the minimum and maximum values are given.
 501  */
 502 static signed char alc_pin_mode_dir_info[5][2] = {
 503         { 0, 2 },    /* ALC_PIN_DIR_IN */
 504         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 505         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 506         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 507         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 508 };
 509 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 510 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 511 #define alc_pin_mode_n_items(_dir) \
 512         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 513
 514 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 515                              struct snd_ctl_elem_info *uinfo)
 516 {
 517         unsigned int item_num = uinfo->value.enumerated.item;
 518         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 519
 520         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 521         uinfo->count = 1;
 522         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 523
 524         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 525                 item_num = alc_pin_mode_min(dir);
 526         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 527         return 0;
 528 }
 529
 530 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 531                             struct snd_ctl_elem_value *ucontrol)
 532 {
 533         unsigned int i;
 534         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 535         hda_nid_t nid = kcontrol->private_value & 0xffff;
 536         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 537         long *valp = ucontrol->value.integer.value;
 538         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 539                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 540                                                  0x00);
 541
 542         /* Find enumerated value for current pinctl setting */
 543         i = alc_pin_mode_min(dir);
 544         while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
 545                 i++;
 546         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 547         return 0;
 548 }
 549
 550 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 551                             struct snd_ctl_elem_value *ucontrol)
 552 {
 553         signed int change;
 554         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 555         hda_nid_t nid = kcontrol->private_value & 0xffff;
 556         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 557         long val = *ucontrol->value.integer.value;
 558         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 559                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 560                                                  0x00);
 561
 562         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 563                 val = alc_pin_mode_min(dir);
 564
 565         change = pinctl != alc_pin_mode_values[val];
 566         if (change) {
 567                 /* Set pin mode to that requested */
 568                 snd_hda_codec_write_cache(codec, nid, 0,
 569                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 570                                           alc_pin_mode_values[val]);
 571
 572                 /* Also enable the retasking pin's input/output as required
 573                  * for the requested pin mode.  Enum values of 2 or less are
 574                  * input modes.
 575                  *
 576                  * Dynamically switching the input/output buffers probably
 577                  * reduces noise slightly (particularly on input) so we'll
 578                  * do it.  However, having both input and output buffers
 579                  * enabled simultaneously doesn't seem to be problematic if
 580                  * this turns out to be necessary in the future.
 581                  */
 582                 if (val <= 2) {
 583                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 584                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 585                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 586                                                  HDA_AMP_MUTE, 0);
 587                 } else {
 588                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 589                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 590                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 591                                                  HDA_AMP_MUTE, 0);
 592                 }
 593         }
 594         return change;
 595 }
 596
 597 #define ALC_PIN_MODE(xname, nid, dir) \
 598         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 599           .info = alc_pin_mode_info, \
 600           .get = alc_pin_mode_get, \
 601           .put = alc_pin_mode_put, \
 602           .private_value = nid | (dir<<16) }
 603
 604 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 605  * together using a mask with more than one bit set.  This control is
 606  * currently used only by the ALC260 test model.  At this stage they are not
 607  * needed for any "production" models.
 608  */
 609 #ifdef CONFIG_SND_DEBUG
 610 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 611
 612 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 613                              struct snd_ctl_elem_value *ucontrol)
 614 {
 615         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 616         hda_nid_t nid = kcontrol->private_value & 0xffff;
 617         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 618         long *valp = ucontrol->value.integer.value;
 619         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 620                                               AC_VERB_GET_GPIO_DATA, 0x00);
 621
 622         *valp = (val & mask) != 0;
 623         return 0;
 624 }
 625 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 626                              struct snd_ctl_elem_value *ucontrol)
 627 {
 628         signed int change;
 629         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 630         hda_nid_t nid = kcontrol->private_value & 0xffff;
 631         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 632         long val = *ucontrol->value.integer.value;
 633         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 634                                                     AC_VERB_GET_GPIO_DATA,
 635                                                     0x00);
 636
 637         /* Set/unset the masked GPIO bit(s) as needed */
 638         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 639         if (val == 0)
 640                 gpio_data &= ~mask;
 641         else
 642                 gpio_data |= mask;
 643         snd_hda_codec_write_cache(codec, nid, 0,
 644                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 645
 646         return change;
 647 }
 648 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 649         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 650           .info = alc_gpio_data_info, \
 651           .get = alc_gpio_data_get, \
 652           .put = alc_gpio_data_put, \
 653           .private_value = nid | (mask<<16) }
 654 #endif   /* CONFIG_SND_DEBUG */
 655
 656 /* A switch control to allow the enabling of the digital IO pins on the
 657  * ALC260.  This is incredibly simplistic; the intention of this control is
 658  * to provide something in the test model allowing digital outputs to be
 659  * identified if present.  If models are found which can utilise these
 660  * outputs a more complete mixer control can be devised for those models if
 661  * necessary.
 662  */
 663 #ifdef CONFIG_SND_DEBUG
 664 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 665
 666 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 667                               struct snd_ctl_elem_value *ucontrol)
 668 {
 669         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 670         hda_nid_t nid = kcontrol->private_value & 0xffff;
 671         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 672         long *valp = ucontrol->value.integer.value;
 673         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 674                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 675
 676         *valp = (val & mask) != 0;
 677         return 0;
 678 }
 679 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 680                               struct snd_ctl_elem_value *ucontrol)
 681 {
 682         signed int change;
 683         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 684         hda_nid_t nid = kcontrol->private_value & 0xffff;
 685         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 686         long val = *ucontrol->value.integer.value;
 687         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 688                                                     AC_VERB_GET_DIGI_CONVERT_1,
 689                                                     0x00);
 690
 691         /* Set/unset the masked control bit(s) as needed */
 692         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 693         if (val==0)
 694                 ctrl_data &= ~mask;
 695         else
 696                 ctrl_data |= mask;
 697         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 698                                   ctrl_data);
 699
 700         return change;
 701 }
 702 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 703         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 704           .info = alc_spdif_ctrl_info, \
 705           .get = alc_spdif_ctrl_get, \
 706           .put = alc_spdif_ctrl_put, \
 707           .private_value = nid | (mask<<16) }
 708 #endif   /* CONFIG_SND_DEBUG */
 709
 710 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 711  * Again, this is only used in the ALC26x test models to help identify when
 712  * the EAPD line must be asserted for features to work.
 713  */
 714 #ifdef CONFIG_SND_DEBUG
 715 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 716
 717 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 718                               struct snd_ctl_elem_value *ucontrol)
 719 {
 720         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 721         hda_nid_t nid = kcontrol->private_value & 0xffff;
 722         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 723         long *valp = ucontrol->value.integer.value;
 724         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 725                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 726
 727         *valp = (val & mask) != 0;
 728         return 0;
 729 }
 730
 731 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 732                               struct snd_ctl_elem_value *ucontrol)
 733 {
 734         int change;
 735         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 736         hda_nid_t nid = kcontrol->private_value & 0xffff;
 737         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 738         long val = *ucontrol->value.integer.value;
 739         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 740                                                     AC_VERB_GET_EAPD_BTLENABLE,
 741                                                     0x00);
 742
 743         /* Set/unset the masked control bit(s) as needed */
 744         change = (!val ? 0 : mask) != (ctrl_data & mask);
 745         if (!val)
 746                 ctrl_data &= ~mask;
 747         else
 748                 ctrl_data |= mask;
 749         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 750                                   ctrl_data);
 751
 752         return change;
 753 }
 754
 755 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 756         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 757           .info = alc_eapd_ctrl_info, \
 758           .get = alc_eapd_ctrl_get, \
 759           .put = alc_eapd_ctrl_put, \
 760           .private_value = nid | (mask<<16) }
 761 #endif   /* CONFIG_SND_DEBUG */
 762
 763 /*
 764  * set up the input pin config (depending on the given auto-pin type)
 765  */
 766 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 767                               int auto_pin_type)
 768 {
 769         unsigned int val = PIN_IN;
 770
 771         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 772                 unsigned int pincap;
 773                 pincap = snd_hda_query_pin_caps(codec, nid);
 774                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 775                 if (pincap & AC_PINCAP_VREF_80)
 776                         val = PIN_VREF80;
 777         }
 778         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 779 }
 780
 781 /*
 782  */
 783 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 784 {
 785         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 786                 return;
 787         spec->mixers[spec->num_mixers++] = mix;
 788 }
 789
 790 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 791 {
 792         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 793                 return;
 794         spec->init_verbs[spec->num_init_verbs++] = verb;
 795 }
 796
 797 #ifdef CONFIG_PROC_FS
 798 /*
 799  * hook for proc
 800  */
 801 static void print_realtek_coef(struct snd_info_buffer *buffer,
 802                                struct hda_codec *codec, hda_nid_t nid)
 803 {
 804         int coeff;
 805
 806         if (nid != 0x20)
 807                 return;
 808         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 809         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 810         coeff = snd_hda_codec_read(codec, nid, 0,
 811                                    AC_VERB_GET_COEF_INDEX, 0);
 812         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 813 }
 814 #else
 815 #define print_realtek_coef      NULL
 816 #endif
 817
 818 /*
 819  * set up from the preset table
 820  */
 821 static void setup_preset(struct alc_spec *spec,
 822                          const struct alc_config_preset *preset)
 823 {
 824         int i;
 825
 826         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 827                 add_mixer(spec, preset->mixers[i]);
 828         spec->cap_mixer = preset->cap_mixer;
 829         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 830              i++)
 831                 add_verb(spec, preset->init_verbs[i]);
 832
 833         spec->channel_mode = preset->channel_mode;
 834         spec->num_channel_mode = preset->num_channel_mode;
 835         spec->need_dac_fix = preset->need_dac_fix;
 836
 837         spec->multiout.max_channels = spec->channel_mode[0].channels;
 838
 839         spec->multiout.num_dacs = preset->num_dacs;
 840         spec->multiout.dac_nids = preset->dac_nids;
 841         spec->multiout.dig_out_nid = preset->dig_out_nid;
 842         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 843         spec->multiout.hp_nid = preset->hp_nid;
 844
 845         spec->num_mux_defs = preset->num_mux_defs;
 846         if (!spec->num_mux_defs)
 847                 spec->num_mux_defs = 1;
 848         spec->input_mux = preset->input_mux;
 849
 850         spec->num_adc_nids = preset->num_adc_nids;
 851         spec->adc_nids = preset->adc_nids;
 852         spec->capsrc_nids = preset->capsrc_nids;
 853         spec->dig_in_nid = preset->dig_in_nid;
 854
 855         spec->unsol_event = preset->unsol_event;
 856         spec->init_hook = preset->init_hook;
 857 #ifdef CONFIG_SND_HDA_POWER_SAVE
 858         spec->loopback.amplist = preset->loopbacks;
 859 #endif
 860 }
 861
 862 /* Enable GPIO mask and set output */
 863 static struct hda_verb alc_gpio1_init_verbs[] = {
 864         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 865         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 866         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 867         { }
 868 };
 869
 870 static struct hda_verb alc_gpio2_init_verbs[] = {
 871         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 872         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 873         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 874         { }
 875 };
 876
 877 static struct hda_verb alc_gpio3_init_verbs[] = {
 878         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 879         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 880         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 881         { }
 882 };
 883
 884 /*
 885  * Fix hardware PLL issue
 886  * On some codecs, the analog PLL gating control must be off while
 887  * the default value is 1.
 888  */
 889 static void alc_fix_pll(struct hda_codec *codec)
 890 {
 891         struct alc_spec *spec = codec->spec;
 892         unsigned int val;
 893
 894         if (!spec->pll_nid)
 895                 return;
 896         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 897                             spec->pll_coef_idx);
 898         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 899                                  AC_VERB_GET_PROC_COEF, 0);
 900         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 901                             spec->pll_coef_idx);
 902         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 903                             val & ~(1 << spec->pll_coef_bit));
 904 }
 905
 906 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 907                              unsigned int coef_idx, unsigned int coef_bit)
 908 {
 909         struct alc_spec *spec = codec->spec;
 910         spec->pll_nid = nid;
 911         spec->pll_coef_idx = coef_idx;
 912         spec->pll_coef_bit = coef_bit;
 913         alc_fix_pll(codec);
 914 }
 915
 916 static void alc_sku_automute(struct hda_codec *codec)
 917 {
 918         struct alc_spec *spec = codec->spec;
 919         unsigned int present;
 920         unsigned int hp_nid = spec->autocfg.hp_pins[0];
 921         unsigned int sp_nid = spec->autocfg.speaker_pins[0];
 922
 923         /* need to execute and sync at first */
 924         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 925         present = snd_hda_codec_read(codec, hp_nid, 0,
 926                                      AC_VERB_GET_PIN_SENSE, 0);
 927         spec->jack_present = (present & 0x80000000) != 0;
 928         snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 929                             spec->jack_present ? 0 : PIN_OUT);
 930 }
 931
 932 #if 0 /* it's broken in some acses -- temporarily disabled */
 933 static void alc_mic_automute(struct hda_codec *codec)
 934 {
 935         struct alc_spec *spec = codec->spec;
 936         unsigned int present;
 937         unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
 938         unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
 939         unsigned int mix_nid = spec->capsrc_nids[0];
 940         unsigned int capsrc_idx_mic, capsrc_idx_fmic;
 941
 942         capsrc_idx_mic = mic_nid - 0x18;
 943         capsrc_idx_fmic = fmic_nid - 0x18;
 944         present = snd_hda_codec_read(codec, mic_nid, 0,
 945                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 946         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 947                     0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
 948         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 949                     0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
 950         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
 951                          HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 952 }
 953 #else
 954 #define alc_mic_automute(codec) do {} while(0) /* NOP */
 955 #endif /* disabled */
 956
 957 /* unsolicited event for HP jack sensing */
 958 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 959 {
 960         if (codec->vendor_id == 0x10ec0880)
 961                 res >>= 28;
 962         else
 963                 res >>= 26;
 964         if (res == ALC880_HP_EVENT)
 965                 alc_sku_automute(codec);
 966
 967         if (res == ALC880_MIC_EVENT)
 968                 alc_mic_automute(codec);
 969 }
 970
 971 static void alc_inithook(struct hda_codec *codec)
 972 {
 973         alc_sku_automute(codec);
 974         alc_mic_automute(codec);
 975 }
 976
 977 /* additional initialization for ALC888 variants */
 978 static void alc888_coef_init(struct hda_codec *codec)
 979 {
 980         unsigned int tmp;
 981
 982         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
 983         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 984         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 985         if ((tmp & 0xf0) == 0x20)
 986                 /* alc888S-VC */
 987                 snd_hda_codec_read(codec, 0x20, 0,
 988                                    AC_VERB_SET_PROC_COEF, 0x830);
 989          else
 990                  /* alc888-VB */
 991                  snd_hda_codec_read(codec, 0x20, 0,
 992                                     AC_VERB_SET_PROC_COEF, 0x3030);
 993 }
 994
 995 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 996  *      31 ~ 16 :       Manufacture ID
 997  *      15 ~ 8  :       SKU ID
 998  *      7  ~ 0  :       Assembly ID
 999  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1000  */
1001 static void alc_subsystem_id(struct hda_codec *codec,
1002                              unsigned int porta, unsigned int porte,
1003                              unsigned int portd)
1004 {
1005         unsigned int ass, tmp, i;
1006         unsigned nid;
1007         struct alc_spec *spec = codec->spec;
1008
1009         ass = codec->subsystem_id & 0xffff;
1010         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1011                 goto do_sku;
1012
1013         /*
1014          * 31~30        : port conetcivity
1015          * 29~21        : reserve
1016          * 20           : PCBEEP input
1017          * 19~16        : Check sum (15:1)
1018          * 15~1         : Custom
1019          * 0            : override
1020         */
1021         nid = 0x1d;
1022         if (codec->vendor_id == 0x10ec0260)
1023                 nid = 0x17;
1024         ass = snd_hda_codec_get_pincfg(codec, nid);
1025         if (!(ass & 1) && !(ass & 0x100000))
1026                 return;
1027         if ((ass >> 30) != 1)   /* no physical connection */
1028                 return;
1029
1030         /* check sum */
1031         tmp = 0;
1032         for (i = 1; i < 16; i++) {
1033                 if ((ass >> i) & 1)
1034                         tmp++;
1035         }
1036         if (((ass >> 16) & 0xf) != tmp)
1037                 return;
1038 do_sku:
1039         /*
1040          * 0 : override
1041          * 1 :  Swap Jack
1042          * 2 : 0 --> Desktop, 1 --> Laptop
1043          * 3~5 : External Amplifier control
1044          * 7~6 : Reserved
1045         */
1046         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1047         switch (tmp) {
1048         case 1:
1049                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1050                 break;
1051         case 3:
1052                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1053                 break;
1054         case 7:
1055                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1056                 break;
1057         case 5: /* set EAPD output high */
1058                 switch (codec->vendor_id) {
1059                 case 0x10ec0260:
1060                         snd_hda_codec_write(codec, 0x0f, 0,
1061                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1062                         snd_hda_codec_write(codec, 0x10, 0,
1063                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1064                         break;
1065                 case 0x10ec0262:
1066                 case 0x10ec0267:
1067                 case 0x10ec0268:
1068                 case 0x10ec0269:
1069                 case 0x10ec0272:
1070                 case 0x10ec0660:
1071                 case 0x10ec0662:
1072                 case 0x10ec0663:
1073                 case 0x10ec0862:
1074                 case 0x10ec0889:
1075                         snd_hda_codec_write(codec, 0x14, 0,
1076                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1077                         snd_hda_codec_write(codec, 0x15, 0,
1078                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1079                         break;
1080                 }
1081                 switch (codec->vendor_id) {
1082                 case 0x10ec0260:
1083                         snd_hda_codec_write(codec, 0x1a, 0,
1084                                             AC_VERB_SET_COEF_INDEX, 7);
1085                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1086                                                  AC_VERB_GET_PROC_COEF, 0);
1087                         snd_hda_codec_write(codec, 0x1a, 0,
1088                                             AC_VERB_SET_COEF_INDEX, 7);
1089                         snd_hda_codec_write(codec, 0x1a, 0,
1090                                             AC_VERB_SET_PROC_COEF,
1091                                             tmp | 0x2010);
1092                         break;
1093                 case 0x10ec0262:
1094                 case 0x10ec0880:
1095                 case 0x10ec0882:
1096                 case 0x10ec0883:
1097                 case 0x10ec0885:
1098                 case 0x10ec0887:
1099                 case 0x10ec0889:
1100                         snd_hda_codec_write(codec, 0x20, 0,
1101                                             AC_VERB_SET_COEF_INDEX, 7);
1102                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1103                                                  AC_VERB_GET_PROC_COEF, 0);
1104                         snd_hda_codec_write(codec, 0x20, 0,
1105                                             AC_VERB_SET_COEF_INDEX, 7);
1106                         snd_hda_codec_write(codec, 0x20, 0,
1107                                             AC_VERB_SET_PROC_COEF,
1108                                             tmp | 0x2010);
1109                         break;
1110                 case 0x10ec0888:
1111                         /*alc888_coef_init(codec);*/ /* called in alc_init() */
1112                         break;
1113                 case 0x10ec0267:
1114                 case 0x10ec0268:
1115                         snd_hda_codec_write(codec, 0x20, 0,
1116                                             AC_VERB_SET_COEF_INDEX, 7);
1117                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1118                                                  AC_VERB_GET_PROC_COEF, 0);
1119                         snd_hda_codec_write(codec, 0x20, 0,
1120                                             AC_VERB_SET_COEF_INDEX, 7);
1121                         snd_hda_codec_write(codec, 0x20, 0,
1122                                             AC_VERB_SET_PROC_COEF,
1123                                             tmp | 0x3000);
1124                         break;
1125                 }
1126         default:
1127                 break;
1128         }
1129
1130         /* is laptop or Desktop and enable the function "Mute internal speaker
1131          * when the external headphone out jack is plugged"
1132          */
1133         if (!(ass & 0x8000))
1134                 return;
1135         /*
1136          * 10~8 : Jack location
1137          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1138          * 14~13: Resvered
1139          * 15   : 1 --> enable the function "Mute internal speaker
1140          *              when the external headphone out jack is plugged"
1141          */
1142         if (!spec->autocfg.speaker_pins[0]) {
1143                 if (spec->autocfg.line_out_pins[0])
1144                         spec->autocfg.speaker_pins[0] =
1145                                 spec->autocfg.line_out_pins[0];
1146                 else
1147                         return;
1148         }
1149
1150         if (!spec->autocfg.hp_pins[0]) {
1151                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1152                 if (tmp == 0)
1153                         spec->autocfg.hp_pins[0] = porta;
1154                 else if (tmp == 1)
1155                         spec->autocfg.hp_pins[0] = porte;
1156                 else if (tmp == 2)
1157                         spec->autocfg.hp_pins[0] = portd;
1158                 else
1159                         return;
1160         }
1161         if (spec->autocfg.hp_pins[0])
1162                 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
1163                         AC_VERB_SET_UNSOLICITED_ENABLE,
1164                         AC_USRSP_EN | ALC880_HP_EVENT);
1165
1166 #if 0 /* it's broken in some acses -- temporarily disabled */
1167         if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
1168                 spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
1169                 snd_hda_codec_write(codec,
1170                         spec->autocfg.input_pins[AUTO_PIN_MIC], 0,
1171                         AC_VERB_SET_UNSOLICITED_ENABLE,
1172                         AC_USRSP_EN | ALC880_MIC_EVENT);
1173 #endif /* disabled */
1174
1175         spec->unsol_event = alc_sku_unsol_event;
1176 }
1177
1178 /*
1179  * Fix-up pin default configurations
1180  */
1181
1182 struct alc_pincfg {
1183         hda_nid_t nid;
1184         u32 val;
1185 };
1186
1187 static void alc_fix_pincfg(struct hda_codec *codec,
1188                            const struct snd_pci_quirk *quirk,
1189                            const struct alc_pincfg **pinfix)
1190 {
1191         const struct alc_pincfg *cfg;
1192
1193         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1194         if (!quirk)
1195                 return;
1196
1197         cfg = pinfix[quirk->value];
1198         for (; cfg->nid; cfg++)
1199                 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1200 }
1201
1202 /*
1203  * ALC888
1204  */
1205
1206 /*
1207  * 2ch mode
1208  */
1209 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1210 /* Mic-in jack as mic in */
1211         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1212         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1213 /* Line-in jack as Line in */
1214         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1215         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1216 /* Line-Out as Front */
1217         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1218         { } /* end */
1219 };
1220
1221 /*
1222  * 4ch mode
1223  */
1224 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1225 /* Mic-in jack as mic in */
1226         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1227         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1228 /* Line-in jack as Surround */
1229         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1230         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1231 /* Line-Out as Front */
1232         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1233         { } /* end */
1234 };
1235
1236 /*
1237  * 6ch mode
1238  */
1239 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1240 /* Mic-in jack as CLFE */
1241         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1242         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1243 /* Line-in jack as Surround */
1244         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1245         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1246 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1247         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1248         { } /* end */
1249 };
1250
1251 /*
1252  * 8ch mode
1253  */
1254 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1255 /* Mic-in jack as CLFE */
1256         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1257         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1258 /* Line-in jack as Surround */
1259         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1260         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1261 /* Line-Out as Side */
1262         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1263         { } /* end */
1264 };
1265
1266 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1267         { 2, alc888_4ST_ch2_intel_init },
1268         { 4, alc888_4ST_ch4_intel_init },
1269         { 6, alc888_4ST_ch6_intel_init },
1270         { 8, alc888_4ST_ch8_intel_init },
1271 };
1272
1273 /*
1274  * ALC888 Fujitsu Siemens Amillo xa3530
1275  */
1276
1277 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1278 /* Front Mic: set to PIN_IN (empty by default) */
1279         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1280 /* Connect Internal HP to Front */
1281         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1282         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1283         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1284 /* Connect Bass HP to Front */
1285         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1286         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1287         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1288 /* Connect Line-Out side jack (SPDIF) to Side */
1289         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1290         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1291         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1292 /* Connect Mic jack to CLFE */
1293         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1294         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1295         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1296 /* Connect Line-in jack to Surround */
1297         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1298         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1299         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1300 /* Connect HP out jack to Front */
1301         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1302         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1303         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1304 /* Enable unsolicited event for HP jack and Line-out jack */
1305         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1306         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1307         {}
1308 };
1309
1310 static void alc888_fujitsu_xa3530_automute(struct hda_codec *codec)
1311 {
1312         unsigned int present;
1313         unsigned int bits;
1314         /* Line out presence */
1315         present = snd_hda_codec_read(codec, 0x17, 0,
1316                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1317         /* HP out presence */
1318         present = present || snd_hda_codec_read(codec, 0x1b, 0,
1319                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1320         bits = present ? HDA_AMP_MUTE : 0;
1321         /* Toggle internal speakers muting */
1322         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1323                                  HDA_AMP_MUTE, bits);
1324         /* Toggle internal bass muting */
1325         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1326                                  HDA_AMP_MUTE, bits);
1327 }
1328
1329 static void alc888_fujitsu_xa3530_unsol_event(struct hda_codec *codec,
1330                 unsigned int res)
1331 {
1332         if (res >> 26 == ALC880_HP_EVENT)
1333                 alc888_fujitsu_xa3530_automute(codec);
1334 }
1335
1336
1337 /*
1338  * ALC888 Acer Aspire 4930G model
1339  */
1340
1341 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1342 /* Front Mic: set to PIN_IN (empty by default) */
1343         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1344 /* Unselect Front Mic by default in input mixer 3 */
1345         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1346 /* Enable unsolicited event for HP jack */
1347         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1348 /* Connect Internal HP to front */
1349         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1350         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1351         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1352 /* Connect HP out to front */
1353         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1354         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1355         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1356         { }
1357 };
1358
1359 static struct hda_input_mux alc888_2_capture_sources[2] = {
1360         /* Front mic only available on one ADC */
1361         {
1362                 .num_items = 4,
1363                 .items = {
1364                         { "Mic", 0x0 },
1365                         { "Line", 0x2 },
1366                         { "CD", 0x4 },
1367                         { "Front Mic", 0xb },
1368                 },
1369         },
1370         {
1371                 .num_items = 3,
1372                 .items = {
1373                         { "Mic", 0x0 },
1374                         { "Line", 0x2 },
1375                         { "CD", 0x4 },
1376                 },
1377         }
1378 };
1379
1380 static struct snd_kcontrol_new alc888_base_mixer[] = {
1381         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1382         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1383         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1384         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1385         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1386                 HDA_OUTPUT),
1387         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1388         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1389         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1390         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1391         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1392         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1393         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1394         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1395         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1396         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1397         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1398         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1399         { } /* end */
1400 };
1401
1402 static void alc888_acer_aspire_4930g_automute(struct hda_codec *codec)
1403 {
1404         unsigned int present;
1405         unsigned int bits;
1406         present = snd_hda_codec_read(codec, 0x15, 0,
1407                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1408         bits = present ? HDA_AMP_MUTE : 0;
1409         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1410                                  HDA_AMP_MUTE, bits);
1411 }
1412
1413 static void alc888_acer_aspire_4930g_unsol_event(struct hda_codec *codec,
1414                 unsigned int res)
1415 {
1416         if (res >> 26 == ALC880_HP_EVENT)
1417                 alc888_acer_aspire_4930g_automute(codec);
1418 }
1419
1420 /*
1421  * ALC880 3-stack model
1422  *
1423  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1424  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1425  *                 F-Mic = 0x1b, HP = 0x19
1426  */
1427
1428 static hda_nid_t alc880_dac_nids[4] = {
1429         /* front, rear, clfe, rear_surr */
1430         0x02, 0x05, 0x04, 0x03
1431 };
1432
1433 static hda_nid_t alc880_adc_nids[3] = {
1434         /* ADC0-2 */
1435         0x07, 0x08, 0x09,
1436 };
1437
1438 /* The datasheet says the node 0x07 is connected from inputs,
1439  * but it shows zero connection in the real implementation on some devices.
1440  * Note: this is a 915GAV bug, fixed on 915GLV
1441  */
1442 static hda_nid_t alc880_adc_nids_alt[2] = {
1443         /* ADC1-2 */
1444         0x08, 0x09,
1445 };
1446
1447 #define ALC880_DIGOUT_NID       0x06
1448 #define ALC880_DIGIN_NID        0x0a
1449
1450 static struct hda_input_mux alc880_capture_source = {
1451         .num_items = 4,
1452         .items = {
1453                 { "Mic", 0x0 },
1454                 { "Front Mic", 0x3 },
1455                 { "Line", 0x2 },
1456                 { "CD", 0x4 },
1457         },
1458 };
1459
1460 /* channel source setting (2/6 channel selection for 3-stack) */
1461 /* 2ch mode */
1462 static struct hda_verb alc880_threestack_ch2_init[] = {
1463         /* set line-in to input, mute it */
1464         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1465         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1466         /* set mic-in to input vref 80%, mute it */
1467         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1468         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1469         { } /* end */
1470 };
1471
1472 /* 6ch mode */
1473 static struct hda_verb alc880_threestack_ch6_init[] = {
1474         /* set line-in to output, unmute it */
1475         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1476         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1477         /* set mic-in to output, unmute it */
1478         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1479         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1480         { } /* end */
1481 };
1482
1483 static struct hda_channel_mode alc880_threestack_modes[2] = {
1484         { 2, alc880_threestack_ch2_init },
1485         { 6, alc880_threestack_ch6_init },
1486 };
1487
1488 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1489         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1490         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1491         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1492         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1493         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1494         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1495         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1496         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1497         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1498         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1499         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1500         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1501         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1502         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1503         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1504         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1505         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1506         {
1507                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1508                 .name = "Channel Mode",
1509                 .info = alc_ch_mode_info,
1510                 .get = alc_ch_mode_get,
1511                 .put = alc_ch_mode_put,
1512         },
1513         { } /* end */
1514 };
1515
1516 /* capture mixer elements */
1517 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1518                             struct snd_ctl_elem_info *uinfo)
1519 {
1520         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1521         struct alc_spec *spec = codec->spec;
1522         int err;
1523
1524         mutex_lock(&codec->control_mutex);
1525         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1526                                                       HDA_INPUT);
1527         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1528         mutex_unlock(&codec->control_mutex);
1529         return err;
1530 }
1531
1532 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1533                            unsigned int size, unsigned int __user *tlv)
1534 {
1535         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1536         struct alc_spec *spec = codec->spec;
1537         int err;
1538
1539         mutex_lock(&codec->control_mutex);
1540         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1541                                                       HDA_INPUT);
1542         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1543         mutex_unlock(&codec->control_mutex);
1544         return err;
1545 }
1546
1547 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1548                              struct snd_ctl_elem_value *ucontrol);
1549
1550 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1551                                  struct snd_ctl_elem_value *ucontrol,
1552                                  getput_call_t func)
1553 {
1554         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1555         struct alc_spec *spec = codec->spec;
1556         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1557         int err;
1558
1559         mutex_lock(&codec->control_mutex);
1560         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1561                                                       3, 0, HDA_INPUT);
1562         err = func(kcontrol, ucontrol);
1563         mutex_unlock(&codec->control_mutex);
1564         return err;
1565 }
1566
1567 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1568                            struct snd_ctl_elem_value *ucontrol)
1569 {
1570         return alc_cap_getput_caller(kcontrol, ucontrol,
1571                                      snd_hda_mixer_amp_volume_get);
1572 }
1573
1574 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1575                            struct snd_ctl_elem_value *ucontrol)
1576 {
1577         return alc_cap_getput_caller(kcontrol, ucontrol,
1578                                      snd_hda_mixer_amp_volume_put);
1579 }
1580
1581 /* capture mixer elements */
1582 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1583
1584 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1585                           struct snd_ctl_elem_value *ucontrol)
1586 {
1587         return alc_cap_getput_caller(kcontrol, ucontrol,
1588                                      snd_hda_mixer_amp_switch_get);
1589 }
1590
1591 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1592                           struct snd_ctl_elem_value *ucontrol)
1593 {
1594         return alc_cap_getput_caller(kcontrol, ucontrol,
1595                                      snd_hda_mixer_amp_switch_put);
1596 }
1597
1598 #define DEFINE_CAPMIX(num) \
1599 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1600         { \
1601                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1602                 .name = "Capture Switch", \
1603                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1604                 .count = num, \
1605                 .info = alc_cap_sw_info, \
1606                 .get = alc_cap_sw_get, \
1607                 .put = alc_cap_sw_put, \
1608         }, \
1609         { \
1610                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1611                 .name = "Capture Volume", \
1612                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1613                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1614                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1615                 .count = num, \
1616                 .info = alc_cap_vol_info, \
1617                 .get = alc_cap_vol_get, \
1618                 .put = alc_cap_vol_put, \
1619                 .tlv = { .c = alc_cap_vol_tlv }, \
1620         }, \
1621         { \
1622                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1623                 /* .name = "Capture Source", */ \
1624                 .name = "Input Source", \
1625                 .count = num, \
1626                 .info = alc_mux_enum_info, \
1627                 .get = alc_mux_enum_get, \
1628                 .put = alc_mux_enum_put, \
1629         }, \
1630         { } /* end */ \
1631 }
1632
1633 /* up to three ADCs */
1634 DEFINE_CAPMIX(1);
1635 DEFINE_CAPMIX(2);
1636 DEFINE_CAPMIX(3);
1637
1638
1639 /*
1640  * ALC880 5-stack model
1641  *
1642  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1643  *      Side = 0x02 (0xd)
1644  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1645  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1646  */
1647
1648 /* additional mixers to alc880_three_stack_mixer */
1649 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1650         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1651         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1652         { } /* end */
1653 };
1654
1655 /* channel source setting (6/8 channel selection for 5-stack) */
1656 /* 6ch mode */
1657 static struct hda_verb alc880_fivestack_ch6_init[] = {
1658         /* set line-in to input, mute it */
1659         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1660         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1661         { } /* end */
1662 };
1663
1664 /* 8ch mode */
1665 static struct hda_verb alc880_fivestack_ch8_init[] = {
1666         /* set line-in to output, unmute it */
1667         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1668         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1669         { } /* end */
1670 };
1671
1672 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1673         { 6, alc880_fivestack_ch6_init },
1674         { 8, alc880_fivestack_ch8_init },
1675 };
1676
1677
1678 /*
1679  * ALC880 6-stack model
1680  *
1681  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1682  *      Side = 0x05 (0x0f)
1683  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1684  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1685  */
1686
1687 static hda_nid_t alc880_6st_dac_nids[4] = {
1688         /* front, rear, clfe, rear_surr */
1689         0x02, 0x03, 0x04, 0x05
1690 };
1691
1692 static struct hda_input_mux alc880_6stack_capture_source = {
1693         .num_items = 4,
1694         .items = {
1695                 { "Mic", 0x0 },
1696                 { "Front Mic", 0x1 },
1697                 { "Line", 0x2 },
1698                 { "CD", 0x4 },
1699         },
1700 };
1701
1702 /* fixed 8-channels */
1703 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1704         { 8, NULL },
1705 };
1706
1707 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1708         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1709         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1710         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1711         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1712         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1713         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1714         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1715         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1716         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1717         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1718         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1719         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1720         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1721         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1722         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1723         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1724         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1725         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1726         {
1727                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1728                 .name = "Channel Mode",
1729                 .info = alc_ch_mode_info,
1730                 .get = alc_ch_mode_get,
1731                 .put = alc_ch_mode_put,
1732         },
1733         { } /* end */
1734 };
1735
1736
1737 /*
1738  * ALC880 W810 model
1739  *
1740  * W810 has rear IO for:
1741  * Front (DAC 02)
1742  * Surround (DAC 03)
1743  * Center/LFE (DAC 04)
1744  * Digital out (06)
1745  *
1746  * The system also has a pair of internal speakers, and a headphone jack.
1747  * These are both connected to Line2 on the codec, hence to DAC 02.
1748  *
1749  * There is a variable resistor to control the speaker or headphone
1750  * volume. This is a hardware-only device without a software API.
1751  *
1752  * Plugging headphones in will disable the internal speakers. This is
1753  * implemented in hardware, not via the driver using jack sense. In
1754  * a similar fashion, plugging into the rear socket marked "front" will
1755  * disable both the speakers and headphones.
1756  *
1757  * For input, there's a microphone jack, and an "audio in" jack.
1758  * These may not do anything useful with this driver yet, because I
1759  * haven't setup any initialization verbs for these yet...
1760  */
1761
1762 static hda_nid_t alc880_w810_dac_nids[3] = {
1763         /* front, rear/surround, clfe */
1764         0x02, 0x03, 0x04
1765 };
1766
1767 /* fixed 6 channels */
1768 static struct hda_channel_mode alc880_w810_modes[1] = {
1769         { 6, NULL }
1770 };
1771
1772 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1773 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1774         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1775         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1776         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1777         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1778         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1779         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1780         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1781         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1782         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1783         { } /* end */
1784 };
1785
1786
1787 /*
1788  * Z710V model
1789  *
1790  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1791  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1792  *                 Line = 0x1a
1793  */
1794
1795 static hda_nid_t alc880_z71v_dac_nids[1] = {
1796         0x02
1797 };
1798 #define ALC880_Z71V_HP_DAC      0x03
1799
1800 /* fixed 2 channels */
1801 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1802         { 2, NULL }
1803 };
1804
1805 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1806         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1807         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1808         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1809         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1810         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1811         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1812         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1813         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1814         { } /* end */
1815 };
1816
1817
1818 /*
1819  * ALC880 F1734 model
1820  *
1821  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1822  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1823  */
1824
1825 static hda_nid_t alc880_f1734_dac_nids[1] = {
1826         0x03
1827 };
1828 #define ALC880_F1734_HP_DAC     0x02
1829
1830 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1831         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1832         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1833         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1834         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1835         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1836         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1837         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1838         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1839         { } /* end */
1840 };
1841
1842 static struct hda_input_mux alc880_f1734_capture_source = {
1843         .num_items = 2,
1844         .items = {
1845                 { "Mic", 0x1 },
1846                 { "CD", 0x4 },
1847         },
1848 };
1849
1850
1851 /*
1852  * ALC880 ASUS model
1853  *
1854  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1855  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1856  *  Mic = 0x18, Line = 0x1a
1857  */
1858
1859 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
1860 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
1861
1862 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1863         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1864         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1865         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1866         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1867         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1868         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1869         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1870         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1871         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1872         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1873         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1874         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1875         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1876         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1877         {
1878                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1879                 .name = "Channel Mode",
1880                 .info = alc_ch_mode_info,
1881                 .get = alc_ch_mode_get,
1882                 .put = alc_ch_mode_put,
1883         },
1884         { } /* end */
1885 };
1886
1887 /*
1888  * ALC880 ASUS W1V model
1889  *
1890  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1891  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1892  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1893  */
1894
1895 /* additional mixers to alc880_asus_mixer */
1896 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1897         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1898         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1899         { } /* end */
1900 };
1901
1902 /* TCL S700 */
1903 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1904         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1905         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1906         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1907         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1908         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1909         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1910         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1911         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1912         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1913         { } /* end */
1914 };
1915
1916 /* Uniwill */
1917 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1918         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1919         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1920         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1921         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1922         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1923         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1924         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1925         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1926         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1927         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1928         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1929         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1930         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1931         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1932         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1933         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1934         {
1935                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1936                 .name = "Channel Mode",
1937                 .info = alc_ch_mode_info,
1938                 .get = alc_ch_mode_get,
1939                 .put = alc_ch_mode_put,
1940         },
1941         { } /* end */
1942 };
1943
1944 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1945         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1946         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1947         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1948         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1949         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1950         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1951         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1952         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1953         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1954         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1955         { } /* end */
1956 };
1957
1958 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1959         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1960         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1961         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1962         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1963         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1964         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1965         { } /* end */
1966 };
1967
1968 /*
1969  * virtual master controls
1970  */
1971
1972 /*
1973  * slave controls for virtual master
1974  */
1975 static const char *alc_slave_vols[] = {
1976         "Front Playback Volume",
1977         "Surround Playback Volume",
1978         "Center Playback Volume",
1979         "LFE Playback Volume",
1980         "Side Playback Volume",
1981         "Headphone Playback Volume",
1982         "Speaker Playback Volume",
1983         "Mono Playback Volume",
1984         "Line-Out Playback Volume",
1985         "PCM Playback Volume",
1986         NULL,
1987 };
1988
1989 static const char *alc_slave_sws[] = {
1990         "Front Playback Switch",
1991         "Surround Playback Switch",
1992         "Center Playback Switch",
1993         "LFE Playback Switch",
1994         "Side Playback Switch",
1995         "Headphone Playback Switch",
1996         "Speaker Playback Switch",
1997         "Mono Playback Switch",
1998         "IEC958 Playback Switch",
1999         NULL,
2000 };
2001
2002 /*
2003  * build control elements
2004  */
2005
2006 static void alc_free_kctls(struct hda_codec *codec);
2007
2008 /* additional beep mixers; the actual parameters are overwritten at build */
2009 static struct snd_kcontrol_new alc_beep_mixer[] = {
2010         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2011         HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
2012         { } /* end */
2013 };
2014
2015 static int alc_build_controls(struct hda_codec *codec)
2016 {
2017         struct alc_spec *spec = codec->spec;
2018         int err;
2019         int i;
2020
2021         for (i = 0; i < spec->num_mixers; i++) {
2022                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2023                 if (err < 0)
2024                         return err;
2025         }
2026         if (spec->cap_mixer) {
2027                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2028                 if (err < 0)
2029                         return err;
2030         }
2031         if (spec->multiout.dig_out_nid) {
2032                 err = snd_hda_create_spdif_out_ctls(codec,
2033                                                     spec->multiout.dig_out_nid);
2034                 if (err < 0)
2035                         return err;
2036                 if (!spec->no_analog) {
2037                         err = snd_hda_create_spdif_share_sw(codec,
2038                                                             &spec->multiout);
2039                         if (err < 0)
2040                                 return err;
2041                         spec->multiout.share_spdif = 1;
2042                 }
2043         }
2044         if (spec->dig_in_nid) {
2045                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2046                 if (err < 0)
2047                         return err;
2048         }
2049
2050         /* create beep controls if needed */
2051         if (spec->beep_amp) {
2052                 struct snd_kcontrol_new *knew;
2053                 for (knew = alc_beep_mixer; knew->name; knew++) {
2054                         struct snd_kcontrol *kctl;
2055                         kctl = snd_ctl_new1(knew, codec);
2056                         if (!kctl)
2057                                 return -ENOMEM;
2058                         kctl->private_value = spec->beep_amp;
2059                         err = snd_hda_ctl_add(codec, kctl);
2060                         if (err < 0)
2061                                 return err;
2062                 }
2063         }
2064
2065         /* if we have no master control, let's create it */
2066         if (!spec->no_analog &&
2067             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2068                 unsigned int vmaster_tlv[4];
2069                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2070                                         HDA_OUTPUT, vmaster_tlv);
2071                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2072                                           vmaster_tlv, alc_slave_vols);
2073                 if (err < 0)
2074                         return err;
2075         }
2076         if (!spec->no_analog &&
2077             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2078                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2079                                           NULL, alc_slave_sws);
2080                 if (err < 0)
2081                         return err;
2082         }
2083
2084         alc_free_kctls(codec); /* no longer needed */
2085         return 0;
2086 }
2087
2088
2089 /*
2090  * initialize the codec volumes, etc
2091  */
2092
2093 /*
2094  * generic initialization of ADC, input mixers and output mixers
2095  */
2096 static struct hda_verb alc880_volume_init_verbs[] = {
2097         /*
2098          * Unmute ADC0-2 and set the default input to mic-in
2099          */
2100         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2101         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2102         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2103         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2104         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2105         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2106
2107         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2108          * mixer widget
2109          * Note: PASD motherboards uses the Line In 2 as the input for front
2110          * panel mic (mic 2)
2111          */
2112         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2113         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2114         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2115         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2116         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2117         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2118         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2119         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2120
2121         /*
2122          * Set up output mixers (0x0c - 0x0f)
2123          */
2124         /* set vol=0 to output mixers */
2125         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2126         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2127         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2128         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2129         /* set up input amps for analog loopback */
2130         /* Amp Indices: DAC = 0, mixer = 1 */
2131         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2132         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2133         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2134         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2135         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2136         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2137         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2138         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2139
2140         { }
2141 };
2142
2143 /*
2144  * 3-stack pin configuration:
2145  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2146  */
2147 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2148         /*
2149          * preset connection lists of input pins
2150          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2151          */
2152         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2153         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2154         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2155
2156         /*
2157          * Set pin mode and muting
2158          */
2159         /* set front pin widgets 0x14 for output */
2160         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2161         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2162         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2163         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2164         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2165         /* Mic2 (as headphone out) for HP output */
2166         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2167         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2168         /* Line In pin widget for input */
2169         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2170         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2171         /* Line2 (as front mic) pin widget for input and vref at 80% */
2172         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2173         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2174         /* CD pin widget for input */
2175         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2176
2177         { }
2178 };
2179
2180 /*
2181  * 5-stack pin configuration:
2182  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2183  * line-in/side = 0x1a, f-mic = 0x1b
2184  */
2185 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2186         /*
2187          * preset connection lists of input pins
2188          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2189          */
2190         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2191         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2192
2193         /*
2194          * Set pin mode and muting
2195          */
2196         /* set pin widgets 0x14-0x17 for output */
2197         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2198         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2199         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2200         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2201         /* unmute pins for output (no gain on this amp) */
2202         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2203         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2204         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2205         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2206
2207         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2208         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2209         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2210         /* Mic2 (as headphone out) for HP output */
2211         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2212         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2213         /* Line In pin widget for input */
2214         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2215         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2216         /* Line2 (as front mic) pin widget for input and vref at 80% */
2217         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2218         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2219         /* CD pin widget for input */
2220         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2221
2222         { }
2223 };
2224
2225 /*
2226  * W810 pin configuration:
2227  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2228  */
2229 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2230         /* hphone/speaker input selector: front DAC */
2231         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2232
2233         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2234         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2235         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2236         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2237         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2238         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2239
2240         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2241         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2242
2243         { }
2244 };
2245
2246 /*
2247  * Z71V pin configuration:
2248  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2249  */
2250 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2251         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2252         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2253         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2254         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2255
2256         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2257         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2258         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2259         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2260
2261         { }
2262 };
2263
2264 /*
2265  * 6-stack pin configuration:
2266  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2267  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2268  */
2269 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2270         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2271
2272         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2273         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2274         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2275         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2276         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2277         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2278         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2279         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2280
2281         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2282         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2283         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2284         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2285         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2286         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2287         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2288         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2289         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2290
2291         { }
2292 };
2293
2294 /*
2295  * Uniwill pin configuration:
2296  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2297  * line = 0x1a
2298  */
2299 static struct hda_verb alc880_uniwill_init_verbs[] = {
2300         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2301
2302         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2303         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2304         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2305         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2306         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2307         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2308         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2309         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2310         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2311         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2312         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2313         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2314         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2315         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2316
2317         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2318         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2319         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2320         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2321         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2322         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2323         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2324         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2325         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2326
2327         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2328         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2329
2330         { }
2331 };
2332
2333 /*
2334 * Uniwill P53
2335 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2336  */
2337 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2338         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2339
2340         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2341         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2342         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2343         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2344         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2345         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2346         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2347         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2348         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2349         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2350         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2351         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2352
2353         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2354         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2355         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2356         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2357         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2358         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2359
2360         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2361         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2362
2363         { }
2364 };
2365
2366 static struct hda_verb alc880_beep_init_verbs[] = {
2367         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2368         { }
2369 };
2370
2371 /* toggle speaker-output according to the hp-jack state */
2372 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
2373 {
2374         unsigned int present;
2375         unsigned char bits;
2376
2377         present = snd_hda_codec_read(codec, 0x14, 0,
2378                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2379         bits = present ? HDA_AMP_MUTE : 0;
2380         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
2381                                  HDA_AMP_MUTE, bits);
2382         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
2383                                  HDA_AMP_MUTE, bits);
2384 }
2385
2386 /* auto-toggle front mic */
2387 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2388 {
2389         unsigned int present;
2390         unsigned char bits;
2391
2392         present = snd_hda_codec_read(codec, 0x18, 0,
2393                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2394         bits = present ? HDA_AMP_MUTE : 0;
2395         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2396 }
2397
2398 static void alc880_uniwill_automute(struct hda_codec *codec)
2399 {
2400         alc880_uniwill_hp_automute(codec);
2401         alc880_uniwill_mic_automute(codec);
2402 }
2403
2404 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2405                                        unsigned int res)
2406 {
2407         /* Looks like the unsol event is incompatible with the standard
2408          * definition.  4bit tag is placed at 28 bit!
2409          */
2410         switch (res >> 28) {
2411         case ALC880_HP_EVENT:
2412                 alc880_uniwill_hp_automute(codec);
2413                 break;
2414         case ALC880_MIC_EVENT:
2415                 alc880_uniwill_mic_automute(codec);
2416                 break;
2417         }
2418 }
2419
2420 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
2421 {
2422         unsigned int present;
2423         unsigned char bits;
2424
2425         present = snd_hda_codec_read(codec, 0x14, 0,
2426                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2427         bits = present ? HDA_AMP_MUTE : 0;
2428         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
2429 }
2430
2431 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2432 {
2433         unsigned int present;
2434
2435         present = snd_hda_codec_read(codec, 0x21, 0,
2436                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2437         present &= HDA_AMP_VOLMASK;
2438         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2439                                  HDA_AMP_VOLMASK, present);
2440         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2441                                  HDA_AMP_VOLMASK, present);
2442 }
2443
2444 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2445                                            unsigned int res)
2446 {
2447         /* Looks like the unsol event is incompatible with the standard
2448          * definition.  4bit tag is placed at 28 bit!
2449          */
2450         if ((res >> 28) == ALC880_HP_EVENT)
2451                 alc880_uniwill_p53_hp_automute(codec);
2452         if ((res >> 28) == ALC880_DCVOL_EVENT)
2453                 alc880_uniwill_p53_dcvol_automute(codec);
2454 }
2455
2456 /*
2457  * F1734 pin configuration:
2458  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2459  */
2460 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2461         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2462         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2463         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2464         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2465         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2466
2467         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2468         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2469         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2470         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2471
2472         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2473         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2474         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2475         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2476         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2477         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2478         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2479         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2480         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2481
2482         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2483         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2484
2485         { }
2486 };
2487
2488 /*
2489  * ASUS pin configuration:
2490  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2491  */
2492 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2493         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2494         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2495         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2496         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2497
2498         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2499         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2500         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2501         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2502         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2503         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2504         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2505         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2506
2507         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2508         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2509         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2510         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2511         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2512         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2513         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2514         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2515         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2516
2517         { }
2518 };
2519
2520 /* Enable GPIO mask and set output */
2521 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2522 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2523
2524 /* Clevo m520g init */
2525 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2526         /* headphone output */
2527         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2528         /* line-out */
2529         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2530         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2531         /* Line-in */
2532         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2533         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2534         /* CD */
2535         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2536         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2537         /* Mic1 (rear panel) */
2538         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2539         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2540         /* Mic2 (front panel) */
2541         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2542         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2543         /* headphone */
2544         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2545         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2546         /* change to EAPD mode */
2547         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2548         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2549
2550         { }
2551 };
2552
2553 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2554         /* change to EAPD mode */
2555         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2556         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2557
2558         /* Headphone output */
2559         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2560         /* Front output*/
2561         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2562         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2563
2564         /* Line In pin widget for input */
2565         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2566         /* CD pin widget for input */
2567         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2568         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2569         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2570
2571         /* change to EAPD mode */
2572         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2573         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2574
2575         { }
2576 };
2577
2578 /*
2579  * LG m1 express dual
2580  *
2581  * Pin assignment:
2582  *   Rear Line-In/Out (blue): 0x14
2583  *   Build-in Mic-In: 0x15
2584  *   Speaker-out: 0x17
2585  *   HP-Out (green): 0x1b
2586  *   Mic-In/Out (red): 0x19
2587  *   SPDIF-Out: 0x1e
2588  */
2589
2590 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2591 static hda_nid_t alc880_lg_dac_nids[3] = {
2592         0x05, 0x02, 0x03
2593 };
2594
2595 /* seems analog CD is not working */
2596 static struct hda_input_mux alc880_lg_capture_source = {
2597         .num_items = 3,
2598         .items = {
2599                 { "Mic", 0x1 },
2600                 { "Line", 0x5 },
2601                 { "Internal Mic", 0x6 },
2602         },
2603 };
2604
2605 /* 2,4,6 channel modes */
2606 static struct hda_verb alc880_lg_ch2_init[] = {
2607         /* set line-in and mic-in to input */
2608         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2609         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2610         { }
2611 };
2612
2613 static struct hda_verb alc880_lg_ch4_init[] = {
2614         /* set line-in to out and mic-in to input */
2615         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2616         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2617         { }
2618 };
2619
2620 static struct hda_verb alc880_lg_ch6_init[] = {
2621         /* set line-in and mic-in to output */
2622         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2623         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2624         { }
2625 };
2626
2627 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2628         { 2, alc880_lg_ch2_init },
2629         { 4, alc880_lg_ch4_init },
2630         { 6, alc880_lg_ch6_init },
2631 };
2632
2633 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2634         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2635         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2636         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2637         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2638         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2639         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2640         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2641         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2642         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2643         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2644         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2645         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2646         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2647         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2648         {
2649                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2650                 .name = "Channel Mode",
2651                 .info = alc_ch_mode_info,
2652                 .get = alc_ch_mode_get,
2653                 .put = alc_ch_mode_put,
2654         },
2655         { } /* end */
2656 };
2657
2658 static struct hda_verb alc880_lg_init_verbs[] = {
2659         /* set capture source to mic-in */
2660         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2661         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2662         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2663         /* mute all amp mixer inputs */
2664         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2665         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2666         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2667         /* line-in to input */
2668         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2669         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2670         /* built-in mic */
2671         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2672         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2673         /* speaker-out */
2674         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2675         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2676         /* mic-in to input */
2677         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2678         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2679         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2680         /* HP-out */
2681         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2682         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2683         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2684         /* jack sense */
2685         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2686         { }
2687 };
2688
2689 /* toggle speaker-output according to the hp-jack state */
2690 static void alc880_lg_automute(struct hda_codec *codec)
2691 {
2692         unsigned int present;
2693         unsigned char bits;
2694
2695         present = snd_hda_codec_read(codec, 0x1b, 0,
2696                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2697         bits = present ? HDA_AMP_MUTE : 0;
2698         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2699                                  HDA_AMP_MUTE, bits);
2700 }
2701
2702 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2703 {
2704         /* Looks like the unsol event is incompatible with the standard
2705          * definition.  4bit tag is placed at 28 bit!
2706          */
2707         if ((res >> 28) == 0x01)
2708                 alc880_lg_automute(codec);
2709 }
2710
2711 /*
2712  * LG LW20
2713  *
2714  * Pin assignment:
2715  *   Speaker-out: 0x14
2716  *   Mic-In: 0x18
2717  *   Built-in Mic-In: 0x19
2718  *   Line-In: 0x1b
2719  *   HP-Out: 0x1a
2720  *   SPDIF-Out: 0x1e
2721  */
2722
2723 static struct hda_input_mux alc880_lg_lw_capture_source = {
2724         .num_items = 3,
2725         .items = {
2726                 { "Mic", 0x0 },
2727                 { "Internal Mic", 0x1 },
2728                 { "Line In", 0x2 },
2729         },
2730 };
2731
2732 #define alc880_lg_lw_modes alc880_threestack_modes
2733
2734 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2735         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2736         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2737         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2738         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2739         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2740         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2741         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2742         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2743         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2744         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2745         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2746         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2747         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2748         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2749         {
2750                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2751                 .name = "Channel Mode",
2752                 .info = alc_ch_mode_info,
2753                 .get = alc_ch_mode_get,
2754                 .put = alc_ch_mode_put,
2755         },
2756         { } /* end */
2757 };
2758
2759 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2760         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2761         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2762         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2763
2764         /* set capture source to mic-in */
2765         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2766         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2767         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2768         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2769         /* speaker-out */
2770         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2771         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2772         /* HP-out */
2773         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2774         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2775         /* mic-in to input */
2776         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2777         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2778         /* built-in mic */
2779         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2780         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2781         /* jack sense */
2782         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2783         { }
2784 };
2785
2786 /* toggle speaker-output according to the hp-jack state */
2787 static void alc880_lg_lw_automute(struct hda_codec *codec)
2788 {
2789         unsigned int present;
2790         unsigned char bits;
2791
2792         present = snd_hda_codec_read(codec, 0x1b, 0,
2793                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2794         bits = present ? HDA_AMP_MUTE : 0;
2795         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2796                                  HDA_AMP_MUTE, bits);
2797 }
2798
2799 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2800 {
2801         /* Looks like the unsol event is incompatible with the standard
2802          * definition.  4bit tag is placed at 28 bit!
2803          */
2804         if ((res >> 28) == 0x01)
2805                 alc880_lg_lw_automute(codec);
2806 }
2807
2808 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2809         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2810         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2811         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2812         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2813         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2814         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2815         { } /* end */
2816 };
2817
2818 static struct hda_input_mux alc880_medion_rim_capture_source = {
2819         .num_items = 2,
2820         .items = {
2821                 { "Mic", 0x0 },
2822                 { "Internal Mic", 0x1 },
2823         },
2824 };
2825
2826 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2827         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2828
2829         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2830         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2831
2832         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2833         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2834         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2835         /* Mic2 (as headphone out) for HP output */
2836         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2837         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2838         /* Internal Speaker */
2839         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2840         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2841
2842         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2843         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2844
2845         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2846         { }
2847 };
2848
2849 /* toggle speaker-output according to the hp-jack state */
2850 static void alc880_medion_rim_automute(struct hda_codec *codec)
2851 {
2852         unsigned int present;
2853         unsigned char bits;
2854
2855         present = snd_hda_codec_read(codec, 0x14, 0,
2856                                      AC_VERB_GET_PIN_SENSE, 0)
2857                 & AC_PINSENSE_PRESENCE;
2858         bits = present ? HDA_AMP_MUTE : 0;
2859         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
2860                                  HDA_AMP_MUTE, bits);
2861         if (present)
2862                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2863         else
2864                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2865 }
2866
2867 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2868                                           unsigned int res)
2869 {
2870         /* Looks like the unsol event is incompatible with the standard
2871          * definition.  4bit tag is placed at 28 bit!
2872          */
2873         if ((res >> 28) == ALC880_HP_EVENT)
2874                 alc880_medion_rim_automute(codec);
2875 }
2876
2877 #ifdef CONFIG_SND_HDA_POWER_SAVE
2878 static struct hda_amp_list alc880_loopbacks[] = {
2879         { 0x0b, HDA_INPUT, 0 },
2880         { 0x0b, HDA_INPUT, 1 },
2881         { 0x0b, HDA_INPUT, 2 },
2882         { 0x0b, HDA_INPUT, 3 },
2883         { 0x0b, HDA_INPUT, 4 },
2884         { } /* end */
2885 };
2886
2887 static struct hda_amp_list alc880_lg_loopbacks[] = {
2888         { 0x0b, HDA_INPUT, 1 },
2889         { 0x0b, HDA_INPUT, 6 },
2890         { 0x0b, HDA_INPUT, 7 },
2891         { } /* end */
2892 };
2893 #endif
2894
2895 /*
2896  * Common callbacks
2897  */
2898
2899 static int alc_init(struct hda_codec *codec)
2900 {
2901         struct alc_spec *spec = codec->spec;
2902         unsigned int i;
2903
2904         alc_fix_pll(codec);
2905         if (codec->vendor_id == 0x10ec0888)
2906                 alc888_coef_init(codec);
2907
2908         for (i = 0; i < spec->num_init_verbs; i++)
2909                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2910
2911         if (spec->init_hook)
2912                 spec->init_hook(codec);
2913
2914         return 0;
2915 }
2916
2917 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2918 {
2919         struct alc_spec *spec = codec->spec;
2920
2921         if (spec->unsol_event)
2922                 spec->unsol_event(codec, res);
2923 }
2924
2925 #ifdef CONFIG_SND_HDA_POWER_SAVE
2926 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2927 {
2928         struct alc_spec *spec = codec->spec;
2929         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2930 }
2931 #endif
2932
2933 /*
2934  * Analog playback callbacks
2935  */
2936 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2937                                     struct hda_codec *codec,
2938                                     struct snd_pcm_substream *substream)
2939 {
2940         struct alc_spec *spec = codec->spec;
2941         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2942                                              hinfo);
2943 }
2944
2945 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2946                                        struct hda_codec *codec,
2947                                        unsigned int stream_tag,
2948                                        unsigned int format,
2949                                        struct snd_pcm_substream *substream)
2950 {
2951         struct alc_spec *spec = codec->spec;
2952         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2953                                                 stream_tag, format, substream);
2954 }
2955
2956 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2957                                        struct hda_codec *codec,
2958                                        struct snd_pcm_substream *substream)
2959 {
2960         struct alc_spec *spec = codec->spec;
2961         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2962 }
2963
2964 /*
2965  * Digital out
2966  */
2967 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2968                                         struct hda_codec *codec,
2969                                         struct snd_pcm_substream *substream)
2970 {
2971         struct alc_spec *spec = codec->spec;
2972         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2973 }
2974
2975 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2976                                            struct hda_codec *codec,
2977                                            unsigned int stream_tag,
2978                                            unsigned int format,
2979                                            struct snd_pcm_substream *substream)
2980 {
2981         struct alc_spec *spec = codec->spec;
2982         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2983                                              stream_tag, format, substream);
2984 }
2985
2986 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2987                                            struct hda_codec *codec,
2988                                            struct snd_pcm_substream *substream)
2989 {
2990         struct alc_spec *spec = codec->spec;
2991         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2992 }
2993
2994 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2995                                          struct hda_codec *codec,
2996                                          struct snd_pcm_substream *substream)
2997 {
2998         struct alc_spec *spec = codec->spec;
2999         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3000 }
3001
3002 /*
3003  * Analog capture
3004  */
3005 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3006                                       struct hda_codec *codec,
3007                                       unsigned int stream_tag,
3008                                       unsigned int format,
3009                                       struct snd_pcm_substream *substream)
3010 {
3011         struct alc_spec *spec = codec->spec;
3012
3013         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3014                                    stream_tag, 0, format);
3015         return 0;
3016 }
3017
3018 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3019                                       struct hda_codec *codec,
3020                                       struct snd_pcm_substream *substream)
3021 {
3022         struct alc_spec *spec = codec->spec;
3023
3024         snd_hda_codec_cleanup_stream(codec,
3025                                      spec->adc_nids[substream->number + 1]);
3026         return 0;
3027 }
3028
3029
3030 /*
3031  */
3032 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3033         .substreams = 1,
3034         .channels_min = 2,
3035         .channels_max = 8,
3036         /* NID is set in alc_build_pcms */
3037         .ops = {
3038                 .open = alc880_playback_pcm_open,
3039                 .prepare = alc880_playback_pcm_prepare,
3040                 .cleanup = alc880_playback_pcm_cleanup
3041         },
3042 };
3043
3044 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3045         .substreams = 1,
3046         .channels_min = 2,
3047         .channels_max = 2,
3048         /* NID is set in alc_build_pcms */
3049 };
3050
3051 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3052         .substreams = 1,
3053         .channels_min = 2,
3054         .channels_max = 2,
3055         /* NID is set in alc_build_pcms */
3056 };
3057
3058 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3059         .substreams = 2, /* can be overridden */
3060         .channels_min = 2,
3061         .channels_max = 2,
3062         /* NID is set in alc_build_pcms */
3063         .ops = {
3064                 .prepare = alc880_alt_capture_pcm_prepare,
3065                 .cleanup = alc880_alt_capture_pcm_cleanup
3066         },
3067 };
3068
3069 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3070         .substreams = 1,
3071         .channels_min = 2,
3072         .channels_max = 2,
3073         /* NID is set in alc_build_pcms */
3074         .ops = {
3075                 .open = alc880_dig_playback_pcm_open,
3076                 .close = alc880_dig_playback_pcm_close,
3077                 .prepare = alc880_dig_playback_pcm_prepare,
3078                 .cleanup = alc880_dig_playback_pcm_cleanup
3079         },
3080 };
3081
3082 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3083         .substreams = 1,
3084         .channels_min = 2,
3085         .channels_max = 2,
3086         /* NID is set in alc_build_pcms */
3087 };
3088
3089 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3090 static struct hda_pcm_stream alc_pcm_null_stream = {
3091         .substreams = 0,
3092         .channels_min = 0,
3093         .channels_max = 0,
3094 };
3095
3096 static int alc_build_pcms(struct hda_codec *codec)
3097 {
3098         struct alc_spec *spec = codec->spec;
3099         struct hda_pcm *info = spec->pcm_rec;
3100         int i;
3101
3102         codec->num_pcms = 1;
3103         codec->pcm_info = info;
3104
3105         if (spec->no_analog)
3106                 goto skip_analog;
3107
3108         info->name = spec->stream_name_analog;
3109         if (spec->stream_analog_playback) {
3110                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3111                         return -EINVAL;
3112                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3113                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3114         }
3115         if (spec->stream_analog_capture) {
3116                 if (snd_BUG_ON(!spec->adc_nids))
3117                         return -EINVAL;
3118                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3119                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3120         }
3121
3122         if (spec->channel_mode) {
3123                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3124                 for (i = 0; i < spec->num_channel_mode; i++) {
3125                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3126                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3127                         }
3128                 }
3129         }
3130
3131  skip_analog:
3132         /* SPDIF for stream index #1 */
3133         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3134                 codec->num_pcms = 2;
3135                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3136                 info = spec->pcm_rec + 1;
3137                 info->name = spec->stream_name_digital;
3138                 if (spec->dig_out_type)
3139                         info->pcm_type = spec->dig_out_type;
3140                 else
3141                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3142                 if (spec->multiout.dig_out_nid &&
3143                     spec->stream_digital_playback) {
3144                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3145                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3146                 }
3147                 if (spec->dig_in_nid &&
3148                     spec->stream_digital_capture) {
3149                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3150                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3151                 }
3152                 /* FIXME: do we need this for all Realtek codec models? */
3153                 codec->spdif_status_reset = 1;
3154         }
3155
3156         if (spec->no_analog)
3157                 return 0;
3158
3159         /* If the use of more than one ADC is requested for the current
3160          * model, configure a second analog capture-only PCM.
3161          */
3162         /* Additional Analaog capture for index #2 */
3163         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3164             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3165                 codec->num_pcms = 3;
3166                 info = spec->pcm_rec + 2;
3167                 info->name = spec->stream_name_analog;
3168                 if (spec->alt_dac_nid) {
3169                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3170                                 *spec->stream_analog_alt_playback;
3171                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3172                                 spec->alt_dac_nid;
3173                 } else {
3174                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3175                                 alc_pcm_null_stream;
3176                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3177                 }
3178                 if (spec->num_adc_nids > 1) {
3179                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3180                                 *spec->stream_analog_alt_capture;
3181                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3182                                 spec->adc_nids[1];
3183                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3184                                 spec->num_adc_nids - 1;
3185                 } else {
3186                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3187                                 alc_pcm_null_stream;
3188                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3189                 }
3190         }
3191
3192         return 0;
3193 }
3194
3195 static void alc_free_kctls(struct hda_codec *codec)
3196 {
3197         struct alc_spec *spec = codec->spec;
3198
3199         if (spec->kctls.list) {
3200                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3201                 int i;
3202                 for (i = 0; i < spec->kctls.used; i++)
3203                         kfree(kctl[i].name);
3204         }
3205         snd_array_free(&spec->kctls);
3206 }
3207
3208 static void alc_free(struct hda_codec *codec)
3209 {
3210         struct alc_spec *spec = codec->spec;
3211
3212         if (!spec)
3213                 return;
3214
3215         alc_free_kctls(codec);
3216         kfree(spec);
3217         snd_hda_detach_beep_device(codec);
3218 }
3219
3220 #ifdef SND_HDA_NEEDS_RESUME
3221 static int alc_resume(struct hda_codec *codec)
3222 {
3223         codec->patch_ops.init(codec);
3224         snd_hda_codec_resume_amp(codec);
3225         snd_hda_codec_resume_cache(codec);
3226         return 0;
3227 }
3228 #endif
3229
3230 /*
3231  */
3232 static struct hda_codec_ops alc_patch_ops = {
3233         .build_controls = alc_build_controls,
3234         .build_pcms = alc_build_pcms,
3235         .init = alc_init,
3236         .free = alc_free,
3237         .unsol_event = alc_unsol_event,
3238 #ifdef SND_HDA_NEEDS_RESUME
3239         .resume = alc_resume,
3240 #endif
3241 #ifdef CONFIG_SND_HDA_POWER_SAVE
3242         .check_power_status = alc_check_power_status,
3243 #endif
3244 };
3245
3246
3247 /*
3248  * Test configuration for debugging
3249  *
3250  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3251  * enum controls.
3252  */
3253 #ifdef CONFIG_SND_DEBUG
3254 static hda_nid_t alc880_test_dac_nids[4] = {
3255         0x02, 0x03, 0x04, 0x05
3256 };
3257
3258 static struct hda_input_mux alc880_test_capture_source = {
3259         .num_items = 7,
3260         .items = {
3261                 { "In-1", 0x0 },
3262                 { "In-2", 0x1 },
3263                 { "In-3", 0x2 },
3264                 { "In-4", 0x3 },
3265                 { "CD", 0x4 },
3266                 { "Front", 0x5 },
3267                 { "Surround", 0x6 },
3268         },
3269 };
3270
3271 static struct hda_channel_mode alc880_test_modes[4] = {
3272         { 2, NULL },
3273         { 4, NULL },
3274         { 6, NULL },
3275         { 8, NULL },
3276 };
3277
3278 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3279                                  struct snd_ctl_elem_info *uinfo)
3280 {
3281         static char *texts[] = {
3282                 "N/A", "Line Out", "HP Out",
3283                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3284         };
3285         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3286         uinfo->count = 1;
3287         uinfo->value.enumerated.items = 8;
3288         if (uinfo->value.enumerated.item >= 8)
3289                 uinfo->value.enumerated.item = 7;
3290         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3291         return 0;
3292 }
3293
3294 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3295                                 struct snd_ctl_elem_value *ucontrol)
3296 {
3297         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3298         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3299         unsigned int pin_ctl, item = 0;
3300
3301         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3302                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3303         if (pin_ctl & AC_PINCTL_OUT_EN) {
3304                 if (pin_ctl & AC_PINCTL_HP_EN)
3305                         item = 2;
3306                 else
3307                         item = 1;
3308         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3309                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3310                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3311                 case AC_PINCTL_VREF_50:  item = 4; break;
3312                 case AC_PINCTL_VREF_GRD: item = 5; break;
3313                 case AC_PINCTL_VREF_80:  item = 6; break;
3314                 case AC_PINCTL_VREF_100: item = 7; break;
3315                 }
3316         }
3317         ucontrol->value.enumerated.item[0] = item;
3318         return 0;
3319 }
3320
3321 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3322                                 struct snd_ctl_elem_value *ucontrol)
3323 {
3324         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3325         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3326         static unsigned int ctls[] = {
3327                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3328                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3329                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3330                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3331                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3332                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3333         };
3334         unsigned int old_ctl, new_ctl;
3335
3336         old_ctl = snd_hda_codec_read(codec, nid, 0,
3337                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3338         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3339         if (old_ctl != new_ctl) {
3340                 int val;
3341                 snd_hda_codec_write_cache(codec, nid, 0,
3342                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3343                                           new_ctl);
3344                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3345                         HDA_AMP_MUTE : 0;
3346                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3347                                          HDA_AMP_MUTE, val);
3348                 return 1;
3349         }
3350         return 0;
3351 }
3352
3353 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3354                                  struct snd_ctl_elem_info *uinfo)
3355 {
3356         static char *texts[] = {
3357                 "Front", "Surround", "CLFE", "Side"
3358         };
3359         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3360         uinfo->count = 1;
3361         uinfo->value.enumerated.items = 4;
3362         if (uinfo->value.enumerated.item >= 4)
3363                 uinfo->value.enumerated.item = 3;
3364         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3365         return 0;
3366 }
3367
3368 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3369                                 struct snd_ctl_elem_value *ucontrol)
3370 {
3371         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3372         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3373         unsigned int sel;
3374
3375         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3376         ucontrol->value.enumerated.item[0] = sel & 3;
3377         return 0;
3378 }
3379
3380 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3381                                 struct snd_ctl_elem_value *ucontrol)
3382 {
3383         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3384         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3385         unsigned int sel;
3386
3387         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3388         if (ucontrol->value.enumerated.item[0] != sel) {
3389                 sel = ucontrol->value.enumerated.item[0] & 3;
3390                 snd_hda_codec_write_cache(codec, nid, 0,
3391                                           AC_VERB_SET_CONNECT_SEL, sel);
3392                 return 1;
3393         }
3394         return 0;
3395 }
3396
3397 #define PIN_CTL_TEST(xname,nid) {                       \
3398                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3399                         .name = xname,                 \
3400                         .info = alc_test_pin_ctl_info, \
3401                         .get = alc_test_pin_ctl_get,   \
3402                         .put = alc_test_pin_ctl_put,   \
3403                         .private_value = nid           \
3404                         }
3405
3406 #define PIN_SRC_TEST(xname,nid) {                       \
3407                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3408                         .name = xname,                 \
3409                         .info = alc_test_pin_src_info, \
3410                         .get = alc_test_pin_src_get,   \
3411                         .put = alc_test_pin_src_put,   \
3412                         .private_value = nid           \
3413                         }
3414
3415 static struct snd_kcontrol_new alc880_test_mixer[] = {
3416         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3417         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3418         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3419         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3420         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3421         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3422         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3423         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3424         PIN_CTL_TEST("Front Pin Mode", 0x14),
3425         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3426         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3427         PIN_CTL_TEST("Side Pin Mode", 0x17),
3428         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3429         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3430         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3431         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3432         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3433         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3434         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3435         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3436         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3437         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3438         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3439         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3440         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3441         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3442         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3443         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3444         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3445         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3446         {
3447                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3448                 .name = "Channel Mode",
3449                 .info = alc_ch_mode_info,
3450                 .get = alc_ch_mode_get,
3451                 .put = alc_ch_mode_put,
3452         },
3453         { } /* end */
3454 };
3455
3456 static struct hda_verb alc880_test_init_verbs[] = {
3457         /* Unmute inputs of 0x0c - 0x0f */
3458         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3459         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3460         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3461         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3462         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3463         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3464         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3465         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3466         /* Vol output for 0x0c-0x0f */
3467         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3468         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3469         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3470         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3471         /* Set output pins 0x14-0x17 */
3472         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3473         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3474         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3475         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3476         /* Unmute output pins 0x14-0x17 */
3477         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3478         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3479         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3480         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3481         /* Set input pins 0x18-0x1c */
3482         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3483         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3484         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3485         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3486         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3487         /* Mute input pins 0x18-0x1b */
3488         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3489         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3490         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3491         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3492         /* ADC set up */
3493         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3494         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3495         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3496         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3497         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3498         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3499         /* Analog input/passthru */
3500         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3501         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3502         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3503         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3504         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3505         { }
3506 };
3507 #endif
3508
3509 /*
3510  */
3511
3512 static const char *alc880_models[ALC880_MODEL_LAST] = {
3513         [ALC880_3ST]            = "3stack",
3514         [ALC880_TCL_S700]       = "tcl",
3515         [ALC880_3ST_DIG]        = "3stack-digout",
3516         [ALC880_CLEVO]          = "clevo",
3517         [ALC880_5ST]            = "5stack",
3518         [ALC880_5ST_DIG]        = "5stack-digout",
3519         [ALC880_W810]           = "w810",
3520         [ALC880_Z71V]           = "z71v",
3521         [ALC880_6ST]            = "6stack",
3522         [ALC880_6ST_DIG]        = "6stack-digout",
3523         [ALC880_ASUS]           = "asus",
3524         [ALC880_ASUS_W1V]       = "asus-w1v",
3525         [ALC880_ASUS_DIG]       = "asus-dig",
3526         [ALC880_ASUS_DIG2]      = "asus-dig2",
3527         [ALC880_UNIWILL_DIG]    = "uniwill",
3528         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3529         [ALC880_FUJITSU]        = "fujitsu",
3530         [ALC880_F1734]          = "F1734",
3531         [ALC880_LG]             = "lg",
3532         [ALC880_LG_LW]          = "lg-lw",
3533         [ALC880_MEDION_RIM]     = "medion",
3534 #ifdef CONFIG_SND_DEBUG
3535         [ALC880_TEST]           = "test",
3536 #endif
3537         [ALC880_AUTO]           = "auto",
3538 };
3539
3540 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3541         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3542         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3543         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3544         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3545         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3546         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3547         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3548         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3549         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3550         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3551         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3552         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3553         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3554         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3555         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3556         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3557         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3558         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3559         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3560         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3561         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3562         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3563         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3564         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3565         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3566         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
3567         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3568         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3569         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3570         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3571         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3572         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3573         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3574         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3575         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3576         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3577         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3578         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3579         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3580         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3581         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3582         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3583         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3584         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3585         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3586         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3587         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3588         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3589         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3590         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3591         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3592         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3593         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3594         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3595         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3596         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3597         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3598         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3599         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3600         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3601         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3602         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3603         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3604         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3605         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3606         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3607         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3608         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3609         /* default Intel */
3610         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
3611         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3612         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3613         {}
3614 };
3615
3616 /*
3617  * ALC880 codec presets
3618  */
3619 static struct alc_config_preset alc880_presets[] = {
3620         [ALC880_3ST] = {
3621                 .mixers = { alc880_three_stack_mixer },
3622                 .init_verbs = { alc880_volume_init_verbs,
3623                                 alc880_pin_3stack_init_verbs },
3624                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3625                 .dac_nids = alc880_dac_nids,
3626                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3627                 .channel_mode = alc880_threestack_modes,
3628                 .need_dac_fix = 1,
3629                 .input_mux = &alc880_capture_source,
3630         },
3631         [ALC880_3ST_DIG] = {
3632                 .mixers = { alc880_three_stack_mixer },
3633                 .init_verbs = { alc880_volume_init_verbs,
3634                                 alc880_pin_3stack_init_verbs },
3635                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3636                 .dac_nids = alc880_dac_nids,
3637                 .dig_out_nid = ALC880_DIGOUT_NID,
3638                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3639                 .channel_mode = alc880_threestack_modes,
3640                 .need_dac_fix = 1,
3641                 .input_mux = &alc880_capture_source,
3642         },
3643         [ALC880_TCL_S700] = {
3644                 .mixers = { alc880_tcl_s700_mixer },
3645                 .init_verbs = { alc880_volume_init_verbs,
3646                                 alc880_pin_tcl_S700_init_verbs,
3647                                 alc880_gpio2_init_verbs },
3648                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3649                 .dac_nids = alc880_dac_nids,
3650                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
3651                 .num_adc_nids = 1, /* single ADC */
3652                 .hp_nid = 0x03,
3653                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3654                 .channel_mode = alc880_2_jack_modes,
3655                 .input_mux = &alc880_capture_source,
3656         },
3657         [ALC880_5ST] = {
3658                 .mixers = { alc880_three_stack_mixer,
3659                             alc880_five_stack_mixer},
3660                 .init_verbs = { alc880_volume_init_verbs,
3661                                 alc880_pin_5stack_init_verbs },
3662                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3663                 .dac_nids = alc880_dac_nids,
3664                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3665                 .channel_mode = alc880_fivestack_modes,
3666                 .input_mux = &alc880_capture_source,
3667         },
3668         [ALC880_5ST_DIG] = {
3669                 .mixers = { alc880_three_stack_mixer,
3670                             alc880_five_stack_mixer },
3671                 .init_verbs = { alc880_volume_init_verbs,
3672                                 alc880_pin_5stack_init_verbs },
3673                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3674                 .dac_nids = alc880_dac_nids,
3675                 .dig_out_nid = ALC880_DIGOUT_NID,
3676                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3677                 .channel_mode = alc880_fivestack_modes,
3678                 .input_mux = &alc880_capture_source,
3679         },
3680         [ALC880_6ST] = {
3681                 .mixers = { alc880_six_stack_mixer },
3682                 .init_verbs = { alc880_volume_init_verbs,
3683                                 alc880_pin_6stack_init_verbs },
3684                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3685                 .dac_nids = alc880_6st_dac_nids,
3686                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3687                 .channel_mode = alc880_sixstack_modes,
3688                 .input_mux = &alc880_6stack_capture_source,
3689         },
3690         [ALC880_6ST_DIG] = {
3691                 .mixers = { alc880_six_stack_mixer },
3692                 .init_verbs = { alc880_volume_init_verbs,
3693                                 alc880_pin_6stack_init_verbs },
3694                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3695                 .dac_nids = alc880_6st_dac_nids,
3696                 .dig_out_nid = ALC880_DIGOUT_NID,
3697                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3698                 .channel_mode = alc880_sixstack_modes,
3699                 .input_mux = &alc880_6stack_capture_source,
3700         },
3701         [ALC880_W810] = {
3702                 .mixers = { alc880_w810_base_mixer },
3703                 .init_verbs = { alc880_volume_init_verbs,
3704                                 alc880_pin_w810_init_verbs,
3705                                 alc880_gpio2_init_verbs },
3706                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3707                 .dac_nids = alc880_w810_dac_nids,
3708                 .dig_out_nid = ALC880_DIGOUT_NID,
3709                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3710                 .channel_mode = alc880_w810_modes,
3711                 .input_mux = &alc880_capture_source,
3712         },
3713         [ALC880_Z71V] = {
3714                 .mixers = { alc880_z71v_mixer },
3715                 .init_verbs = { alc880_volume_init_verbs,
3716                                 alc880_pin_z71v_init_verbs },
3717                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3718                 .dac_nids = alc880_z71v_dac_nids,
3719                 .dig_out_nid = ALC880_DIGOUT_NID,
3720                 .hp_nid = 0x03,
3721                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3722                 .channel_mode = alc880_2_jack_modes,
3723                 .input_mux = &alc880_capture_source,
3724         },
3725         [ALC880_F1734] = {
3726                 .mixers = { alc880_f1734_mixer },
3727                 .init_verbs = { alc880_volume_init_verbs,
3728                                 alc880_pin_f1734_init_verbs },
3729                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3730                 .dac_nids = alc880_f1734_dac_nids,
3731                 .hp_nid = 0x02,
3732                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3733                 .channel_mode = alc880_2_jack_modes,
3734                 .input_mux = &alc880_f1734_capture_source,
3735                 .unsol_event = alc880_uniwill_p53_unsol_event,
3736                 .init_hook = alc880_uniwill_p53_hp_automute,
3737         },
3738         [ALC880_ASUS] = {
3739                 .mixers = { alc880_asus_mixer },
3740                 .init_verbs = { alc880_volume_init_verbs,
3741                                 alc880_pin_asus_init_verbs,
3742                                 alc880_gpio1_init_verbs },
3743                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3744                 .dac_nids = alc880_asus_dac_nids,
3745                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3746                 .channel_mode = alc880_asus_modes,
3747                 .need_dac_fix = 1,
3748                 .input_mux = &alc880_capture_source,
3749         },
3750         [ALC880_ASUS_DIG] = {
3751                 .mixers = { alc880_asus_mixer },
3752                 .init_verbs = { alc880_volume_init_verbs,
3753                                 alc880_pin_asus_init_verbs,
3754                                 alc880_gpio1_init_verbs },
3755                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3756                 .dac_nids = alc880_asus_dac_nids,
3757                 .dig_out_nid = ALC880_DIGOUT_NID,
3758                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3759                 .channel_mode = alc880_asus_modes,
3760                 .need_dac_fix = 1,
3761                 .input_mux = &alc880_capture_source,
3762         },
3763         [ALC880_ASUS_DIG2] = {
3764                 .mixers = { alc880_asus_mixer },
3765                 .init_verbs = { alc880_volume_init_verbs,
3766                                 alc880_pin_asus_init_verbs,
3767                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
3768                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3769                 .dac_nids = alc880_asus_dac_nids,
3770                 .dig_out_nid = ALC880_DIGOUT_NID,
3771                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3772                 .channel_mode = alc880_asus_modes,
3773                 .need_dac_fix = 1,
3774                 .input_mux = &alc880_capture_source,
3775         },
3776         [ALC880_ASUS_W1V] = {
3777                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3778                 .init_verbs = { alc880_volume_init_verbs,
3779                                 alc880_pin_asus_init_verbs,
3780                                 alc880_gpio1_init_verbs },
3781                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3782                 .dac_nids = alc880_asus_dac_nids,
3783                 .dig_out_nid = ALC880_DIGOUT_NID,
3784                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3785                 .channel_mode = alc880_asus_modes,
3786                 .need_dac_fix = 1,
3787                 .input_mux = &alc880_capture_source,
3788         },
3789         [ALC880_UNIWILL_DIG] = {
3790                 .mixers = { alc880_asus_mixer },
3791                 .init_verbs = { alc880_volume_init_verbs,
3792                                 alc880_pin_asus_init_verbs },
3793                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3794                 .dac_nids = alc880_asus_dac_nids,
3795                 .dig_out_nid = ALC880_DIGOUT_NID,
3796                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3797                 .channel_mode = alc880_asus_modes,
3798                 .need_dac_fix = 1,
3799                 .input_mux = &alc880_capture_source,
3800         },
3801         [ALC880_UNIWILL] = {
3802                 .mixers = { alc880_uniwill_mixer },
3803                 .init_verbs = { alc880_volume_init_verbs,
3804                                 alc880_uniwill_init_verbs },
3805                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3806                 .dac_nids = alc880_asus_dac_nids,
3807                 .dig_out_nid = ALC880_DIGOUT_NID,
3808                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3809                 .channel_mode = alc880_threestack_modes,
3810                 .need_dac_fix = 1,
3811                 .input_mux = &alc880_capture_source,
3812                 .unsol_event = alc880_uniwill_unsol_event,
3813                 .init_hook = alc880_uniwill_automute,
3814         },
3815         [ALC880_UNIWILL_P53] = {
3816                 .mixers = { alc880_uniwill_p53_mixer },
3817                 .init_verbs = { alc880_volume_init_verbs,
3818                                 alc880_uniwill_p53_init_verbs },
3819                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3820                 .dac_nids = alc880_asus_dac_nids,
3821                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3822                 .channel_mode = alc880_threestack_modes,
3823                 .input_mux = &alc880_capture_source,
3824                 .unsol_event = alc880_uniwill_p53_unsol_event,
3825                 .init_hook = alc880_uniwill_p53_hp_automute,
3826         },
3827         [ALC880_FUJITSU] = {
3828                 .mixers = { alc880_fujitsu_mixer },
3829                 .init_verbs = { alc880_volume_init_verbs,
3830                                 alc880_uniwill_p53_init_verbs,
3831                                 alc880_beep_init_verbs },
3832                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3833                 .dac_nids = alc880_dac_nids,
3834                 .dig_out_nid = ALC880_DIGOUT_NID,
3835                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3836                 .channel_mode = alc880_2_jack_modes,
3837                 .input_mux = &alc880_capture_source,
3838                 .unsol_event = alc880_uniwill_p53_unsol_event,
3839                 .init_hook = alc880_uniwill_p53_hp_automute,
3840         },
3841         [ALC880_CLEVO] = {
3842                 .mixers = { alc880_three_stack_mixer },
3843                 .init_verbs = { alc880_volume_init_verbs,
3844                                 alc880_pin_clevo_init_verbs },
3845                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3846                 .dac_nids = alc880_dac_nids,
3847                 .hp_nid = 0x03,
3848                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3849                 .channel_mode = alc880_threestack_modes,
3850                 .need_dac_fix = 1,
3851                 .input_mux = &alc880_capture_source,
3852         },
3853         [ALC880_LG] = {
3854                 .mixers = { alc880_lg_mixer },
3855                 .init_verbs = { alc880_volume_init_verbs,
3856                                 alc880_lg_init_verbs },
3857                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3858                 .dac_nids = alc880_lg_dac_nids,
3859                 .dig_out_nid = ALC880_DIGOUT_NID,
3860                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3861                 .channel_mode = alc880_lg_ch_modes,
3862                 .need_dac_fix = 1,
3863                 .input_mux = &alc880_lg_capture_source,
3864                 .unsol_event = alc880_lg_unsol_event,
3865                 .init_hook = alc880_lg_automute,
3866 #ifdef CONFIG_SND_HDA_POWER_SAVE
3867                 .loopbacks = alc880_lg_loopbacks,
3868 #endif
3869         },
3870         [ALC880_LG_LW] = {
3871                 .mixers = { alc880_lg_lw_mixer },
3872                 .init_verbs = { alc880_volume_init_verbs,
3873                                 alc880_lg_lw_init_verbs },
3874                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3875                 .dac_nids = alc880_dac_nids,
3876                 .dig_out_nid = ALC880_DIGOUT_NID,
3877                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3878                 .channel_mode = alc880_lg_lw_modes,
3879                 .input_mux = &alc880_lg_lw_capture_source,
3880                 .unsol_event = alc880_lg_lw_unsol_event,
3881                 .init_hook = alc880_lg_lw_automute,
3882         },
3883         [ALC880_MEDION_RIM] = {
3884                 .mixers = { alc880_medion_rim_mixer },
3885                 .init_verbs = { alc880_volume_init_verbs,
3886                                 alc880_medion_rim_init_verbs,
3887                                 alc_gpio2_init_verbs },
3888                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3889                 .dac_nids = alc880_dac_nids,
3890                 .dig_out_nid = ALC880_DIGOUT_NID,
3891                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3892                 .channel_mode = alc880_2_jack_modes,
3893                 .input_mux = &alc880_medion_rim_capture_source,
3894                 .unsol_event = alc880_medion_rim_unsol_event,
3895                 .init_hook = alc880_medion_rim_automute,
3896         },
3897 #ifdef CONFIG_SND_DEBUG
3898         [ALC880_TEST] = {
3899                 .mixers = { alc880_test_mixer },
3900                 .init_verbs = { alc880_test_init_verbs },
3901                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3902                 .dac_nids = alc880_test_dac_nids,
3903                 .dig_out_nid = ALC880_DIGOUT_NID,
3904                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3905                 .channel_mode = alc880_test_modes,
3906                 .input_mux = &alc880_test_capture_source,
3907         },
3908 #endif
3909 };
3910
3911 /*
3912  * Automatic parse of I/O pins from the BIOS configuration
3913  */
3914
3915 enum {
3916         ALC_CTL_WIDGET_VOL,
3917         ALC_CTL_WIDGET_MUTE,
3918         ALC_CTL_BIND_MUTE,
3919 };
3920 static struct snd_kcontrol_new alc880_control_templates[] = {
3921         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3922         HDA_CODEC_MUTE(NULL, 0, 0, 0),
3923         HDA_BIND_MUTE(NULL, 0, 0, 0),
3924 };
3925
3926 /* add dynamic controls */
3927 static int add_control(struct alc_spec *spec, int type, const char *name,
3928                        unsigned long val)
3929 {
3930         struct snd_kcontrol_new *knew;
3931
3932         snd_array_init(&spec->kctls, sizeof(*knew), 32);
3933         knew = snd_array_new(&spec->kctls);
3934         if (!knew)
3935                 return -ENOMEM;
3936         *knew = alc880_control_templates[type];
3937         knew->name = kstrdup(name, GFP_KERNEL);
3938         if (!knew->name)
3939                 return -ENOMEM;
3940         knew->private_value = val;
3941         return 0;
3942 }
3943
3944 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
3945 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
3946 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
3947 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
3948 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
3949 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
3950 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
3951 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
3952 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
3953 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
3954 #define ALC880_PIN_CD_NID               0x1c
3955
3956 /* fill in the dac_nids table from the parsed pin configuration */
3957 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
3958                                      const struct auto_pin_cfg *cfg)
3959 {
3960         hda_nid_t nid;
3961         int assigned[4];
3962         int i, j;
3963
3964         memset(assigned, 0, sizeof(assigned));
3965         spec->multiout.dac_nids = spec->private_dac_nids;
3966
3967         /* check the pins hardwired to audio widget */
3968         for (i = 0; i < cfg->line_outs; i++) {
3969                 nid = cfg->line_out_pins[i];
3970                 if (alc880_is_fixed_pin(nid)) {
3971                         int idx = alc880_fixed_pin_idx(nid);
3972                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
3973                         assigned[idx] = 1;
3974                 }
3975         }
3976         /* left pins can be connect to any audio widget */
3977         for (i = 0; i < cfg->line_outs; i++) {
3978                 nid = cfg->line_out_pins[i];
3979                 if (alc880_is_fixed_pin(nid))
3980                         continue;
3981                 /* search for an empty channel */
3982                 for (j = 0; j < cfg->line_outs; j++) {
3983                         if (!assigned[j]) {
3984                                 spec->multiout.dac_nids[i] =
3985                                         alc880_idx_to_dac(j);
3986                                 assigned[j] = 1;
3987                                 break;
3988                         }
3989                 }
3990         }
3991         spec->multiout.num_dacs = cfg->line_outs;
3992         return 0;
3993 }
3994
3995 /* add playback controls from the parsed DAC table */
3996 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
3997                                              const struct auto_pin_cfg *cfg)
3998 {
3999         char name[32];
4000         static const char *chname[4] = {
4001                 "Front", "Surround", NULL /*CLFE*/, "Side"
4002         };
4003         hda_nid_t nid;
4004         int i, err;
4005
4006         for (i = 0; i < cfg->line_outs; i++) {
4007                 if (!spec->multiout.dac_nids[i])
4008                         continue;
4009                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4010                 if (i == 2) {
4011                         /* Center/LFE */
4012                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4013                                           "Center Playback Volume",
4014                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4015                                                               HDA_OUTPUT));
4016                         if (err < 0)
4017                                 return err;
4018                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4019                                           "LFE Playback Volume",
4020                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4021                                                               HDA_OUTPUT));
4022                         if (err < 0)
4023                                 return err;
4024                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4025                                           "Center Playback Switch",
4026                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4027                                                               HDA_INPUT));
4028                         if (err < 0)
4029                                 return err;
4030                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4031                                           "LFE Playback Switch",
4032                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4033                                                               HDA_INPUT));
4034                         if (err < 0)
4035                                 return err;
4036                 } else {
4037                         sprintf(name, "%s Playback Volume", chname[i]);
4038                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4039                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4040                                                               HDA_OUTPUT));
4041                         if (err < 0)
4042                                 return err;
4043                         sprintf(name, "%s Playback Switch", chname[i]);
4044                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4045                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4046                                                               HDA_INPUT));
4047                         if (err < 0)
4048                                 return err;
4049                 }
4050         }
4051         return 0;
4052 }
4053
4054 /* add playback controls for speaker and HP outputs */
4055 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4056                                         const char *pfx)
4057 {
4058         hda_nid_t nid;
4059         int err;
4060         char name[32];
4061
4062         if (!pin)
4063                 return 0;
4064
4065         if (alc880_is_fixed_pin(pin)) {
4066                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4067                 /* specify the DAC as the extra output */
4068                 if (!spec->multiout.hp_nid)
4069                         spec->multiout.hp_nid = nid;
4070                 else
4071                         spec->multiout.extra_out_nid[0] = nid;
4072                 /* control HP volume/switch on the output mixer amp */
4073                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4074                 sprintf(name, "%s Playback Volume", pfx);
4075                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4076                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4077                 if (err < 0)
4078                         return err;
4079                 sprintf(name, "%s Playback Switch", pfx);
4080                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4081                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4082                 if (err < 0)
4083                         return err;
4084         } else if (alc880_is_multi_pin(pin)) {
4085                 /* set manual connection */
4086                 /* we have only a switch on HP-out PIN */
4087                 sprintf(name, "%s Playback Switch", pfx);
4088                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4089                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4090                 if (err < 0)
4091                         return err;
4092         }
4093         return 0;
4094 }
4095
4096 /* create input playback/capture controls for the given pin */
4097 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4098                             const char *ctlname,
4099                             int idx, hda_nid_t mix_nid)
4100 {
4101         char name[32];
4102         int err;
4103
4104         sprintf(name, "%s Playback Volume", ctlname);
4105         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4106                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4107         if (err < 0)
4108                 return err;
4109         sprintf(name, "%s Playback Switch", ctlname);
4110         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4111                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4112         if (err < 0)
4113                 return err;
4114         return 0;
4115 }
4116
4117 /* create playback/capture controls for input pins */
4118 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
4119                                                 const struct auto_pin_cfg *cfg)
4120 {
4121         struct hda_input_mux *imux = &spec->private_imux[0];
4122         int i, err, idx;
4123
4124         for (i = 0; i < AUTO_PIN_LAST; i++) {
4125                 if (alc880_is_input_pin(cfg->input_pins[i])) {
4126                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
4127                         err = new_analog_input(spec, cfg->input_pins[i],
4128                                                auto_pin_cfg_labels[i],
4129                                                idx, 0x0b);
4130                         if (err < 0)
4131                                 return err;
4132                         imux->items[imux->num_items].label =
4133                                 auto_pin_cfg_labels[i];
4134                         imux->items[imux->num_items].index =
4135                                 alc880_input_pin_idx(cfg->input_pins[i]);
4136                         imux->num_items++;
4137                 }
4138         }
4139         return 0;
4140 }
4141
4142 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4143                                unsigned int pin_type)
4144 {
4145         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4146                             pin_type);
4147         /* unmute pin */
4148         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4149                             AMP_OUT_UNMUTE);
4150 }
4151
4152 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4153                                               hda_nid_t nid, int pin_type,
4154                                               int dac_idx)
4155 {
4156         alc_set_pin_output(codec, nid, pin_type);
4157         /* need the manual connection? */
4158         if (alc880_is_multi_pin(nid)) {
4159                 struct alc_spec *spec = codec->spec;
4160                 int idx = alc880_multi_pin_idx(nid);
4161                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4162                                     AC_VERB_SET_CONNECT_SEL,
4163                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4164         }
4165 }
4166
4167 static int get_pin_type(int line_out_type)
4168 {
4169         if (line_out_type == AUTO_PIN_HP_OUT)
4170                 return PIN_HP;
4171         else
4172                 return PIN_OUT;
4173 }
4174
4175 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4176 {
4177         struct alc_spec *spec = codec->spec;
4178         int i;
4179
4180         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
4181         for (i = 0; i < spec->autocfg.line_outs; i++) {
4182                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4183                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4184                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4185         }
4186 }
4187
4188 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4189 {
4190         struct alc_spec *spec = codec->spec;
4191         hda_nid_t pin;
4192
4193         pin = spec->autocfg.speaker_pins[0];
4194         if (pin) /* connect to front */
4195                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4196         pin = spec->autocfg.hp_pins[0];
4197         if (pin) /* connect to front */
4198                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4199 }
4200
4201 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4202 {
4203         struct alc_spec *spec = codec->spec;
4204         int i;
4205
4206         for (i = 0; i < AUTO_PIN_LAST; i++) {
4207                 hda_nid_t nid = spec->autocfg.input_pins[i];
4208                 if (alc880_is_input_pin(nid)) {
4209                         alc_set_input_pin(codec, nid, i);
4210                         if (nid != ALC880_PIN_CD_NID &&
4211                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4212                                 snd_hda_codec_write(codec, nid, 0,
4213                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4214                                                     AMP_OUT_MUTE);
4215                 }
4216         }
4217 }
4218
4219 /* parse the BIOS configuration and set up the alc_spec */
4220 /* return 1 if successful, 0 if the proper config is not found,
4221  * or a negative error code
4222  */
4223 static int alc880_parse_auto_config(struct hda_codec *codec)
4224 {
4225         struct alc_spec *spec = codec->spec;
4226         int i, err;
4227         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4228
4229         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4230                                            alc880_ignore);
4231         if (err < 0)
4232                 return err;
4233         if (!spec->autocfg.line_outs)
4234                 return 0; /* can't find valid BIOS pin config */
4235
4236         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4237         if (err < 0)
4238                 return err;
4239         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4240         if (err < 0)
4241                 return err;
4242         err = alc880_auto_create_extra_out(spec,
4243                                            spec->autocfg.speaker_pins[0],
4244                                            "Speaker");
4245         if (err < 0)
4246                 return err;
4247         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4248                                            "Headphone");
4249         if (err < 0)
4250                 return err;
4251         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
4252         if (err < 0)
4253                 return err;
4254
4255         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4256
4257         /* check multiple SPDIF-out (for recent codecs) */
4258         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4259                 hda_nid_t dig_nid;
4260                 err = snd_hda_get_connections(codec,
4261                                               spec->autocfg.dig_out_pins[i],
4262                                               &dig_nid, 1);
4263                 if (err < 0)
4264                         continue;
4265                 if (!i)
4266                         spec->multiout.dig_out_nid = dig_nid;
4267                 else {
4268                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4269                         spec->slave_dig_outs[i - 1] = dig_nid;
4270                         if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
4271                                 break;
4272                 }
4273         }
4274         if (spec->autocfg.dig_in_pin)
4275                 spec->dig_in_nid = ALC880_DIGIN_NID;
4276
4277         if (spec->kctls.list)
4278                 add_mixer(spec, spec->kctls.list);
4279
4280         add_verb(spec, alc880_volume_init_verbs);
4281
4282         spec->num_mux_defs = 1;
4283         spec->input_mux = &spec->private_imux[0];
4284
4285         return 1;
4286 }
4287
4288 /* additional initialization for auto-configuration model */
4289 static void alc880_auto_init(struct hda_codec *codec)
4290 {
4291         struct alc_spec *spec = codec->spec;
4292         alc880_auto_init_multi_out(codec);
4293         alc880_auto_init_extra_out(codec);
4294         alc880_auto_init_analog_input(codec);
4295         if (spec->unsol_event)
4296                 alc_inithook(codec);
4297 }
4298
4299 static void set_capture_mixer(struct alc_spec *spec)
4300 {
4301         static struct snd_kcontrol_new *caps[3] = {
4302                 alc_capture_mixer1,
4303                 alc_capture_mixer2,
4304                 alc_capture_mixer3,
4305         };
4306         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3)
4307                 spec->cap_mixer = caps[spec->num_adc_nids - 1];
4308 }
4309
4310 #define set_beep_amp(spec, nid, idx, dir) \
4311         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4312
4313 /*
4314  * OK, here we have finally the patch for ALC880
4315  */
4316
4317 static int patch_alc880(struct hda_codec *codec)
4318 {
4319         struct alc_spec *spec;
4320         int board_config;
4321         int err;
4322
4323         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4324         if (spec == NULL)
4325                 return -ENOMEM;
4326
4327         codec->spec = spec;
4328
4329         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4330                                                   alc880_models,
4331                                                   alc880_cfg_tbl);
4332         if (board_config < 0) {
4333                 printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
4334                        "trying auto-probe from BIOS...\n");
4335                 board_config = ALC880_AUTO;
4336         }
4337
4338         if (board_config == ALC880_AUTO) {
4339                 /* automatic parse from the BIOS config */
4340                 err = alc880_parse_auto_config(codec);
4341                 if (err < 0) {
4342                         alc_free(codec);
4343                         return err;
4344                 } else if (!err) {
4345                         printk(KERN_INFO
4346                                "hda_codec: Cannot set up configuration "
4347                                "from BIOS.  Using 3-stack mode...\n");
4348                         board_config = ALC880_3ST;
4349                 }
4350         }
4351
4352         err = snd_hda_attach_beep_device(codec, 0x1);
4353         if (err < 0) {
4354                 alc_free(codec);
4355                 return err;
4356         }
4357
4358         if (board_config != ALC880_AUTO)
4359                 setup_preset(spec, &alc880_presets[board_config]);
4360
4361         spec->stream_name_analog = "ALC880 Analog";
4362         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4363         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4364         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4365
4366         spec->stream_name_digital = "ALC880 Digital";
4367         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4368         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4369
4370         if (!spec->adc_nids && spec->input_mux) {
4371                 /* check whether NID 0x07 is valid */
4372                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4373                 /* get type */
4374                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
4375                 if (wcap != AC_WID_AUD_IN) {
4376                         spec->adc_nids = alc880_adc_nids_alt;
4377                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4378                 } else {
4379                         spec->adc_nids = alc880_adc_nids;
4380                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4381                 }
4382         }
4383         set_capture_mixer(spec);
4384         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4385
4386         spec->vmaster_nid = 0x0c;
4387
4388         codec->patch_ops = alc_patch_ops;
4389         if (board_config == ALC880_AUTO)
4390                 spec->init_hook = alc880_auto_init;
4391 #ifdef CONFIG_SND_HDA_POWER_SAVE
4392         if (!spec->loopback.amplist)
4393                 spec->loopback.amplist = alc880_loopbacks;
4394 #endif
4395         codec->proc_widget_hook = print_realtek_coef;
4396
4397         return 0;
4398 }
4399
4400
4401 /*
4402  * ALC260 support
4403  */
4404
4405 static hda_nid_t alc260_dac_nids[1] = {
4406         /* front */
4407         0x02,
4408 };
4409
4410 static hda_nid_t alc260_adc_nids[1] = {
4411         /* ADC0 */
4412         0x04,
4413 };
4414
4415 static hda_nid_t alc260_adc_nids_alt[1] = {
4416         /* ADC1 */
4417         0x05,
4418 };
4419
4420 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4421  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4422  */
4423 static hda_nid_t alc260_dual_adc_nids[2] = {
4424         /* ADC0, ADC1 */
4425         0x04, 0x05
4426 };
4427
4428 #define ALC260_DIGOUT_NID       0x03
4429 #define ALC260_DIGIN_NID        0x06
4430
4431 static struct hda_input_mux alc260_capture_source = {
4432         .num_items = 4,
4433         .items = {
4434                 { "Mic", 0x0 },
4435                 { "Front Mic", 0x1 },
4436                 { "Line", 0x2 },
4437                 { "CD", 0x4 },
4438         },
4439 };
4440
4441 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4442  * headphone jack and the internal CD lines since these are the only pins at
4443  * which audio can appear.  For flexibility, also allow the option of
4444  * recording the mixer output on the second ADC (ADC0 doesn't have a
4445  * connection to the mixer output).
4446  */
4447 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4448         {
4449                 .num_items = 3,
4450                 .items = {
4451                         { "Mic/Line", 0x0 },
4452                         { "CD", 0x4 },
4453                         { "Headphone", 0x2 },
4454                 },
4455         },
4456         {
4457                 .num_items = 4,
4458                 .items = {
4459                         { "Mic/Line", 0x0 },
4460                         { "CD", 0x4 },
4461                         { "Headphone", 0x2 },
4462                         { "Mixer", 0x5 },
4463                 },
4464         },
4465
4466 };
4467
4468 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4469  * the Fujitsu S702x, but jacks are marked differently.
4470  */
4471 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4472         {
4473                 .num_items = 4,
4474                 .items = {
4475                         { "Mic", 0x0 },
4476                         { "Line", 0x2 },
4477                         { "CD", 0x4 },
4478                         { "Headphone", 0x5 },
4479                 },
4480         },
4481         {
4482                 .num_items = 5,
4483                 .items = {
4484                         { "Mic", 0x0 },
4485                         { "Line", 0x2 },
4486                         { "CD", 0x4 },
4487                         { "Headphone", 0x6 },
4488                         { "Mixer", 0x5 },
4489                 },
4490         },
4491 };
4492
4493 /* Maxdata Favorit 100XS */
4494 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
4495         {
4496                 .num_items = 2,
4497                 .items = {
4498                         { "Line/Mic", 0x0 },
4499                         { "CD", 0x4 },
4500                 },
4501         },
4502         {
4503                 .num_items = 3,
4504                 .items = {
4505                         { "Line/Mic", 0x0 },
4506                         { "CD", 0x4 },
4507                         { "Mixer", 0x5 },
4508                 },
4509         },
4510 };
4511
4512 /*
4513  * This is just place-holder, so there's something for alc_build_pcms to look
4514  * at when it calculates the maximum number of channels. ALC260 has no mixer
4515  * element which allows changing the channel mode, so the verb list is
4516  * never used.
4517  */
4518 static struct hda_channel_mode alc260_modes[1] = {
4519         { 2, NULL },
4520 };
4521
4522
4523 /* Mixer combinations
4524  *
4525  * basic: base_output + input + pc_beep + capture
4526  * HP: base_output + input + capture_alt
4527  * HP_3013: hp_3013 + input + capture
4528  * fujitsu: fujitsu + capture
4529  * acer: acer + capture
4530  */
4531
4532 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4533         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4534         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4535         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4536         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4537         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4538         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4539         { } /* end */
4540 };
4541
4542 static struct snd_kcontrol_new alc260_input_mixer[] = {
4543         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4544         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4545         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4546         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4547         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4548         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4549         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4550         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4551         { } /* end */
4552 };
4553
4554 /* update HP, line and mono out pins according to the master switch */
4555 static void alc260_hp_master_update(struct hda_codec *codec,
4556                                     hda_nid_t hp, hda_nid_t line,
4557                                     hda_nid_t mono)
4558 {
4559         struct alc_spec *spec = codec->spec;
4560         unsigned int val = spec->master_sw ? PIN_HP : 0;
4561         /* change HP and line-out pins */
4562         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4563                             val);
4564         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4565                             val);
4566         /* mono (speaker) depending on the HP jack sense */
4567         val = (val && !spec->jack_present) ? PIN_OUT : 0;
4568         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4569                             val);
4570 }
4571
4572 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4573                                    struct snd_ctl_elem_value *ucontrol)
4574 {
4575         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4576         struct alc_spec *spec = codec->spec;
4577         *ucontrol->value.integer.value = spec->master_sw;
4578         return 0;
4579 }
4580
4581 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4582                                    struct snd_ctl_elem_value *ucontrol)
4583 {
4584         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4585         struct alc_spec *spec = codec->spec;
4586         int val = !!*ucontrol->value.integer.value;
4587         hda_nid_t hp, line, mono;
4588
4589         if (val == spec->master_sw)
4590                 return 0;
4591         spec->master_sw = val;
4592         hp = (kcontrol->private_value >> 16) & 0xff;
4593         line = (kcontrol->private_value >> 8) & 0xff;
4594         mono = kcontrol->private_value & 0xff;
4595         alc260_hp_master_update(codec, hp, line, mono);
4596         return 1;
4597 }
4598
4599 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4600         {
4601                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4602                 .name = "Master Playback Switch",
4603                 .info = snd_ctl_boolean_mono_info,
4604                 .get = alc260_hp_master_sw_get,
4605                 .put = alc260_hp_master_sw_put,
4606                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4607         },
4608         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4609         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4610         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4611         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4612         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4613                               HDA_OUTPUT),
4614         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4615         { } /* end */
4616 };
4617
4618 static struct hda_verb alc260_hp_unsol_verbs[] = {
4619         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4620         {},
4621 };
4622
4623 static void alc260_hp_automute(struct hda_codec *codec)
4624 {
4625         struct alc_spec *spec = codec->spec;
4626         unsigned int present;
4627
4628         present = snd_hda_codec_read(codec, 0x10, 0,
4629                                      AC_VERB_GET_PIN_SENSE, 0);
4630         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4631         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4632 }
4633
4634 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4635 {
4636         if ((res >> 26) == ALC880_HP_EVENT)
4637                 alc260_hp_automute(codec);
4638 }
4639
4640 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4641         {
4642                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4643                 .name = "Master Playback Switch",
4644                 .info = snd_ctl_boolean_mono_info,
4645                 .get = alc260_hp_master_sw_get,
4646                 .put = alc260_hp_master_sw_put,
4647                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
4648         },
4649         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4650         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4651         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4652         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4653         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4654         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4655         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4656         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4657         { } /* end */
4658 };
4659
4660 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4661         .ops = &snd_hda_bind_vol,
4662         .values = {
4663                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4664                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4665                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4666                 0
4667         },
4668 };
4669
4670 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4671         .ops = &snd_hda_bind_sw,
4672         .values = {
4673                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4674                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4675                 0
4676         },
4677 };
4678
4679 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4680         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4681         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4682         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4683         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4684         { } /* end */
4685 };
4686
4687 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4688         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4689         {},
4690 };
4691
4692 static void alc260_hp_3013_automute(struct hda_codec *codec)
4693 {
4694         struct alc_spec *spec = codec->spec;
4695         unsigned int present;
4696
4697         present = snd_hda_codec_read(codec, 0x15, 0,
4698                                      AC_VERB_GET_PIN_SENSE, 0);
4699         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4700         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
4701 }
4702
4703 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4704                                        unsigned int res)
4705 {
4706         if ((res >> 26) == ALC880_HP_EVENT)
4707                 alc260_hp_3013_automute(codec);
4708 }
4709
4710 static void alc260_hp_3012_automute(struct hda_codec *codec)
4711 {
4712         unsigned int present, bits;
4713
4714         present = snd_hda_codec_read(codec, 0x10, 0,
4715                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4716
4717         bits = present ? 0 : PIN_OUT;
4718         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4719                             bits);
4720         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4721                             bits);
4722         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4723                             bits);
4724 }
4725
4726 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4727                                        unsigned int res)
4728 {
4729         if ((res >> 26) == ALC880_HP_EVENT)
4730                 alc260_hp_3012_automute(codec);
4731 }
4732
4733 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
4734  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
4735  */
4736 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4737         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4738         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4739         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4740         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4741         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4742         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4743         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4744         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4745         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4746         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4747         { } /* end */
4748 };
4749
4750 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
4751  * versions of the ALC260 don't act on requests to enable mic bias from NID
4752  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
4753  * datasheet doesn't mention this restriction.  At this stage it's not clear
4754  * whether this behaviour is intentional or is a hardware bug in chip
4755  * revisions available in early 2006.  Therefore for now allow the
4756  * "Headphone Jack Mode" control to span all choices, but if it turns out
4757  * that the lack of mic bias for this NID is intentional we could change the
4758  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4759  *
4760  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4761  * don't appear to make the mic bias available from the "line" jack, even
4762  * though the NID used for this jack (0x14) can supply it.  The theory is
4763  * that perhaps Acer have included blocking capacitors between the ALC260
4764  * and the output jack.  If this turns out to be the case for all such
4765  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4766  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4767  *
4768  * The C20x Tablet series have a mono internal speaker which is controlled
4769  * via the chip's Mono sum widget and pin complex, so include the necessary
4770  * controls for such models.  On models without a "mono speaker" the control
4771  * won't do anything.
4772  */
4773 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4774         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4775         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4776         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4777         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4778                               HDA_OUTPUT),
4779         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4780                            HDA_INPUT),
4781         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4782         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4783         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4784         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4785         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4786         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4787         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4788         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4789         { } /* end */
4790 };
4791
4792 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
4793  */
4794 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
4795         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4796         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4797         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4798         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4799         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4800         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4801         { } /* end */
4802 };
4803
4804 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4805  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
4806  */
4807 static struct snd_kcontrol_new alc260_will_mixer[] = {
4808         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4809         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4810         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4811         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4812         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4813         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4814         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4815         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4816         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4817         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4818         { } /* end */
4819 };
4820
4821 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4822  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4823  */
4824 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4825         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4826         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4827         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4828         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4829         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4830         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4831         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4832         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4833         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4834         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4835         { } /* end */
4836 };
4837
4838 /*
4839  * initialization verbs
4840  */
4841 static struct hda_verb alc260_init_verbs[] = {
4842         /* Line In pin widget for input */
4843         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4844         /* CD pin widget for input */
4845         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4846         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4847         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4848         /* Mic2 (front panel) pin widget for input and vref at 80% */
4849         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4850         /* LINE-2 is used for line-out in rear */
4851         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4852         /* select line-out */
4853         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4854         /* LINE-OUT pin */
4855         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4856         /* enable HP */
4857         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4858         /* enable Mono */
4859         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4860         /* mute capture amp left and right */
4861         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4862         /* set connection select to line in (default select for this ADC) */
4863         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4864         /* mute capture amp left and right */
4865         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4866         /* set connection select to line in (default select for this ADC) */
4867         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4868         /* set vol=0 Line-Out mixer amp left and right */
4869         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4870         /* unmute pin widget amp left and right (no gain on this amp) */
4871         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4872         /* set vol=0 HP mixer amp left and right */
4873         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4874         /* unmute pin widget amp left and right (no gain on this amp) */
4875         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4876         /* set vol=0 Mono mixer amp left and right */
4877         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4878         /* unmute pin widget amp left and right (no gain on this amp) */
4879         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4880         /* unmute LINE-2 out pin */
4881         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4882         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4883          * Line In 2 = 0x03
4884          */
4885         /* mute analog inputs */
4886         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4887         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4888         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4889         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4890         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4891         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4892         /* mute Front out path */
4893         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4894         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4895         /* mute Headphone out path */
4896         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4897         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4898         /* mute Mono out path */
4899         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4900         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4901         { }
4902 };
4903
4904 #if 0 /* should be identical with alc260_init_verbs? */
4905 static struct hda_verb alc260_hp_init_verbs[] = {
4906         /* Headphone and output */
4907         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4908         /* mono output */
4909         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4910         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4911         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4912         /* Mic2 (front panel) pin widget for input and vref at 80% */
4913         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4914         /* Line In pin widget for input */
4915         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4916         /* Line-2 pin widget for output */
4917         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4918         /* CD pin widget for input */
4919         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4920         /* unmute amp left and right */
4921         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4922         /* set connection select to line in (default select for this ADC) */
4923         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4924         /* unmute Line-Out mixer amp left and right (volume = 0) */
4925         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4926         /* mute pin widget amp left and right (no gain on this amp) */
4927         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4928         /* unmute HP mixer amp left and right (volume = 0) */
4929         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4930         /* mute pin widget amp left and right (no gain on this amp) */
4931         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4932         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4933          * Line In 2 = 0x03
4934          */
4935         /* mute analog inputs */
4936         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4937         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4938         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4939         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4940         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4941         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4942         /* Unmute Front out path */
4943         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4944         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4945         /* Unmute Headphone out path */
4946         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4947         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4948         /* Unmute Mono out path */
4949         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4950         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4951         { }
4952 };
4953 #endif
4954
4955 static struct hda_verb alc260_hp_3013_init_verbs[] = {
4956         /* Line out and output */
4957         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4958         /* mono output */
4959         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4960         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4961         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4962         /* Mic2 (front panel) pin widget for input and vref at 80% */
4963         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4964         /* Line In pin widget for input */
4965         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4966         /* Headphone pin widget for output */
4967         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4968         /* CD pin widget for input */
4969         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4970         /* unmute amp left and right */
4971         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4972         /* set connection select to line in (default select for this ADC) */
4973         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4974         /* unmute Line-Out mixer amp left and right (volume = 0) */
4975         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4976         /* mute pin widget amp left and right (no gain on this amp) */
4977         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4978         /* unmute HP mixer amp left and right (volume = 0) */
4979         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4980         /* mute pin widget amp left and right (no gain on this amp) */
4981         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4982         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4983          * Line In 2 = 0x03
4984          */
4985         /* mute analog inputs */
4986         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4987         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4988         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4989         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4990         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4991         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4992         /* Unmute Front out path */
4993         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4994         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4995         /* Unmute Headphone out path */
4996         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4997         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4998         /* Unmute Mono out path */
4999         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5000         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5001         { }
5002 };
5003
5004 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5005  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5006  * audio = 0x16, internal speaker = 0x10.
5007  */
5008 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5009         /* Disable all GPIOs */
5010         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5011         /* Internal speaker is connected to headphone pin */
5012         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5013         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5014         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5015         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5016         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5017         /* Ensure all other unused pins are disabled and muted. */
5018         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5019         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5020         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5021         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5022         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5023         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5024         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5025         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5026
5027         /* Disable digital (SPDIF) pins */
5028         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5029         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5030
5031         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5032          * when acting as an output.
5033          */
5034         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5035
5036         /* Start with output sum widgets muted and their output gains at min */
5037         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5038         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5039         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5040         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5041         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5042         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5043         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5044         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5045         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5046
5047         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5048         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5049         /* Unmute Line1 pin widget output buffer since it starts as an output.
5050          * If the pin mode is changed by the user the pin mode control will
5051          * take care of enabling the pin's input/output buffers as needed.
5052          * Therefore there's no need to enable the input buffer at this
5053          * stage.
5054          */
5055         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5056         /* Unmute input buffer of pin widget used for Line-in (no equiv
5057          * mixer ctrl)
5058          */
5059         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5060
5061         /* Mute capture amp left and right */
5062         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5063         /* Set ADC connection select to match default mixer setting - line
5064          * in (on mic1 pin)
5065          */
5066         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5067
5068         /* Do the same for the second ADC: mute capture input amp and
5069          * set ADC connection to line in (on mic1 pin)
5070          */
5071         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5072         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5073
5074         /* Mute all inputs to mixer widget (even unconnected ones) */
5075         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5076         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5077         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5078         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5079         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5080         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5081         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5082         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5083
5084         { }
5085 };
5086
5087 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5088  * similar laptops (adapted from Fujitsu init verbs).
5089  */
5090 static struct hda_verb alc260_acer_init_verbs[] = {
5091         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5092          * the headphone jack.  Turn this on and rely on the standard mute
5093          * methods whenever the user wants to turn these outputs off.
5094          */
5095         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5096         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5097         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5098         /* Internal speaker/Headphone jack is connected to Line-out pin */
5099         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5100         /* Internal microphone/Mic jack is connected to Mic1 pin */
5101         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5102         /* Line In jack is connected to Line1 pin */
5103         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5104         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5105         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5106         /* Ensure all other unused pins are disabled and muted. */
5107         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5108         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5109         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5110         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5111         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5112         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5113         /* Disable digital (SPDIF) pins */
5114         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5115         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5116
5117         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5118          * bus when acting as outputs.
5119          */
5120         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5121         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5122
5123         /* Start with output sum widgets muted and their output gains at min */
5124         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5125         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5126         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5127         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5128         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5129         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5130         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5131         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5132         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5133
5134         /* Unmute Line-out pin widget amp left and right
5135          * (no equiv mixer ctrl)
5136          */
5137         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5138         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5139         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5140         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5141          * inputs. If the pin mode is changed by the user the pin mode control
5142          * will take care of enabling the pin's input/output buffers as needed.
5143          * Therefore there's no need to enable the input buffer at this
5144          * stage.
5145          */
5146         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5147         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5148
5149         /* Mute capture amp left and right */
5150         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5151         /* Set ADC connection select to match default mixer setting - mic
5152          * (on mic1 pin)
5153          */
5154         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5155
5156         /* Do similar with the second ADC: mute capture input amp and
5157          * set ADC connection to mic to match ALSA's default state.
5158          */
5159         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5160         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5161
5162         /* Mute all inputs to mixer widget (even unconnected ones) */
5163         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5164         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5165         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5166         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5167         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5168         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5169         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5170         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5171
5172         { }
5173 };
5174
5175 /* Initialisation sequence for Maxdata Favorit 100XS
5176  * (adapted from Acer init verbs).
5177  */
5178 static struct hda_verb alc260_favorit100_init_verbs[] = {
5179         /* GPIO 0 enables the output jack.
5180          * Turn this on and rely on the standard mute
5181          * methods whenever the user wants to turn these outputs off.
5182          */
5183         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5184         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5185         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5186         /* Line/Mic input jack is connected to Mic1 pin */
5187         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5188         /* Ensure all other unused pins are disabled and muted. */
5189         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5190         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5191         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5192         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5193         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5194         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5195         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5196         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5197         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5198         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5199         /* Disable digital (SPDIF) pins */
5200         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5201         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5202
5203         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5204          * bus when acting as outputs.
5205          */
5206         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5207         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5208
5209         /* Start with output sum widgets muted and their output gains at min */
5210         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5211         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5212         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5213         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5214         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5215         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5216         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5217         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5218         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5219
5220         /* Unmute Line-out pin widget amp left and right
5221          * (no equiv mixer ctrl)
5222          */
5223         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5224         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5225          * inputs. If the pin mode is changed by the user the pin mode control
5226          * will take care of enabling the pin's input/output buffers as needed.
5227          * Therefore there's no need to enable the input buffer at this
5228          * stage.
5229          */
5230         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5231
5232         /* Mute capture amp left and right */
5233         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5234         /* Set ADC connection select to match default mixer setting - mic
5235          * (on mic1 pin)
5236          */
5237         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5238
5239         /* Do similar with the second ADC: mute capture input amp and
5240          * set ADC connection to mic to match ALSA's default state.
5241          */
5242         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5243         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5244
5245         /* Mute all inputs to mixer widget (even unconnected ones) */
5246         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5247         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5248         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5249         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5250         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5251         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5252         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5253         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5254
5255         { }
5256 };
5257
5258 static struct hda_verb alc260_will_verbs[] = {
5259         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5260         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5261         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5262         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5263         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5264         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5265         {}
5266 };
5267
5268 static struct hda_verb alc260_replacer_672v_verbs[] = {
5269         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5270         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5271         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5272
5273         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5274         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5275         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5276
5277         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5278         {}
5279 };
5280
5281 /* toggle speaker-output according to the hp-jack state */
5282 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5283 {
5284         unsigned int present;
5285
5286         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5287         present = snd_hda_codec_read(codec, 0x0f, 0,
5288                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5289         if (present) {
5290                 snd_hda_codec_write_cache(codec, 0x01, 0,
5291                                           AC_VERB_SET_GPIO_DATA, 1);
5292                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5293                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5294                                           PIN_HP);
5295         } else {
5296                 snd_hda_codec_write_cache(codec, 0x01, 0,
5297                                           AC_VERB_SET_GPIO_DATA, 0);
5298                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5299                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5300                                           PIN_OUT);
5301         }
5302 }
5303
5304 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5305                                        unsigned int res)
5306 {
5307         if ((res >> 26) == ALC880_HP_EVENT)
5308                 alc260_replacer_672v_automute(codec);
5309 }
5310
5311 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5312         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5313         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5314         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5315         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5316         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5317         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5318         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5319         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5320         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5321         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5322         {}
5323 };
5324
5325 /* Test configuration for debugging, modelled after the ALC880 test
5326  * configuration.
5327  */
5328 #ifdef CONFIG_SND_DEBUG
5329 static hda_nid_t alc260_test_dac_nids[1] = {
5330         0x02,
5331 };
5332 static hda_nid_t alc260_test_adc_nids[2] = {
5333         0x04, 0x05,
5334 };
5335 /* For testing the ALC260, each input MUX needs its own definition since
5336  * the signal assignments are different.  This assumes that the first ADC
5337  * is NID 0x04.
5338  */
5339 static struct hda_input_mux alc260_test_capture_sources[2] = {
5340         {
5341                 .num_items = 7,
5342                 .items = {
5343                         { "MIC1 pin", 0x0 },
5344                         { "MIC2 pin", 0x1 },
5345                         { "LINE1 pin", 0x2 },
5346                         { "LINE2 pin", 0x3 },
5347                         { "CD pin", 0x4 },
5348                         { "LINE-OUT pin", 0x5 },
5349                         { "HP-OUT pin", 0x6 },
5350                 },
5351         },
5352         {
5353                 .num_items = 8,
5354                 .items = {
5355                         { "MIC1 pin", 0x0 },
5356                         { "MIC2 pin", 0x1 },
5357                         { "LINE1 pin", 0x2 },
5358                         { "LINE2 pin", 0x3 },
5359                         { "CD pin", 0x4 },
5360                         { "Mixer", 0x5 },
5361                         { "LINE-OUT pin", 0x6 },
5362                         { "HP-OUT pin", 0x7 },
5363                 },
5364         },
5365 };
5366 static struct snd_kcontrol_new alc260_test_mixer[] = {
5367         /* Output driver widgets */
5368         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5369         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5370         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5371         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5372         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5373         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5374
5375         /* Modes for retasking pin widgets
5376          * Note: the ALC260 doesn't seem to act on requests to enable mic
5377          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5378          * mention this restriction.  At this stage it's not clear whether
5379          * this behaviour is intentional or is a hardware bug in chip
5380          * revisions available at least up until early 2006.  Therefore for
5381          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5382          * choices, but if it turns out that the lack of mic bias for these
5383          * NIDs is intentional we could change their modes from
5384          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5385          */
5386         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5387         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5388         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5389         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5390         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5391         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5392
5393         /* Loopback mixer controls */
5394         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5395         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5396         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5397         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5398         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5399         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5400         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5401         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5402         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5403         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5404         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5405         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5406         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5407         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5408
5409         /* Controls for GPIO pins, assuming they are configured as outputs */
5410         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5411         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5412         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5413         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5414
5415         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5416          * is ambigious as to which NID is which; testing on laptops which
5417          * make this output available should provide clarification.
5418          */
5419         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5420         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5421
5422         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5423          * this output to turn on an external amplifier.
5424          */
5425         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5426         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5427
5428         { } /* end */
5429 };
5430 static struct hda_verb alc260_test_init_verbs[] = {
5431         /* Enable all GPIOs as outputs with an initial value of 0 */
5432         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5433         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5434         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5435
5436         /* Enable retasking pins as output, initially without power amp */
5437         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5438         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5439         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5440         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5441         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5442         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5443
5444         /* Disable digital (SPDIF) pins initially, but users can enable
5445          * them via a mixer switch.  In the case of SPDIF-out, this initverb
5446          * payload also sets the generation to 0, output to be in "consumer"
5447          * PCM format, copyright asserted, no pre-emphasis and no validity
5448          * control.
5449          */
5450         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5451         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5452
5453         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5454          * OUT1 sum bus when acting as an output.
5455          */
5456         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5457         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5458         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5459         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5460
5461         /* Start with output sum widgets muted and their output gains at min */
5462         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5463         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5464         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5465         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5466         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5467         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5468         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5469         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5470         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5471
5472         /* Unmute retasking pin widget output buffers since the default
5473          * state appears to be output.  As the pin mode is changed by the
5474          * user the pin mode control will take care of enabling the pin's
5475          * input/output buffers as needed.
5476          */
5477         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5478         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5479         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5480         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5481         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5482         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5483         /* Also unmute the mono-out pin widget */
5484         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5485
5486         /* Mute capture amp left and right */
5487         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5488         /* Set ADC connection select to match default mixer setting (mic1
5489          * pin)
5490          */
5491         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5492
5493         /* Do the same for the second ADC: mute capture input amp and
5494          * set ADC connection to mic1 pin
5495          */
5496         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5497         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5498
5499         /* Mute all inputs to mixer widget (even unconnected ones) */
5500         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5501         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5502         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5503         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5504         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5505         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5506         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5507         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5508
5509         { }
5510 };
5511 #endif
5512
5513 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
5514 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
5515
5516 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
5517 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
5518
5519 /*
5520  * for BIOS auto-configuration
5521  */
5522
5523 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5524                                         const char *pfx, int *vol_bits)
5525 {
5526         hda_nid_t nid_vol;
5527         unsigned long vol_val, sw_val;
5528         char name[32];
5529         int err;
5530
5531         if (nid >= 0x0f && nid < 0x11) {
5532                 nid_vol = nid - 0x7;
5533                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5534                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5535         } else if (nid == 0x11) {
5536                 nid_vol = nid - 0x7;
5537                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5538                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5539         } else if (nid >= 0x12 && nid <= 0x15) {
5540                 nid_vol = 0x08;
5541                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5542                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5543         } else
5544                 return 0; /* N/A */
5545
5546         if (!(*vol_bits & (1 << nid_vol))) {
5547                 /* first control for the volume widget */
5548                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5549                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5550                 if (err < 0)
5551                         return err;
5552                 *vol_bits |= (1 << nid_vol);
5553         }
5554         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5555         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5556         if (err < 0)
5557                 return err;
5558         return 1;
5559 }
5560
5561 /* add playback controls from the parsed DAC table */
5562 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5563                                              const struct auto_pin_cfg *cfg)
5564 {
5565         hda_nid_t nid;
5566         int err;
5567         int vols = 0;
5568
5569         spec->multiout.num_dacs = 1;
5570         spec->multiout.dac_nids = spec->private_dac_nids;
5571         spec->multiout.dac_nids[0] = 0x02;
5572
5573         nid = cfg->line_out_pins[0];
5574         if (nid) {
5575                 err = alc260_add_playback_controls(spec, nid, "Front", &vols);
5576                 if (err < 0)
5577                         return err;
5578         }
5579
5580         nid = cfg->speaker_pins[0];
5581         if (nid) {
5582                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
5583                 if (err < 0)
5584                         return err;
5585         }
5586
5587         nid = cfg->hp_pins[0];
5588         if (nid) {
5589                 err = alc260_add_playback_controls(spec, nid, "Headphone",
5590                                                    &vols);
5591                 if (err < 0)
5592                         return err;
5593         }
5594         return 0;
5595 }
5596
5597 /* create playback/capture controls for input pins */
5598 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5599                                                 const struct auto_pin_cfg *cfg)
5600 {
5601         struct hda_input_mux *imux = &spec->private_imux[0];
5602         int i, err, idx;
5603
5604         for (i = 0; i < AUTO_PIN_LAST; i++) {
5605                 if (cfg->input_pins[i] >= 0x12) {
5606                         idx = cfg->input_pins[i] - 0x12;
5607                         err = new_analog_input(spec, cfg->input_pins[i],
5608                                                auto_pin_cfg_labels[i], idx,
5609                                                0x07);
5610                         if (err < 0)
5611                                 return err;
5612                         imux->items[imux->num_items].label =
5613                                 auto_pin_cfg_labels[i];
5614                         imux->items[imux->num_items].index = idx;
5615                         imux->num_items++;
5616                 }
5617                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5618                         idx = cfg->input_pins[i] - 0x09;
5619                         err = new_analog_input(spec, cfg->input_pins[i],
5620                                                auto_pin_cfg_labels[i], idx,
5621                                                0x07);
5622                         if (err < 0)
5623                                 return err;
5624                         imux->items[imux->num_items].label =
5625                                 auto_pin_cfg_labels[i];
5626                         imux->items[imux->num_items].index = idx;
5627                         imux->num_items++;
5628                 }
5629         }
5630         return 0;
5631 }
5632
5633 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5634                                               hda_nid_t nid, int pin_type,
5635                                               int sel_idx)
5636 {
5637         alc_set_pin_output(codec, nid, pin_type);
5638         /* need the manual connection? */
5639         if (nid >= 0x12) {
5640                 int idx = nid - 0x12;
5641                 snd_hda_codec_write(codec, idx + 0x0b, 0,
5642                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
5643         }
5644 }
5645
5646 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5647 {
5648         struct alc_spec *spec = codec->spec;
5649         hda_nid_t nid;
5650
5651         alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
5652         nid = spec->autocfg.line_out_pins[0];
5653         if (nid) {
5654                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5655                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5656         }
5657
5658         nid = spec->autocfg.speaker_pins[0];
5659         if (nid)
5660                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5661
5662         nid = spec->autocfg.hp_pins[0];
5663         if (nid)
5664                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5665 }
5666
5667 #define ALC260_PIN_CD_NID               0x16
5668 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5669 {
5670         struct alc_spec *spec = codec->spec;
5671         int i;
5672
5673         for (i = 0; i < AUTO_PIN_LAST; i++) {
5674                 hda_nid_t nid = spec->autocfg.input_pins[i];
5675                 if (nid >= 0x12) {
5676                         alc_set_input_pin(codec, nid, i);
5677                         if (nid != ALC260_PIN_CD_NID &&
5678                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5679                                 snd_hda_codec_write(codec, nid, 0,
5680                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5681                                                     AMP_OUT_MUTE);
5682                 }
5683         }
5684 }
5685
5686 /*
5687  * generic initialization of ADC, input mixers and output mixers
5688  */
5689 static struct hda_verb alc260_volume_init_verbs[] = {
5690         /*
5691          * Unmute ADC0-1 and set the default input to mic-in
5692          */
5693         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5694         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5695         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5696         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5697
5698         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5699          * mixer widget
5700          * Note: PASD motherboards uses the Line In 2 as the input for
5701          * front panel mic (mic 2)
5702          */
5703         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5704         /* mute analog inputs */
5705         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5706         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5707         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5708         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5709         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5710
5711         /*
5712          * Set up output mixers (0x08 - 0x0a)
5713          */
5714         /* set vol=0 to output mixers */
5715         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5716         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5717         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5718         /* set up input amps for analog loopback */
5719         /* Amp Indices: DAC = 0, mixer = 1 */
5720         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5721         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5722         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5723         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5724         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5725         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5726
5727         { }
5728 };
5729
5730 static int alc260_parse_auto_config(struct hda_codec *codec)
5731 {
5732         struct alc_spec *spec = codec->spec;
5733         int err;
5734         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5735
5736         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5737                                            alc260_ignore);
5738         if (err < 0)
5739                 return err;
5740         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5741         if (err < 0)
5742                 return err;
5743         if (!spec->kctls.list)
5744                 return 0; /* can't find valid BIOS pin config */
5745         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5746         if (err < 0)
5747                 return err;
5748
5749         spec->multiout.max_channels = 2;
5750
5751         if (spec->autocfg.dig_outs)
5752                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5753         if (spec->kctls.list)
5754                 add_mixer(spec, spec->kctls.list);
5755
5756         add_verb(spec, alc260_volume_init_verbs);
5757
5758         spec->num_mux_defs = 1;
5759         spec->input_mux = &spec->private_imux[0];
5760
5761         return 1;
5762 }
5763
5764 /* additional initialization for auto-configuration model */
5765 static void alc260_auto_init(struct hda_codec *codec)
5766 {
5767         struct alc_spec *spec = codec->spec;
5768         alc260_auto_init_multi_out(codec);
5769         alc260_auto_init_analog_input(codec);
5770         if (spec->unsol_event)
5771                 alc_inithook(codec);
5772 }
5773
5774 #ifdef CONFIG_SND_HDA_POWER_SAVE
5775 static struct hda_amp_list alc260_loopbacks[] = {
5776         { 0x07, HDA_INPUT, 0 },
5777         { 0x07, HDA_INPUT, 1 },
5778         { 0x07, HDA_INPUT, 2 },
5779         { 0x07, HDA_INPUT, 3 },
5780         { 0x07, HDA_INPUT, 4 },
5781         { } /* end */
5782 };
5783 #endif
5784
5785 /*
5786  * ALC260 configurations
5787  */
5788 static const char *alc260_models[ALC260_MODEL_LAST] = {
5789         [ALC260_BASIC]          = "basic",
5790         [ALC260_HP]             = "hp",
5791         [ALC260_HP_3013]        = "hp-3013",
5792         [ALC260_HP_DC7600]      = "hp-dc7600",
5793         [ALC260_FUJITSU_S702X]  = "fujitsu",
5794         [ALC260_ACER]           = "acer",
5795         [ALC260_WILL]           = "will",
5796         [ALC260_REPLACER_672V]  = "replacer",
5797         [ALC260_FAVORIT100]     = "favorit100",
5798 #ifdef CONFIG_SND_DEBUG
5799         [ALC260_TEST]           = "test",
5800 #endif
5801         [ALC260_AUTO]           = "auto",
5802 };
5803
5804 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5805         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5806         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5807         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
5808         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5809         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5810         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5811         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
5812         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
5813         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5814         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5815         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5816         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5817         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5818         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5819         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5820         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5821         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5822         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5823         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5824         {}
5825 };
5826
5827 static struct alc_config_preset alc260_presets[] = {
5828         [ALC260_BASIC] = {
5829                 .mixers = { alc260_base_output_mixer,
5830                             alc260_input_mixer },
5831                 .init_verbs = { alc260_init_verbs },
5832                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5833                 .dac_nids = alc260_dac_nids,
5834                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5835                 .adc_nids = alc260_adc_nids,
5836                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5837                 .channel_mode = alc260_modes,
5838                 .input_mux = &alc260_capture_source,
5839         },
5840         [ALC260_HP] = {
5841                 .mixers = { alc260_hp_output_mixer,
5842                             alc260_input_mixer },
5843                 .init_verbs = { alc260_init_verbs,
5844                                 alc260_hp_unsol_verbs },
5845                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5846                 .dac_nids = alc260_dac_nids,
5847                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5848                 .adc_nids = alc260_adc_nids_alt,
5849                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5850                 .channel_mode = alc260_modes,
5851                 .input_mux = &alc260_capture_source,
5852                 .unsol_event = alc260_hp_unsol_event,
5853                 .init_hook = alc260_hp_automute,
5854         },
5855         [ALC260_HP_DC7600] = {
5856                 .mixers = { alc260_hp_dc7600_mixer,
5857                             alc260_input_mixer },
5858                 .init_verbs = { alc260_init_verbs,
5859                                 alc260_hp_dc7600_verbs },
5860                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5861                 .dac_nids = alc260_dac_nids,
5862                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5863                 .adc_nids = alc260_adc_nids_alt,
5864                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5865                 .channel_mode = alc260_modes,
5866                 .input_mux = &alc260_capture_source,
5867                 .unsol_event = alc260_hp_3012_unsol_event,
5868                 .init_hook = alc260_hp_3012_automute,
5869         },
5870         [ALC260_HP_3013] = {
5871                 .mixers = { alc260_hp_3013_mixer,
5872                             alc260_input_mixer },
5873                 .init_verbs = { alc260_hp_3013_init_verbs,
5874                                 alc260_hp_3013_unsol_verbs },
5875                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5876                 .dac_nids = alc260_dac_nids,
5877                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5878                 .adc_nids = alc260_adc_nids_alt,
5879                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5880                 .channel_mode = alc260_modes,
5881                 .input_mux = &alc260_capture_source,
5882                 .unsol_event = alc260_hp_3013_unsol_event,
5883                 .init_hook = alc260_hp_3013_automute,
5884         },
5885         [ALC260_FUJITSU_S702X] = {
5886                 .mixers = { alc260_fujitsu_mixer },
5887                 .init_verbs = { alc260_fujitsu_init_verbs },
5888                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5889                 .dac_nids = alc260_dac_nids,
5890                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5891                 .adc_nids = alc260_dual_adc_nids,
5892                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5893                 .channel_mode = alc260_modes,
5894                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5895                 .input_mux = alc260_fujitsu_capture_sources,
5896         },
5897         [ALC260_ACER] = {
5898                 .mixers = { alc260_acer_mixer },
5899                 .init_verbs = { alc260_acer_init_verbs },
5900                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5901                 .dac_nids = alc260_dac_nids,
5902                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5903                 .adc_nids = alc260_dual_adc_nids,
5904                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5905                 .channel_mode = alc260_modes,
5906                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5907                 .input_mux = alc260_acer_capture_sources,
5908         },
5909         [ALC260_FAVORIT100] = {
5910                 .mixers = { alc260_favorit100_mixer },
5911                 .init_verbs = { alc260_favorit100_init_verbs },
5912                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5913                 .dac_nids = alc260_dac_nids,
5914                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5915                 .adc_nids = alc260_dual_adc_nids,
5916                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5917                 .channel_mode = alc260_modes,
5918                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
5919                 .input_mux = alc260_favorit100_capture_sources,
5920         },
5921         [ALC260_WILL] = {
5922                 .mixers = { alc260_will_mixer },
5923                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
5924                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5925                 .dac_nids = alc260_dac_nids,
5926                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5927                 .adc_nids = alc260_adc_nids,
5928                 .dig_out_nid = ALC260_DIGOUT_NID,
5929                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5930                 .channel_mode = alc260_modes,
5931                 .input_mux = &alc260_capture_source,
5932         },
5933         [ALC260_REPLACER_672V] = {
5934                 .mixers = { alc260_replacer_672v_mixer },
5935                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
5936                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5937                 .dac_nids = alc260_dac_nids,
5938                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5939                 .adc_nids = alc260_adc_nids,
5940                 .dig_out_nid = ALC260_DIGOUT_NID,
5941                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5942                 .channel_mode = alc260_modes,
5943                 .input_mux = &alc260_capture_source,
5944                 .unsol_event = alc260_replacer_672v_unsol_event,
5945                 .init_hook = alc260_replacer_672v_automute,
5946         },
5947 #ifdef CONFIG_SND_DEBUG
5948         [ALC260_TEST] = {
5949                 .mixers = { alc260_test_mixer },
5950                 .init_verbs = { alc260_test_init_verbs },
5951                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
5952                 .dac_nids = alc260_test_dac_nids,
5953                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
5954                 .adc_nids = alc260_test_adc_nids,
5955                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5956                 .channel_mode = alc260_modes,
5957                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
5958                 .input_mux = alc260_test_capture_sources,
5959         },
5960 #endif
5961 };
5962
5963 static int patch_alc260(struct hda_codec *codec)
5964 {
5965         struct alc_spec *spec;
5966         int err, board_config;
5967
5968         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5969         if (spec == NULL)
5970                 return -ENOMEM;
5971
5972         codec->spec = spec;
5973
5974         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
5975                                                   alc260_models,
5976                                                   alc260_cfg_tbl);
5977         if (board_config < 0) {
5978                 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
5979                            "trying auto-probe from BIOS...\n");
5980                 board_config = ALC260_AUTO;
5981         }
5982
5983         if (board_config == ALC260_AUTO) {
5984                 /* automatic parse from the BIOS config */
5985                 err = alc260_parse_auto_config(codec);
5986                 if (err < 0) {
5987                         alc_free(codec);
5988                         return err;
5989                 } else if (!err) {
5990                         printk(KERN_INFO
5991                                "hda_codec: Cannot set up configuration "
5992                                "from BIOS.  Using base mode...\n");
5993                         board_config = ALC260_BASIC;
5994                 }
5995         }
5996
5997         err = snd_hda_attach_beep_device(codec, 0x1);
5998         if (err < 0) {
5999                 alc_free(codec);
6000                 return err;
6001         }
6002
6003         if (board_config != ALC260_AUTO)
6004                 setup_preset(spec, &alc260_presets[board_config]);
6005
6006         spec->stream_name_analog = "ALC260 Analog";
6007         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6008         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6009
6010         spec->stream_name_digital = "ALC260 Digital";
6011         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6012         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6013
6014         if (!spec->adc_nids && spec->input_mux) {
6015                 /* check whether NID 0x04 is valid */
6016                 unsigned int wcap = get_wcaps(codec, 0x04);
6017                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6018                 /* get type */
6019                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6020                         spec->adc_nids = alc260_adc_nids_alt;
6021                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6022                 } else {
6023                         spec->adc_nids = alc260_adc_nids;
6024                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6025                 }
6026         }
6027         set_capture_mixer(spec);
6028         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6029
6030         spec->vmaster_nid = 0x08;
6031
6032         codec->patch_ops = alc_patch_ops;
6033         if (board_config == ALC260_AUTO)
6034                 spec->init_hook = alc260_auto_init;
6035 #ifdef CONFIG_SND_HDA_POWER_SAVE
6036         if (!spec->loopback.amplist)
6037                 spec->loopback.amplist = alc260_loopbacks;
6038 #endif
6039         codec->proc_widget_hook = print_realtek_coef;
6040
6041         return 0;
6042 }
6043
6044
6045 /*
6046  * ALC882 support
6047  *
6048  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6049  * configuration.  Each pin widget can choose any input DACs and a mixer.
6050  * Each ADC is connected from a mixer of all inputs.  This makes possible
6051  * 6-channel independent captures.
6052  *
6053  * In addition, an independent DAC for the multi-playback (not used in this
6054  * driver yet).
6055  */
6056 #define ALC882_DIGOUT_NID       0x06
6057 #define ALC882_DIGIN_NID        0x0a
6058
6059 static struct hda_channel_mode alc882_ch_modes[1] = {
6060         { 8, NULL }
6061 };
6062
6063 static hda_nid_t alc882_dac_nids[4] = {
6064         /* front, rear, clfe, rear_surr */
6065         0x02, 0x03, 0x04, 0x05
6066 };
6067
6068 /* identical with ALC880 */
6069 #define alc882_adc_nids         alc880_adc_nids
6070 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6071
6072 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6073 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6074
6075 /* input MUX */
6076 /* FIXME: should be a matrix-type input source selection */
6077
6078 static struct hda_input_mux alc882_capture_source = {
6079         .num_items = 4,
6080         .items = {
6081                 { "Mic", 0x0 },
6082                 { "Front Mic", 0x1 },
6083                 { "Line", 0x2 },
6084                 { "CD", 0x4 },
6085         },
6086 };
6087 /*
6088  * 2ch mode
6089  */
6090 static struct hda_verb alc882_3ST_ch2_init[] = {
6091         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6092         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6093         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6094         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6095         { } /* end */
6096 };
6097
6098 /*
6099  * 6ch mode
6100  */
6101 static struct hda_verb alc882_3ST_ch6_init[] = {
6102         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6103         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6104         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6105         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6106         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6107         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6108         { } /* end */
6109 };
6110
6111 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
6112         { 2, alc882_3ST_ch2_init },
6113         { 6, alc882_3ST_ch6_init },
6114 };
6115
6116 /*
6117  * 6ch mode
6118  */
6119 static struct hda_verb alc882_sixstack_ch6_init[] = {
6120         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6121         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6122         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6123         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6124         { } /* end */
6125 };
6126
6127 /*
6128  * 8ch mode
6129  */
6130 static struct hda_verb alc882_sixstack_ch8_init[] = {
6131         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6132         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6133         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6134         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6135         { } /* end */
6136 };
6137
6138 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6139         { 6, alc882_sixstack_ch6_init },
6140         { 8, alc882_sixstack_ch8_init },
6141 };
6142
6143 /*
6144  * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
6145  */
6146
6147 /*
6148  * 2ch mode
6149  */
6150 static struct hda_verb alc885_mbp_ch2_init[] = {
6151         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6152         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6153         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6154         { } /* end */
6155 };
6156
6157 /*
6158  * 6ch mode
6159  */
6160 static struct hda_verb alc885_mbp_ch6_init[] = {
6161         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6162         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6163         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6164         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6165         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6166         { } /* end */
6167 };
6168
6169 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
6170         { 2, alc885_mbp_ch2_init },
6171         { 6, alc885_mbp_ch6_init },
6172 };
6173
6174
6175 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6176  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6177  */
6178 static struct snd_kcontrol_new alc882_base_mixer[] = {
6179         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6180         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6181         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6182         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6183         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6184         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6185         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6186         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6187         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6188         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6189         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6190         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6191         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6192         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6193         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6194         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6195         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6196         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6197         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6198         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6199         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6200         { } /* end */
6201 };
6202
6203 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
6204         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6205         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6206         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
6207         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6208         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6209         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6210         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
6211         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
6212         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
6213         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
6214         { } /* end */
6215 };
6216 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
6217         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6218         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6219         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6220         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6221         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6222         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6223         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6224         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6225         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6226         { } /* end */
6227 };
6228
6229 static struct snd_kcontrol_new alc882_targa_mixer[] = {
6230         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6231         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6232         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6233         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6234         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6235         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6236         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6237         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6238         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6239         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6240         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6241         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6242         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6243         { } /* end */
6244 };
6245
6246 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
6247  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
6248  */
6249 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
6250         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6251         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6252         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6253         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
6254         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6255         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6256         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6257         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6258         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
6259         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
6260         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6261         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6262         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6263         { } /* end */
6264 };
6265
6266 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
6267         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6268         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6269         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6270         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6271         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6272         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6273         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6274         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6275         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6276         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6277         { } /* end */
6278 };
6279
6280 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
6281         {
6282                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6283                 .name = "Channel Mode",
6284                 .info = alc_ch_mode_info,
6285                 .get = alc_ch_mode_get,
6286                 .put = alc_ch_mode_put,
6287         },
6288         { } /* end */
6289 };
6290
6291 static struct hda_verb alc882_init_verbs[] = {
6292         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6293         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6294         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6295         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6296         /* Rear mixer */
6297         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6298         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6299         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6300         /* CLFE mixer */
6301         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6302         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6303         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6304         /* Side mixer */
6305         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6306         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6307         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6308
6309         /* Front Pin: output 0 (0x0c) */
6310         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6311         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6312         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6313         /* Rear Pin: output 1 (0x0d) */
6314         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6315         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6316         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6317         /* CLFE Pin: output 2 (0x0e) */
6318         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6319         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6320         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
6321         /* Side Pin: output 3 (0x0f) */
6322         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6323         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6324         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
6325         /* Mic (rear) pin: input vref at 80% */
6326         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6327         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6328         /* Front Mic pin: input vref at 80% */
6329         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6330         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6331         /* Line In pin: input */
6332         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6333         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6334         /* Line-2 In: Headphone output (output 0 - 0x0c) */
6335         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6336         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6337         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
6338         /* CD pin widget for input */
6339         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6340
6341         /* FIXME: use matrix-type input source selection */
6342         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6343         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6344         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6345         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6346         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6347         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6348         /* Input mixer2 */
6349         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6350         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6351         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6352         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6353         /* Input mixer3 */
6354         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6355         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6356         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6357         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6358         /* ADC1: mute amp left and right */
6359         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6360         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6361         /* ADC2: mute amp left and right */
6362         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6363         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6364         /* ADC3: mute amp left and right */
6365         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6366         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6367
6368         { }
6369 };
6370
6371 static struct hda_verb alc882_eapd_verbs[] = {
6372         /* change to EAPD mode */
6373         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6374         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
6375         { }
6376 };
6377
6378 /* Mac Pro test */
6379 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
6380         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6381         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6382         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
6383         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
6384         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
6385         /* FIXME: this looks suspicious...
6386         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
6387         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
6388         */
6389         { } /* end */
6390 };
6391
6392 static struct hda_verb alc882_macpro_init_verbs[] = {
6393         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6394         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6395         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6396         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6397         /* Front Pin: output 0 (0x0c) */
6398         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6399         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6400         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6401         /* Front Mic pin: input vref at 80% */
6402         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6403         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6404         /* Speaker:  output */
6405         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6406         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6407         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
6408         /* Headphone output (output 0 - 0x0c) */
6409         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6410         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6411         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6412
6413         /* FIXME: use matrix-type input source selection */
6414         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6415         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6416         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6417         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6418         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6419         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6420         /* Input mixer2 */
6421         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6422         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6423         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6424         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6425         /* Input mixer3 */
6426         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6427         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6428         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6429         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6430         /* ADC1: mute amp left and right */
6431         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6432         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6433         /* ADC2: mute amp left and right */
6434         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6435         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6436         /* ADC3: mute amp left and right */
6437         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6438         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6439
6440         { }
6441 };
6442
6443 /* Macbook Pro rev3 */
6444 static struct hda_verb alc885_mbp3_init_verbs[] = {
6445         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6446         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6447         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6448         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6449         /* Rear mixer */
6450         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6451         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6452         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6453         /* Front Pin: output 0 (0x0c) */
6454         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6455         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6456         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6457         /* HP Pin: output 0 (0x0d) */
6458         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
6459         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6460         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6461         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6462         /* Mic (rear) pin: input vref at 80% */
6463         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6464         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6465         /* Front Mic pin: input vref at 80% */
6466         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6467         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6468         /* Line In pin: use output 1 when in LineOut mode */
6469         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6470         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6471         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
6472
6473         /* FIXME: use matrix-type input source selection */
6474         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6475         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6476         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6477         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6478         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6479         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6480         /* Input mixer2 */
6481         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6482         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6483         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6484         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6485         /* Input mixer3 */
6486         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6487         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6488         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6489         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6490         /* ADC1: mute amp left and right */
6491         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6492         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6493         /* ADC2: mute amp left and right */
6494         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6495         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6496         /* ADC3: mute amp left and right */
6497         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6498         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6499
6500         { }
6501 };
6502
6503 /* iMac 24 mixer. */
6504 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
6505         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6506         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
6507         { } /* end */
6508 };
6509
6510 /* iMac 24 init verbs. */
6511 static struct hda_verb alc885_imac24_init_verbs[] = {
6512         /* Internal speakers: output 0 (0x0c) */
6513         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6514         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6515         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6516         /* Internal speakers: output 0 (0x0c) */
6517         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6518         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6519         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
6520         /* Headphone: output 0 (0x0c) */
6521         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6522         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6523         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6524         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6525         /* Front Mic: input vref at 80% */
6526         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6527         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6528         { }
6529 };
6530
6531 /* Toggle speaker-output according to the hp-jack state */
6532 static void alc885_imac24_automute(struct hda_codec *codec)
6533 {
6534         unsigned int present;
6535
6536         present = snd_hda_codec_read(codec, 0x14, 0,
6537                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6538         snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
6539                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6540         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
6541                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6542 }
6543
6544 /* Processes unsolicited events. */
6545 static void alc885_imac24_unsol_event(struct hda_codec *codec,
6546                                       unsigned int res)
6547 {
6548         /* Headphone insertion or removal. */
6549         if ((res >> 26) == ALC880_HP_EVENT)
6550                 alc885_imac24_automute(codec);
6551 }
6552
6553 static void alc885_mbp3_automute(struct hda_codec *codec)
6554 {
6555         unsigned int present;
6556
6557         present = snd_hda_codec_read(codec, 0x15, 0,
6558                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6559         snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
6560                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6561         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
6562                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
6563
6564 }
6565 static void alc885_mbp3_unsol_event(struct hda_codec *codec,
6566                                     unsigned int res)
6567 {
6568         /* Headphone insertion or removal. */
6569         if ((res >> 26) == ALC880_HP_EVENT)
6570                 alc885_mbp3_automute(codec);
6571 }
6572
6573
6574 static struct hda_verb alc882_targa_verbs[] = {
6575         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6576         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6577
6578         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6579         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6580
6581         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6582         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6583         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6584
6585         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6586         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6587         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
6588         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
6589         { } /* end */
6590 };
6591
6592 /* toggle speaker-output according to the hp-jack state */
6593 static void alc882_targa_automute(struct hda_codec *codec)
6594 {
6595         unsigned int present;
6596
6597         present = snd_hda_codec_read(codec, 0x14, 0,
6598                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6599         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
6600                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6601         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
6602                                   present ? 1 : 3);
6603 }
6604
6605 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
6606 {
6607         /* Looks like the unsol event is incompatible with the standard
6608          * definition.  4bit tag is placed at 26 bit!
6609          */
6610         if (((res >> 26) == ALC880_HP_EVENT)) {
6611                 alc882_targa_automute(codec);
6612         }
6613 }
6614
6615 static struct hda_verb alc882_asus_a7j_verbs[] = {
6616         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6617         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6618
6619         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6620         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6621         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6622
6623         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6624         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6625         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6626
6627         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6628         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6629         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6630         { } /* end */
6631 };
6632
6633 static struct hda_verb alc882_asus_a7m_verbs[] = {
6634         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6635         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6636
6637         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6638         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6639         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6640
6641         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6642         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6643         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6644
6645         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6646         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6647         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6648         { } /* end */
6649 };
6650
6651 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
6652 {
6653         unsigned int gpiostate, gpiomask, gpiodir;
6654
6655         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
6656                                        AC_VERB_GET_GPIO_DATA, 0);
6657
6658         if (!muted)
6659                 gpiostate |= (1 << pin);
6660         else
6661                 gpiostate &= ~(1 << pin);
6662
6663         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
6664                                       AC_VERB_GET_GPIO_MASK, 0);
6665         gpiomask |= (1 << pin);
6666
6667         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
6668                                      AC_VERB_GET_GPIO_DIRECTION, 0);
6669         gpiodir |= (1 << pin);
6670
6671
6672         snd_hda_codec_write(codec, codec->afg, 0,
6673                             AC_VERB_SET_GPIO_MASK, gpiomask);
6674         snd_hda_codec_write(codec, codec->afg, 0,
6675                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
6676
6677         msleep(1);
6678
6679         snd_hda_codec_write(codec, codec->afg, 0,
6680                             AC_VERB_SET_GPIO_DATA, gpiostate);
6681 }
6682
6683 /* set up GPIO at initialization */
6684 static void alc885_macpro_init_hook(struct hda_codec *codec)
6685 {
6686         alc882_gpio_mute(codec, 0, 0);
6687         alc882_gpio_mute(codec, 1, 0);
6688 }
6689
6690 /* set up GPIO and update auto-muting at initialization */
6691 static void alc885_imac24_init_hook(struct hda_codec *codec)
6692 {
6693         alc885_macpro_init_hook(codec);
6694         alc885_imac24_automute(codec);
6695 }
6696
6697 /*
6698  * generic initialization of ADC, input mixers and output mixers
6699  */
6700 static struct hda_verb alc882_auto_init_verbs[] = {
6701         /*
6702          * Unmute ADC0-2 and set the default input to mic-in
6703          */
6704         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6705         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6706         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6707         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6708         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6709         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6710
6711         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6712          * mixer widget
6713          * Note: PASD motherboards uses the Line In 2 as the input for
6714          * front panel mic (mic 2)
6715          */
6716         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6717         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6718         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6719         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6720         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6721         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6722
6723         /*
6724          * Set up output mixers (0x0c - 0x0f)
6725          */
6726         /* set vol=0 to output mixers */
6727         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6728         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6729         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6730         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6731         /* set up input amps for analog loopback */
6732         /* Amp Indices: DAC = 0, mixer = 1 */
6733         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6734         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6735         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6736         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6737         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6738         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6739         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6740         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6741         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6742         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6743
6744         /* FIXME: use matrix-type input source selection */
6745         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6746         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6747         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6748         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6749         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6750         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6751         /* Input mixer2 */
6752         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6753         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6754         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6755         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6756         /* Input mixer3 */
6757         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6758         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6759         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6760         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6761
6762         { }
6763 };
6764
6765 #ifdef CONFIG_SND_HDA_POWER_SAVE
6766 #define alc882_loopbacks        alc880_loopbacks
6767 #endif
6768
6769 /* pcm configuration: identiacal with ALC880 */
6770 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
6771 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
6772 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
6773 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
6774
6775 /*
6776  * configuration and preset
6777  */
6778 static const char *alc882_models[ALC882_MODEL_LAST] = {
6779         [ALC882_3ST_DIG]        = "3stack-dig",
6780         [ALC882_6ST_DIG]        = "6stack-dig",
6781         [ALC882_ARIMA]          = "arima",
6782         [ALC882_W2JC]           = "w2jc",
6783         [ALC882_TARGA]          = "targa",
6784         [ALC882_ASUS_A7J]       = "asus-a7j",
6785         [ALC882_ASUS_A7M]       = "asus-a7m",
6786         [ALC885_MACPRO]         = "macpro",
6787         [ALC885_MBP3]           = "mbp3",
6788         [ALC885_IMAC24]         = "imac24",
6789         [ALC882_AUTO]           = "auto",
6790 };
6791
6792 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6793         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6794         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6795         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6796         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6797         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6798         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6799         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6800         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6801         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6802         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
6803         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6804         SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6805         {}
6806 };
6807
6808 static struct alc_config_preset alc882_presets[] = {
6809         [ALC882_3ST_DIG] = {
6810                 .mixers = { alc882_base_mixer },
6811                 .init_verbs = { alc882_init_verbs },
6812                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6813                 .dac_nids = alc882_dac_nids,
6814                 .dig_out_nid = ALC882_DIGOUT_NID,
6815                 .dig_in_nid = ALC882_DIGIN_NID,
6816                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6817                 .channel_mode = alc882_ch_modes,
6818                 .need_dac_fix = 1,
6819                 .input_mux = &alc882_capture_source,
6820         },
6821         [ALC882_6ST_DIG] = {
6822                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6823                 .init_verbs = { alc882_init_verbs },
6824                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6825                 .dac_nids = alc882_dac_nids,
6826                 .dig_out_nid = ALC882_DIGOUT_NID,
6827                 .dig_in_nid = ALC882_DIGIN_NID,
6828                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6829                 .channel_mode = alc882_sixstack_modes,
6830                 .input_mux = &alc882_capture_source,
6831         },
6832         [ALC882_ARIMA] = {
6833                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6834                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
6835                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6836                 .dac_nids = alc882_dac_nids,
6837                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6838                 .channel_mode = alc882_sixstack_modes,
6839                 .input_mux = &alc882_capture_source,
6840         },
6841         [ALC882_W2JC] = {
6842                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
6843                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6844                                 alc880_gpio1_init_verbs },
6845                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6846                 .dac_nids = alc882_dac_nids,
6847                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6848                 .channel_mode = alc880_threestack_modes,
6849                 .need_dac_fix = 1,
6850                 .input_mux = &alc882_capture_source,
6851                 .dig_out_nid = ALC882_DIGOUT_NID,
6852         },
6853         [ALC885_MBP3] = {
6854                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
6855                 .init_verbs = { alc885_mbp3_init_verbs,
6856                                 alc880_gpio1_init_verbs },
6857                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6858                 .dac_nids = alc882_dac_nids,
6859                 .channel_mode = alc885_mbp_6ch_modes,
6860                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6861                 .input_mux = &alc882_capture_source,
6862                 .dig_out_nid = ALC882_DIGOUT_NID,
6863                 .dig_in_nid = ALC882_DIGIN_NID,
6864                 .unsol_event = alc885_mbp3_unsol_event,
6865                 .init_hook = alc885_mbp3_automute,
6866         },
6867         [ALC885_MACPRO] = {
6868                 .mixers = { alc882_macpro_mixer },
6869                 .init_verbs = { alc882_macpro_init_verbs },
6870                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6871                 .dac_nids = alc882_dac_nids,
6872                 .dig_out_nid = ALC882_DIGOUT_NID,
6873                 .dig_in_nid = ALC882_DIGIN_NID,
6874                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6875                 .channel_mode = alc882_ch_modes,
6876                 .input_mux = &alc882_capture_source,
6877                 .init_hook = alc885_macpro_init_hook,
6878         },
6879         [ALC885_IMAC24] = {
6880                 .mixers = { alc885_imac24_mixer },
6881                 .init_verbs = { alc885_imac24_init_verbs },
6882                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6883                 .dac_nids = alc882_dac_nids,
6884                 .dig_out_nid = ALC882_DIGOUT_NID,
6885                 .dig_in_nid = ALC882_DIGIN_NID,
6886                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6887                 .channel_mode = alc882_ch_modes,
6888                 .input_mux = &alc882_capture_source,
6889                 .unsol_event = alc885_imac24_unsol_event,
6890                 .init_hook = alc885_imac24_init_hook,
6891         },
6892         [ALC882_TARGA] = {
6893                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
6894                 .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
6895                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6896                 .dac_nids = alc882_dac_nids,
6897                 .dig_out_nid = ALC882_DIGOUT_NID,
6898                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6899                 .adc_nids = alc882_adc_nids,
6900                 .capsrc_nids = alc882_capsrc_nids,
6901                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6902                 .channel_mode = alc882_3ST_6ch_modes,
6903                 .need_dac_fix = 1,
6904                 .input_mux = &alc882_capture_source,
6905                 .unsol_event = alc882_targa_unsol_event,
6906                 .init_hook = alc882_targa_automute,
6907         },
6908         [ALC882_ASUS_A7J] = {
6909                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
6910                 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
6911                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6912                 .dac_nids = alc882_dac_nids,
6913                 .dig_out_nid = ALC882_DIGOUT_NID,
6914                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6915                 .adc_nids = alc882_adc_nids,
6916                 .capsrc_nids = alc882_capsrc_nids,
6917                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6918                 .channel_mode = alc882_3ST_6ch_modes,
6919                 .need_dac_fix = 1,
6920                 .input_mux = &alc882_capture_source,
6921         },
6922         [ALC882_ASUS_A7M] = {
6923                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
6924                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6925                                 alc880_gpio1_init_verbs,
6926                                 alc882_asus_a7m_verbs },
6927                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6928                 .dac_nids = alc882_dac_nids,
6929                 .dig_out_nid = ALC882_DIGOUT_NID,
6930                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6931                 .channel_mode = alc880_threestack_modes,
6932                 .need_dac_fix = 1,
6933                 .input_mux = &alc882_capture_source,
6934         },
6935 };
6936
6937
6938 /*
6939  * Pin config fixes
6940  */
6941 enum {
6942         PINFIX_ABIT_AW9D_MAX
6943 };
6944
6945 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
6946         { 0x15, 0x01080104 }, /* side */
6947         { 0x16, 0x01011012 }, /* rear */
6948         { 0x17, 0x01016011 }, /* clfe */
6949         { }
6950 };
6951
6952 static const struct alc_pincfg *alc882_pin_fixes[] = {
6953         [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
6954 };
6955
6956 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
6957         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
6958         {}
6959 };
6960
6961 /*
6962  * BIOS auto configuration
6963  */
6964 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
6965                                               hda_nid_t nid, int pin_type,
6966                                               int dac_idx)
6967 {
6968         /* set as output */
6969         struct alc_spec *spec = codec->spec;
6970         int idx;
6971
6972         alc_set_pin_output(codec, nid, pin_type);
6973         if (spec->multiout.dac_nids[dac_idx] == 0x25)
6974                 idx = 4;
6975         else
6976                 idx = spec->multiout.dac_nids[dac_idx] - 2;
6977         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
6978
6979 }
6980
6981 static void alc882_auto_init_multi_out(struct hda_codec *codec)
6982 {
6983         struct alc_spec *spec = codec->spec;
6984         int i;
6985
6986         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
6987         for (i = 0; i <= HDA_SIDE; i++) {
6988                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
6989                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6990                 if (nid)
6991                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
6992                                                           i);
6993         }
6994 }
6995
6996 static void alc882_auto_init_hp_out(struct hda_codec *codec)
6997 {
6998         struct alc_spec *spec = codec->spec;
6999         hda_nid_t pin;
7000
7001         pin = spec->autocfg.hp_pins[0];
7002         if (pin) /* connect to front */
7003                 /* use dac 0 */
7004                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
7005         pin = spec->autocfg.speaker_pins[0];
7006         if (pin)
7007                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
7008 }
7009
7010 #define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
7011 #define ALC882_PIN_CD_NID               ALC880_PIN_CD_NID
7012
7013 static void alc882_auto_init_analog_input(struct hda_codec *codec)
7014 {
7015         struct alc_spec *spec = codec->spec;
7016         int i;
7017
7018         for (i = 0; i < AUTO_PIN_LAST; i++) {
7019                 hda_nid_t nid = spec->autocfg.input_pins[i];
7020                 if (!nid)
7021                         continue;
7022                 alc_set_input_pin(codec, nid, AUTO_PIN_FRONT_MIC /*i*/);
7023                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
7024                         snd_hda_codec_write(codec, nid, 0,
7025                                             AC_VERB_SET_AMP_GAIN_MUTE,
7026                                             AMP_OUT_MUTE);
7027         }
7028 }
7029
7030 static void alc882_auto_init_input_src(struct hda_codec *codec)
7031 {
7032         struct alc_spec *spec = codec->spec;
7033         int c;
7034
7035         for (c = 0; c < spec->num_adc_nids; c++) {
7036                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
7037                 hda_nid_t nid = spec->capsrc_nids[c];
7038                 unsigned int mux_idx;
7039                 const struct hda_input_mux *imux;
7040                 int conns, mute, idx, item;
7041
7042                 conns = snd_hda_get_connections(codec, nid, conn_list,
7043                                                 ARRAY_SIZE(conn_list));
7044                 if (conns < 0)
7045                         continue;
7046                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
7047                 imux = &spec->input_mux[mux_idx];
7048                 for (idx = 0; idx < conns; idx++) {
7049                         /* if the current connection is the selected one,
7050                          * unmute it as default - otherwise mute it
7051                          */
7052                         mute = AMP_IN_MUTE(idx);
7053                         for (item = 0; item < imux->num_items; item++) {
7054                                 if (imux->items[item].index == idx) {
7055                                         if (spec->cur_mux[c] == item)
7056                                                 mute = AMP_IN_UNMUTE(idx);
7057                                         break;
7058                                 }
7059                         }
7060                         /* check if we have a selector or mixer
7061                          * we could check for the widget type instead, but
7062                          * just check for Amp-In presence (in case of mixer
7063                          * without amp-in there is something wrong, this
7064                          * function shouldn't be used or capsrc nid is wrong)
7065                          */
7066                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
7067                                 snd_hda_codec_write(codec, nid, 0,
7068                                                     AC_VERB_SET_AMP_GAIN_MUTE,
7069                                                     mute);
7070                         else if (mute != AMP_IN_MUTE(idx))
7071                                 snd_hda_codec_write(codec, nid, 0,
7072                                                     AC_VERB_SET_CONNECT_SEL,
7073                                                     idx);
7074                 }
7075         }
7076 }
7077
7078 /* add mic boosts if needed */
7079 static int alc_auto_add_mic_boost(struct hda_codec *codec)
7080 {
7081         struct alc_spec *spec = codec->spec;
7082         int err;
7083         hda_nid_t nid;
7084
7085         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
7086         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
7087                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
7088                                   "Mic Boost",
7089                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
7090                 if (err < 0)
7091                         return err;
7092         }
7093         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
7094         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
7095                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
7096                                   "Front Mic Boost",
7097                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
7098                 if (err < 0)
7099                         return err;
7100         }
7101         return 0;
7102 }
7103
7104 /* almost identical with ALC880 parser... */
7105 static int alc882_parse_auto_config(struct hda_codec *codec)
7106 {
7107         struct alc_spec *spec = codec->spec;
7108         int err = alc880_parse_auto_config(codec);
7109
7110         if (err < 0)
7111                 return err;
7112         else if (!err)
7113                 return 0; /* no config found */
7114
7115         err = alc_auto_add_mic_boost(codec);
7116         if (err < 0)
7117                 return err;
7118
7119         /* hack - override the init verbs */
7120         spec->init_verbs[0] = alc882_auto_init_verbs;
7121
7122         return 1; /* config found */
7123 }
7124
7125 /* additional initialization for auto-configuration model */
7126 static void alc882_auto_init(struct hda_codec *codec)
7127 {
7128         struct alc_spec *spec = codec->spec;
7129         alc882_auto_init_multi_out(codec);
7130         alc882_auto_init_hp_out(codec);
7131         alc882_auto_init_analog_input(codec);
7132         alc882_auto_init_input_src(codec);
7133         if (spec->unsol_event)
7134                 alc_inithook(codec);
7135 }
7136
7137 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
7138
7139 static int patch_alc882(struct hda_codec *codec)
7140 {
7141         struct alc_spec *spec;
7142         int err, board_config;
7143
7144         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7145         if (spec == NULL)
7146                 return -ENOMEM;
7147
7148         codec->spec = spec;
7149
7150         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
7151                                                   alc882_models,
7152                                                   alc882_cfg_tbl);
7153
7154         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
7155                 /* Pick up systems that don't supply PCI SSID */
7156                 switch (codec->subsystem_id) {
7157                 case 0x106b0c00: /* Mac Pro */
7158                         board_config = ALC885_MACPRO;
7159                         break;
7160                 case 0x106b1000: /* iMac 24 */
7161                 case 0x106b2800: /* AppleTV */
7162                 case 0x106b3e00: /* iMac 24 Aluminium */
7163                         board_config = ALC885_IMAC24;
7164                         break;
7165                 case 0x106b00a0: /* MacBookPro3,1 - Another revision */
7166                 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
7167                 case 0x106b00a4: /* MacbookPro4,1 */
7168                 case 0x106b2c00: /* Macbook Pro rev3 */
7169                 case 0x106b3600: /* Macbook 3.1 */
7170                 case 0x106b3800: /* MacbookPro4,1 - latter revision */
7171                         board_config = ALC885_MBP3;
7172                         break;
7173                 default:
7174                         /* ALC889A is handled better as ALC888-compatible */
7175                         if (codec->revision_id == 0x100101 ||
7176                             codec->revision_id == 0x100103) {
7177                                 alc_free(codec);
7178                                 return patch_alc883(codec);
7179                         }
7180                         printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
7181                                          "trying auto-probe from BIOS...\n");
7182                         board_config = ALC882_AUTO;
7183                 }
7184         }
7185
7186         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
7187
7188         if (board_config == ALC882_AUTO) {
7189                 /* automatic parse from the BIOS config */
7190                 err = alc882_parse_auto_config(codec);
7191                 if (err < 0) {
7192                         alc_free(codec);
7193                         return err;
7194                 } else if (!err) {
7195                         printk(KERN_INFO
7196                                "hda_codec: Cannot set up configuration "
7197                                "from BIOS.  Using base mode...\n");
7198                         board_config = ALC882_3ST_DIG;
7199                 }
7200         }
7201
7202         err = snd_hda_attach_beep_device(codec, 0x1);
7203         if (err < 0) {
7204                 alc_free(codec);
7205                 return err;
7206         }
7207
7208         if (board_config != ALC882_AUTO)
7209                 setup_preset(spec, &alc882_presets[board_config]);
7210
7211         if (codec->vendor_id == 0x10ec0885) {
7212                 spec->stream_name_analog = "ALC885 Analog";
7213                 spec->stream_name_digital = "ALC885 Digital";
7214         } else {
7215                 spec->stream_name_analog = "ALC882 Analog";
7216                 spec->stream_name_digital = "ALC882 Digital";
7217         }
7218
7219         spec->stream_analog_playback = &alc882_pcm_analog_playback;
7220         spec->stream_analog_capture = &alc882_pcm_analog_capture;
7221         /* FIXME: setup DAC5 */
7222         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
7223         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
7224
7225         spec->stream_digital_playback = &alc882_pcm_digital_playback;
7226         spec->stream_digital_capture = &alc882_pcm_digital_capture;
7227
7228         spec->capture_style = CAPT_MIX; /* matrix-style capture */
7229         if (!spec->adc_nids && spec->input_mux) {
7230                 /* check whether NID 0x07 is valid */
7231                 unsigned int wcap = get_wcaps(codec, 0x07);
7232                 /* get type */
7233                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
7234                 if (wcap != AC_WID_AUD_IN) {
7235                         spec->adc_nids = alc882_adc_nids_alt;
7236                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
7237                         spec->capsrc_nids = alc882_capsrc_nids_alt;
7238                 } else {
7239                         spec->adc_nids = alc882_adc_nids;
7240                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
7241                         spec->capsrc_nids = alc882_capsrc_nids;
7242                 }
7243         }
7244         set_capture_mixer(spec);
7245         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
7246
7247         spec->vmaster_nid = 0x0c;
7248
7249         codec->patch_ops = alc_patch_ops;
7250         if (board_config == ALC882_AUTO)
7251                 spec->init_hook = alc882_auto_init;
7252 #ifdef CONFIG_SND_HDA_POWER_SAVE
7253         if (!spec->loopback.amplist)
7254                 spec->loopback.amplist = alc882_loopbacks;
7255 #endif
7256         codec->proc_widget_hook = print_realtek_coef;
7257
7258         return 0;
7259 }
7260
7261 /*
7262  * ALC883 support
7263  *
7264  * ALC883 is almost identical with ALC880 but has cleaner and more flexible
7265  * configuration.  Each pin widget can choose any input DACs and a mixer.
7266  * Each ADC is connected from a mixer of all inputs.  This makes possible
7267  * 6-channel independent captures.
7268  *
7269  * In addition, an independent DAC for the multi-playback (not used in this
7270  * driver yet).
7271  */
7272 #define ALC883_DIGOUT_NID       0x06
7273 #define ALC883_DIGIN_NID        0x0a
7274
7275 #define ALC1200_DIGOUT_NID      0x10
7276
7277 static hda_nid_t alc883_dac_nids[4] = {
7278         /* front, rear, clfe, rear_surr */
7279         0x02, 0x03, 0x04, 0x05
7280 };
7281
7282 static hda_nid_t alc883_adc_nids[2] = {
7283         /* ADC1-2 */
7284         0x08, 0x09,
7285 };
7286
7287 static hda_nid_t alc883_adc_nids_alt[1] = {
7288         /* ADC1 */
7289         0x08,
7290 };
7291
7292 static hda_nid_t alc883_adc_nids_rev[2] = {
7293         /* ADC2-1 */
7294         0x09, 0x08
7295 };
7296
7297 #define alc889_adc_nids         alc880_adc_nids
7298
7299 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
7300
7301 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7302
7303 #define alc889_capsrc_nids      alc882_capsrc_nids
7304
7305 /* input MUX */
7306 /* FIXME: should be a matrix-type input source selection */
7307
7308 static struct hda_input_mux alc883_capture_source = {
7309         .num_items = 4,
7310         .items = {
7311                 { "Mic", 0x0 },
7312                 { "Front Mic", 0x1 },
7313                 { "Line", 0x2 },
7314                 { "CD", 0x4 },
7315         },
7316 };
7317
7318 static struct hda_input_mux alc883_3stack_6ch_intel = {
7319         .num_items = 4,
7320         .items = {
7321                 { "Mic", 0x1 },
7322                 { "Front Mic", 0x0 },
7323                 { "Line", 0x2 },
7324                 { "CD", 0x4 },
7325         },
7326 };
7327
7328 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7329         .num_items = 2,
7330         .items = {
7331                 { "Mic", 0x1 },
7332                 { "Line", 0x2 },
7333         },
7334 };
7335
7336 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7337         .num_items = 4,
7338         .items = {
7339                 { "Mic", 0x0 },
7340                 { "iMic", 0x1 },
7341                 { "Line", 0x2 },
7342                 { "CD", 0x4 },
7343         },
7344 };
7345
7346 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7347         .num_items = 2,
7348         .items = {
7349                 { "Mic", 0x0 },
7350                 { "Int Mic", 0x1 },
7351         },
7352 };
7353
7354 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7355         .num_items = 3,
7356         .items = {
7357                 { "Mic", 0x0 },
7358                 { "Front Mic", 0x1 },
7359                 { "Line", 0x4 },
7360         },
7361 };
7362
7363 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7364         .num_items = 2,
7365         .items = {
7366                 { "Mic", 0x0 },
7367                 { "Line", 0x2 },
7368         },
7369 };
7370
7371 /*
7372  * 2ch mode
7373  */
7374 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7375         { 2, NULL }
7376 };
7377
7378 /*
7379  * 2ch mode
7380  */
7381 static struct hda_verb alc883_3ST_ch2_init[] = {
7382         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7383         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7384         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7385         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7386         { } /* end */
7387 };
7388
7389 /*
7390  * 4ch mode
7391  */
7392 static struct hda_verb alc883_3ST_ch4_init[] = {
7393         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7394         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7395         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7396         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7397         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7398         { } /* end */
7399 };
7400
7401 /*
7402  * 6ch mode
7403  */
7404 static struct hda_verb alc883_3ST_ch6_init[] = {
7405         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7406         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7407         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7408         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7409         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7410         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7411         { } /* end */
7412 };
7413
7414 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
7415         { 2, alc883_3ST_ch2_init },
7416         { 4, alc883_3ST_ch4_init },
7417         { 6, alc883_3ST_ch6_init },
7418 };
7419
7420 /*
7421  * 2ch mode
7422  */
7423 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7424         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7425         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7426         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7427         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7428         { } /* end */
7429 };
7430
7431 /*
7432  * 4ch mode
7433  */
7434 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7435         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7436         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7437         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7438         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7439         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7440         { } /* end */
7441 };
7442
7443 /*
7444  * 6ch mode
7445  */
7446 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7447         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7448         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7449         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7450         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7451         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7452         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7453         { } /* end */
7454 };
7455
7456 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7457         { 2, alc883_3ST_ch2_intel_init },
7458         { 4, alc883_3ST_ch4_intel_init },
7459         { 6, alc883_3ST_ch6_intel_init },
7460 };
7461
7462 /*
7463  * 6ch mode
7464  */
7465 static struct hda_verb alc883_sixstack_ch6_init[] = {
7466         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7467         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7468         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7469         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7470         { } /* end */
7471 };
7472
7473 /*
7474  * 8ch mode
7475  */
7476 static struct hda_verb alc883_sixstack_ch8_init[] = {
7477         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7478         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7479         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7480         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7481         { } /* end */
7482 };
7483
7484 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7485         { 6, alc883_sixstack_ch6_init },
7486         { 8, alc883_sixstack_ch8_init },
7487 };
7488
7489 static struct hda_verb alc883_medion_eapd_verbs[] = {
7490         /* eanable EAPD on medion laptop */
7491         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7492         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7493         { }
7494 };
7495
7496 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7497  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7498  */
7499
7500 static struct snd_kcontrol_new alc883_base_mixer[] = {
7501         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7502         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7503         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7504         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7505         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7506         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7507         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7508         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7509         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7510         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7511         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7512         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7513         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7514         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7515         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7516         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7517         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7518         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7519         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7520         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7521         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7522         { } /* end */
7523 };
7524
7525 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7526         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7527         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7528         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7529         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7530         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7531         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7532         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7533         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7534         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7535         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7536         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7537         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7538         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7539         { } /* end */
7540 };
7541
7542 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7543         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7544         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7545         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7546         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7547         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7548         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7549         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7550         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7551         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7552         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7553         { } /* end */
7554 };
7555
7556 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7557         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7558         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7559         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7560         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7561         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7562         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7563         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7564         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7565         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7566         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7567         { } /* end */
7568 };
7569
7570 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7571         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7572         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7573         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7574         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7575         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7576         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7577         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7578         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7579         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7580         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7581         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7582         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7583         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7584         { } /* end */
7585 };
7586
7587 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7588         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7589         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7590         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7591         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7592         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7593         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7594         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7595         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7596         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7597         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7598         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7599         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7600         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7601         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7602         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7603         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7604         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7605         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7606         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7607         { } /* end */
7608 };
7609
7610 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7611         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7612         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7613         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7614         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7615         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7616                               HDA_OUTPUT),
7617         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7618         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7619         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7620         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7621         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7622         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7623         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7624         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7625         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7626         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7627         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7628         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7629         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7630         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7631         { } /* end */
7632 };
7633
7634 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7635         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7636         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7637         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7638         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7639         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7640         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7641         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7642         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7643         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7644         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7645         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7646         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7647         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7648         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7649         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7650         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7651         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7652         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7653         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7654         { } /* end */
7655 };
7656
7657 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7658         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7659         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7660         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7661         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7662         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7663         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7664         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7665         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7666         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7667         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7668         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7669         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7670         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7671         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7672         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7673         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7674         { } /* end */
7675 };
7676
7677 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7678         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7679         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7680         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7681         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7682         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7683         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7684         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7685         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7686         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7687         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7688         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7689         { } /* end */
7690 };
7691
7692 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7693         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7694         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7695         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7696         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7697         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7698         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7699         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7700         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7701         { } /* end */
7702 };
7703
7704 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7705         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7706         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7707         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7708         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7709         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7710         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7711         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7712         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7713         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7714         { } /* end */
7715 };
7716
7717 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7718         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7719         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7720         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7721         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7722         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7723         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7724         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7725         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7726         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7727         { } /* end */
7728 };
7729
7730 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7731         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7732         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7733         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7734         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7735         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7736         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7737         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7738         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7739         { } /* end */
7740 };
7741
7742 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7743         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7744         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7745         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7746         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7747         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7748                                                 0x0d, 1, 0x0, HDA_OUTPUT),
7749         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7750         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7751         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7752         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7753         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7754         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7755         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
7756         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7757         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7758         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7759         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7760         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7761         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7762         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7763         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7764         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7765         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7766         { } /* end */
7767 };
7768
7769 static struct hda_bind_ctls alc883_bind_cap_vol = {
7770         .ops = &snd_hda_bind_vol,
7771         .values = {
7772                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7773                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7774                 0
7775         },
7776 };
7777
7778 static struct hda_bind_ctls alc883_bind_cap_switch = {
7779         .ops = &snd_hda_bind_sw,
7780         .values = {
7781                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7782                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7783                 0
7784         },
7785 };
7786
7787 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
7788         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7789         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7790         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7791         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7792         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7793         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7794         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7795         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7796         { } /* end */
7797 };
7798
7799 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
7800         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
7801         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
7802         {
7803                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7804                 /* .name = "Capture Source", */
7805                 .name = "Input Source",
7806                 .count = 1,
7807                 .info = alc_mux_enum_info,
7808                 .get = alc_mux_enum_get,
7809                 .put = alc_mux_enum_put,
7810         },
7811         { } /* end */
7812 };
7813
7814 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7815         {
7816                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7817                 .name = "Channel Mode",
7818                 .info = alc_ch_mode_info,
7819                 .get = alc_ch_mode_get,
7820                 .put = alc_ch_mode_put,
7821         },
7822         { } /* end */
7823 };
7824
7825 static struct hda_verb alc883_init_verbs[] = {
7826         /* ADC1: mute amp left and right */
7827         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7828         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7829         /* ADC2: mute amp left and right */
7830         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7831         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7832         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7833         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7834         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7835         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7836         /* Rear mixer */
7837         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7838         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7839         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7840         /* CLFE mixer */
7841         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7842         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7843         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7844         /* Side mixer */
7845         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7846         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7847         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7848
7849         /* mute analog input loopbacks */
7850         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7851         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7852         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7853         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7854         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7855
7856         /* Front Pin: output 0 (0x0c) */
7857         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7858         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7859         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7860         /* Rear Pin: output 1 (0x0d) */
7861         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7862         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7863         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7864         /* CLFE Pin: output 2 (0x0e) */
7865         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7866         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7867         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7868         /* Side Pin: output 3 (0x0f) */
7869         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7870         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7871         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7872         /* Mic (rear) pin: input vref at 80% */
7873         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7874         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7875         /* Front Mic pin: input vref at 80% */
7876         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7877         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7878         /* Line In pin: input */
7879         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7880         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7881         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7882         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7883         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7884         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7885         /* CD pin widget for input */
7886         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7887
7888         /* FIXME: use matrix-type input source selection */
7889         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7890         /* Input mixer2 */
7891         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7892         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7893         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7894         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7895         /* Input mixer3 */
7896         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7897         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7898         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7899         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7900         { }
7901 };
7902
7903 /* toggle speaker-output according to the hp-jack state */
7904 static void alc883_mitac_hp_automute(struct hda_codec *codec)
7905 {
7906         unsigned int present;
7907
7908         present = snd_hda_codec_read(codec, 0x15, 0,
7909                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7910         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7911                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7912         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7913                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7914 }
7915
7916 /* auto-toggle front mic */
7917 /*
7918 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7919 {
7920         unsigned int present;
7921         unsigned char bits;
7922
7923         present = snd_hda_codec_read(codec, 0x18, 0,
7924                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7925         bits = present ? HDA_AMP_MUTE : 0;
7926         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7927 }
7928 */
7929
7930 static void alc883_mitac_automute(struct hda_codec *codec)
7931 {
7932         alc883_mitac_hp_automute(codec);
7933         /* alc883_mitac_mic_automute(codec); */
7934 }
7935
7936 static void alc883_mitac_unsol_event(struct hda_codec *codec,
7937                                            unsigned int res)
7938 {
7939         switch (res >> 26) {
7940         case ALC880_HP_EVENT:
7941                 alc883_mitac_hp_automute(codec);
7942                 break;
7943         case ALC880_MIC_EVENT:
7944                 /* alc883_mitac_mic_automute(codec); */
7945                 break;
7946         }
7947 }
7948
7949 static struct hda_verb alc883_mitac_verbs[] = {
7950         /* HP */
7951         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7952         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7953         /* Subwoofer */
7954         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7955         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7956
7957         /* enable unsolicited event */
7958         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7959         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7960
7961         { } /* end */
7962 };
7963
7964 static struct hda_verb alc883_clevo_m720_verbs[] = {
7965         /* HP */
7966         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7967         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7968         /* Int speaker */
7969         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
7970         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7971
7972         /* enable unsolicited event */
7973         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7974         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
7975
7976         { } /* end */
7977 };
7978
7979 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
7980         /* HP */
7981         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7982         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7983         /* Subwoofer */
7984         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7985         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7986
7987         /* enable unsolicited event */
7988         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7989
7990         { } /* end */
7991 };
7992
7993 static struct hda_verb alc883_tagra_verbs[] = {
7994         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7995         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7996
7997         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7998         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7999
8000         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8001         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8002         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8003
8004         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8005         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
8006         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
8007         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
8008
8009         { } /* end */
8010 };
8011
8012 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8013         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8014         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8015         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8016         { } /* end */
8017 };
8018
8019 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8020         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8021         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8022         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8023         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8024         { } /* end */
8025 };
8026
8027 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8028         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8029         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8030         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8031         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8032         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8033         { } /* end */
8034 };
8035
8036 static struct hda_verb alc883_haier_w66_verbs[] = {
8037         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8038         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8039
8040         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8041
8042         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8043         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8044         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8045         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8046         { } /* end */
8047 };
8048
8049 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8050         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8051         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8052         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8053         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8054         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8055         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8056         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8057         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8058         { } /* end */
8059 };
8060
8061 static struct hda_verb alc888_6st_dell_verbs[] = {
8062         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8063         { }
8064 };
8065
8066 static void alc888_3st_hp_front_automute(struct hda_codec *codec)
8067 {
8068         unsigned int present, bits;
8069
8070         present = snd_hda_codec_read(codec, 0x1b, 0,
8071                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8072         bits = present ? HDA_AMP_MUTE : 0;
8073         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8074                                  HDA_AMP_MUTE, bits);
8075         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8076                                  HDA_AMP_MUTE, bits);
8077         snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
8078                                  HDA_AMP_MUTE, bits);
8079 }
8080
8081 static void alc888_3st_hp_unsol_event(struct hda_codec *codec,
8082                                       unsigned int res)
8083 {
8084         switch (res >> 26) {
8085         case ALC880_HP_EVENT:
8086                 alc888_3st_hp_front_automute(codec);
8087                 break;
8088         }
8089 }
8090
8091 static struct hda_verb alc888_3st_hp_verbs[] = {
8092         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8093         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8094         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8095         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8096         { } /* end */
8097 };
8098
8099 /*
8100  * 2ch mode
8101  */
8102 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8103         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8104         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8105         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8106         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8107         { } /* end */
8108 };
8109
8110 /*
8111  * 4ch mode
8112  */
8113 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8114         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8115         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8116         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8117         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8118         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8119         { } /* end */
8120 };
8121
8122 /*
8123  * 6ch mode
8124  */
8125 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8126         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8127         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8128         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8129         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8130         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8131         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8132         { } /* end */
8133 };
8134
8135 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8136         { 2, alc888_3st_hp_2ch_init },
8137         { 4, alc888_3st_hp_4ch_init },
8138         { 6, alc888_3st_hp_6ch_init },
8139 };
8140
8141 /* toggle front-jack and RCA according to the hp-jack state */
8142 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8143 {
8144         unsigned int present;
8145
8146         present = snd_hda_codec_read(codec, 0x1b, 0,
8147                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8148         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8149                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8150         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8151                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8152 }
8153
8154 /* toggle RCA according to the front-jack state */
8155 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8156 {
8157         unsigned int present;
8158
8159         present = snd_hda_codec_read(codec, 0x14, 0,
8160                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8161         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8162                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8163 }
8164
8165 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8166                                              unsigned int res)
8167 {
8168         if ((res >> 26) == ALC880_HP_EVENT)
8169                 alc888_lenovo_ms7195_front_automute(codec);
8170         if ((res >> 26) == ALC880_FRONT_EVENT)
8171                 alc888_lenovo_ms7195_rca_automute(codec);
8172 }
8173
8174 static struct hda_verb alc883_medion_md2_verbs[] = {
8175         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8176         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8177
8178         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8179
8180         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8181         { } /* end */
8182 };
8183
8184 /* toggle speaker-output according to the hp-jack state */
8185 static void alc883_medion_md2_automute(struct hda_codec *codec)
8186 {
8187         unsigned int present;
8188
8189         present = snd_hda_codec_read(codec, 0x14, 0,
8190                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8191         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8192                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8193 }
8194
8195 static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
8196                                           unsigned int res)
8197 {
8198         if ((res >> 26) == ALC880_HP_EVENT)
8199                 alc883_medion_md2_automute(codec);
8200 }
8201
8202 /* toggle speaker-output according to the hp-jack state */
8203 static void alc883_tagra_automute(struct hda_codec *codec)
8204 {
8205         unsigned int present;
8206         unsigned char bits;
8207
8208         present = snd_hda_codec_read(codec, 0x14, 0,
8209                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8210         bits = present ? HDA_AMP_MUTE : 0;
8211         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
8212                                  HDA_AMP_MUTE, bits);
8213         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8214                                   present ? 1 : 3);
8215 }
8216
8217 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
8218 {
8219         if ((res >> 26) == ALC880_HP_EVENT)
8220                 alc883_tagra_automute(codec);
8221 }
8222
8223 /* toggle speaker-output according to the hp-jack state */
8224 static void alc883_clevo_m720_hp_automute(struct hda_codec *codec)
8225 {
8226         unsigned int present;
8227         unsigned char bits;
8228
8229         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
8230                 & AC_PINSENSE_PRESENCE;
8231         bits = present ? HDA_AMP_MUTE : 0;
8232         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8233                                  HDA_AMP_MUTE, bits);
8234 }
8235
8236 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8237 {
8238         unsigned int present;
8239
8240         present = snd_hda_codec_read(codec, 0x18, 0,
8241                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8242         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8243                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8244 }
8245
8246 static void alc883_clevo_m720_automute(struct hda_codec *codec)
8247 {
8248         alc883_clevo_m720_hp_automute(codec);
8249         alc883_clevo_m720_mic_automute(codec);
8250 }
8251
8252 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8253                                            unsigned int res)
8254 {
8255         switch (res >> 26) {
8256         case ALC880_HP_EVENT:
8257                 alc883_clevo_m720_hp_automute(codec);
8258                 break;
8259         case ALC880_MIC_EVENT:
8260                 alc883_clevo_m720_mic_automute(codec);
8261                 break;
8262         }
8263 }
8264
8265 /* toggle speaker-output according to the hp-jack state */
8266 static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec)
8267 {
8268         unsigned int present;
8269         unsigned char bits;
8270
8271         present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
8272                 & AC_PINSENSE_PRESENCE;
8273         bits = present ? HDA_AMP_MUTE : 0;
8274         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8275                                  HDA_AMP_MUTE, bits);
8276 }
8277
8278 static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec,
8279                                                   unsigned int res)
8280 {
8281         if ((res >> 26) == ALC880_HP_EVENT)
8282                 alc883_2ch_fujitsu_pi2515_automute(codec);
8283 }
8284
8285 static void alc883_haier_w66_automute(struct hda_codec *codec)
8286 {
8287         unsigned int present;
8288         unsigned char bits;
8289
8290         present = snd_hda_codec_read(codec, 0x1b, 0,
8291                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8292         bits = present ? 0x80 : 0;
8293         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8294                                  0x80, bits);
8295 }
8296
8297 static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
8298                                          unsigned int res)
8299 {
8300         if ((res >> 26) == ALC880_HP_EVENT)
8301                 alc883_haier_w66_automute(codec);
8302 }
8303
8304 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8305 {
8306         unsigned int present;
8307         unsigned char bits;
8308
8309         present = snd_hda_codec_read(codec, 0x14, 0,
8310                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8311         bits = present ? HDA_AMP_MUTE : 0;
8312         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8313                                  HDA_AMP_MUTE, bits);
8314 }
8315
8316 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8317 {
8318         unsigned int present;
8319         unsigned char bits;
8320
8321         present = snd_hda_codec_read(codec, 0x1b, 0,
8322                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8323         bits = present ? HDA_AMP_MUTE : 0;
8324         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8325                                  HDA_AMP_MUTE, bits);
8326         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8327                                  HDA_AMP_MUTE, bits);
8328 }
8329
8330 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8331                                            unsigned int res)
8332 {
8333         if ((res >> 26) == ALC880_HP_EVENT)
8334                 alc883_lenovo_101e_all_automute(codec);
8335         if ((res >> 26) == ALC880_FRONT_EVENT)
8336                 alc883_lenovo_101e_ispeaker_automute(codec);
8337 }
8338
8339 /* toggle speaker-output according to the hp-jack state */
8340 static void alc883_acer_aspire_automute(struct hda_codec *codec)
8341 {
8342         unsigned int present;
8343
8344         present = snd_hda_codec_read(codec, 0x14, 0,
8345                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8346         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8347                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8348         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8349                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8350 }
8351
8352 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
8353                                            unsigned int res)
8354 {
8355         if ((res >> 26) == ALC880_HP_EVENT)
8356                 alc883_acer_aspire_automute(codec);
8357 }
8358
8359 static struct hda_verb alc883_acer_eapd_verbs[] = {
8360         /* HP Pin: output 0 (0x0c) */
8361         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8362         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8363         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8364         /* Front Pin: output 0 (0x0c) */
8365         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8366         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8367         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8368         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8369         /* eanable EAPD on medion laptop */
8370         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8371         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8372         /* enable unsolicited event */
8373         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8374         { }
8375 };
8376
8377 static void alc888_6st_dell_front_automute(struct hda_codec *codec)
8378 {
8379         unsigned int present;
8380
8381         present = snd_hda_codec_read(codec, 0x1b, 0,
8382                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8383         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8384                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8385         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8386                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8387         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8388                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8389         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8390                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8391 }
8392
8393 static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
8394                                              unsigned int res)
8395 {
8396         switch (res >> 26) {
8397         case ALC880_HP_EVENT:
8398                 /* printk(KERN_DEBUG "hp_event\n"); */
8399                 alc888_6st_dell_front_automute(codec);
8400                 break;
8401         }
8402 }
8403
8404 static void alc888_lenovo_sky_front_automute(struct hda_codec *codec)
8405 {
8406         unsigned int mute;
8407         unsigned int present;
8408
8409         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8410         present = snd_hda_codec_read(codec, 0x1b, 0,
8411                                      AC_VERB_GET_PIN_SENSE, 0);
8412         present = (present & 0x80000000) != 0;
8413         if (present) {
8414                 /* mute internal speaker */
8415                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8416                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8417                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8418                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8419                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8420                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8421                 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8422                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8423                 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8424                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8425         } else {
8426                 /* unmute internal speaker if necessary */
8427                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
8428                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8429                                          HDA_AMP_MUTE, mute);
8430                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8431                                          HDA_AMP_MUTE, mute);
8432                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8433                                          HDA_AMP_MUTE, mute);
8434                 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8435                                          HDA_AMP_MUTE, mute);
8436                 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8437                                          HDA_AMP_MUTE, mute);
8438         }
8439 }
8440
8441 static void alc883_lenovo_sky_unsol_event(struct hda_codec *codec,
8442                                              unsigned int res)
8443 {
8444         if ((res >> 26) == ALC880_HP_EVENT)
8445                 alc888_lenovo_sky_front_automute(codec);
8446 }
8447
8448 /*
8449  * generic initialization of ADC, input mixers and output mixers
8450  */
8451 static struct hda_verb alc883_auto_init_verbs[] = {
8452         /*
8453          * Unmute ADC0-2 and set the default input to mic-in
8454          */
8455         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8456         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8457         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8458         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8459
8460         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8461          * mixer widget
8462          * Note: PASD motherboards uses the Line In 2 as the input for
8463          * front panel mic (mic 2)
8464          */
8465         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8466         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8467         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8468         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8469         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8470         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8471
8472         /*
8473          * Set up output mixers (0x0c - 0x0f)
8474          */
8475         /* set vol=0 to output mixers */
8476         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8477         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8478         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8479         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8480         /* set up input amps for analog loopback */
8481         /* Amp Indices: DAC = 0, mixer = 1 */
8482         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8483         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8484         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8485         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8486         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8487         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8488         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8489         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8490         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8491         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8492
8493         /* FIXME: use matrix-type input source selection */
8494         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8495         /* Input mixer1 */
8496         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8497         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8498         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8499         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8500         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8501         /* Input mixer2 */
8502         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8503         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8504         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8505         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8506         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8507
8508         { }
8509 };
8510
8511 static struct hda_verb alc888_asus_m90v_verbs[] = {
8512         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8513         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8514         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8515         /* enable unsolicited event */
8516         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8517         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8518         { } /* end */
8519 };
8520
8521 static void alc883_nb_mic_automute(struct hda_codec *codec)
8522 {
8523         unsigned int present;
8524
8525         present = snd_hda_codec_read(codec, 0x18, 0,
8526                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8527         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8528                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8529         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8530                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8531 }
8532
8533 static void alc883_M90V_speaker_automute(struct hda_codec *codec)
8534 {
8535         unsigned int present;
8536         unsigned char bits;
8537
8538         present = snd_hda_codec_read(codec, 0x1b, 0,
8539                                      AC_VERB_GET_PIN_SENSE, 0)
8540                 & AC_PINSENSE_PRESENCE;
8541         bits = present ? 0 : PIN_OUT;
8542         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8543                             bits);
8544         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8545                             bits);
8546         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8547                             bits);
8548 }
8549
8550 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8551                                            unsigned int res)
8552 {
8553         switch (res >> 26) {
8554         case ALC880_HP_EVENT:
8555                 alc883_M90V_speaker_automute(codec);
8556                 break;
8557         case ALC880_MIC_EVENT:
8558                 alc883_nb_mic_automute(codec);
8559                 break;
8560         }
8561 }
8562
8563 static void alc883_mode2_inithook(struct hda_codec *codec)
8564 {
8565         alc883_M90V_speaker_automute(codec);
8566         alc883_nb_mic_automute(codec);
8567 }
8568
8569 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8570         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8571         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8572         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8573         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8574         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8575         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8576         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8577         /* enable unsolicited event */
8578         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8579         { } /* end */
8580 };
8581
8582 static void alc883_eee1601_speaker_automute(struct hda_codec *codec)
8583 {
8584         unsigned int present;
8585         unsigned char bits;
8586
8587         present = snd_hda_codec_read(codec, 0x14, 0,
8588                                      AC_VERB_GET_PIN_SENSE, 0)
8589                 & AC_PINSENSE_PRESENCE;
8590         bits = present ? 0 : PIN_OUT;
8591         snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8592                             bits);
8593 }
8594
8595 static void alc883_eee1601_unsol_event(struct hda_codec *codec,
8596                                            unsigned int res)
8597 {
8598         switch (res >> 26) {
8599         case ALC880_HP_EVENT:
8600                 alc883_eee1601_speaker_automute(codec);
8601                 break;
8602         }
8603 }
8604
8605 static void alc883_eee1601_inithook(struct hda_codec *codec)
8606 {
8607         alc883_eee1601_speaker_automute(codec);
8608 }
8609
8610 #ifdef CONFIG_SND_HDA_POWER_SAVE
8611 #define alc883_loopbacks        alc880_loopbacks
8612 #endif
8613
8614 /* pcm configuration: identiacal with ALC880 */
8615 #define alc883_pcm_analog_playback      alc880_pcm_analog_playback
8616 #define alc883_pcm_analog_capture       alc880_pcm_analog_capture
8617 #define alc883_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
8618 #define alc883_pcm_digital_playback     alc880_pcm_digital_playback
8619 #define alc883_pcm_digital_capture      alc880_pcm_digital_capture
8620
8621 /*
8622  * configuration and preset
8623  */
8624 static const char *alc883_models[ALC883_MODEL_LAST] = {
8625         [ALC883_3ST_2ch_DIG]    = "3stack-dig",
8626         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8627         [ALC883_3ST_6ch]        = "3stack-6ch",
8628         [ALC883_6ST_DIG]        = "6stack-dig",
8629         [ALC883_TARGA_DIG]      = "targa-dig",
8630         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8631         [ALC883_ACER]           = "acer",
8632         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8633         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8634         [ALC883_MEDION]         = "medion",
8635         [ALC883_MEDION_MD2]     = "medion-md2",
8636         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8637         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8638         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8639         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8640         [ALC888_LENOVO_SKY] = "lenovo-sky",
8641         [ALC883_HAIER_W66]      = "haier-w66",
8642         [ALC888_3ST_HP]         = "3stack-hp",
8643         [ALC888_6ST_DELL]       = "6stack-dell",
8644         [ALC883_MITAC]          = "mitac",
8645         [ALC883_CLEVO_M720]     = "clevo-m720",
8646         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8647         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8648         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8649         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8650         [ALC883_AUTO]           = "auto",
8651 };
8652
8653 static struct snd_pci_quirk alc883_cfg_tbl[] = {
8654         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
8655         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8656         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8657         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8658         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8659         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8660         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8661                 ALC888_ACER_ASPIRE_4930G),
8662         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8663                 ALC888_ACER_ASPIRE_4930G),
8664         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC883_AUTO),
8665         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC883_AUTO),
8666         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8667                 ALC888_ACER_ASPIRE_4930G),
8668         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8669                 ALC888_ACER_ASPIRE_4930G),
8670         /* default Acer */
8671         SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER),
8672         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8673         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8674         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8675         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8676         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8677         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8678         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
8679         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8680         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8681         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8682         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8683         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8684         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8685         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
8686         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8687         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8688         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8689         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8690         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8691         SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
8692         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8693         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8694         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8695         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8696         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8697         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8698         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8699         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8700         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8701         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8702         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8703         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8704         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8705         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8706         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8707         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8708         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8709         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8710         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8711         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8712         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8713         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8714         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8715         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8716         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8717         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8718         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
8719         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8720         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8721         SND_PCI_QUIRK(0x1734, 0x1107, "FSC AMILO Xi2550",
8722                       ALC883_FUJITSU_PI2515),
8723         SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515),
8724         SND_PCI_QUIRK(0x1734, 0x113d, "Fujitsu AMILO Xa3530",
8725                 ALC888_FUJITSU_XA3530),
8726         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8727         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8728         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8729         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8730         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8731         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8732         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
8733         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8734         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8735         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8736         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8737         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
8738         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL),
8739         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8740         {}
8741 };
8742
8743 static hda_nid_t alc1200_slave_dig_outs[] = {
8744         ALC883_DIGOUT_NID, 0,
8745 };
8746
8747 static struct alc_config_preset alc883_presets[] = {
8748         [ALC883_3ST_2ch_DIG] = {
8749                 .mixers = { alc883_3ST_2ch_mixer },
8750                 .init_verbs = { alc883_init_verbs },
8751                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8752                 .dac_nids = alc883_dac_nids,
8753                 .dig_out_nid = ALC883_DIGOUT_NID,
8754                 .dig_in_nid = ALC883_DIGIN_NID,
8755                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8756                 .channel_mode = alc883_3ST_2ch_modes,
8757                 .input_mux = &alc883_capture_source,
8758         },
8759         [ALC883_3ST_6ch_DIG] = {
8760                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8761                 .init_verbs = { alc883_init_verbs },
8762                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8763                 .dac_nids = alc883_dac_nids,
8764                 .dig_out_nid = ALC883_DIGOUT_NID,
8765                 .dig_in_nid = ALC883_DIGIN_NID,
8766                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8767                 .channel_mode = alc883_3ST_6ch_modes,
8768                 .need_dac_fix = 1,
8769                 .input_mux = &alc883_capture_source,
8770         },
8771         [ALC883_3ST_6ch] = {
8772                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8773                 .init_verbs = { alc883_init_verbs },
8774                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8775                 .dac_nids = alc883_dac_nids,
8776                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8777                 .channel_mode = alc883_3ST_6ch_modes,
8778                 .need_dac_fix = 1,
8779                 .input_mux = &alc883_capture_source,
8780         },
8781         [ALC883_3ST_6ch_INTEL] = {
8782                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8783                 .init_verbs = { alc883_init_verbs },
8784                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8785                 .dac_nids = alc883_dac_nids,
8786                 .dig_out_nid = ALC883_DIGOUT_NID,
8787                 .dig_in_nid = ALC883_DIGIN_NID,
8788                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8789                 .channel_mode = alc883_3ST_6ch_intel_modes,
8790                 .need_dac_fix = 1,
8791                 .input_mux = &alc883_3stack_6ch_intel,
8792         },
8793         [ALC883_6ST_DIG] = {
8794                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8795                 .init_verbs = { alc883_init_verbs },
8796                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8797                 .dac_nids = alc883_dac_nids,
8798                 .dig_out_nid = ALC883_DIGOUT_NID,
8799                 .dig_in_nid = ALC883_DIGIN_NID,
8800                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8801                 .channel_mode = alc883_sixstack_modes,
8802                 .input_mux = &alc883_capture_source,
8803         },
8804         [ALC883_TARGA_DIG] = {
8805                 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8806                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8807                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8808                 .dac_nids = alc883_dac_nids,
8809                 .dig_out_nid = ALC883_DIGOUT_NID,
8810                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8811                 .channel_mode = alc883_3ST_6ch_modes,
8812                 .need_dac_fix = 1,
8813                 .input_mux = &alc883_capture_source,
8814                 .unsol_event = alc883_tagra_unsol_event,
8815                 .init_hook = alc883_tagra_automute,
8816         },
8817         [ALC883_TARGA_2ch_DIG] = {
8818                 .mixers = { alc883_tagra_2ch_mixer},
8819                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8820                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8821                 .dac_nids = alc883_dac_nids,
8822                 .adc_nids = alc883_adc_nids_alt,
8823                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8824                 .dig_out_nid = ALC883_DIGOUT_NID,
8825                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8826                 .channel_mode = alc883_3ST_2ch_modes,
8827                 .input_mux = &alc883_capture_source,
8828                 .unsol_event = alc883_tagra_unsol_event,
8829                 .init_hook = alc883_tagra_automute,
8830         },
8831         [ALC883_ACER] = {
8832                 .mixers = { alc883_base_mixer },
8833                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8834                  * and the headphone jack.  Turn this on and rely on the
8835                  * standard mute methods whenever the user wants to turn
8836                  * these outputs off.
8837                  */
8838                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8839                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8840                 .dac_nids = alc883_dac_nids,
8841                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8842                 .channel_mode = alc883_3ST_2ch_modes,
8843                 .input_mux = &alc883_capture_source,
8844         },
8845         [ALC883_ACER_ASPIRE] = {
8846                 .mixers = { alc883_acer_aspire_mixer },
8847                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8848                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8849                 .dac_nids = alc883_dac_nids,
8850                 .dig_out_nid = ALC883_DIGOUT_NID,
8851                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8852                 .channel_mode = alc883_3ST_2ch_modes,
8853                 .input_mux = &alc883_capture_source,
8854                 .unsol_event = alc883_acer_aspire_unsol_event,
8855                 .init_hook = alc883_acer_aspire_automute,
8856         },
8857         [ALC888_ACER_ASPIRE_4930G] = {
8858                 .mixers = { alc888_base_mixer,
8859                                 alc883_chmode_mixer },
8860                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
8861                                 alc888_acer_aspire_4930g_verbs },
8862                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8863                 .dac_nids = alc883_dac_nids,
8864                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8865                 .adc_nids = alc883_adc_nids_rev,
8866                 .capsrc_nids = alc883_capsrc_nids_rev,
8867                 .dig_out_nid = ALC883_DIGOUT_NID,
8868                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8869                 .channel_mode = alc883_3ST_6ch_modes,
8870                 .need_dac_fix = 1,
8871                 .num_mux_defs =
8872                         ARRAY_SIZE(alc888_2_capture_sources),
8873                 .input_mux = alc888_2_capture_sources,
8874                 .unsol_event = alc888_acer_aspire_4930g_unsol_event,
8875                 .init_hook = alc888_acer_aspire_4930g_automute,
8876         },
8877         [ALC883_MEDION] = {
8878                 .mixers = { alc883_fivestack_mixer,
8879                             alc883_chmode_mixer },
8880                 .init_verbs = { alc883_init_verbs,
8881                                 alc883_medion_eapd_verbs },
8882                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8883                 .dac_nids = alc883_dac_nids,
8884                 .adc_nids = alc883_adc_nids_alt,
8885                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8886                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8887                 .channel_mode = alc883_sixstack_modes,
8888                 .input_mux = &alc883_capture_source,
8889         },
8890         [ALC883_MEDION_MD2] = {
8891                 .mixers = { alc883_medion_md2_mixer},
8892                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8893                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8894                 .dac_nids = alc883_dac_nids,
8895                 .dig_out_nid = ALC883_DIGOUT_NID,
8896                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8897                 .channel_mode = alc883_3ST_2ch_modes,
8898                 .input_mux = &alc883_capture_source,
8899                 .unsol_event = alc883_medion_md2_unsol_event,
8900                 .init_hook = alc883_medion_md2_automute,
8901         },
8902         [ALC883_LAPTOP_EAPD] = {
8903                 .mixers = { alc883_base_mixer },
8904                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8905                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8906                 .dac_nids = alc883_dac_nids,
8907                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8908                 .channel_mode = alc883_3ST_2ch_modes,
8909                 .input_mux = &alc883_capture_source,
8910         },
8911         [ALC883_CLEVO_M720] = {
8912                 .mixers = { alc883_clevo_m720_mixer },
8913                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8914                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8915                 .dac_nids = alc883_dac_nids,
8916                 .dig_out_nid = ALC883_DIGOUT_NID,
8917                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8918                 .channel_mode = alc883_3ST_2ch_modes,
8919                 .input_mux = &alc883_capture_source,
8920                 .unsol_event = alc883_clevo_m720_unsol_event,
8921                 .init_hook = alc883_clevo_m720_automute,
8922         },
8923         [ALC883_LENOVO_101E_2ch] = {
8924                 .mixers = { alc883_lenovo_101e_2ch_mixer},
8925                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8926                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8927                 .dac_nids = alc883_dac_nids,
8928                 .adc_nids = alc883_adc_nids_alt,
8929                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8930                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8931                 .channel_mode = alc883_3ST_2ch_modes,
8932                 .input_mux = &alc883_lenovo_101e_capture_source,
8933                 .unsol_event = alc883_lenovo_101e_unsol_event,
8934                 .init_hook = alc883_lenovo_101e_all_automute,
8935         },
8936         [ALC883_LENOVO_NB0763] = {
8937                 .mixers = { alc883_lenovo_nb0763_mixer },
8938                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8939                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8940                 .dac_nids = alc883_dac_nids,
8941                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8942                 .channel_mode = alc883_3ST_2ch_modes,
8943                 .need_dac_fix = 1,
8944                 .input_mux = &alc883_lenovo_nb0763_capture_source,
8945                 .unsol_event = alc883_medion_md2_unsol_event,
8946                 .init_hook = alc883_medion_md2_automute,
8947         },
8948         [ALC888_LENOVO_MS7195_DIG] = {
8949                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8950                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8951                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8952                 .dac_nids = alc883_dac_nids,
8953                 .dig_out_nid = ALC883_DIGOUT_NID,
8954                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8955                 .channel_mode = alc883_3ST_6ch_modes,
8956                 .need_dac_fix = 1,
8957                 .input_mux = &alc883_capture_source,
8958                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
8959                 .init_hook = alc888_lenovo_ms7195_front_automute,
8960         },
8961         [ALC883_HAIER_W66] = {
8962                 .mixers = { alc883_tagra_2ch_mixer},
8963                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8964                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8965                 .dac_nids = alc883_dac_nids,
8966                 .dig_out_nid = ALC883_DIGOUT_NID,
8967                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8968                 .channel_mode = alc883_3ST_2ch_modes,
8969                 .input_mux = &alc883_capture_source,
8970                 .unsol_event = alc883_haier_w66_unsol_event,
8971                 .init_hook = alc883_haier_w66_automute,
8972         },
8973         [ALC888_3ST_HP] = {
8974                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8975                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
8976                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8977                 .dac_nids = alc883_dac_nids,
8978                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
8979                 .channel_mode = alc888_3st_hp_modes,
8980                 .need_dac_fix = 1,
8981                 .input_mux = &alc883_capture_source,
8982                 .unsol_event = alc888_3st_hp_unsol_event,
8983                 .init_hook = alc888_3st_hp_front_automute,
8984         },
8985         [ALC888_6ST_DELL] = {
8986                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8987                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
8988                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8989                 .dac_nids = alc883_dac_nids,
8990                 .dig_out_nid = ALC883_DIGOUT_NID,
8991                 .dig_in_nid = ALC883_DIGIN_NID,
8992                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8993                 .channel_mode = alc883_sixstack_modes,
8994                 .input_mux = &alc883_capture_source,
8995                 .unsol_event = alc888_6st_dell_unsol_event,
8996                 .init_hook = alc888_6st_dell_front_automute,
8997         },
8998         [ALC883_MITAC] = {
8999                 .mixers = { alc883_mitac_mixer },
9000                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9001                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9002                 .dac_nids = alc883_dac_nids,
9003                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9004                 .channel_mode = alc883_3ST_2ch_modes,
9005                 .input_mux = &alc883_capture_source,
9006                 .unsol_event = alc883_mitac_unsol_event,
9007                 .init_hook = alc883_mitac_automute,
9008         },
9009         [ALC883_FUJITSU_PI2515] = {
9010                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9011                 .init_verbs = { alc883_init_verbs,
9012                                 alc883_2ch_fujitsu_pi2515_verbs},
9013                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9014                 .dac_nids = alc883_dac_nids,
9015                 .dig_out_nid = ALC883_DIGOUT_NID,
9016                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9017                 .channel_mode = alc883_3ST_2ch_modes,
9018                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9019                 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
9020                 .init_hook = alc883_2ch_fujitsu_pi2515_automute,
9021         },
9022         [ALC888_FUJITSU_XA3530] = {
9023                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
9024                 .init_verbs = { alc883_init_verbs,
9025                         alc888_fujitsu_xa3530_verbs },
9026                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9027                 .dac_nids = alc883_dac_nids,
9028                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9029                 .adc_nids = alc883_adc_nids_rev,
9030                 .capsrc_nids = alc883_capsrc_nids_rev,
9031                 .dig_out_nid = ALC883_DIGOUT_NID,
9032                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9033                 .channel_mode = alc888_4ST_8ch_intel_modes,
9034                 .num_mux_defs =
9035                         ARRAY_SIZE(alc888_2_capture_sources),
9036                 .input_mux = alc888_2_capture_sources,
9037                 .unsol_event = alc888_fujitsu_xa3530_unsol_event,
9038                 .init_hook = alc888_fujitsu_xa3530_automute,
9039         },
9040         [ALC888_LENOVO_SKY] = {
9041                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9042                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9043                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9044                 .dac_nids = alc883_dac_nids,
9045                 .dig_out_nid = ALC883_DIGOUT_NID,
9046                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9047                 .channel_mode = alc883_sixstack_modes,
9048                 .need_dac_fix = 1,
9049                 .input_mux = &alc883_lenovo_sky_capture_source,
9050                 .unsol_event = alc883_lenovo_sky_unsol_event,
9051                 .init_hook = alc888_lenovo_sky_front_automute,
9052         },
9053         [ALC888_ASUS_M90V] = {
9054                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9055                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9056                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9057                 .dac_nids = alc883_dac_nids,
9058                 .dig_out_nid = ALC883_DIGOUT_NID,
9059                 .dig_in_nid = ALC883_DIGIN_NID,
9060                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9061                 .channel_mode = alc883_3ST_6ch_modes,
9062                 .need_dac_fix = 1,
9063                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9064                 .unsol_event = alc883_mode2_unsol_event,
9065                 .init_hook = alc883_mode2_inithook,
9066         },
9067         [ALC888_ASUS_EEE1601] = {
9068                 .mixers = { alc883_asus_eee1601_mixer },
9069                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
9070                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9071                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9072                 .dac_nids = alc883_dac_nids,
9073                 .dig_out_nid = ALC883_DIGOUT_NID,
9074                 .dig_in_nid = ALC883_DIGIN_NID,
9075                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9076                 .channel_mode = alc883_3ST_2ch_modes,
9077                 .need_dac_fix = 1,
9078                 .input_mux = &alc883_asus_eee1601_capture_source,
9079                 .unsol_event = alc883_eee1601_unsol_event,
9080                 .init_hook = alc883_eee1601_inithook,
9081         },
9082         [ALC1200_ASUS_P5Q] = {
9083                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9084                 .init_verbs = { alc883_init_verbs },
9085                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9086                 .dac_nids = alc883_dac_nids,
9087                 .dig_out_nid = ALC1200_DIGOUT_NID,
9088                 .dig_in_nid = ALC883_DIGIN_NID,
9089                 .slave_dig_outs = alc1200_slave_dig_outs,
9090                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9091                 .channel_mode = alc883_sixstack_modes,
9092                 .input_mux = &alc883_capture_source,
9093         },
9094 };
9095
9096
9097 /*
9098  * BIOS auto configuration
9099  */
9100 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
9101                                               hda_nid_t nid, int pin_type,
9102                                               int dac_idx)
9103 {
9104         /* set as output */
9105         struct alc_spec *spec = codec->spec;
9106         int idx;
9107
9108         alc_set_pin_output(codec, nid, pin_type);
9109         if (spec->multiout.dac_nids[dac_idx] == 0x25)
9110                 idx = 4;
9111         else
9112                 idx = spec->multiout.dac_nids[dac_idx] - 2;
9113         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9114
9115 }
9116
9117 static void alc883_auto_init_multi_out(struct hda_codec *codec)
9118 {
9119         struct alc_spec *spec = codec->spec;
9120         int i;
9121
9122         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
9123         for (i = 0; i <= HDA_SIDE; i++) {
9124                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9125                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
9126                 if (nid)
9127                         alc883_auto_set_output_and_unmute(codec, nid, pin_type,
9128                                                           i);
9129         }
9130 }
9131
9132 static void alc883_auto_init_hp_out(struct hda_codec *codec)
9133 {
9134         struct alc_spec *spec = codec->spec;
9135         hda_nid_t pin;
9136
9137         pin = spec->autocfg.hp_pins[0];
9138         if (pin) /* connect to front */
9139                 /* use dac 0 */
9140                 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9141         pin = spec->autocfg.speaker_pins[0];
9142         if (pin)
9143                 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9144 }
9145
9146 #define alc883_is_input_pin(nid)        alc880_is_input_pin(nid)
9147 #define ALC883_PIN_CD_NID               ALC880_PIN_CD_NID
9148
9149 static void alc883_auto_init_analog_input(struct hda_codec *codec)
9150 {
9151         struct alc_spec *spec = codec->spec;
9152         int i;
9153
9154         for (i = 0; i < AUTO_PIN_LAST; i++) {
9155                 hda_nid_t nid = spec->autocfg.input_pins[i];
9156                 if (alc883_is_input_pin(nid)) {
9157                         alc_set_input_pin(codec, nid, i);
9158                         if (nid != ALC883_PIN_CD_NID &&
9159                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
9160                                 snd_hda_codec_write(codec, nid, 0,
9161                                                     AC_VERB_SET_AMP_GAIN_MUTE,
9162                                                     AMP_OUT_MUTE);
9163                 }
9164         }
9165 }
9166
9167 #define alc883_auto_init_input_src      alc882_auto_init_input_src
9168
9169 /* almost identical with ALC880 parser... */
9170 static int alc883_parse_auto_config(struct hda_codec *codec)
9171 {
9172         struct alc_spec *spec = codec->spec;
9173         int err = alc880_parse_auto_config(codec);
9174         struct auto_pin_cfg *cfg = &spec->autocfg;
9175         int i;
9176
9177         if (err < 0)
9178                 return err;
9179         else if (!err)
9180                 return 0; /* no config found */
9181
9182         err = alc_auto_add_mic_boost(codec);
9183         if (err < 0)
9184                 return err;
9185
9186         /* hack - override the init verbs */
9187         spec->init_verbs[0] = alc883_auto_init_verbs;
9188
9189         /* setup input_mux for ALC889 */
9190         if (codec->vendor_id == 0x10ec0889) {
9191                 /* digital-mic input pin is excluded in alc880_auto_create..()
9192                  * because it's under 0x18
9193                  */
9194                 if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
9195                     cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
9196                         struct hda_input_mux *imux = &spec->private_imux[0];
9197                         for (i = 1; i < 3; i++)
9198                                 memcpy(&spec->private_imux[i],
9199                                        &spec->private_imux[0],
9200                                        sizeof(spec->private_imux[0]));
9201                         imux->items[imux->num_items].label = "Int DMic";
9202                         imux->items[imux->num_items].index = 0x0b;
9203                         imux->num_items++;
9204                         spec->num_mux_defs = 3;
9205                         spec->input_mux = spec->private_imux;
9206                 }
9207         }
9208
9209         return 1; /* config found */
9210 }
9211
9212 /* additional initialization for auto-configuration model */
9213 static void alc883_auto_init(struct hda_codec *codec)
9214 {
9215         struct alc_spec *spec = codec->spec;
9216         alc883_auto_init_multi_out(codec);
9217         alc883_auto_init_hp_out(codec);
9218         alc883_auto_init_analog_input(codec);
9219         alc883_auto_init_input_src(codec);
9220         if (spec->unsol_event)
9221                 alc_inithook(codec);
9222 }
9223
9224 static int patch_alc883(struct hda_codec *codec)
9225 {
9226         struct alc_spec *spec;
9227         int err, board_config;
9228
9229         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9230         if (spec == NULL)
9231                 return -ENOMEM;
9232
9233         codec->spec = spec;
9234
9235         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9236
9237         board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
9238                                                   alc883_models,
9239                                                   alc883_cfg_tbl);
9240         if (board_config < 0) {
9241                 printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
9242                        "trying auto-probe from BIOS...\n");
9243                 board_config = ALC883_AUTO;
9244         }
9245
9246         if (board_config == ALC883_AUTO) {
9247                 /* automatic parse from the BIOS config */
9248                 err = alc883_parse_auto_config(codec);
9249                 if (err < 0) {
9250                         alc_free(codec);
9251                         return err;
9252                 } else if (!err) {
9253                         printk(KERN_INFO
9254                                "hda_codec: Cannot set up configuration "
9255                                "from BIOS.  Using base mode...\n");
9256                         board_config = ALC883_3ST_2ch_DIG;
9257                 }
9258         }
9259
9260         err = snd_hda_attach_beep_device(codec, 0x1);
9261         if (err < 0) {
9262                 alc_free(codec);
9263                 return err;
9264         }
9265
9266         if (board_config != ALC883_AUTO)
9267                 setup_preset(spec, &alc883_presets[board_config]);
9268
9269         switch (codec->vendor_id) {
9270         case 0x10ec0888:
9271                 if (codec->revision_id == 0x100101) {
9272                         spec->stream_name_analog = "ALC1200 Analog";
9273                         spec->stream_name_digital = "ALC1200 Digital";
9274                 } else {
9275                         spec->stream_name_analog = "ALC888 Analog";
9276                         spec->stream_name_digital = "ALC888 Digital";
9277                 }
9278                 if (!spec->num_adc_nids) {
9279                         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9280                         spec->adc_nids = alc883_adc_nids;
9281                 }
9282                 if (!spec->capsrc_nids)
9283                         spec->capsrc_nids = alc883_capsrc_nids;
9284                 spec->capture_style = CAPT_MIX; /* matrix-style capture */
9285                 break;
9286         case 0x10ec0889:
9287                 spec->stream_name_analog = "ALC889 Analog";
9288                 spec->stream_name_digital = "ALC889 Digital";
9289                 if (!spec->num_adc_nids) {
9290                         spec->num_adc_nids = ARRAY_SIZE(alc889_adc_nids);
9291                         spec->adc_nids = alc889_adc_nids;
9292                 }
9293                 if (!spec->capsrc_nids)
9294                         spec->capsrc_nids = alc889_capsrc_nids;
9295                 spec->capture_style = CAPT_1MUX_MIX; /* 1mux/Nmix-style
9296                                                         capture */
9297                 break;
9298         default:
9299                 spec->stream_name_analog = "ALC883 Analog";
9300                 spec->stream_name_digital = "ALC883 Digital";
9301                 if (!spec->num_adc_nids) {
9302                         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9303                         spec->adc_nids = alc883_adc_nids;
9304                 }
9305                 if (!spec->capsrc_nids)
9306                         spec->capsrc_nids = alc883_capsrc_nids;
9307                 spec->capture_style = CAPT_MIX; /* matrix-style capture */
9308                 break;
9309         }
9310
9311         spec->stream_analog_playback = &alc883_pcm_analog_playback;
9312         spec->stream_analog_capture = &alc883_pcm_analog_capture;
9313         spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
9314
9315         spec->stream_digital_playback = &alc883_pcm_digital_playback;
9316         spec->stream_digital_capture = &alc883_pcm_digital_capture;
9317
9318         if (!spec->cap_mixer)
9319                 set_capture_mixer(spec);
9320         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9321
9322         spec->vmaster_nid = 0x0c;
9323
9324         codec->patch_ops = alc_patch_ops;
9325         if (board_config == ALC883_AUTO)
9326                 spec->init_hook = alc883_auto_init;
9327
9328 #ifdef CONFIG_SND_HDA_POWER_SAVE
9329         if (!spec->loopback.amplist)
9330                 spec->loopback.amplist = alc883_loopbacks;
9331 #endif
9332         codec->proc_widget_hook = print_realtek_coef;
9333
9334         return 0;
9335 }
9336
9337 /*
9338  * ALC262 support
9339  */
9340
9341 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
9342 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
9343
9344 #define alc262_dac_nids         alc260_dac_nids
9345 #define alc262_adc_nids         alc882_adc_nids
9346 #define alc262_adc_nids_alt     alc882_adc_nids_alt
9347 #define alc262_capsrc_nids      alc882_capsrc_nids
9348 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
9349
9350 #define alc262_modes            alc260_modes
9351 #define alc262_capture_source   alc882_capture_source
9352
9353 static hda_nid_t alc262_dmic_adc_nids[1] = {
9354         /* ADC0 */
9355         0x09
9356 };
9357
9358 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
9359
9360 static struct snd_kcontrol_new alc262_base_mixer[] = {
9361         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9362         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9363         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9364         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9365         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9366         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9367         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9368         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9369         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9370         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9371         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9372         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9373         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
9374         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9375         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9376         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
9377         { } /* end */
9378 };
9379
9380 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
9381         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9382         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9383         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9384         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9385         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9386         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9387         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9388         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9389         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9390         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9391         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9392         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9393         /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
9394         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9395         { } /* end */
9396 };
9397
9398 /* update HP, line and mono-out pins according to the master switch */
9399 static void alc262_hp_master_update(struct hda_codec *codec)
9400 {
9401         struct alc_spec *spec = codec->spec;
9402         int val = spec->master_sw;
9403
9404         /* HP & line-out */
9405         snd_hda_codec_write_cache(codec, 0x1b, 0,
9406                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9407                                   val ? PIN_HP : 0);
9408         snd_hda_codec_write_cache(codec, 0x15, 0,
9409                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9410                                   val ? PIN_HP : 0);
9411         /* mono (speaker) depending on the HP jack sense */
9412         val = val && !spec->jack_present;
9413         snd_hda_codec_write_cache(codec, 0x16, 0,
9414                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9415                                   val ? PIN_OUT : 0);
9416 }
9417
9418 static void alc262_hp_bpc_automute(struct hda_codec *codec)
9419 {
9420         struct alc_spec *spec = codec->spec;
9421         unsigned int presence;
9422         presence = snd_hda_codec_read(codec, 0x1b, 0,
9423                                       AC_VERB_GET_PIN_SENSE, 0);
9424         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9425         alc262_hp_master_update(codec);
9426 }
9427
9428 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
9429 {
9430         if ((res >> 26) != ALC880_HP_EVENT)
9431                 return;
9432         alc262_hp_bpc_automute(codec);
9433 }
9434
9435 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
9436 {
9437         struct alc_spec *spec = codec->spec;
9438         unsigned int presence;
9439         presence = snd_hda_codec_read(codec, 0x15, 0,
9440                                       AC_VERB_GET_PIN_SENSE, 0);
9441         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9442         alc262_hp_master_update(codec);
9443 }
9444
9445 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
9446                                            unsigned int res)
9447 {
9448         if ((res >> 26) != ALC880_HP_EVENT)
9449                 return;
9450         alc262_hp_wildwest_automute(codec);
9451 }
9452
9453 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
9454                                    struct snd_ctl_elem_value *ucontrol)
9455 {
9456         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9457         struct alc_spec *spec = codec->spec;
9458         *ucontrol->value.integer.value = spec->master_sw;
9459         return 0;
9460 }
9461
9462 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9463                                    struct snd_ctl_elem_value *ucontrol)
9464 {
9465         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9466         struct alc_spec *spec = codec->spec;
9467         int val = !!*ucontrol->value.integer.value;
9468
9469         if (val == spec->master_sw)
9470                 return 0;
9471         spec->master_sw = val;
9472         alc262_hp_master_update(codec);
9473         return 1;
9474 }
9475
9476 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9477         {
9478                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9479                 .name = "Master Playback Switch",
9480                 .info = snd_ctl_boolean_mono_info,
9481                 .get = alc262_hp_master_sw_get,
9482                 .put = alc262_hp_master_sw_put,
9483         },
9484         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9485         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9486         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9487         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9488                               HDA_OUTPUT),
9489         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9490                             HDA_OUTPUT),
9491         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9492         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9493         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9494         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9495         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9496         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9497         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9498         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9499         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9500         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9501         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9502         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9503         { } /* end */
9504 };
9505
9506 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9507         {
9508                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9509                 .name = "Master Playback Switch",
9510                 .info = snd_ctl_boolean_mono_info,
9511                 .get = alc262_hp_master_sw_get,
9512                 .put = alc262_hp_master_sw_put,
9513         },
9514         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9515         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9516         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9517         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9518         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9519                               HDA_OUTPUT),
9520         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9521                             HDA_OUTPUT),
9522         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9523         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9524         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9525         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9526         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9527         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9528         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9529         { } /* end */
9530 };
9531
9532 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9533         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9534         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9535         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9536         { } /* end */
9537 };
9538
9539 /* mute/unmute internal speaker according to the hp jack and mute state */
9540 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
9541 {
9542         struct alc_spec *spec = codec->spec;
9543
9544         if (force || !spec->sense_updated) {
9545                 unsigned int present;
9546                 present = snd_hda_codec_read(codec, 0x15, 0,
9547                                              AC_VERB_GET_PIN_SENSE, 0);
9548                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9549                 spec->sense_updated = 1;
9550         }
9551         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
9552                                  spec->jack_present ? HDA_AMP_MUTE : 0);
9553 }
9554
9555 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
9556                                         unsigned int res)
9557 {
9558         if ((res >> 26) != ALC880_HP_EVENT)
9559                 return;
9560         alc262_hp_t5735_automute(codec, 1);
9561 }
9562
9563 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9564 {
9565         alc262_hp_t5735_automute(codec, 1);
9566 }
9567
9568 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9569         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9570         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9571         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9572         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9573         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9574         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9575         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9576         { } /* end */
9577 };
9578
9579 static struct hda_verb alc262_hp_t5735_verbs[] = {
9580         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9581         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9582
9583         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9584         { }
9585 };
9586
9587 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9588         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9589         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9590         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9591         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9592         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9593         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9594         { } /* end */
9595 };
9596
9597 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9598         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9599         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9600         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9601         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9602         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9603         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9604         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9605         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9606         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9607         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9608         {}
9609 };
9610
9611 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9612         .num_items = 1,
9613         .items = {
9614                 { "Line", 0x1 },
9615         },
9616 };
9617
9618 /* bind hp and internal speaker mute (with plug check) */
9619 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
9620                                      struct snd_ctl_elem_value *ucontrol)
9621 {
9622         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9623         long *valp = ucontrol->value.integer.value;
9624         int change;
9625
9626         /* change hp mute */
9627         change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
9628                                           HDA_AMP_MUTE,
9629                                           valp[0] ? 0 : HDA_AMP_MUTE);
9630         change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
9631                                            HDA_AMP_MUTE,
9632                                            valp[1] ? 0 : HDA_AMP_MUTE);
9633         if (change) {
9634                 /* change speaker according to HP jack state */
9635                 struct alc_spec *spec = codec->spec;
9636                 unsigned int mute;
9637                 if (spec->jack_present)
9638                         mute = HDA_AMP_MUTE;
9639                 else
9640                         mute = snd_hda_codec_amp_read(codec, 0x15, 0,
9641                                                       HDA_OUTPUT, 0);
9642                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9643                                          HDA_AMP_MUTE, mute);
9644         }
9645         return change;
9646 }
9647
9648 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9649         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9650         {
9651                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9652                 .name = "Master Playback Switch",
9653                 .info = snd_hda_mixer_amp_switch_info,
9654                 .get = snd_hda_mixer_amp_switch_get,
9655                 .put = alc262_sony_master_sw_put,
9656                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9657         },
9658         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9659         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9660         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9661         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9662         { } /* end */
9663 };
9664
9665 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9666         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9667         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9668         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9669         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9670         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9671         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9672         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9673         { } /* end */
9674 };
9675
9676 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
9677         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9678         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9679         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
9680         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
9681         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9682         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9683         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9684         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9685         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9686         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9687         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9688         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9689         { } /* end */
9690 };
9691
9692 static struct hda_verb alc262_tyan_verbs[] = {
9693         /* Headphone automute */
9694         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9695         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9696         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9697
9698         /* P11 AUX_IN, white 4-pin connector */
9699         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9700         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
9701         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
9702         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
9703
9704         {}
9705 };
9706
9707 /* unsolicited event for HP jack sensing */
9708 static void alc262_tyan_automute(struct hda_codec *codec)
9709 {
9710         unsigned int mute;
9711         unsigned int present;
9712
9713         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9714         present = snd_hda_codec_read(codec, 0x1b, 0,
9715                                      AC_VERB_GET_PIN_SENSE, 0);
9716         present = (present & 0x80000000) != 0;
9717         if (present) {
9718                 /* mute line output on ATX panel */
9719                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9720                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9721         } else {
9722                 /* unmute line output if necessary */
9723                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9724                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9725                                          HDA_AMP_MUTE, mute);
9726         }
9727 }
9728
9729 static void alc262_tyan_unsol_event(struct hda_codec *codec,
9730                                        unsigned int res)
9731 {
9732         if ((res >> 26) != ALC880_HP_EVENT)
9733                 return;
9734         alc262_tyan_automute(codec);
9735 }
9736
9737 #define alc262_capture_mixer            alc882_capture_mixer
9738 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
9739
9740 /*
9741  * generic initialization of ADC, input mixers and output mixers
9742  */
9743 static struct hda_verb alc262_init_verbs[] = {
9744         /*
9745          * Unmute ADC0-2 and set the default input to mic-in
9746          */
9747         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9748         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9749         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9750         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9751         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9752         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9753
9754         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9755          * mixer widget
9756          * Note: PASD motherboards uses the Line In 2 as the input for
9757          * front panel mic (mic 2)
9758          */
9759         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9760         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9761         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9762         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9763         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9764         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9765
9766         /*
9767          * Set up output mixers (0x0c - 0x0e)
9768          */
9769         /* set vol=0 to output mixers */
9770         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9771         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9772         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9773         /* set up input amps for analog loopback */
9774         /* Amp Indices: DAC = 0, mixer = 1 */
9775         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9776         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9777         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9778         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9779         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9780         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9781
9782         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9783         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9784         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9785         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9786         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9787         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9788
9789         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9790         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9791         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9792         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9793         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9794
9795         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9796         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9797
9798         /* FIXME: use matrix-type input source selection */
9799         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9800         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9801         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9802         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9803         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9804         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9805         /* Input mixer2 */
9806         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9807         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9808         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9809         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9810         /* Input mixer3 */
9811         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9812         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9813         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9814         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9815
9816         { }
9817 };
9818
9819 static struct hda_verb alc262_eapd_verbs[] = {
9820         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9821         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9822         { }
9823 };
9824
9825 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9826         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9827         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9828         {}
9829 };
9830
9831 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9832         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9833         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9834         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9835
9836         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9837         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9838         {}
9839 };
9840
9841 static struct hda_verb alc262_sony_unsol_verbs[] = {
9842         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9843         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9844         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
9845
9846         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9847         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9848         {}
9849 };
9850
9851 static struct hda_input_mux alc262_dmic_capture_source = {
9852         .num_items = 2,
9853         .items = {
9854                 { "Int DMic", 0x9 },
9855                 { "Mic", 0x0 },
9856         },
9857 };
9858
9859 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
9860         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9861         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9862         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9863         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9864         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9865         { } /* end */
9866 };
9867
9868 static struct hda_verb alc262_toshiba_s06_verbs[] = {
9869         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9870         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9871         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9872         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9873         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
9874         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9875         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
9876         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9877         {}
9878 };
9879
9880 static void alc262_dmic_automute(struct hda_codec *codec)
9881 {
9882         unsigned int present;
9883
9884         present = snd_hda_codec_read(codec, 0x18, 0,
9885                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9886         snd_hda_codec_write(codec, 0x22, 0,
9887                                 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
9888 }
9889
9890 /* toggle speaker-output according to the hp-jack state */
9891 static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec)
9892 {
9893         unsigned int present;
9894         unsigned char bits;
9895
9896         present = snd_hda_codec_read(codec, 0x15, 0,
9897                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9898         bits = present ? 0 : PIN_OUT;
9899         snd_hda_codec_write(codec, 0x14, 0,
9900                                         AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
9901 }
9902
9903
9904
9905 /* unsolicited event for HP jack sensing */
9906 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
9907                                        unsigned int res)
9908 {
9909         if ((res >> 26) == ALC880_HP_EVENT)
9910                 alc262_toshiba_s06_speaker_automute(codec);
9911         if ((res >> 26) == ALC880_MIC_EVENT)
9912                 alc262_dmic_automute(codec);
9913
9914 }
9915
9916 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
9917 {
9918         alc262_toshiba_s06_speaker_automute(codec);
9919         alc262_dmic_automute(codec);
9920 }
9921
9922 /* mute/unmute internal speaker according to the hp jack and mute state */
9923 static void alc262_hippo_automute(struct hda_codec *codec)
9924 {
9925         struct alc_spec *spec = codec->spec;
9926         unsigned int mute;
9927         unsigned int present;
9928
9929         /* need to execute and sync at first */
9930         snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9931         present = snd_hda_codec_read(codec, 0x15, 0,
9932                                      AC_VERB_GET_PIN_SENSE, 0);
9933         spec->jack_present = (present & 0x80000000) != 0;
9934         if (spec->jack_present) {
9935                 /* mute internal speaker */
9936                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9937                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9938         } else {
9939                 /* unmute internal speaker if necessary */
9940                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
9941                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9942                                          HDA_AMP_MUTE, mute);
9943         }
9944 }
9945
9946 /* unsolicited event for HP jack sensing */
9947 static void alc262_hippo_unsol_event(struct hda_codec *codec,
9948                                        unsigned int res)
9949 {
9950         if ((res >> 26) != ALC880_HP_EVENT)
9951                 return;
9952         alc262_hippo_automute(codec);
9953 }
9954
9955 static void alc262_hippo1_automute(struct hda_codec *codec)
9956 {
9957         unsigned int mute;
9958         unsigned int present;
9959
9960         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9961         present = snd_hda_codec_read(codec, 0x1b, 0,
9962                                      AC_VERB_GET_PIN_SENSE, 0);
9963         present = (present & 0x80000000) != 0;
9964         if (present) {
9965                 /* mute internal speaker */
9966                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9967                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9968         } else {
9969                 /* unmute internal speaker if necessary */
9970                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9971                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9972                                          HDA_AMP_MUTE, mute);
9973         }
9974 }
9975
9976 /* unsolicited event for HP jack sensing */
9977 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
9978                                        unsigned int res)
9979 {
9980         if ((res >> 26) != ALC880_HP_EVENT)
9981                 return;
9982         alc262_hippo1_automute(codec);
9983 }
9984
9985 /*
9986  * nec model
9987  *  0x15 = headphone
9988  *  0x16 = internal speaker
9989  *  0x18 = external mic
9990  */
9991
9992 static struct snd_kcontrol_new alc262_nec_mixer[] = {
9993         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9994         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
9995
9996         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9997         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9998         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9999
10000         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10001         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10002         { } /* end */
10003 };
10004
10005 static struct hda_verb alc262_nec_verbs[] = {
10006         /* Unmute Speaker */
10007         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10008
10009         /* Headphone */
10010         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10011         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10012
10013         /* External mic to headphone */
10014         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10015         /* External mic to speaker */
10016         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10017         {}
10018 };
10019
10020 /*
10021  * fujitsu model
10022  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10023  *  0x1b = port replicator headphone out
10024  */
10025
10026 #define ALC_HP_EVENT    0x37
10027
10028 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10029         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10030         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10031         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10032         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10033         {}
10034 };
10035
10036 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10037         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10038         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10039         {}
10040 };
10041
10042 static struct hda_input_mux alc262_fujitsu_capture_source = {
10043         .num_items = 3,
10044         .items = {
10045                 { "Mic", 0x0 },
10046                 { "Int Mic", 0x1 },
10047                 { "CD", 0x4 },
10048         },
10049 };
10050
10051 static struct hda_input_mux alc262_HP_capture_source = {
10052         .num_items = 5,
10053         .items = {
10054                 { "Mic", 0x0 },
10055                 { "Front Mic", 0x1 },
10056                 { "Line", 0x2 },
10057                 { "CD", 0x4 },
10058                 { "AUX IN", 0x6 },
10059         },
10060 };
10061
10062 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10063         .num_items = 4,
10064         .items = {
10065                 { "Mic", 0x0 },
10066                 { "Front Mic", 0x2 },
10067                 { "Line", 0x1 },
10068                 { "CD", 0x4 },
10069         },
10070 };
10071
10072 /* mute/unmute internal speaker according to the hp jacks and mute state */
10073 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10074 {
10075         struct alc_spec *spec = codec->spec;
10076         unsigned int mute;
10077
10078         if (force || !spec->sense_updated) {
10079                 unsigned int present;
10080                 /* need to execute and sync at first */
10081                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
10082                 /* check laptop HP jack */
10083                 present = snd_hda_codec_read(codec, 0x14, 0,
10084                                              AC_VERB_GET_PIN_SENSE, 0);
10085                 /* need to execute and sync at first */
10086                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10087                 /* check docking HP jack */
10088                 present |= snd_hda_codec_read(codec, 0x1b, 0,
10089                                               AC_VERB_GET_PIN_SENSE, 0);
10090                 if (present & AC_PINSENSE_PRESENCE)
10091                         spec->jack_present = 1;
10092                 else
10093                         spec->jack_present = 0;
10094                 spec->sense_updated = 1;
10095         }
10096         /* unmute internal speaker only if both HPs are unplugged and
10097          * master switch is on
10098          */
10099         if (spec->jack_present)
10100                 mute = HDA_AMP_MUTE;
10101         else
10102                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10103         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10104                                  HDA_AMP_MUTE, mute);
10105 }
10106
10107 /* unsolicited event for HP jack sensing */
10108 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10109                                        unsigned int res)
10110 {
10111         if ((res >> 26) != ALC_HP_EVENT)
10112                 return;
10113         alc262_fujitsu_automute(codec, 1);
10114 }
10115
10116 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10117 {
10118         alc262_fujitsu_automute(codec, 1);
10119 }
10120
10121 /* bind volumes of both NID 0x0c and 0x0d */
10122 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10123         .ops = &snd_hda_bind_vol,
10124         .values = {
10125                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10126                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10127                 0
10128         },
10129 };
10130
10131 /* mute/unmute internal speaker according to the hp jack and mute state */
10132 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10133 {
10134         struct alc_spec *spec = codec->spec;
10135         unsigned int mute;
10136
10137         if (force || !spec->sense_updated) {
10138                 unsigned int present_int_hp;
10139                 /* need to execute and sync at first */
10140                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10141                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
10142                                         AC_VERB_GET_PIN_SENSE, 0);
10143                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
10144                 spec->sense_updated = 1;
10145         }
10146         if (spec->jack_present) {
10147                 /* mute internal speaker */
10148                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10149                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10150                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10151                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10152         } else {
10153                 /* unmute internal speaker if necessary */
10154                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10155                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10156                                          HDA_AMP_MUTE, mute);
10157                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10158                                          HDA_AMP_MUTE, mute);
10159         }
10160 }
10161
10162 /* unsolicited event for HP jack sensing */
10163 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10164                                        unsigned int res)
10165 {
10166         if ((res >> 26) != ALC_HP_EVENT)
10167                 return;
10168         alc262_lenovo_3000_automute(codec, 1);
10169 }
10170
10171 /* bind hp and internal speaker mute (with plug check) */
10172 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10173                                          struct snd_ctl_elem_value *ucontrol)
10174 {
10175         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10176         long *valp = ucontrol->value.integer.value;
10177         int change;
10178
10179         change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10180                                                  HDA_AMP_MUTE,
10181                                                  valp ? 0 : HDA_AMP_MUTE);
10182         change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10183                                                  HDA_AMP_MUTE,
10184                                                  valp ? 0 : HDA_AMP_MUTE);
10185
10186         if (change)
10187                 alc262_fujitsu_automute(codec, 0);
10188         return change;
10189 }
10190
10191 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10192         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10193         {
10194                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10195                 .name = "Master Playback Switch",
10196                 .info = snd_hda_mixer_amp_switch_info,
10197                 .get = snd_hda_mixer_amp_switch_get,
10198                 .put = alc262_fujitsu_master_sw_put,
10199                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10200         },
10201         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10202         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10203         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10204         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10205         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10206         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10207         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10208         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10209         { } /* end */
10210 };
10211
10212 /* bind hp and internal speaker mute (with plug check) */
10213 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10214                                          struct snd_ctl_elem_value *ucontrol)
10215 {
10216         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10217         long *valp = ucontrol->value.integer.value;
10218         int change;
10219
10220         change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10221                                                  HDA_AMP_MUTE,
10222                                                  valp ? 0 : HDA_AMP_MUTE);
10223
10224         if (change)
10225                 alc262_lenovo_3000_automute(codec, 0);
10226         return change;
10227 }
10228
10229 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10230         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10231         {
10232                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10233                 .name = "Master Playback Switch",
10234                 .info = snd_hda_mixer_amp_switch_info,
10235                 .get = snd_hda_mixer_amp_switch_get,
10236                 .put = alc262_lenovo_3000_master_sw_put,
10237                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10238         },
10239         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10240         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10241         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10242         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10243         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10244         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10245         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10246         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10247         { } /* end */
10248 };
10249
10250 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10251         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10252         {
10253                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10254                 .name = "Master Playback Switch",
10255                 .info = snd_hda_mixer_amp_switch_info,
10256                 .get = snd_hda_mixer_amp_switch_get,
10257                 .put = alc262_sony_master_sw_put,
10258                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
10259         },
10260         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10261         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10262         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10263         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10264         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10265         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10266         { } /* end */
10267 };
10268
10269 /* additional init verbs for Benq laptops */
10270 static struct hda_verb alc262_EAPD_verbs[] = {
10271         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10272         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10273         {}
10274 };
10275
10276 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10277         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10278         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10279
10280         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10281         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10282         {}
10283 };
10284
10285 /* Samsung Q1 Ultra Vista model setup */
10286 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10287         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10288         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10289         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10290         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10291         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10292         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10293         { } /* end */
10294 };
10295
10296 static struct hda_verb alc262_ultra_verbs[] = {
10297         /* output mixer */
10298         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10299         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10300         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10301         /* speaker */
10302         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10303         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10304         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10305         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10306         /* HP */
10307         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10308         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10309         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10310         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10311         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10312         /* internal mic */
10313         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10314         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10315         /* ADC, choose mic */
10316         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10317         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10318         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10319         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10320         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10321         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10322         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10323         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10324         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10325         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
10326         {}
10327 };
10328
10329 /* mute/unmute internal speaker according to the hp jack and mute state */
10330 static void alc262_ultra_automute(struct hda_codec *codec)
10331 {
10332         struct alc_spec *spec = codec->spec;
10333         unsigned int mute;
10334
10335         mute = 0;
10336         /* auto-mute only when HP is used as HP */
10337         if (!spec->cur_mux[0]) {
10338                 unsigned int present;
10339                 /* need to execute and sync at first */
10340                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
10341                 present = snd_hda_codec_read(codec, 0x15, 0,
10342                                              AC_VERB_GET_PIN_SENSE, 0);
10343                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
10344                 if (spec->jack_present)
10345                         mute = HDA_AMP_MUTE;
10346         }
10347         /* mute/unmute internal speaker */
10348         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10349                                  HDA_AMP_MUTE, mute);
10350         /* mute/unmute HP */
10351         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10352                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
10353 }
10354
10355 /* unsolicited event for HP jack sensing */
10356 static void alc262_ultra_unsol_event(struct hda_codec *codec,
10357                                        unsigned int res)
10358 {
10359         if ((res >> 26) != ALC880_HP_EVENT)
10360                 return;
10361         alc262_ultra_automute(codec);
10362 }
10363
10364 static struct hda_input_mux alc262_ultra_capture_source = {
10365         .num_items = 2,
10366         .items = {
10367                 { "Mic", 0x1 },
10368                 { "Headphone", 0x7 },
10369         },
10370 };
10371
10372 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
10373                                      struct snd_ctl_elem_value *ucontrol)
10374 {
10375         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10376         struct alc_spec *spec = codec->spec;
10377         int ret;
10378
10379         ret = alc_mux_enum_put(kcontrol, ucontrol);
10380         if (!ret)
10381                 return 0;
10382         /* reprogram the HP pin as mic or HP according to the input source */
10383         snd_hda_codec_write_cache(codec, 0x15, 0,
10384                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10385                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
10386         alc262_ultra_automute(codec); /* mute/unmute HP */
10387         return ret;
10388 }
10389
10390 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
10391         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10392         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10393         {
10394                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10395                 .name = "Capture Source",
10396                 .info = alc_mux_enum_info,
10397                 .get = alc_mux_enum_get,
10398                 .put = alc262_ultra_mux_enum_put,
10399         },
10400         { } /* end */
10401 };
10402
10403 /* add playback controls from the parsed DAC table */
10404 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
10405                                              const struct auto_pin_cfg *cfg)
10406 {
10407         hda_nid_t nid;
10408         int err;
10409
10410         spec->multiout.num_dacs = 1;    /* only use one dac */
10411         spec->multiout.dac_nids = spec->private_dac_nids;
10412         spec->multiout.dac_nids[0] = 2;
10413
10414         nid = cfg->line_out_pins[0];
10415         if (nid) {
10416                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10417                                   "Front Playback Volume",
10418                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
10419                 if (err < 0)
10420                         return err;
10421                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10422                                   "Front Playback Switch",
10423                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10424                 if (err < 0)
10425                         return err;
10426         }
10427
10428         nid = cfg->speaker_pins[0];
10429         if (nid) {
10430                 if (nid == 0x16) {
10431                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10432                                           "Speaker Playback Volume",
10433                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10434                                                               HDA_OUTPUT));
10435                         if (err < 0)
10436                                 return err;
10437                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10438                                           "Speaker Playback Switch",
10439                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10440                                                               HDA_OUTPUT));
10441                         if (err < 0)
10442                                 return err;
10443                 } else {
10444                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10445                                           "Speaker Playback Switch",
10446                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10447                                                               HDA_OUTPUT));
10448                         if (err < 0)
10449                                 return err;
10450                 }
10451         }
10452         nid = cfg->hp_pins[0];
10453         if (nid) {
10454                 /* spec->multiout.hp_nid = 2; */
10455                 if (nid == 0x16) {
10456                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10457                                           "Headphone Playback Volume",
10458                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10459                                                               HDA_OUTPUT));
10460                         if (err < 0)
10461                                 return err;
10462                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10463                                           "Headphone Playback Switch",
10464                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10465                                                               HDA_OUTPUT));
10466                         if (err < 0)
10467                                 return err;
10468                 } else {
10469                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10470                                           "Headphone Playback Switch",
10471                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10472                                                               HDA_OUTPUT));
10473                         if (err < 0)
10474                                 return err;
10475                 }
10476         }
10477         return 0;
10478 }
10479
10480 /* identical with ALC880 */
10481 #define alc262_auto_create_analog_input_ctls \
10482         alc880_auto_create_analog_input_ctls
10483
10484 /*
10485  * generic initialization of ADC, input mixers and output mixers
10486  */
10487 static struct hda_verb alc262_volume_init_verbs[] = {
10488         /*
10489          * Unmute ADC0-2 and set the default input to mic-in
10490          */
10491         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10492         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10493         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10494         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10495         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10496         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10497
10498         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10499          * mixer widget
10500          * Note: PASD motherboards uses the Line In 2 as the input for
10501          * front panel mic (mic 2)
10502          */
10503         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10504         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10505         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10506         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10507         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10508         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10509
10510         /*
10511          * Set up output mixers (0x0c - 0x0f)
10512          */
10513         /* set vol=0 to output mixers */
10514         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10515         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10516         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10517
10518         /* set up input amps for analog loopback */
10519         /* Amp Indices: DAC = 0, mixer = 1 */
10520         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10521         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10522         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10523         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10524         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10525         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10526
10527         /* FIXME: use matrix-type input source selection */
10528         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10529         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10530         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10531         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10532         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10533         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10534         /* Input mixer2 */
10535         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10536         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10537         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10538         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10539         /* Input mixer3 */
10540         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10541         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10542         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10543         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10544
10545         { }
10546 };
10547
10548 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10549         /*
10550          * Unmute ADC0-2 and set the default input to mic-in
10551          */
10552         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10553         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10554         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10555         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10556         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10557         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10558
10559         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10560          * mixer widget
10561          * Note: PASD motherboards uses the Line In 2 as the input for
10562          * front panel mic (mic 2)
10563          */
10564         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10565         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10566         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10567         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10568         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10569         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10570         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10571         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10572
10573         /*
10574          * Set up output mixers (0x0c - 0x0e)
10575          */
10576         /* set vol=0 to output mixers */
10577         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10578         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10579         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10580
10581         /* set up input amps for analog loopback */
10582         /* Amp Indices: DAC = 0, mixer = 1 */
10583         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10584         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10585         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10586         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10587         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10588         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10589
10590         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10591         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10592         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10593
10594         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10595         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10596
10597         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10598         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10599
10600         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10601         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10602         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10603         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10604         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10605
10606         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10607         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10608         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10609         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10610         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10611         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10612
10613
10614         /* FIXME: use matrix-type input source selection */
10615         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10616         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10617         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10618         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10619         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10620         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10621         /* Input mixer2 */
10622         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10623         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10624         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10625         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10626         /* Input mixer3 */
10627         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10628         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10629         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10630         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10631
10632         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10633
10634         { }
10635 };
10636
10637 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10638         /*
10639          * Unmute ADC0-2 and set the default input to mic-in
10640          */
10641         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10642         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10643         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10644         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10645         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10646         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10647
10648         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10649          * mixer widget
10650          * Note: PASD motherboards uses the Line In 2 as the input for front
10651          * panel mic (mic 2)
10652          */
10653         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10654         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10655         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10656         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10657         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10658         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10659         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10660         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10661         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10662         /*
10663          * Set up output mixers (0x0c - 0x0e)
10664          */
10665         /* set vol=0 to output mixers */
10666         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10667         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10668         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10669
10670         /* set up input amps for analog loopback */
10671         /* Amp Indices: DAC = 0, mixer = 1 */
10672         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10673         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10674         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10675         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10676         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10677         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10678
10679
10680         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
10681         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
10682         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
10683         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
10684         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10685         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
10686         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
10687
10688         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10689         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10690
10691         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10692         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10693
10694         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10695         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10696         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10697         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10698         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10699         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10700
10701         /* FIXME: use matrix-type input source selection */
10702         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10703         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10704         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10705         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10706         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10707         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10708         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10709         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
10710         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10711         /* Input mixer2 */
10712         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10713         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10714         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10715         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10716         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10717         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10718         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10719         /* Input mixer3 */
10720         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10721         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10722         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10723         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10724         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10725         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10726         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10727
10728         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10729
10730         { }
10731 };
10732
10733 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10734
10735         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
10736         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10737         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10738
10739         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
10740         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10741         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10742         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10743
10744         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
10745         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10746         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10747         {}
10748 };
10749
10750
10751 #ifdef CONFIG_SND_HDA_POWER_SAVE
10752 #define alc262_loopbacks        alc880_loopbacks
10753 #endif
10754
10755 /* pcm configuration: identiacal with ALC880 */
10756 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
10757 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
10758 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
10759 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
10760
10761 /*
10762  * BIOS auto configuration
10763  */
10764 static int alc262_parse_auto_config(struct hda_codec *codec)
10765 {
10766         struct alc_spec *spec = codec->spec;
10767         int err;
10768         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10769
10770         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10771                                            alc262_ignore);
10772         if (err < 0)
10773                 return err;
10774         if (!spec->autocfg.line_outs) {
10775                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
10776                         spec->multiout.max_channels = 2;
10777                         spec->no_analog = 1;
10778                         goto dig_only;
10779                 }
10780                 return 0; /* can't find valid BIOS pin config */
10781         }
10782         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10783         if (err < 0)
10784                 return err;
10785         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10786         if (err < 0)
10787                 return err;
10788
10789         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10790
10791  dig_only:
10792         if (spec->autocfg.dig_outs) {
10793                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10794                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
10795         }
10796         if (spec->autocfg.dig_in_pin)
10797                 spec->dig_in_nid = ALC262_DIGIN_NID;
10798
10799         if (spec->kctls.list)
10800                 add_mixer(spec, spec->kctls.list);
10801
10802         add_verb(spec, alc262_volume_init_verbs);
10803         spec->num_mux_defs = 1;
10804         spec->input_mux = &spec->private_imux[0];
10805
10806         err = alc_auto_add_mic_boost(codec);
10807         if (err < 0)
10808                 return err;
10809
10810         return 1;
10811 }
10812
10813 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
10814 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
10815 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
10816 #define alc262_auto_init_input_src      alc882_auto_init_input_src
10817
10818
10819 /* init callback for auto-configuration model -- overriding the default init */
10820 static void alc262_auto_init(struct hda_codec *codec)
10821 {
10822         struct alc_spec *spec = codec->spec;
10823         alc262_auto_init_multi_out(codec);
10824         alc262_auto_init_hp_out(codec);
10825         alc262_auto_init_analog_input(codec);
10826         alc262_auto_init_input_src(codec);
10827         if (spec->unsol_event)
10828                 alc_inithook(codec);
10829 }
10830
10831 /*
10832  * configuration and preset
10833  */
10834 static const char *alc262_models[ALC262_MODEL_LAST] = {
10835         [ALC262_BASIC]          = "basic",
10836         [ALC262_HIPPO]          = "hippo",
10837         [ALC262_HIPPO_1]        = "hippo_1",
10838         [ALC262_FUJITSU]        = "fujitsu",
10839         [ALC262_HP_BPC]         = "hp-bpc",
10840         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10841         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
10842         [ALC262_HP_RP5700]      = "hp-rp5700",
10843         [ALC262_BENQ_ED8]       = "benq",
10844         [ALC262_BENQ_T31]       = "benq-t31",
10845         [ALC262_SONY_ASSAMD]    = "sony-assamd",
10846         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
10847         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
10848         [ALC262_ULTRA]          = "ultra",
10849         [ALC262_LENOVO_3000]    = "lenovo-3000",
10850         [ALC262_NEC]            = "nec",
10851         [ALC262_TYAN]           = "tyan",
10852         [ALC262_AUTO]           = "auto",
10853 };
10854
10855 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10856         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10857         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10858         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
10859                            ALC262_HP_BPC),
10860         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
10861                            ALC262_HP_BPC),
10862         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
10863                            ALC262_HP_BPC),
10864         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10865         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10866         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10867         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10868         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10869         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10870         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10871         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10872         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10873         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10874         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10875         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10876                       ALC262_HP_TC_T5735),
10877         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10878         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10879         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10880         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10881         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
10882         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
10883                            ALC262_SONY_ASSAMD),
10884         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10885                       ALC262_TOSHIBA_RX1),
10886         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
10887         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10888         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10889         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
10890         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
10891                            ALC262_ULTRA),
10892         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
10893         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10894         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10895         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10896         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
10897         {}
10898 };
10899
10900 static struct alc_config_preset alc262_presets[] = {
10901         [ALC262_BASIC] = {
10902                 .mixers = { alc262_base_mixer },
10903                 .init_verbs = { alc262_init_verbs },
10904                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10905                 .dac_nids = alc262_dac_nids,
10906                 .hp_nid = 0x03,
10907                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10908                 .channel_mode = alc262_modes,
10909                 .input_mux = &alc262_capture_source,
10910         },
10911         [ALC262_HIPPO] = {
10912                 .mixers = { alc262_base_mixer },
10913                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
10914                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10915                 .dac_nids = alc262_dac_nids,
10916                 .hp_nid = 0x03,
10917                 .dig_out_nid = ALC262_DIGOUT_NID,
10918                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10919                 .channel_mode = alc262_modes,
10920                 .input_mux = &alc262_capture_source,
10921                 .unsol_event = alc262_hippo_unsol_event,
10922                 .init_hook = alc262_hippo_automute,
10923         },
10924         [ALC262_HIPPO_1] = {
10925                 .mixers = { alc262_hippo1_mixer },
10926                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
10927                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10928                 .dac_nids = alc262_dac_nids,
10929                 .hp_nid = 0x02,
10930                 .dig_out_nid = ALC262_DIGOUT_NID,
10931                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10932                 .channel_mode = alc262_modes,
10933                 .input_mux = &alc262_capture_source,
10934                 .unsol_event = alc262_hippo1_unsol_event,
10935                 .init_hook = alc262_hippo1_automute,
10936         },
10937         [ALC262_FUJITSU] = {
10938                 .mixers = { alc262_fujitsu_mixer },
10939                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10940                                 alc262_fujitsu_unsol_verbs },
10941                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10942                 .dac_nids = alc262_dac_nids,
10943                 .hp_nid = 0x03,
10944                 .dig_out_nid = ALC262_DIGOUT_NID,
10945                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10946                 .channel_mode = alc262_modes,
10947                 .input_mux = &alc262_fujitsu_capture_source,
10948                 .unsol_event = alc262_fujitsu_unsol_event,
10949                 .init_hook = alc262_fujitsu_init_hook,
10950         },
10951         [ALC262_HP_BPC] = {
10952                 .mixers = { alc262_HP_BPC_mixer },
10953                 .init_verbs = { alc262_HP_BPC_init_verbs },
10954                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10955                 .dac_nids = alc262_dac_nids,
10956                 .hp_nid = 0x03,
10957                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10958                 .channel_mode = alc262_modes,
10959                 .input_mux = &alc262_HP_capture_source,
10960                 .unsol_event = alc262_hp_bpc_unsol_event,
10961                 .init_hook = alc262_hp_bpc_automute,
10962         },
10963         [ALC262_HP_BPC_D7000_WF] = {
10964                 .mixers = { alc262_HP_BPC_WildWest_mixer },
10965                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10966                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10967                 .dac_nids = alc262_dac_nids,
10968                 .hp_nid = 0x03,
10969                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10970                 .channel_mode = alc262_modes,
10971                 .input_mux = &alc262_HP_D7000_capture_source,
10972                 .unsol_event = alc262_hp_wildwest_unsol_event,
10973                 .init_hook = alc262_hp_wildwest_automute,
10974         },
10975         [ALC262_HP_BPC_D7000_WL] = {
10976                 .mixers = { alc262_HP_BPC_WildWest_mixer,
10977                             alc262_HP_BPC_WildWest_option_mixer },
10978                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10979                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10980                 .dac_nids = alc262_dac_nids,
10981                 .hp_nid = 0x03,
10982                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10983                 .channel_mode = alc262_modes,
10984                 .input_mux = &alc262_HP_D7000_capture_source,
10985                 .unsol_event = alc262_hp_wildwest_unsol_event,
10986                 .init_hook = alc262_hp_wildwest_automute,
10987         },
10988         [ALC262_HP_TC_T5735] = {
10989                 .mixers = { alc262_hp_t5735_mixer },
10990                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
10991                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10992                 .dac_nids = alc262_dac_nids,
10993                 .hp_nid = 0x03,
10994                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10995                 .channel_mode = alc262_modes,
10996                 .input_mux = &alc262_capture_source,
10997                 .unsol_event = alc262_hp_t5735_unsol_event,
10998                 .init_hook = alc262_hp_t5735_init_hook,
10999         },
11000         [ALC262_HP_RP5700] = {
11001                 .mixers = { alc262_hp_rp5700_mixer },
11002                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11003                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11004                 .dac_nids = alc262_dac_nids,
11005                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11006                 .channel_mode = alc262_modes,
11007                 .input_mux = &alc262_hp_rp5700_capture_source,
11008         },
11009         [ALC262_BENQ_ED8] = {
11010                 .mixers = { alc262_base_mixer },
11011                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11012                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11013                 .dac_nids = alc262_dac_nids,
11014                 .hp_nid = 0x03,
11015                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11016                 .channel_mode = alc262_modes,
11017                 .input_mux = &alc262_capture_source,
11018         },
11019         [ALC262_SONY_ASSAMD] = {
11020                 .mixers = { alc262_sony_mixer },
11021                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11022                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11023                 .dac_nids = alc262_dac_nids,
11024                 .hp_nid = 0x02,
11025                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11026                 .channel_mode = alc262_modes,
11027                 .input_mux = &alc262_capture_source,
11028                 .unsol_event = alc262_hippo_unsol_event,
11029                 .init_hook = alc262_hippo_automute,
11030         },
11031         [ALC262_BENQ_T31] = {
11032                 .mixers = { alc262_benq_t31_mixer },
11033                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
11034                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11035                 .dac_nids = alc262_dac_nids,
11036                 .hp_nid = 0x03,
11037                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11038                 .channel_mode = alc262_modes,
11039                 .input_mux = &alc262_capture_source,
11040                 .unsol_event = alc262_hippo_unsol_event,
11041                 .init_hook = alc262_hippo_automute,
11042         },
11043         [ALC262_ULTRA] = {
11044                 .mixers = { alc262_ultra_mixer },
11045                 .cap_mixer = alc262_ultra_capture_mixer,
11046                 .init_verbs = { alc262_ultra_verbs },
11047                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11048                 .dac_nids = alc262_dac_nids,
11049                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11050                 .channel_mode = alc262_modes,
11051                 .input_mux = &alc262_ultra_capture_source,
11052                 .adc_nids = alc262_adc_nids, /* ADC0 */
11053                 .capsrc_nids = alc262_capsrc_nids,
11054                 .num_adc_nids = 1, /* single ADC */
11055                 .unsol_event = alc262_ultra_unsol_event,
11056                 .init_hook = alc262_ultra_automute,
11057         },
11058         [ALC262_LENOVO_3000] = {
11059                 .mixers = { alc262_lenovo_3000_mixer },
11060                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11061                                 alc262_lenovo_3000_unsol_verbs },
11062                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11063                 .dac_nids = alc262_dac_nids,
11064                 .hp_nid = 0x03,
11065                 .dig_out_nid = ALC262_DIGOUT_NID,
11066                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11067                 .channel_mode = alc262_modes,
11068                 .input_mux = &alc262_fujitsu_capture_source,
11069                 .unsol_event = alc262_lenovo_3000_unsol_event,
11070         },
11071         [ALC262_NEC] = {
11072                 .mixers = { alc262_nec_mixer },
11073                 .init_verbs = { alc262_nec_verbs },
11074                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11075                 .dac_nids = alc262_dac_nids,
11076                 .hp_nid = 0x03,
11077                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11078                 .channel_mode = alc262_modes,
11079                 .input_mux = &alc262_capture_source,
11080         },
11081         [ALC262_TOSHIBA_S06] = {
11082                 .mixers = { alc262_toshiba_s06_mixer },
11083                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11084                                                         alc262_eapd_verbs },
11085                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11086                 .capsrc_nids = alc262_dmic_capsrc_nids,
11087                 .dac_nids = alc262_dac_nids,
11088                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11089                 .dig_out_nid = ALC262_DIGOUT_NID,
11090                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11091                 .channel_mode = alc262_modes,
11092                 .input_mux = &alc262_dmic_capture_source,
11093                 .unsol_event = alc262_toshiba_s06_unsol_event,
11094                 .init_hook = alc262_toshiba_s06_init_hook,
11095         },
11096         [ALC262_TOSHIBA_RX1] = {
11097                 .mixers = { alc262_toshiba_rx1_mixer },
11098                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11099                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11100                 .dac_nids = alc262_dac_nids,
11101                 .hp_nid = 0x03,
11102                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11103                 .channel_mode = alc262_modes,
11104                 .input_mux = &alc262_capture_source,
11105                 .unsol_event = alc262_hippo_unsol_event,
11106                 .init_hook = alc262_hippo_automute,
11107         },
11108         [ALC262_TYAN] = {
11109                 .mixers = { alc262_tyan_mixer },
11110                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11111                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11112                 .dac_nids = alc262_dac_nids,
11113                 .hp_nid = 0x02,
11114                 .dig_out_nid = ALC262_DIGOUT_NID,
11115                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11116                 .channel_mode = alc262_modes,
11117                 .input_mux = &alc262_capture_source,
11118                 .unsol_event = alc262_tyan_unsol_event,
11119                 .init_hook = alc262_tyan_automute,
11120         },
11121 };
11122
11123 static int patch_alc262(struct hda_codec *codec)
11124 {
11125         struct alc_spec *spec;
11126         int board_config;
11127         int err;
11128
11129         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11130         if (spec == NULL)
11131                 return -ENOMEM;
11132
11133         codec->spec = spec;
11134 #if 0
11135         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11136          * under-run
11137          */
11138         {
11139         int tmp;
11140         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11141         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11142         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11143         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11144         }
11145 #endif
11146
11147         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11148
11149         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11150                                                   alc262_models,
11151                                                   alc262_cfg_tbl);
11152
11153         if (board_config < 0) {
11154                 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
11155                        "trying auto-probe from BIOS...\n");
11156                 board_config = ALC262_AUTO;
11157         }
11158
11159         if (board_config == ALC262_AUTO) {
11160                 /* automatic parse from the BIOS config */
11161                 err = alc262_parse_auto_config(codec);
11162                 if (err < 0) {
11163                         alc_free(codec);
11164                         return err;
11165                 } else if (!err) {
11166                         printk(KERN_INFO
11167                                "hda_codec: Cannot set up configuration "
11168                                "from BIOS.  Using base mode...\n");
11169                         board_config = ALC262_BASIC;
11170                 }
11171         }
11172
11173         if (!spec->no_analog) {
11174                 err = snd_hda_attach_beep_device(codec, 0x1);
11175                 if (err < 0) {
11176                         alc_free(codec);
11177                         return err;
11178                 }
11179         }
11180
11181         if (board_config != ALC262_AUTO)
11182                 setup_preset(spec, &alc262_presets[board_config]);
11183
11184         spec->stream_name_analog = "ALC262 Analog";
11185         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11186         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11187
11188         spec->stream_name_digital = "ALC262 Digital";
11189         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11190         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11191
11192         spec->capture_style = CAPT_MIX;
11193         if (!spec->adc_nids && spec->input_mux) {
11194                 /* check whether NID 0x07 is valid */
11195                 unsigned int wcap = get_wcaps(codec, 0x07);
11196
11197                 /* get type */
11198                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11199                 if (wcap != AC_WID_AUD_IN) {
11200                         spec->adc_nids = alc262_adc_nids_alt;
11201                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
11202                         spec->capsrc_nids = alc262_capsrc_nids_alt;
11203                 } else {
11204                         spec->adc_nids = alc262_adc_nids;
11205                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
11206                         spec->capsrc_nids = alc262_capsrc_nids;
11207                 }
11208         }
11209         if (!spec->cap_mixer && !spec->no_analog)
11210                 set_capture_mixer(spec);
11211         if (!spec->no_analog)
11212                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11213
11214         spec->vmaster_nid = 0x0c;
11215
11216         codec->patch_ops = alc_patch_ops;
11217         if (board_config == ALC262_AUTO)
11218                 spec->init_hook = alc262_auto_init;
11219 #ifdef CONFIG_SND_HDA_POWER_SAVE
11220         if (!spec->loopback.amplist)
11221                 spec->loopback.amplist = alc262_loopbacks;
11222 #endif
11223         codec->proc_widget_hook = print_realtek_coef;
11224
11225         return 0;
11226 }
11227
11228 /*
11229  *  ALC268 channel source setting (2 channel)
11230  */
11231 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
11232 #define alc268_modes            alc260_modes
11233
11234 static hda_nid_t alc268_dac_nids[2] = {
11235         /* front, hp */
11236         0x02, 0x03
11237 };
11238
11239 static hda_nid_t alc268_adc_nids[2] = {
11240         /* ADC0-1 */
11241         0x08, 0x07
11242 };
11243
11244 static hda_nid_t alc268_adc_nids_alt[1] = {
11245         /* ADC0 */
11246         0x08
11247 };
11248
11249 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11250
11251 static struct snd_kcontrol_new alc268_base_mixer[] = {
11252         /* output mixer control */
11253         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11254         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11255         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11256         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11257         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11258         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11259         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11260         { }
11261 };
11262
11263 /* bind Beep switches of both NID 0x0f and 0x10 */
11264 static struct hda_bind_ctls alc268_bind_beep_sw = {
11265         .ops = &snd_hda_bind_sw,
11266         .values = {
11267                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
11268                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
11269                 0
11270         },
11271 };
11272
11273 static struct snd_kcontrol_new alc268_beep_mixer[] = {
11274         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
11275         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
11276         { }
11277 };
11278
11279 static struct hda_verb alc268_eapd_verbs[] = {
11280         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11281         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11282         { }
11283 };
11284
11285 /* Toshiba specific */
11286 #define alc268_toshiba_automute alc262_hippo_automute
11287
11288 static struct hda_verb alc268_toshiba_verbs[] = {
11289         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11290         { } /* end */
11291 };
11292
11293 static struct hda_input_mux alc268_acer_lc_capture_source = {
11294         .num_items = 2,
11295         .items = {
11296                 { "i-Mic", 0x6 },
11297                 { "E-Mic", 0x0 },
11298         },
11299 };
11300
11301 /* Acer specific */
11302 /* bind volumes of both NID 0x02 and 0x03 */
11303 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
11304         .ops = &snd_hda_bind_vol,
11305         .values = {
11306                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11307                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11308                 0
11309         },
11310 };
11311
11312 /* mute/unmute internal speaker according to the hp jack and mute state */
11313 static void alc268_acer_automute(struct hda_codec *codec, int force)
11314 {
11315         struct alc_spec *spec = codec->spec;
11316         unsigned int mute;
11317
11318         if (force || !spec->sense_updated) {
11319                 unsigned int present;
11320                 present = snd_hda_codec_read(codec, 0x14, 0,
11321                                          AC_VERB_GET_PIN_SENSE, 0);
11322                 spec->jack_present = (present & 0x80000000) != 0;
11323                 spec->sense_updated = 1;
11324         }
11325         if (spec->jack_present)
11326                 mute = HDA_AMP_MUTE; /* mute internal speaker */
11327         else /* unmute internal speaker if necessary */
11328                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11329         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11330                                  HDA_AMP_MUTE, mute);
11331 }
11332
11333
11334 /* bind hp and internal speaker mute (with plug check) */
11335 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
11336                                      struct snd_ctl_elem_value *ucontrol)
11337 {
11338         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11339         long *valp = ucontrol->value.integer.value;
11340         int change;
11341
11342         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
11343                                           HDA_AMP_MUTE,
11344                                           valp[0] ? 0 : HDA_AMP_MUTE);
11345         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
11346                                            HDA_AMP_MUTE,
11347                                            valp[1] ? 0 : HDA_AMP_MUTE);
11348         if (change)
11349                 alc268_acer_automute(codec, 0);
11350         return change;
11351 }
11352
11353 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
11354         /* output mixer control */
11355         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11356         {
11357                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11358                 .name = "Master Playback Switch",
11359                 .info = snd_hda_mixer_amp_switch_info,
11360                 .get = snd_hda_mixer_amp_switch_get,
11361                 .put = alc268_acer_master_sw_put,
11362                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11363         },
11364         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
11365         { }
11366 };
11367
11368 static struct snd_kcontrol_new alc268_acer_mixer[] = {
11369         /* output mixer control */
11370         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11371         {
11372                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11373                 .name = "Master Playback Switch",
11374                 .info = snd_hda_mixer_amp_switch_info,
11375                 .get = snd_hda_mixer_amp_switch_get,
11376                 .put = alc268_acer_master_sw_put,
11377                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11378         },
11379         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11380         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11381         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11382         { }
11383 };
11384
11385 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
11386         /* output mixer control */
11387         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11388         {
11389                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11390                 .name = "Master Playback Switch",
11391                 .info = snd_hda_mixer_amp_switch_info,
11392                 .get = snd_hda_mixer_amp_switch_get,
11393                 .put = alc268_acer_master_sw_put,
11394                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11395         },
11396         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11397         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11398         { }
11399 };
11400
11401 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
11402         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11403         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11404         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11405         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11406         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
11407         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
11408         { }
11409 };
11410
11411 static struct hda_verb alc268_acer_verbs[] = {
11412         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
11413         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11414         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11415         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11416         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11417         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11418         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11419         { }
11420 };
11421
11422 /* unsolicited event for HP jack sensing */
11423 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
11424                                        unsigned int res)
11425 {
11426         if ((res >> 26) != ALC880_HP_EVENT)
11427                 return;
11428         alc268_toshiba_automute(codec);
11429 }
11430
11431 static void alc268_acer_unsol_event(struct hda_codec *codec,
11432                                        unsigned int res)
11433 {
11434         if ((res >> 26) != ALC880_HP_EVENT)
11435                 return;
11436         alc268_acer_automute(codec, 1);
11437 }
11438
11439 static void alc268_acer_init_hook(struct hda_codec *codec)
11440 {
11441         alc268_acer_automute(codec, 1);
11442 }
11443
11444 /* toggle speaker-output according to the hp-jack state */
11445 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
11446 {
11447         unsigned int present;
11448         unsigned char bits;
11449
11450         present = snd_hda_codec_read(codec, 0x15, 0,
11451                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11452         bits = present ? AMP_IN_MUTE(0) : 0;
11453         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
11454                                 AMP_IN_MUTE(0), bits);
11455         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
11456                                 AMP_IN_MUTE(0), bits);
11457 }
11458
11459
11460 static void alc268_acer_mic_automute(struct hda_codec *codec)
11461 {
11462         unsigned int present;
11463
11464         present = snd_hda_codec_read(codec, 0x18, 0,
11465                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11466         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11467                             present ? 0x0 : 0x6);
11468 }
11469
11470 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
11471                                     unsigned int res)
11472 {
11473         if ((res >> 26) == ALC880_HP_EVENT)
11474                 alc268_aspire_one_speaker_automute(codec);
11475         if ((res >> 26) == ALC880_MIC_EVENT)
11476                 alc268_acer_mic_automute(codec);
11477 }
11478
11479 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
11480 {
11481         alc268_aspire_one_speaker_automute(codec);
11482         alc268_acer_mic_automute(codec);
11483 }
11484
11485 static struct snd_kcontrol_new alc268_dell_mixer[] = {
11486         /* output mixer control */
11487         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11488         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11489         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11490         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11491         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11492         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11493         { }
11494 };
11495
11496 static struct hda_verb alc268_dell_verbs[] = {
11497         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11498         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11499         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11500         { }
11501 };
11502
11503 /* mute/unmute internal speaker according to the hp jack and mute state */
11504 static void alc268_dell_automute(struct hda_codec *codec)
11505 {
11506         unsigned int present;
11507         unsigned int mute;
11508
11509         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
11510         if (present & 0x80000000)
11511                 mute = HDA_AMP_MUTE;
11512         else
11513                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
11514         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11515                                  HDA_AMP_MUTE, mute);
11516 }
11517
11518 static void alc268_dell_unsol_event(struct hda_codec *codec,
11519                                     unsigned int res)
11520 {
11521         if ((res >> 26) != ALC880_HP_EVENT)
11522                 return;
11523         alc268_dell_automute(codec);
11524 }
11525
11526 #define alc268_dell_init_hook   alc268_dell_automute
11527
11528 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
11529         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11530         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11531         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11532         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11533         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11534         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
11535         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
11536         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11537         { }
11538 };
11539
11540 static struct hda_verb alc267_quanta_il1_verbs[] = {
11541         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11542         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11543         { }
11544 };
11545
11546 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
11547 {
11548         unsigned int present;
11549
11550         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
11551                 & AC_PINSENSE_PRESENCE;
11552         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11553                             present ? 0 : PIN_OUT);
11554 }
11555
11556 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11557 {
11558         unsigned int present;
11559
11560         present = snd_hda_codec_read(codec, 0x18, 0,
11561                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11562         snd_hda_codec_write(codec, 0x23, 0,
11563                             AC_VERB_SET_CONNECT_SEL,
11564                             present ? 0x00 : 0x01);
11565 }
11566
11567 static void alc267_quanta_il1_automute(struct hda_codec *codec)
11568 {
11569         alc267_quanta_il1_hp_automute(codec);
11570         alc267_quanta_il1_mic_automute(codec);
11571 }
11572
11573 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11574                                            unsigned int res)
11575 {
11576         switch (res >> 26) {
11577         case ALC880_HP_EVENT:
11578                 alc267_quanta_il1_hp_automute(codec);
11579                 break;
11580         case ALC880_MIC_EVENT:
11581                 alc267_quanta_il1_mic_automute(codec);
11582                 break;
11583         }
11584 }
11585
11586 /*
11587  * generic initialization of ADC, input mixers and output mixers
11588  */
11589 static struct hda_verb alc268_base_init_verbs[] = {
11590         /* Unmute DAC0-1 and set vol = 0 */
11591         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11592         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11593
11594         /*
11595          * Set up output mixers (0x0c - 0x0e)
11596          */
11597         /* set vol=0 to output mixers */
11598         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11599         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11600
11601         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11602         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11603
11604         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11605         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11606         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11607         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11608         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11609         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11610         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11611         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11612
11613         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11614         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11615         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11616         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11617         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11618
11619         /* set PCBEEP vol = 0, mute connections */
11620         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11621         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11622         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11623
11624         /* Unmute Selector 23h,24h and set the default input to mic-in */
11625
11626         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11627         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11628         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11629         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11630
11631         { }
11632 };
11633
11634 /*
11635  * generic initialization of ADC, input mixers and output mixers
11636  */
11637 static struct hda_verb alc268_volume_init_verbs[] = {
11638         /* set output DAC */
11639         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11640         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11641
11642         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11643         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11644         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11645         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11646         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11647
11648         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11649         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11650         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11651
11652         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11653         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11654
11655         /* set PCBEEP vol = 0, mute connections */
11656         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11657         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11658         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11659
11660         { }
11661 };
11662
11663 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11664         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11665         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11666         {
11667                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11668                 /* The multiple "Capture Source" controls confuse alsamixer
11669                  * So call somewhat different..
11670                  */
11671                 /* .name = "Capture Source", */
11672                 .name = "Input Source",
11673                 .count = 1,
11674                 .info = alc_mux_enum_info,
11675                 .get = alc_mux_enum_get,
11676                 .put = alc_mux_enum_put,
11677         },
11678         { } /* end */
11679 };
11680
11681 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11682         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11683         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11684         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11685         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11686         {
11687                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11688                 /* The multiple "Capture Source" controls confuse alsamixer
11689                  * So call somewhat different..
11690                  */
11691                 /* .name = "Capture Source", */
11692                 .name = "Input Source",
11693                 .count = 2,
11694                 .info = alc_mux_enum_info,
11695                 .get = alc_mux_enum_get,
11696                 .put = alc_mux_enum_put,
11697         },
11698         { } /* end */
11699 };
11700
11701 static struct hda_input_mux alc268_capture_source = {
11702         .num_items = 4,
11703         .items = {
11704                 { "Mic", 0x0 },
11705                 { "Front Mic", 0x1 },
11706                 { "Line", 0x2 },
11707                 { "CD", 0x3 },
11708         },
11709 };
11710
11711 static struct hda_input_mux alc268_acer_capture_source = {
11712         .num_items = 3,
11713         .items = {
11714                 { "Mic", 0x0 },
11715                 { "Internal Mic", 0x1 },
11716                 { "Line", 0x2 },
11717         },
11718 };
11719
11720 static struct hda_input_mux alc268_acer_dmic_capture_source = {
11721         .num_items = 3,
11722         .items = {
11723                 { "Mic", 0x0 },
11724                 { "Internal Mic", 0x6 },
11725                 { "Line", 0x2 },
11726         },
11727 };
11728
11729 #ifdef CONFIG_SND_DEBUG
11730 static struct snd_kcontrol_new alc268_test_mixer[] = {
11731         /* Volume widgets */
11732         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11733         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11734         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11735         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11736         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11737         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11738         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11739         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11740         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11741         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11742         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11743         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11744         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11745         /* The below appears problematic on some hardwares */
11746         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11747         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11748         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11749         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11750         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11751
11752         /* Modes for retasking pin widgets */
11753         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11754         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11755         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11756         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11757
11758         /* Controls for GPIO pins, assuming they are configured as outputs */
11759         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11760         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11761         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11762         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11763
11764         /* Switches to allow the digital SPDIF output pin to be enabled.
11765          * The ALC268 does not have an SPDIF input.
11766          */
11767         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11768
11769         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
11770          * this output to turn on an external amplifier.
11771          */
11772         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11773         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11774
11775         { } /* end */
11776 };
11777 #endif
11778
11779 /* create input playback/capture controls for the given pin */
11780 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11781                                     const char *ctlname, int idx)
11782 {
11783         char name[32];
11784         int err;
11785
11786         sprintf(name, "%s Playback Volume", ctlname);
11787         if (nid == 0x14) {
11788                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11789                                   HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
11790                                                       HDA_OUTPUT));
11791                 if (err < 0)
11792                         return err;
11793         } else if (nid == 0x15) {
11794                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11795                                   HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
11796                                                       HDA_OUTPUT));
11797                 if (err < 0)
11798                         return err;
11799         } else
11800                 return -1;
11801         sprintf(name, "%s Playback Switch", ctlname);
11802         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11803                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11804         if (err < 0)
11805                 return err;
11806         return 0;
11807 }
11808
11809 /* add playback controls from the parsed DAC table */
11810 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11811                                              const struct auto_pin_cfg *cfg)
11812 {
11813         hda_nid_t nid;
11814         int err;
11815
11816         spec->multiout.num_dacs = 2;    /* only use one dac */
11817         spec->multiout.dac_nids = spec->private_dac_nids;
11818         spec->multiout.dac_nids[0] = 2;
11819         spec->multiout.dac_nids[1] = 3;
11820
11821         nid = cfg->line_out_pins[0];
11822         if (nid)
11823                 alc268_new_analog_output(spec, nid, "Front", 0);
11824
11825         nid = cfg->speaker_pins[0];
11826         if (nid == 0x1d) {
11827                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11828                                   "Speaker Playback Volume",
11829                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11830                 if (err < 0)
11831                         return err;
11832         }
11833         nid = cfg->hp_pins[0];
11834         if (nid)
11835                 alc268_new_analog_output(spec, nid, "Headphone", 0);
11836
11837         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11838         if (nid == 0x16) {
11839                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11840                                   "Mono Playback Switch",
11841                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
11842                 if (err < 0)
11843                         return err;
11844         }
11845         return 0;
11846 }
11847
11848 /* create playback/capture controls for input pins */
11849 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11850                                                 const struct auto_pin_cfg *cfg)
11851 {
11852         struct hda_input_mux *imux = &spec->private_imux[0];
11853         int i, idx1;
11854
11855         for (i = 0; i < AUTO_PIN_LAST; i++) {
11856                 switch(cfg->input_pins[i]) {
11857                 case 0x18:
11858                         idx1 = 0;       /* Mic 1 */
11859                         break;
11860                 case 0x19:
11861                         idx1 = 1;       /* Mic 2 */
11862                         break;
11863                 case 0x1a:
11864                         idx1 = 2;       /* Line In */
11865                         break;
11866                 case 0x1c:
11867                         idx1 = 3;       /* CD */
11868                         break;
11869                 case 0x12:
11870                 case 0x13:
11871                         idx1 = 6;       /* digital mics */
11872                         break;
11873                 default:
11874                         continue;
11875                 }
11876                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11877                 imux->items[imux->num_items].index = idx1;
11878                 imux->num_items++;
11879         }
11880         return 0;
11881 }
11882
11883 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11884 {
11885         struct alc_spec *spec = codec->spec;
11886         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11887         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11888         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11889         unsigned int    dac_vol1, dac_vol2;
11890
11891         if (speaker_nid) {
11892                 snd_hda_codec_write(codec, speaker_nid, 0,
11893                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11894                 snd_hda_codec_write(codec, 0x0f, 0,
11895                                     AC_VERB_SET_AMP_GAIN_MUTE,
11896                                     AMP_IN_UNMUTE(1));
11897                 snd_hda_codec_write(codec, 0x10, 0,
11898                                     AC_VERB_SET_AMP_GAIN_MUTE,
11899                                     AMP_IN_UNMUTE(1));
11900         } else {
11901                 snd_hda_codec_write(codec, 0x0f, 0,
11902                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11903                 snd_hda_codec_write(codec, 0x10, 0,
11904                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11905         }
11906
11907         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
11908         if (line_nid == 0x14)
11909                 dac_vol2 = AMP_OUT_ZERO;
11910         else if (line_nid == 0x15)
11911                 dac_vol1 = AMP_OUT_ZERO;
11912         if (hp_nid == 0x14)
11913                 dac_vol2 = AMP_OUT_ZERO;
11914         else if (hp_nid == 0x15)
11915                 dac_vol1 = AMP_OUT_ZERO;
11916         if (line_nid != 0x16 || hp_nid != 0x16 ||
11917             spec->autocfg.line_out_pins[1] != 0x16 ||
11918             spec->autocfg.line_out_pins[2] != 0x16)
11919                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
11920
11921         snd_hda_codec_write(codec, 0x02, 0,
11922                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
11923         snd_hda_codec_write(codec, 0x03, 0,
11924                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
11925 }
11926
11927 /* pcm configuration: identiacal with ALC880 */
11928 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
11929 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
11930 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
11931 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
11932
11933 /*
11934  * BIOS auto configuration
11935  */
11936 static int alc268_parse_auto_config(struct hda_codec *codec)
11937 {
11938         struct alc_spec *spec = codec->spec;
11939         int err;
11940         static hda_nid_t alc268_ignore[] = { 0 };
11941
11942         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11943                                            alc268_ignore);
11944         if (err < 0)
11945                 return err;
11946         if (!spec->autocfg.line_outs) {
11947                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11948                         spec->multiout.max_channels = 2;
11949                         spec->no_analog = 1;
11950                         goto dig_only;
11951                 }
11952                 return 0; /* can't find valid BIOS pin config */
11953         }
11954         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
11955         if (err < 0)
11956                 return err;
11957         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
11958         if (err < 0)
11959                 return err;
11960
11961         spec->multiout.max_channels = 2;
11962
11963  dig_only:
11964         /* digital only support output */
11965         if (spec->autocfg.dig_outs) {
11966                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
11967                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11968         }
11969         if (spec->kctls.list)
11970                 add_mixer(spec, spec->kctls.list);
11971
11972         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
11973                 add_mixer(spec, alc268_beep_mixer);
11974
11975         add_verb(spec, alc268_volume_init_verbs);
11976         spec->num_mux_defs = 1;
11977         spec->input_mux = &spec->private_imux[0];
11978
11979         err = alc_auto_add_mic_boost(codec);
11980         if (err < 0)
11981                 return err;
11982
11983         return 1;
11984 }
11985
11986 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
11987 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
11988 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
11989
11990 /* init callback for auto-configuration model -- overriding the default init */
11991 static void alc268_auto_init(struct hda_codec *codec)
11992 {
11993         struct alc_spec *spec = codec->spec;
11994         alc268_auto_init_multi_out(codec);
11995         alc268_auto_init_hp_out(codec);
11996         alc268_auto_init_mono_speaker_out(codec);
11997         alc268_auto_init_analog_input(codec);
11998         if (spec->unsol_event)
11999                 alc_inithook(codec);
12000 }
12001
12002 /*
12003  * configuration and preset
12004  */
12005 static const char *alc268_models[ALC268_MODEL_LAST] = {
12006         [ALC267_QUANTA_IL1]     = "quanta-il1",
12007         [ALC268_3ST]            = "3stack",
12008         [ALC268_TOSHIBA]        = "toshiba",
12009         [ALC268_ACER]           = "acer",
12010         [ALC268_ACER_DMIC]      = "acer-dmic",
12011         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
12012         [ALC268_DELL]           = "dell",
12013         [ALC268_ZEPTO]          = "zepto",
12014 #ifdef CONFIG_SND_DEBUG
12015         [ALC268_TEST]           = "test",
12016 #endif
12017         [ALC268_AUTO]           = "auto",
12018 };
12019
12020 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12021         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12022         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12023         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12024         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12025         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12026         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12027                                                 ALC268_ACER_ASPIRE_ONE),
12028         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12029         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
12030         SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
12031         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12032         SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
12033         SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
12034         SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
12035         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12036         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12037         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12038         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12039         {}
12040 };
12041
12042 static struct alc_config_preset alc268_presets[] = {
12043         [ALC267_QUANTA_IL1] = {
12044                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
12045                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12046                                 alc267_quanta_il1_verbs },
12047                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12048                 .dac_nids = alc268_dac_nids,
12049                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12050                 .adc_nids = alc268_adc_nids_alt,
12051                 .hp_nid = 0x03,
12052                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12053                 .channel_mode = alc268_modes,
12054                 .input_mux = &alc268_capture_source,
12055                 .unsol_event = alc267_quanta_il1_unsol_event,
12056                 .init_hook = alc267_quanta_il1_automute,
12057         },
12058         [ALC268_3ST] = {
12059                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12060                             alc268_beep_mixer },
12061                 .init_verbs = { alc268_base_init_verbs },
12062                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12063                 .dac_nids = alc268_dac_nids,
12064                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12065                 .adc_nids = alc268_adc_nids_alt,
12066                 .capsrc_nids = alc268_capsrc_nids,
12067                 .hp_nid = 0x03,
12068                 .dig_out_nid = ALC268_DIGOUT_NID,
12069                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12070                 .channel_mode = alc268_modes,
12071                 .input_mux = &alc268_capture_source,
12072         },
12073         [ALC268_TOSHIBA] = {
12074                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12075                             alc268_beep_mixer },
12076                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12077                                 alc268_toshiba_verbs },
12078                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12079                 .dac_nids = alc268_dac_nids,
12080                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12081                 .adc_nids = alc268_adc_nids_alt,
12082                 .capsrc_nids = alc268_capsrc_nids,
12083                 .hp_nid = 0x03,
12084                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12085                 .channel_mode = alc268_modes,
12086                 .input_mux = &alc268_capture_source,
12087                 .unsol_event = alc268_toshiba_unsol_event,
12088                 .init_hook = alc268_toshiba_automute,
12089         },
12090         [ALC268_ACER] = {
12091                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12092                             alc268_beep_mixer },
12093                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12094                                 alc268_acer_verbs },
12095                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12096                 .dac_nids = alc268_dac_nids,
12097                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12098                 .adc_nids = alc268_adc_nids_alt,
12099                 .capsrc_nids = alc268_capsrc_nids,
12100                 .hp_nid = 0x02,
12101                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12102                 .channel_mode = alc268_modes,
12103                 .input_mux = &alc268_acer_capture_source,
12104                 .unsol_event = alc268_acer_unsol_event,
12105                 .init_hook = alc268_acer_init_hook,
12106         },
12107         [ALC268_ACER_DMIC] = {
12108                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12109                             alc268_beep_mixer },
12110                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12111                                 alc268_acer_verbs },
12112                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12113                 .dac_nids = alc268_dac_nids,
12114                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12115                 .adc_nids = alc268_adc_nids_alt,
12116                 .capsrc_nids = alc268_capsrc_nids,
12117                 .hp_nid = 0x02,
12118                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12119                 .channel_mode = alc268_modes,
12120                 .input_mux = &alc268_acer_dmic_capture_source,
12121                 .unsol_event = alc268_acer_unsol_event,
12122                 .init_hook = alc268_acer_init_hook,
12123         },
12124         [ALC268_ACER_ASPIRE_ONE] = {
12125                 .mixers = { alc268_acer_aspire_one_mixer,
12126                             alc268_beep_mixer,
12127                             alc268_capture_alt_mixer },
12128                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12129                                 alc268_acer_aspire_one_verbs },
12130                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12131                 .dac_nids = alc268_dac_nids,
12132                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12133                 .adc_nids = alc268_adc_nids_alt,
12134                 .capsrc_nids = alc268_capsrc_nids,
12135                 .hp_nid = 0x03,
12136                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12137                 .channel_mode = alc268_modes,
12138                 .input_mux = &alc268_acer_lc_capture_source,
12139                 .unsol_event = alc268_acer_lc_unsol_event,
12140                 .init_hook = alc268_acer_lc_init_hook,
12141         },
12142         [ALC268_DELL] = {
12143                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
12144                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12145                                 alc268_dell_verbs },
12146                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12147                 .dac_nids = alc268_dac_nids,
12148                 .hp_nid = 0x02,
12149                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12150                 .channel_mode = alc268_modes,
12151                 .unsol_event = alc268_dell_unsol_event,
12152                 .init_hook = alc268_dell_init_hook,
12153                 .input_mux = &alc268_capture_source,
12154         },
12155         [ALC268_ZEPTO] = {
12156                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12157                             alc268_beep_mixer },
12158                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12159                                 alc268_toshiba_verbs },
12160                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12161                 .dac_nids = alc268_dac_nids,
12162                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12163                 .adc_nids = alc268_adc_nids_alt,
12164                 .capsrc_nids = alc268_capsrc_nids,
12165                 .hp_nid = 0x03,
12166                 .dig_out_nid = ALC268_DIGOUT_NID,
12167                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12168                 .channel_mode = alc268_modes,
12169                 .input_mux = &alc268_capture_source,
12170                 .unsol_event = alc268_toshiba_unsol_event,
12171                 .init_hook = alc268_toshiba_automute
12172         },
12173 #ifdef CONFIG_SND_DEBUG
12174         [ALC268_TEST] = {
12175                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
12176                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12177                                 alc268_volume_init_verbs },
12178                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12179                 .dac_nids = alc268_dac_nids,
12180                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12181                 .adc_nids = alc268_adc_nids_alt,
12182                 .capsrc_nids = alc268_capsrc_nids,
12183                 .hp_nid = 0x03,
12184                 .dig_out_nid = ALC268_DIGOUT_NID,
12185                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12186                 .channel_mode = alc268_modes,
12187                 .input_mux = &alc268_capture_source,
12188         },
12189 #endif
12190 };
12191
12192 static int patch_alc268(struct hda_codec *codec)
12193 {
12194         struct alc_spec *spec;
12195         int board_config;
12196         int i, has_beep, err;
12197
12198         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12199         if (spec == NULL)
12200                 return -ENOMEM;
12201
12202         codec->spec = spec;
12203
12204         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12205                                                   alc268_models,
12206                                                   alc268_cfg_tbl);
12207
12208         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12209                 printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
12210                        "trying auto-probe from BIOS...\n");
12211                 board_config = ALC268_AUTO;
12212         }
12213
12214         if (board_config == ALC268_AUTO) {
12215                 /* automatic parse from the BIOS config */
12216                 err = alc268_parse_auto_config(codec);
12217                 if (err < 0) {
12218                         alc_free(codec);
12219                         return err;
12220                 } else if (!err) {
12221                         printk(KERN_INFO
12222                                "hda_codec: Cannot set up configuration "
12223                                "from BIOS.  Using base mode...\n");
12224                         board_config = ALC268_3ST;
12225                 }
12226         }
12227
12228         if (board_config != ALC268_AUTO)
12229                 setup_preset(spec, &alc268_presets[board_config]);
12230
12231         if (codec->vendor_id == 0x10ec0267) {
12232                 spec->stream_name_analog = "ALC267 Analog";
12233                 spec->stream_name_digital = "ALC267 Digital";
12234         } else {
12235                 spec->stream_name_analog = "ALC268 Analog";
12236                 spec->stream_name_digital = "ALC268 Digital";
12237         }
12238
12239         spec->stream_analog_playback = &alc268_pcm_analog_playback;
12240         spec->stream_analog_capture = &alc268_pcm_analog_capture;
12241         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12242
12243         spec->stream_digital_playback = &alc268_pcm_digital_playback;
12244
12245         has_beep = 0;
12246         for (i = 0; i < spec->num_mixers; i++) {
12247                 if (spec->mixers[i] == alc268_beep_mixer) {
12248                         has_beep = 1;
12249                         break;
12250                 }
12251         }
12252
12253         if (has_beep) {
12254                 err = snd_hda_attach_beep_device(codec, 0x1);
12255                 if (err < 0) {
12256                         alc_free(codec);
12257                         return err;
12258                 }
12259                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12260                         /* override the amp caps for beep generator */
12261                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12262                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12263                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12264                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12265                                           (0 << AC_AMPCAP_MUTE_SHIFT));
12266         }
12267
12268         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12269                 /* check whether NID 0x07 is valid */
12270                 unsigned int wcap = get_wcaps(codec, 0x07);
12271                 int i;
12272
12273                 /* get type */
12274                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
12275                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
12276                         spec->adc_nids = alc268_adc_nids_alt;
12277                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
12278                         add_mixer(spec, alc268_capture_alt_mixer);
12279                 } else {
12280                         spec->adc_nids = alc268_adc_nids;
12281                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
12282                         add_mixer(spec, alc268_capture_mixer);
12283                 }
12284                 spec->capsrc_nids = alc268_capsrc_nids;
12285                 /* set default input source */
12286                 for (i = 0; i < spec->num_adc_nids; i++)
12287                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
12288                                 0, AC_VERB_SET_CONNECT_SEL,
12289                                 spec->input_mux->items[0].index);
12290         }
12291
12292         spec->vmaster_nid = 0x02;
12293
12294         codec->patch_ops = alc_patch_ops;
12295         if (board_config == ALC268_AUTO)
12296                 spec->init_hook = alc268_auto_init;
12297
12298         codec->proc_widget_hook = print_realtek_coef;
12299
12300         return 0;
12301 }
12302
12303 /*
12304  *  ALC269 channel source setting (2 channel)
12305  */
12306 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
12307
12308 #define alc269_dac_nids         alc260_dac_nids
12309
12310 static hda_nid_t alc269_adc_nids[1] = {
12311         /* ADC1 */
12312         0x08,
12313 };
12314
12315 static hda_nid_t alc269_capsrc_nids[1] = {
12316         0x23,
12317 };
12318
12319 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
12320  *       not a mux!
12321  */
12322
12323 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
12324         .num_items = 2,
12325         .items = {
12326                 { "i-Mic", 0x5 },
12327                 { "e-Mic", 0x0 },
12328         },
12329 };
12330
12331 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
12332         .num_items = 2,
12333         .items = {
12334                 { "i-Mic", 0x1 },
12335                 { "e-Mic", 0x0 },
12336         },
12337 };
12338
12339 #define alc269_modes            alc260_modes
12340 #define alc269_capture_source   alc880_lg_lw_capture_source
12341
12342 static struct snd_kcontrol_new alc269_base_mixer[] = {
12343         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12344         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12345         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12346         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12347         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12348         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12349         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12350         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12351         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12352         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12353         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12354         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
12355         { } /* end */
12356 };
12357
12358 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
12359         /* output mixer control */
12360         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12361         {
12362                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12363                 .name = "Master Playback Switch",
12364                 .info = snd_hda_mixer_amp_switch_info,
12365                 .get = snd_hda_mixer_amp_switch_get,
12366                 .put = alc268_acer_master_sw_put,
12367                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12368         },
12369         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12370         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12371         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12372         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12373         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12374         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12375         { }
12376 };
12377
12378 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
12379         /* output mixer control */
12380         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12381         {
12382                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12383                 .name = "Master Playback Switch",
12384                 .info = snd_hda_mixer_amp_switch_info,
12385                 .get = snd_hda_mixer_amp_switch_get,
12386                 .put = alc268_acer_master_sw_put,
12387                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12388         },
12389         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12390         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12391         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12392         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12393         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12394         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12395         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
12396         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
12397         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
12398         { }
12399 };
12400
12401 /* bind volumes of both NID 0x0c and 0x0d */
12402 static struct hda_bind_ctls alc269_epc_bind_vol = {
12403         .ops = &snd_hda_bind_vol,
12404         .values = {
12405                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12406                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12407                 0
12408         },
12409 };
12410
12411 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
12412         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12413         HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
12414         HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12415         { } /* end */
12416 };
12417
12418 /* capture mixer elements */
12419 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
12420         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12421         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12422         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12423         { } /* end */
12424 };
12425
12426 /* FSC amilo */
12427 static struct snd_kcontrol_new alc269_fujitsu_mixer[] = {
12428         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12429         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12430         HDA_BIND_VOL("PCM Playback Volume", &alc269_epc_bind_vol),
12431         { } /* end */
12432 };
12433
12434 static struct hda_verb alc269_quanta_fl1_verbs[] = {
12435         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12436         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12437         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12438         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12439         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12440         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12441         { }
12442 };
12443
12444 static struct hda_verb alc269_lifebook_verbs[] = {
12445         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12446         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
12447         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12448         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12449         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12450         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12451         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12452         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12453         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12454         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12455         { }
12456 };
12457
12458 /* toggle speaker-output according to the hp-jack state */
12459 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
12460 {
12461         unsigned int present;
12462         unsigned char bits;
12463
12464         present = snd_hda_codec_read(codec, 0x15, 0,
12465                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12466         bits = present ? AMP_IN_MUTE(0) : 0;
12467         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12468                         AMP_IN_MUTE(0), bits);
12469         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12470                         AMP_IN_MUTE(0), bits);
12471
12472         snd_hda_codec_write(codec, 0x20, 0,
12473                         AC_VERB_SET_COEF_INDEX, 0x0c);
12474         snd_hda_codec_write(codec, 0x20, 0,
12475                         AC_VERB_SET_PROC_COEF, 0x680);
12476
12477         snd_hda_codec_write(codec, 0x20, 0,
12478                         AC_VERB_SET_COEF_INDEX, 0x0c);
12479         snd_hda_codec_write(codec, 0x20, 0,
12480                         AC_VERB_SET_PROC_COEF, 0x480);
12481 }
12482
12483 /* toggle speaker-output according to the hp-jacks state */
12484 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
12485 {
12486         unsigned int present;
12487         unsigned char bits;
12488
12489         /* Check laptop headphone socket */
12490         present = snd_hda_codec_read(codec, 0x15, 0,
12491                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12492
12493         /* Check port replicator headphone socket */
12494         present |= snd_hda_codec_read(codec, 0x1a, 0,
12495                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12496
12497         bits = present ? AMP_IN_MUTE(0) : 0;
12498         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12499                         AMP_IN_MUTE(0), bits);
12500         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12501                         AMP_IN_MUTE(0), bits);
12502
12503         snd_hda_codec_write(codec, 0x20, 0,
12504                         AC_VERB_SET_COEF_INDEX, 0x0c);
12505         snd_hda_codec_write(codec, 0x20, 0,
12506                         AC_VERB_SET_PROC_COEF, 0x680);
12507
12508         snd_hda_codec_write(codec, 0x20, 0,
12509                         AC_VERB_SET_COEF_INDEX, 0x0c);
12510         snd_hda_codec_write(codec, 0x20, 0,
12511                         AC_VERB_SET_PROC_COEF, 0x480);
12512 }
12513
12514 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
12515 {
12516         unsigned int present;
12517
12518         present = snd_hda_codec_read(codec, 0x18, 0,
12519                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12520         snd_hda_codec_write(codec, 0x23, 0,
12521                             AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
12522 }
12523
12524 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
12525 {
12526         unsigned int present_laptop;
12527         unsigned int present_dock;
12528
12529         present_laptop = snd_hda_codec_read(codec, 0x18, 0,
12530                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12531
12532         present_dock = snd_hda_codec_read(codec, 0x1b, 0,
12533                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12534
12535         /* Laptop mic port overrides dock mic port, design decision */
12536         if (present_dock)
12537                 snd_hda_codec_write(codec, 0x23, 0,
12538                                 AC_VERB_SET_CONNECT_SEL, 0x3);
12539         if (present_laptop)
12540                 snd_hda_codec_write(codec, 0x23, 0,
12541                                 AC_VERB_SET_CONNECT_SEL, 0x0);
12542         if (!present_dock && !present_laptop)
12543                 snd_hda_codec_write(codec, 0x23, 0,
12544                                 AC_VERB_SET_CONNECT_SEL, 0x1);
12545 }
12546
12547 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
12548                                     unsigned int res)
12549 {
12550         if ((res >> 26) == ALC880_HP_EVENT)
12551                 alc269_quanta_fl1_speaker_automute(codec);
12552         if ((res >> 26) == ALC880_MIC_EVENT)
12553                 alc269_quanta_fl1_mic_automute(codec);
12554 }
12555
12556 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
12557                                         unsigned int res)
12558 {
12559         if ((res >> 26) == ALC880_HP_EVENT)
12560                 alc269_lifebook_speaker_automute(codec);
12561         if ((res >> 26) == ALC880_MIC_EVENT)
12562                 alc269_lifebook_mic_autoswitch(codec);
12563 }
12564
12565 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
12566 {
12567         alc269_quanta_fl1_speaker_automute(codec);
12568         alc269_quanta_fl1_mic_automute(codec);
12569 }
12570
12571 static void alc269_lifebook_init_hook(struct hda_codec *codec)
12572 {
12573         alc269_lifebook_speaker_automute(codec);
12574         alc269_lifebook_mic_autoswitch(codec);
12575 }
12576
12577 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
12578         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12579         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
12580         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12581         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
12582         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12583         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12584         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12585         {}
12586 };
12587
12588 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
12589         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12590         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
12591         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12592         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
12593         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12594         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12595         {}
12596 };
12597
12598 /* toggle speaker-output according to the hp-jack state */
12599 static void alc269_speaker_automute(struct hda_codec *codec)
12600 {
12601         unsigned int present;
12602         unsigned char bits;
12603
12604         present = snd_hda_codec_read(codec, 0x15, 0,
12605                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12606         bits = present ? AMP_IN_MUTE(0) : 0;
12607         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12608                                 AMP_IN_MUTE(0), bits);
12609         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12610                                 AMP_IN_MUTE(0), bits);
12611 }
12612
12613 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
12614 {
12615         unsigned int present;
12616
12617         present = snd_hda_codec_read(codec, 0x18, 0,
12618                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12619         snd_hda_codec_write(codec, 0x23, 0,
12620                                 AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
12621 }
12622
12623 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
12624 {
12625         unsigned int present;
12626
12627         present = snd_hda_codec_read(codec, 0x18, 0,
12628                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12629         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12630                                 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
12631         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12632                                 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
12633 }
12634
12635 /* unsolicited event for HP jack sensing */
12636 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
12637                                      unsigned int res)
12638 {
12639         if ((res >> 26) == ALC880_HP_EVENT)
12640                 alc269_speaker_automute(codec);
12641
12642         if ((res >> 26) == ALC880_MIC_EVENT)
12643                 alc269_eeepc_dmic_automute(codec);
12644 }
12645
12646 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
12647 {
12648         alc269_speaker_automute(codec);
12649         alc269_eeepc_dmic_automute(codec);
12650 }
12651
12652 /* unsolicited event for HP jack sensing */
12653 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
12654                                      unsigned int res)
12655 {
12656         if ((res >> 26) == ALC880_HP_EVENT)
12657                 alc269_speaker_automute(codec);
12658
12659         if ((res >> 26) == ALC880_MIC_EVENT)
12660                 alc269_eeepc_amic_automute(codec);
12661 }
12662
12663 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12664 {
12665         alc269_speaker_automute(codec);
12666         alc269_eeepc_amic_automute(codec);
12667 }
12668
12669 /*
12670  * generic initialization of ADC, input mixers and output mixers
12671  */
12672 static struct hda_verb alc269_init_verbs[] = {
12673         /*
12674          * Unmute ADC0 and set the default input to mic-in
12675          */
12676         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12677
12678         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12679          * analog-loopback mixer widget
12680          * Note: PASD motherboards uses the Line In 2 as the input for
12681          * front panel mic (mic 2)
12682          */
12683         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12684         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12685         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12686         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12687         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12688         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12689
12690         /*
12691          * Set up output mixers (0x0c - 0x0e)
12692          */
12693         /* set vol=0 to output mixers */
12694         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12695         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12696
12697         /* set up input amps for analog loopback */
12698         /* Amp Indices: DAC = 0, mixer = 1 */
12699         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12700         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12701         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12702         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12703         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12704         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12705
12706         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12707         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12708         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12709         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12710         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12711         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12712         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12713
12714         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12715         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12716         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12717         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12718         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12719         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12720         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12721
12722         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12723         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12724
12725         /* FIXME: use matrix-type input source selection */
12726         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12727         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12728         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12729         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12730         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12731         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12732
12733         /* set EAPD */
12734         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12735         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12736         { }
12737 };
12738
12739 /* add playback controls from the parsed DAC table */
12740 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12741                                              const struct auto_pin_cfg *cfg)
12742 {
12743         hda_nid_t nid;
12744         int err;
12745
12746         spec->multiout.num_dacs = 1;    /* only use one dac */
12747         spec->multiout.dac_nids = spec->private_dac_nids;
12748         spec->multiout.dac_nids[0] = 2;
12749
12750         nid = cfg->line_out_pins[0];
12751         if (nid) {
12752                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12753                                   "Front Playback Volume",
12754                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12755                 if (err < 0)
12756                         return err;
12757                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12758                                   "Front Playback Switch",
12759                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12760                 if (err < 0)
12761                         return err;
12762         }
12763
12764         nid = cfg->speaker_pins[0];
12765         if (nid) {
12766                 if (!cfg->line_out_pins[0]) {
12767                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12768                                           "Speaker Playback Volume",
12769                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12770                                                               HDA_OUTPUT));
12771                         if (err < 0)
12772                                 return err;
12773                 }
12774                 if (nid == 0x16) {
12775                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12776                                           "Speaker Playback Switch",
12777                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12778                                                               HDA_OUTPUT));
12779                         if (err < 0)
12780                                 return err;
12781                 } else {
12782                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12783                                           "Speaker Playback Switch",
12784                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12785                                                               HDA_OUTPUT));
12786                         if (err < 0)
12787                                 return err;
12788                 }
12789         }
12790         nid = cfg->hp_pins[0];
12791         if (nid) {
12792                 /* spec->multiout.hp_nid = 2; */
12793                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12794                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12795                                           "Headphone Playback Volume",
12796                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12797                                                               HDA_OUTPUT));
12798                         if (err < 0)
12799                                 return err;
12800                 }
12801                 if (nid == 0x16) {
12802                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12803                                           "Headphone Playback Switch",
12804                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12805                                                               HDA_OUTPUT));
12806                         if (err < 0)
12807                                 return err;
12808                 } else {
12809                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12810                                           "Headphone Playback Switch",
12811                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12812                                                               HDA_OUTPUT));
12813                         if (err < 0)
12814                                 return err;
12815                 }
12816         }
12817         return 0;
12818 }
12819
12820 static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec,
12821                                                 const struct auto_pin_cfg *cfg)
12822 {
12823         int err;
12824
12825         err = alc880_auto_create_analog_input_ctls(spec, cfg);
12826         if (err < 0)
12827                 return err;
12828         /* digital-mic input pin is excluded in alc880_auto_create..()
12829          * because it's under 0x18
12830          */
12831         if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
12832             cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
12833                 struct hda_input_mux *imux = &spec->private_imux[0];
12834                 imux->items[imux->num_items].label = "Int Mic";
12835                 imux->items[imux->num_items].index = 0x05;
12836                 imux->num_items++;
12837         }
12838         return 0;
12839 }
12840
12841 #ifdef CONFIG_SND_HDA_POWER_SAVE
12842 #define alc269_loopbacks        alc880_loopbacks
12843 #endif
12844
12845 /* pcm configuration: identiacal with ALC880 */
12846 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
12847 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
12848 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
12849 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
12850
12851 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
12852         .substreams = 1,
12853         .channels_min = 2,
12854         .channels_max = 8,
12855         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
12856         /* NID is set in alc_build_pcms */
12857         .ops = {
12858                 .open = alc880_playback_pcm_open,
12859                 .prepare = alc880_playback_pcm_prepare,
12860                 .cleanup = alc880_playback_pcm_cleanup
12861         },
12862 };
12863
12864 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
12865         .substreams = 1,
12866         .channels_min = 2,
12867         .channels_max = 2,
12868         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
12869         /* NID is set in alc_build_pcms */
12870 };
12871
12872 /*
12873  * BIOS auto configuration
12874  */
12875 static int alc269_parse_auto_config(struct hda_codec *codec)
12876 {
12877         struct alc_spec *spec = codec->spec;
12878         int err;
12879         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12880
12881         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12882                                            alc269_ignore);
12883         if (err < 0)
12884                 return err;
12885
12886         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12887         if (err < 0)
12888                 return err;
12889         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12890         if (err < 0)
12891                 return err;
12892
12893         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12894
12895         if (spec->autocfg.dig_outs)
12896                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12897
12898         if (spec->kctls.list)
12899                 add_mixer(spec, spec->kctls.list);
12900
12901         add_verb(spec, alc269_init_verbs);
12902         spec->num_mux_defs = 1;
12903         spec->input_mux = &spec->private_imux[0];
12904         /* set default input source */
12905         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12906                                   0, AC_VERB_SET_CONNECT_SEL,
12907                                   spec->input_mux->items[0].index);
12908
12909         err = alc_auto_add_mic_boost(codec);
12910         if (err < 0)
12911                 return err;
12912
12913         if (!spec->cap_mixer && !spec->no_analog)
12914                 set_capture_mixer(spec);
12915
12916         return 1;
12917 }
12918
12919 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
12920 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
12921 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
12922
12923
12924 /* init callback for auto-configuration model -- overriding the default init */
12925 static void alc269_auto_init(struct hda_codec *codec)
12926 {
12927         struct alc_spec *spec = codec->spec;
12928         alc269_auto_init_multi_out(codec);
12929         alc269_auto_init_hp_out(codec);
12930         alc269_auto_init_analog_input(codec);
12931         if (spec->unsol_event)
12932                 alc_inithook(codec);
12933 }
12934
12935 /*
12936  * configuration and preset
12937  */
12938 static const char *alc269_models[ALC269_MODEL_LAST] = {
12939         [ALC269_BASIC]                  = "basic",
12940         [ALC269_QUANTA_FL1]             = "quanta",
12941         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
12942         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
12943         [ALC269_FUJITSU]                = "fujitsu",
12944         [ALC269_LIFEBOOK]               = "lifebook"
12945 };
12946
12947 static struct snd_pci_quirk alc269_cfg_tbl[] = {
12948         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
12949         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
12950                       ALC269_ASUS_EEEPC_P703),
12951         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
12952                       ALC269_ASUS_EEEPC_P901),
12953         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
12954                       ALC269_ASUS_EEEPC_P901),
12955         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
12956         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
12957         {}
12958 };
12959
12960 static struct alc_config_preset alc269_presets[] = {
12961         [ALC269_BASIC] = {
12962                 .mixers = { alc269_base_mixer },
12963                 .init_verbs = { alc269_init_verbs },
12964                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12965                 .dac_nids = alc269_dac_nids,
12966                 .hp_nid = 0x03,
12967                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12968                 .channel_mode = alc269_modes,
12969                 .input_mux = &alc269_capture_source,
12970         },
12971         [ALC269_QUANTA_FL1] = {
12972                 .mixers = { alc269_quanta_fl1_mixer },
12973                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
12974                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12975                 .dac_nids = alc269_dac_nids,
12976                 .hp_nid = 0x03,
12977                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12978                 .channel_mode = alc269_modes,
12979                 .input_mux = &alc269_capture_source,
12980                 .unsol_event = alc269_quanta_fl1_unsol_event,
12981                 .init_hook = alc269_quanta_fl1_init_hook,
12982         },
12983         [ALC269_ASUS_EEEPC_P703] = {
12984                 .mixers = { alc269_eeepc_mixer },
12985                 .cap_mixer = alc269_epc_capture_mixer,
12986                 .init_verbs = { alc269_init_verbs,
12987                                 alc269_eeepc_amic_init_verbs },
12988                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12989                 .dac_nids = alc269_dac_nids,
12990                 .hp_nid = 0x03,
12991                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12992                 .channel_mode = alc269_modes,
12993                 .input_mux = &alc269_eeepc_amic_capture_source,
12994                 .unsol_event = alc269_eeepc_amic_unsol_event,
12995                 .init_hook = alc269_eeepc_amic_inithook,
12996         },
12997         [ALC269_ASUS_EEEPC_P901] = {
12998                 .mixers = { alc269_eeepc_mixer },
12999                 .cap_mixer = alc269_epc_capture_mixer,
13000                 .init_verbs = { alc269_init_verbs,
13001                                 alc269_eeepc_dmic_init_verbs },
13002                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13003                 .dac_nids = alc269_dac_nids,
13004                 .hp_nid = 0x03,
13005                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13006                 .channel_mode = alc269_modes,
13007                 .input_mux = &alc269_eeepc_dmic_capture_source,
13008                 .unsol_event = alc269_eeepc_dmic_unsol_event,
13009                 .init_hook = alc269_eeepc_dmic_inithook,
13010         },
13011         [ALC269_FUJITSU] = {
13012                 .mixers = { alc269_fujitsu_mixer },
13013                 .cap_mixer = alc269_epc_capture_mixer,
13014                 .init_verbs = { alc269_init_verbs,
13015                                 alc269_eeepc_dmic_init_verbs },
13016                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13017                 .dac_nids = alc269_dac_nids,
13018                 .hp_nid = 0x03,
13019                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13020                 .channel_mode = alc269_modes,
13021                 .input_mux = &alc269_eeepc_dmic_capture_source,
13022                 .unsol_event = alc269_eeepc_dmic_unsol_event,
13023                 .init_hook = alc269_eeepc_dmic_inithook,
13024         },
13025         [ALC269_LIFEBOOK] = {
13026                 .mixers = { alc269_lifebook_mixer },
13027                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13028                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13029                 .dac_nids = alc269_dac_nids,
13030                 .hp_nid = 0x03,
13031                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13032                 .channel_mode = alc269_modes,
13033                 .input_mux = &alc269_capture_source,
13034                 .unsol_event = alc269_lifebook_unsol_event,
13035                 .init_hook = alc269_lifebook_init_hook,
13036         },
13037 };
13038
13039 static int patch_alc269(struct hda_codec *codec)
13040 {
13041         struct alc_spec *spec;
13042         int board_config;
13043         int err;
13044
13045         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13046         if (spec == NULL)
13047                 return -ENOMEM;
13048
13049         codec->spec = spec;
13050
13051         alc_fix_pll_init(codec, 0x20, 0x04, 15);
13052
13053         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13054                                                   alc269_models,
13055                                                   alc269_cfg_tbl);
13056
13057         if (board_config < 0) {
13058                 printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
13059                        "trying auto-probe from BIOS...\n");
13060                 board_config = ALC269_AUTO;
13061         }
13062
13063         if (board_config == ALC269_AUTO) {
13064                 /* automatic parse from the BIOS config */
13065                 err = alc269_parse_auto_config(codec);
13066                 if (err < 0) {
13067                         alc_free(codec);
13068                         return err;
13069                 } else if (!err) {
13070                         printk(KERN_INFO
13071                                "hda_codec: Cannot set up configuration "
13072                                "from BIOS.  Using base mode...\n");
13073                         board_config = ALC269_BASIC;
13074                 }
13075         }
13076
13077         err = snd_hda_attach_beep_device(codec, 0x1);
13078         if (err < 0) {
13079                 alc_free(codec);
13080                 return err;
13081         }
13082
13083         if (board_config != ALC269_AUTO)
13084                 setup_preset(spec, &alc269_presets[board_config]);
13085
13086         spec->stream_name_analog = "ALC269 Analog";
13087         if (codec->subsystem_id == 0x17aa3bf8) {
13088                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
13089                  * fix the sample rate of analog I/O to 44.1kHz
13090                  */
13091                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
13092                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
13093         } else {
13094                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
13095                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
13096         }
13097         spec->stream_name_digital = "ALC269 Digital";
13098         spec->stream_digital_playback = &alc269_pcm_digital_playback;
13099         spec->stream_digital_capture = &alc269_pcm_digital_capture;
13100
13101         spec->adc_nids = alc269_adc_nids;
13102         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13103         spec->capsrc_nids = alc269_capsrc_nids;
13104         if (!spec->cap_mixer)
13105                 set_capture_mixer(spec);
13106         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13107
13108         codec->patch_ops = alc_patch_ops;
13109         if (board_config == ALC269_AUTO)
13110                 spec->init_hook = alc269_auto_init;
13111 #ifdef CONFIG_SND_HDA_POWER_SAVE
13112         if (!spec->loopback.amplist)
13113                 spec->loopback.amplist = alc269_loopbacks;
13114 #endif
13115         codec->proc_widget_hook = print_realtek_coef;
13116
13117         return 0;
13118 }
13119
13120 /*
13121  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13122  */
13123
13124 /*
13125  * set the path ways for 2 channel output
13126  * need to set the codec line out and mic 1 pin widgets to inputs
13127  */
13128 static struct hda_verb alc861_threestack_ch2_init[] = {
13129         /* set pin widget 1Ah (line in) for input */
13130         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13131         /* set pin widget 18h (mic1/2) for input, for mic also enable
13132          * the vref
13133          */
13134         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13135
13136         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13137 #if 0
13138         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13139         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13140 #endif
13141         { } /* end */
13142 };
13143 /*
13144  * 6ch mode
13145  * need to set the codec line out and mic 1 pin widgets to outputs
13146  */
13147 static struct hda_verb alc861_threestack_ch6_init[] = {
13148         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13149         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13150         /* set pin widget 18h (mic1) for output (CLFE)*/
13151         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13152
13153         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13154         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13155
13156         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13157 #if 0
13158         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13159         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13160 #endif
13161         { } /* end */
13162 };
13163
13164 static struct hda_channel_mode alc861_threestack_modes[2] = {
13165         { 2, alc861_threestack_ch2_init },
13166         { 6, alc861_threestack_ch6_init },
13167 };
13168 /* Set mic1 as input and unmute the mixer */
13169 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13170         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13171         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13172         { } /* end */
13173 };
13174 /* Set mic1 as output and mute mixer */
13175 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13176         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13177         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13178         { } /* end */
13179 };
13180
13181 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13182         { 2, alc861_uniwill_m31_ch2_init },
13183         { 4, alc861_uniwill_m31_ch4_init },
13184 };
13185
13186 /* Set mic1 and line-in as input and unmute the mixer */
13187 static struct hda_verb alc861_asus_ch2_init[] = {
13188         /* set pin widget 1Ah (line in) for input */
13189         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13190         /* set pin widget 18h (mic1/2) for input, for mic also enable
13191          * the vref
13192          */
13193         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13194
13195         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13196 #if 0
13197         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13198         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13199 #endif
13200         { } /* end */
13201 };
13202 /* Set mic1 nad line-in as output and mute mixer */
13203 static struct hda_verb alc861_asus_ch6_init[] = {
13204         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13205         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13206         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13207         /* set pin widget 18h (mic1) for output (CLFE)*/
13208         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13209         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13210         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13211         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13212
13213         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13214 #if 0
13215         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13216         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13217 #endif
13218         { } /* end */
13219 };
13220
13221 static struct hda_channel_mode alc861_asus_modes[2] = {
13222         { 2, alc861_asus_ch2_init },
13223         { 6, alc861_asus_ch6_init },
13224 };
13225
13226 /* patch-ALC861 */
13227
13228 static struct snd_kcontrol_new alc861_base_mixer[] = {
13229         /* output mixer control */
13230         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13231         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13232         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13233         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13234         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13235
13236         /*Input mixer control */
13237         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13238            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13239         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13240         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13241         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13242         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13243         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13244         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13245         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13246         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13247
13248         { } /* end */
13249 };
13250
13251 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13252         /* output mixer control */
13253         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13254         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13255         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13256         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13257         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13258
13259         /* Input mixer control */
13260         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13261            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13262         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13263         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13264         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13265         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13266         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13267         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13268         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13269         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13270
13271         {
13272                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13273                 .name = "Channel Mode",
13274                 .info = alc_ch_mode_info,
13275                 .get = alc_ch_mode_get,
13276                 .put = alc_ch_mode_put,
13277                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13278         },
13279         { } /* end */
13280 };
13281
13282 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13283         /* output mixer control */
13284         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13285         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13286         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13287
13288         { } /* end */
13289 };
13290
13291 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13292         /* output mixer control */
13293         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13294         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13295         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13296         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13297         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13298
13299         /* Input mixer control */
13300         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13301            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13302         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13303         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13304         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13305         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13306         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13307         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13308         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13309         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13310
13311         {
13312                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13313                 .name = "Channel Mode",
13314                 .info = alc_ch_mode_info,
13315                 .get = alc_ch_mode_get,
13316                 .put = alc_ch_mode_put,
13317                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13318         },
13319         { } /* end */
13320 };
13321
13322 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13323         /* output mixer control */
13324         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13325         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13326         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13327         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13328         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13329
13330         /* Input mixer control */
13331         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13332         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13333         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13334         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13335         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13336         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13337         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13338         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13339         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13340         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13341
13342         {
13343                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13344                 .name = "Channel Mode",
13345                 .info = alc_ch_mode_info,
13346                 .get = alc_ch_mode_get,
13347                 .put = alc_ch_mode_put,
13348                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13349         },
13350         { }
13351 };
13352
13353 /* additional mixer */
13354 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13355         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13356         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13357         { }
13358 };
13359
13360 /*
13361  * generic initialization of ADC, input mixers and output mixers
13362  */
13363 static struct hda_verb alc861_base_init_verbs[] = {
13364         /*
13365          * Unmute ADC0 and set the default input to mic-in
13366          */
13367         /* port-A for surround (rear panel) */
13368         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13369         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
13370         /* port-B for mic-in (rear panel) with vref */
13371         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13372         /* port-C for line-in (rear panel) */
13373         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13374         /* port-D for Front */
13375         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13376         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13377         /* port-E for HP out (front panel) */
13378         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13379         /* route front PCM to HP */
13380         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13381         /* port-F for mic-in (front panel) with vref */
13382         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13383         /* port-G for CLFE (rear panel) */
13384         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13385         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13386         /* port-H for side (rear panel) */
13387         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13388         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
13389         /* CD-in */
13390         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13391         /* route front mic to ADC1*/
13392         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13393         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13394
13395         /* Unmute DAC0~3 & spdif out*/
13396         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13397         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13398         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13399         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13400         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13401
13402         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13403         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13404         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13405         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13406         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13407
13408         /* Unmute Stereo Mixer 15 */
13409         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13410         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13411         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13412         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13413
13414         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13415         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13416         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13417         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13418         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13419         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13420         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13421         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13422         /* hp used DAC 3 (Front) */
13423         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13424         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13425
13426         { }
13427 };
13428
13429 static struct hda_verb alc861_threestack_init_verbs[] = {
13430         /*
13431          * Unmute ADC0 and set the default input to mic-in
13432          */
13433         /* port-A for surround (rear panel) */
13434         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13435         /* port-B for mic-in (rear panel) with vref */
13436         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13437         /* port-C for line-in (rear panel) */
13438         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13439         /* port-D for Front */
13440         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13441         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13442         /* port-E for HP out (front panel) */
13443         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13444         /* route front PCM to HP */
13445         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13446         /* port-F for mic-in (front panel) with vref */
13447         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13448         /* port-G for CLFE (rear panel) */
13449         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13450         /* port-H for side (rear panel) */
13451         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13452         /* CD-in */
13453         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13454         /* route front mic to ADC1*/
13455         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13456         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13457         /* Unmute DAC0~3 & spdif out*/
13458         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13459         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13460         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13461         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13462         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13463
13464         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13465         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13466         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13467         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13468         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13469
13470         /* Unmute Stereo Mixer 15 */
13471         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13472         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13473         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13474         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13475
13476         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13477         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13478         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13479         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13480         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13481         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13482         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13483         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13484         /* hp used DAC 3 (Front) */
13485         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13486         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13487         { }
13488 };
13489
13490 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
13491         /*
13492          * Unmute ADC0 and set the default input to mic-in
13493          */
13494         /* port-A for surround (rear panel) */
13495         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13496         /* port-B for mic-in (rear panel) with vref */
13497         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13498         /* port-C for line-in (rear panel) */
13499         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13500         /* port-D for Front */
13501         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13502         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13503         /* port-E for HP out (front panel) */
13504         /* this has to be set to VREF80 */
13505         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13506         /* route front PCM to HP */
13507         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13508         /* port-F for mic-in (front panel) with vref */
13509         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13510         /* port-G for CLFE (rear panel) */
13511         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13512         /* port-H for side (rear panel) */
13513         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13514         /* CD-in */
13515         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13516         /* route front mic to ADC1*/
13517         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13518         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13519         /* Unmute DAC0~3 & spdif out*/
13520         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13521         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13522         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13523         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13524         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13525
13526         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13527         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13528         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13529         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13530         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13531
13532         /* Unmute Stereo Mixer 15 */
13533         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13534         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13535         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13536         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13537
13538         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13539         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13540         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13541         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13542         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13543         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13544         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13545         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13546         /* hp used DAC 3 (Front) */
13547         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13548         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13549         { }
13550 };
13551
13552 static struct hda_verb alc861_asus_init_verbs[] = {
13553         /*
13554          * Unmute ADC0 and set the default input to mic-in
13555          */
13556         /* port-A for surround (rear panel)
13557          * according to codec#0 this is the HP jack
13558          */
13559         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
13560         /* route front PCM to HP */
13561         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
13562         /* port-B for mic-in (rear panel) with vref */
13563         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13564         /* port-C for line-in (rear panel) */
13565         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13566         /* port-D for Front */
13567         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13568         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13569         /* port-E for HP out (front panel) */
13570         /* this has to be set to VREF80 */
13571         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13572         /* route front PCM to HP */
13573         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13574         /* port-F for mic-in (front panel) with vref */
13575         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13576         /* port-G for CLFE (rear panel) */
13577         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13578         /* port-H for side (rear panel) */
13579         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13580         /* CD-in */
13581         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13582         /* route front mic to ADC1*/
13583         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13584         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13585         /* Unmute DAC0~3 & spdif out*/
13586         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13587         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13588         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13589         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13590         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13591         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13592         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13593         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13594         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13595         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13596
13597         /* Unmute Stereo Mixer 15 */
13598         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13599         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13600         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13601         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13602
13603         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13604         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13605         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13606         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13607         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13608         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13609         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13610         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13611         /* hp used DAC 3 (Front) */
13612         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13613         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13614         { }
13615 };
13616
13617 /* additional init verbs for ASUS laptops */
13618 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
13619         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
13620         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
13621         { }
13622 };
13623
13624 /*
13625  * generic initialization of ADC, input mixers and output mixers
13626  */
13627 static struct hda_verb alc861_auto_init_verbs[] = {
13628         /*
13629          * Unmute ADC0 and set the default input to mic-in
13630          */
13631         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
13632         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13633
13634         /* Unmute DAC0~3 & spdif out*/
13635         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13636         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13637         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13638         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13639         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13640
13641         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13642         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13643         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13644         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13645         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13646
13647         /* Unmute Stereo Mixer 15 */
13648         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13649         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13650         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13651         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
13652
13653         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13654         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13655         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13656         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13657         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13658         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13659         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13660         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13661
13662         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13663         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13664         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13665         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13666         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13667         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13668         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13669         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13670
13671         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
13672
13673         { }
13674 };
13675
13676 static struct hda_verb alc861_toshiba_init_verbs[] = {
13677         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13678
13679         { }
13680 };
13681
13682 /* toggle speaker-output according to the hp-jack state */
13683 static void alc861_toshiba_automute(struct hda_codec *codec)
13684 {
13685         unsigned int present;
13686
13687         present = snd_hda_codec_read(codec, 0x0f, 0,
13688                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13689         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13690                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13691         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13692                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13693 }
13694
13695 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13696                                        unsigned int res)
13697 {
13698         if ((res >> 26) == ALC880_HP_EVENT)
13699                 alc861_toshiba_automute(codec);
13700 }
13701
13702 /* pcm configuration: identiacal with ALC880 */
13703 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
13704 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
13705 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
13706 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
13707
13708
13709 #define ALC861_DIGOUT_NID       0x07
13710
13711 static struct hda_channel_mode alc861_8ch_modes[1] = {
13712         { 8, NULL }
13713 };
13714
13715 static hda_nid_t alc861_dac_nids[4] = {
13716         /* front, surround, clfe, side */
13717         0x03, 0x06, 0x05, 0x04
13718 };
13719
13720 static hda_nid_t alc660_dac_nids[3] = {
13721         /* front, clfe, surround */
13722         0x03, 0x05, 0x06
13723 };
13724
13725 static hda_nid_t alc861_adc_nids[1] = {
13726         /* ADC0-2 */
13727         0x08,
13728 };
13729
13730 static struct hda_input_mux alc861_capture_source = {
13731         .num_items = 5,
13732         .items = {
13733                 { "Mic", 0x0 },
13734                 { "Front Mic", 0x3 },
13735                 { "Line", 0x1 },
13736                 { "CD", 0x4 },
13737                 { "Mixer", 0x5 },
13738         },
13739 };
13740
13741 /* fill in the dac_nids table from the parsed pin configuration */
13742 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13743                                      const struct auto_pin_cfg *cfg)
13744 {
13745         int i;
13746         hda_nid_t nid;
13747
13748         spec->multiout.dac_nids = spec->private_dac_nids;
13749         for (i = 0; i < cfg->line_outs; i++) {
13750                 nid = cfg->line_out_pins[i];
13751                 if (nid) {
13752                         if (i >= ARRAY_SIZE(alc861_dac_nids))
13753                                 continue;
13754                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13755                 }
13756         }
13757         spec->multiout.num_dacs = cfg->line_outs;
13758         return 0;
13759 }
13760
13761 /* add playback controls from the parsed DAC table */
13762 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13763                                              const struct auto_pin_cfg *cfg)
13764 {
13765         char name[32];
13766         static const char *chname[4] = {
13767                 "Front", "Surround", NULL /*CLFE*/, "Side"
13768         };
13769         hda_nid_t nid;
13770         int i, idx, err;
13771
13772         for (i = 0; i < cfg->line_outs; i++) {
13773                 nid = spec->multiout.dac_nids[i];
13774                 if (!nid)
13775                         continue;
13776                 if (nid == 0x05) {
13777                         /* Center/LFE */
13778                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13779                                           "Center Playback Switch",
13780                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13781                                                               HDA_OUTPUT));
13782                         if (err < 0)
13783                                 return err;
13784                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13785                                           "LFE Playback Switch",
13786                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13787                                                               HDA_OUTPUT));
13788                         if (err < 0)
13789                                 return err;
13790                 } else {
13791                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13792                              idx++)
13793                                 if (nid == alc861_dac_nids[idx])
13794                                         break;
13795                         sprintf(name, "%s Playback Switch", chname[idx]);
13796                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13797                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13798                                                               HDA_OUTPUT));
13799                         if (err < 0)
13800                                 return err;
13801                 }
13802         }
13803         return 0;
13804 }
13805
13806 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13807 {
13808         int err;
13809         hda_nid_t nid;
13810
13811         if (!pin)
13812                 return 0;
13813
13814         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13815                 nid = 0x03;
13816                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13817                                   "Headphone Playback Switch",
13818                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13819                 if (err < 0)
13820                         return err;
13821                 spec->multiout.hp_nid = nid;
13822         }
13823         return 0;
13824 }
13825
13826 /* create playback/capture controls for input pins */
13827 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13828                                                 const struct auto_pin_cfg *cfg)
13829 {
13830         struct hda_input_mux *imux = &spec->private_imux[0];
13831         int i, err, idx, idx1;
13832
13833         for (i = 0; i < AUTO_PIN_LAST; i++) {
13834                 switch (cfg->input_pins[i]) {
13835                 case 0x0c:
13836                         idx1 = 1;
13837                         idx = 2;        /* Line In */
13838                         break;
13839                 case 0x0f:
13840                         idx1 = 2;
13841                         idx = 2;        /* Line In */
13842                         break;
13843                 case 0x0d:
13844                         idx1 = 0;
13845                         idx = 1;        /* Mic In */
13846                         break;
13847                 case 0x10:
13848                         idx1 = 3;
13849                         idx = 1;        /* Mic In */
13850                         break;
13851                 case 0x11:
13852                         idx1 = 4;
13853                         idx = 0;        /* CD */
13854                         break;
13855                 default:
13856                         continue;
13857                 }
13858
13859                 err = new_analog_input(spec, cfg->input_pins[i],
13860                                        auto_pin_cfg_labels[i], idx, 0x15);
13861                 if (err < 0)
13862                         return err;
13863
13864                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13865                 imux->items[imux->num_items].index = idx1;
13866                 imux->num_items++;
13867         }
13868         return 0;
13869 }
13870
13871 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13872                                               hda_nid_t nid,
13873                                               int pin_type, int dac_idx)
13874 {
13875         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13876                             pin_type);
13877         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13878                             AMP_OUT_UNMUTE);
13879 }
13880
13881 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13882 {
13883         struct alc_spec *spec = codec->spec;
13884         int i;
13885
13886         alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
13887         for (i = 0; i < spec->autocfg.line_outs; i++) {
13888                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13889                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13890                 if (nid)
13891                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13892                                                           spec->multiout.dac_nids[i]);
13893         }
13894 }
13895
13896 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13897 {
13898         struct alc_spec *spec = codec->spec;
13899         hda_nid_t pin;
13900
13901         pin = spec->autocfg.hp_pins[0];
13902         if (pin) /* connect to front */
13903                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13904                                                   spec->multiout.dac_nids[0]);
13905         pin = spec->autocfg.speaker_pins[0];
13906         if (pin)
13907                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13908 }
13909
13910 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13911 {
13912         struct alc_spec *spec = codec->spec;
13913         int i;
13914
13915         for (i = 0; i < AUTO_PIN_LAST; i++) {
13916                 hda_nid_t nid = spec->autocfg.input_pins[i];
13917                 if (nid >= 0x0c && nid <= 0x11)
13918                         alc_set_input_pin(codec, nid, i);
13919         }
13920 }
13921
13922 /* parse the BIOS configuration and set up the alc_spec */
13923 /* return 1 if successful, 0 if the proper config is not found,
13924  * or a negative error code
13925  */
13926 static int alc861_parse_auto_config(struct hda_codec *codec)
13927 {
13928         struct alc_spec *spec = codec->spec;
13929         int err;
13930         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
13931
13932         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13933                                            alc861_ignore);
13934         if (err < 0)
13935                 return err;
13936         if (!spec->autocfg.line_outs)
13937                 return 0; /* can't find valid BIOS pin config */
13938
13939         err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
13940         if (err < 0)
13941                 return err;
13942         err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
13943         if (err < 0)
13944                 return err;
13945         err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
13946         if (err < 0)
13947                 return err;
13948         err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
13949         if (err < 0)
13950                 return err;
13951
13952         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13953
13954         if (spec->autocfg.dig_outs)
13955                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
13956
13957         if (spec->kctls.list)
13958                 add_mixer(spec, spec->kctls.list);
13959
13960         add_verb(spec, alc861_auto_init_verbs);
13961
13962         spec->num_mux_defs = 1;
13963         spec->input_mux = &spec->private_imux[0];
13964
13965         spec->adc_nids = alc861_adc_nids;
13966         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
13967         set_capture_mixer(spec);
13968
13969         return 1;
13970 }
13971
13972 /* additional initialization for auto-configuration model */
13973 static void alc861_auto_init(struct hda_codec *codec)
13974 {
13975         struct alc_spec *spec = codec->spec;
13976         alc861_auto_init_multi_out(codec);
13977         alc861_auto_init_hp_out(codec);
13978         alc861_auto_init_analog_input(codec);
13979         if (spec->unsol_event)
13980                 alc_inithook(codec);
13981 }
13982
13983 #ifdef CONFIG_SND_HDA_POWER_SAVE
13984 static struct hda_amp_list alc861_loopbacks[] = {
13985         { 0x15, HDA_INPUT, 0 },
13986         { 0x15, HDA_INPUT, 1 },
13987         { 0x15, HDA_INPUT, 2 },
13988         { 0x15, HDA_INPUT, 3 },
13989         { } /* end */
13990 };
13991 #endif
13992
13993
13994 /*
13995  * configuration and preset
13996  */
13997 static const char *alc861_models[ALC861_MODEL_LAST] = {
13998         [ALC861_3ST]            = "3stack",
13999         [ALC660_3ST]            = "3stack-660",
14000         [ALC861_3ST_DIG]        = "3stack-dig",
14001         [ALC861_6ST_DIG]        = "6stack-dig",
14002         [ALC861_UNIWILL_M31]    = "uniwill-m31",
14003         [ALC861_TOSHIBA]        = "toshiba",
14004         [ALC861_ASUS]           = "asus",
14005         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
14006         [ALC861_AUTO]           = "auto",
14007 };
14008
14009 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14010         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14011         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14012         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14013         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14014         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14015         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14016         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14017         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14018          *        Any other models that need this preset?
14019          */
14020         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14021         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14022         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14023         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14024         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14025         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14026         /* FIXME: the below seems conflict */
14027         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14028         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14029         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14030         {}
14031 };
14032
14033 static struct alc_config_preset alc861_presets[] = {
14034         [ALC861_3ST] = {
14035                 .mixers = { alc861_3ST_mixer },
14036                 .init_verbs = { alc861_threestack_init_verbs },
14037                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14038                 .dac_nids = alc861_dac_nids,
14039                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14040                 .channel_mode = alc861_threestack_modes,
14041                 .need_dac_fix = 1,
14042                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14043                 .adc_nids = alc861_adc_nids,
14044                 .input_mux = &alc861_capture_source,
14045         },
14046         [ALC861_3ST_DIG] = {
14047                 .mixers = { alc861_base_mixer },
14048                 .init_verbs = { alc861_threestack_init_verbs },
14049                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14050                 .dac_nids = alc861_dac_nids,
14051                 .dig_out_nid = ALC861_DIGOUT_NID,
14052                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14053                 .channel_mode = alc861_threestack_modes,
14054                 .need_dac_fix = 1,
14055                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14056                 .adc_nids = alc861_adc_nids,
14057                 .input_mux = &alc861_capture_source,
14058         },
14059         [ALC861_6ST_DIG] = {
14060                 .mixers = { alc861_base_mixer },
14061                 .init_verbs = { alc861_base_init_verbs },
14062                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14063                 .dac_nids = alc861_dac_nids,
14064                 .dig_out_nid = ALC861_DIGOUT_NID,
14065                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14066                 .channel_mode = alc861_8ch_modes,
14067                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14068                 .adc_nids = alc861_adc_nids,
14069                 .input_mux = &alc861_capture_source,
14070         },
14071         [ALC660_3ST] = {
14072                 .mixers = { alc861_3ST_mixer },
14073                 .init_verbs = { alc861_threestack_init_verbs },
14074                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
14075                 .dac_nids = alc660_dac_nids,
14076                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14077                 .channel_mode = alc861_threestack_modes,
14078                 .need_dac_fix = 1,
14079                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14080                 .adc_nids = alc861_adc_nids,
14081                 .input_mux = &alc861_capture_source,
14082         },
14083         [ALC861_UNIWILL_M31] = {
14084                 .mixers = { alc861_uniwill_m31_mixer },
14085                 .init_verbs = { alc861_uniwill_m31_init_verbs },
14086                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14087                 .dac_nids = alc861_dac_nids,
14088                 .dig_out_nid = ALC861_DIGOUT_NID,
14089                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14090                 .channel_mode = alc861_uniwill_m31_modes,
14091                 .need_dac_fix = 1,
14092                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14093                 .adc_nids = alc861_adc_nids,
14094                 .input_mux = &alc861_capture_source,
14095         },
14096         [ALC861_TOSHIBA] = {
14097                 .mixers = { alc861_toshiba_mixer },
14098                 .init_verbs = { alc861_base_init_verbs,
14099                                 alc861_toshiba_init_verbs },
14100                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14101                 .dac_nids = alc861_dac_nids,
14102                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14103                 .channel_mode = alc883_3ST_2ch_modes,
14104                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14105                 .adc_nids = alc861_adc_nids,
14106                 .input_mux = &alc861_capture_source,
14107                 .unsol_event = alc861_toshiba_unsol_event,
14108                 .init_hook = alc861_toshiba_automute,
14109         },
14110         [ALC861_ASUS] = {
14111                 .mixers = { alc861_asus_mixer },
14112                 .init_verbs = { alc861_asus_init_verbs },
14113                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14114                 .dac_nids = alc861_dac_nids,
14115                 .dig_out_nid = ALC861_DIGOUT_NID,
14116                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14117                 .channel_mode = alc861_asus_modes,
14118                 .need_dac_fix = 1,
14119                 .hp_nid = 0x06,
14120                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14121                 .adc_nids = alc861_adc_nids,
14122                 .input_mux = &alc861_capture_source,
14123         },
14124         [ALC861_ASUS_LAPTOP] = {
14125                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14126                 .init_verbs = { alc861_asus_init_verbs,
14127                                 alc861_asus_laptop_init_verbs },
14128                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14129                 .dac_nids = alc861_dac_nids,
14130                 .dig_out_nid = ALC861_DIGOUT_NID,
14131                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14132                 .channel_mode = alc883_3ST_2ch_modes,
14133                 .need_dac_fix = 1,
14134                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14135                 .adc_nids = alc861_adc_nids,
14136                 .input_mux = &alc861_capture_source,
14137         },
14138 };
14139
14140
14141 static int patch_alc861(struct hda_codec *codec)
14142 {
14143         struct alc_spec *spec;
14144         int board_config;
14145         int err;
14146
14147         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14148         if (spec == NULL)
14149                 return -ENOMEM;
14150
14151         codec->spec = spec;
14152
14153         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14154                                                   alc861_models,
14155                                                   alc861_cfg_tbl);
14156
14157         if (board_config < 0) {
14158                 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
14159                        "trying auto-probe from BIOS...\n");
14160                 board_config = ALC861_AUTO;
14161         }
14162
14163         if (board_config == ALC861_AUTO) {
14164                 /* automatic parse from the BIOS config */
14165                 err = alc861_parse_auto_config(codec);
14166                 if (err < 0) {
14167                         alc_free(codec);
14168                         return err;
14169                 } else if (!err) {
14170                         printk(KERN_INFO
14171                                "hda_codec: Cannot set up configuration "
14172                                "from BIOS.  Using base mode...\n");
14173                    board_config = ALC861_3ST_DIG;
14174                 }
14175         }
14176
14177         err = snd_hda_attach_beep_device(codec, 0x23);
14178         if (err < 0) {
14179                 alc_free(codec);
14180                 return err;
14181         }
14182
14183         if (board_config != ALC861_AUTO)
14184                 setup_preset(spec, &alc861_presets[board_config]);
14185
14186         spec->stream_name_analog = "ALC861 Analog";
14187         spec->stream_analog_playback = &alc861_pcm_analog_playback;
14188         spec->stream_analog_capture = &alc861_pcm_analog_capture;
14189
14190         spec->stream_name_digital = "ALC861 Digital";
14191         spec->stream_digital_playback = &alc861_pcm_digital_playback;
14192         spec->stream_digital_capture = &alc861_pcm_digital_capture;
14193
14194         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14195
14196         spec->vmaster_nid = 0x03;
14197
14198         codec->patch_ops = alc_patch_ops;
14199         if (board_config == ALC861_AUTO)
14200                 spec->init_hook = alc861_auto_init;
14201 #ifdef CONFIG_SND_HDA_POWER_SAVE
14202         if (!spec->loopback.amplist)
14203                 spec->loopback.amplist = alc861_loopbacks;
14204 #endif
14205         codec->proc_widget_hook = print_realtek_coef;
14206
14207         return 0;
14208 }
14209
14210 /*
14211  * ALC861-VD support
14212  *
14213  * Based on ALC882
14214  *
14215  * In addition, an independent DAC
14216  */
14217 #define ALC861VD_DIGOUT_NID     0x06
14218
14219 static hda_nid_t alc861vd_dac_nids[4] = {
14220         /* front, surr, clfe, side surr */
14221         0x02, 0x03, 0x04, 0x05
14222 };
14223
14224 /* dac_nids for ALC660vd are in a different order - according to
14225  * Realtek's driver.
14226  * This should probably tesult in a different mixer for 6stack models
14227  * of ALC660vd codecs, but for now there is only 3stack mixer
14228  * - and it is the same as in 861vd.
14229  * adc_nids in ALC660vd are (is) the same as in 861vd
14230  */
14231 static hda_nid_t alc660vd_dac_nids[3] = {
14232         /* front, rear, clfe, rear_surr */
14233         0x02, 0x04, 0x03
14234 };
14235
14236 static hda_nid_t alc861vd_adc_nids[1] = {
14237         /* ADC0 */
14238         0x09,
14239 };
14240
14241 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14242
14243 /* input MUX */
14244 /* FIXME: should be a matrix-type input source selection */
14245 static struct hda_input_mux alc861vd_capture_source = {
14246         .num_items = 4,
14247         .items = {
14248                 { "Mic", 0x0 },
14249                 { "Front Mic", 0x1 },
14250                 { "Line", 0x2 },
14251                 { "CD", 0x4 },
14252         },
14253 };
14254
14255 static struct hda_input_mux alc861vd_dallas_capture_source = {
14256         .num_items = 2,
14257         .items = {
14258                 { "Ext Mic", 0x0 },
14259                 { "Int Mic", 0x1 },
14260         },
14261 };
14262
14263 static struct hda_input_mux alc861vd_hp_capture_source = {
14264         .num_items = 2,
14265         .items = {
14266                 { "Front Mic", 0x0 },
14267                 { "ATAPI Mic", 0x1 },
14268         },
14269 };
14270
14271 /*
14272  * 2ch mode
14273  */
14274 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14275         { 2, NULL }
14276 };
14277
14278 /*
14279  * 6ch mode
14280  */
14281 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14282         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14283         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14284         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14285         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14286         { } /* end */
14287 };
14288
14289 /*
14290  * 8ch mode
14291  */
14292 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14293         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14294         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14295         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14296         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14297         { } /* end */
14298 };
14299
14300 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14301         { 6, alc861vd_6stack_ch6_init },
14302         { 8, alc861vd_6stack_ch8_init },
14303 };
14304
14305 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14306         {
14307                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14308                 .name = "Channel Mode",
14309                 .info = alc_ch_mode_info,
14310                 .get = alc_ch_mode_get,
14311                 .put = alc_ch_mode_put,
14312         },
14313         { } /* end */
14314 };
14315
14316 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14317  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14318  */
14319 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14320         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14321         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14322
14323         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14324         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14325
14326         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14327                                 HDA_OUTPUT),
14328         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14329                                 HDA_OUTPUT),
14330         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14331         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14332
14333         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14334         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14335
14336         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14337
14338         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14339         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14340         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14341
14342         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14343         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14344         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14345
14346         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14347         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14348
14349         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14350         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14351
14352         { } /* end */
14353 };
14354
14355 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
14356         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14357         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14358
14359         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14360
14361         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14362         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14363         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14364
14365         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14366         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14367         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14368
14369         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14370         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14371
14372         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14373         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14374
14375         { } /* end */
14376 };
14377
14378 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
14379         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14380         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
14381         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14382
14383         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14384
14385         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14386         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14387         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14388
14389         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14390         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14391         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14392
14393         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14394         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14395
14396         { } /* end */
14397 };
14398
14399 /* Pin assignment: Speaker=0x14, HP = 0x15,
14400  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
14401  */
14402 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
14403         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14404         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
14405         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14406         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14407         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
14408         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14409         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14410         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
14411         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14412         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14413         { } /* end */
14414 };
14415
14416 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
14417  *                 Front Mic=0x18, ATAPI Mic = 0x19,
14418  */
14419 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
14420         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14421         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14422         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14423         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14424         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14425         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14426         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14427         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14428
14429         { } /* end */
14430 };
14431
14432 /*
14433  * generic initialization of ADC, input mixers and output mixers
14434  */
14435 static struct hda_verb alc861vd_volume_init_verbs[] = {
14436         /*
14437          * Unmute ADC0 and set the default input to mic-in
14438          */
14439         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14440         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14441
14442         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
14443          * the analog-loopback mixer widget
14444          */
14445         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14446         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14447         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14448         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14449         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14450         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14451
14452         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
14453         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14454         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14455         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14456         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14457
14458         /*
14459          * Set up output mixers (0x02 - 0x05)
14460          */
14461         /* set vol=0 to output mixers */
14462         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14463         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14464         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14465         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14466
14467         /* set up input amps for analog loopback */
14468         /* Amp Indices: DAC = 0, mixer = 1 */
14469         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14470         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14471         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14472         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14473         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14474         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14475         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14476         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14477
14478         { }
14479 };
14480
14481 /*
14482  * 3-stack pin configuration:
14483  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
14484  */
14485 static struct hda_verb alc861vd_3stack_init_verbs[] = {
14486         /*
14487          * Set pin mode and muting
14488          */
14489         /* set front pin widgets 0x14 for output */
14490         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14491         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14492         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14493
14494         /* Mic (rear) pin: input vref at 80% */
14495         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14496         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14497         /* Front Mic pin: input vref at 80% */
14498         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14499         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14500         /* Line In pin: input */
14501         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14502         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14503         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14504         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14505         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14506         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14507         /* CD pin widget for input */
14508         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14509
14510         { }
14511 };
14512
14513 /*
14514  * 6-stack pin configuration:
14515  */
14516 static struct hda_verb alc861vd_6stack_init_verbs[] = {
14517         /*
14518          * Set pin mode and muting
14519          */
14520         /* set front pin widgets 0x14 for output */
14521         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14522         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14523         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14524
14525         /* Rear Pin: output 1 (0x0d) */
14526         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14527         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14528         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14529         /* CLFE Pin: output 2 (0x0e) */
14530         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14531         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14532         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
14533         /* Side Pin: output 3 (0x0f) */
14534         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14535         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14536         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
14537
14538         /* Mic (rear) pin: input vref at 80% */
14539         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14540         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14541         /* Front Mic pin: input vref at 80% */
14542         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14543         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14544         /* Line In pin: input */
14545         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14546         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14547         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14548         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14549         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14550         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14551         /* CD pin widget for input */
14552         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14553
14554         { }
14555 };
14556
14557 static struct hda_verb alc861vd_eapd_verbs[] = {
14558         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14559         { }
14560 };
14561
14562 static struct hda_verb alc660vd_eapd_verbs[] = {
14563         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14564         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14565         { }
14566 };
14567
14568 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
14569         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14570         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14571         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
14572         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14573         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14574         {}
14575 };
14576
14577 /* toggle speaker-output according to the hp-jack state */
14578 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
14579 {
14580         unsigned int present;
14581         unsigned char bits;
14582
14583         present = snd_hda_codec_read(codec, 0x1b, 0,
14584                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14585         bits = present ? HDA_AMP_MUTE : 0;
14586         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14587                                  HDA_AMP_MUTE, bits);
14588 }
14589
14590 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
14591 {
14592         unsigned int present;
14593         unsigned char bits;
14594
14595         present = snd_hda_codec_read(codec, 0x18, 0,
14596                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14597         bits = present ? HDA_AMP_MUTE : 0;
14598         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
14599                                  HDA_AMP_MUTE, bits);
14600 }
14601
14602 static void alc861vd_lenovo_automute(struct hda_codec *codec)
14603 {
14604         alc861vd_lenovo_hp_automute(codec);
14605         alc861vd_lenovo_mic_automute(codec);
14606 }
14607
14608 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
14609                                         unsigned int res)
14610 {
14611         switch (res >> 26) {
14612         case ALC880_HP_EVENT:
14613                 alc861vd_lenovo_hp_automute(codec);
14614                 break;
14615         case ALC880_MIC_EVENT:
14616                 alc861vd_lenovo_mic_automute(codec);
14617                 break;
14618         }
14619 }
14620
14621 static struct hda_verb alc861vd_dallas_verbs[] = {
14622         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14623         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14624         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14625         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14626
14627         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14628         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14629         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14630         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14631         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14632         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14633         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14634         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14635
14636         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14637         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14638         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14639         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14640         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14641         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14642         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14643         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14644
14645         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14646         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14647         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14648         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14649         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14650         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14651         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14652         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14653
14654         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14655         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14656         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14657         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14658
14659         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14660         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14661         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14662
14663         { } /* end */
14664 };
14665
14666 /* toggle speaker-output according to the hp-jack state */
14667 static void alc861vd_dallas_automute(struct hda_codec *codec)
14668 {
14669         unsigned int present;
14670
14671         present = snd_hda_codec_read(codec, 0x15, 0,
14672                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14673         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14674                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14675 }
14676
14677 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
14678 {
14679         if ((res >> 26) == ALC880_HP_EVENT)
14680                 alc861vd_dallas_automute(codec);
14681 }
14682
14683 #ifdef CONFIG_SND_HDA_POWER_SAVE
14684 #define alc861vd_loopbacks      alc880_loopbacks
14685 #endif
14686
14687 /* pcm configuration: identiacal with ALC880 */
14688 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
14689 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
14690 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
14691 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
14692
14693 /*
14694  * configuration and preset
14695  */
14696 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14697         [ALC660VD_3ST]          = "3stack-660",
14698         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
14699         [ALC660VD_ASUS_V1S]     = "asus-v1s",
14700         [ALC861VD_3ST]          = "3stack",
14701         [ALC861VD_3ST_DIG]      = "3stack-digout",
14702         [ALC861VD_6ST_DIG]      = "6stack-digout",
14703         [ALC861VD_LENOVO]       = "lenovo",
14704         [ALC861VD_DALLAS]       = "dallas",
14705         [ALC861VD_HP]           = "hp",
14706         [ALC861VD_AUTO]         = "auto",
14707 };
14708
14709 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14710         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14711         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14712         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14713         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14714         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
14715         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14716         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14717         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14718         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14719         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14720         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14721         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14722         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14723         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
14724         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14725         {}
14726 };
14727
14728 static struct alc_config_preset alc861vd_presets[] = {
14729         [ALC660VD_3ST] = {
14730                 .mixers = { alc861vd_3st_mixer },
14731                 .init_verbs = { alc861vd_volume_init_verbs,
14732                                  alc861vd_3stack_init_verbs },
14733                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14734                 .dac_nids = alc660vd_dac_nids,
14735                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14736                 .channel_mode = alc861vd_3stack_2ch_modes,
14737                 .input_mux = &alc861vd_capture_source,
14738         },
14739         [ALC660VD_3ST_DIG] = {
14740                 .mixers = { alc861vd_3st_mixer },
14741                 .init_verbs = { alc861vd_volume_init_verbs,
14742                                  alc861vd_3stack_init_verbs },
14743                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14744                 .dac_nids = alc660vd_dac_nids,
14745                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14746                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14747                 .channel_mode = alc861vd_3stack_2ch_modes,
14748                 .input_mux = &alc861vd_capture_source,
14749         },
14750         [ALC861VD_3ST] = {
14751                 .mixers = { alc861vd_3st_mixer },
14752                 .init_verbs = { alc861vd_volume_init_verbs,
14753                                  alc861vd_3stack_init_verbs },
14754                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14755                 .dac_nids = alc861vd_dac_nids,
14756                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14757                 .channel_mode = alc861vd_3stack_2ch_modes,
14758                 .input_mux = &alc861vd_capture_source,
14759         },
14760         [ALC861VD_3ST_DIG] = {
14761                 .mixers = { alc861vd_3st_mixer },
14762                 .init_verbs = { alc861vd_volume_init_verbs,
14763                                  alc861vd_3stack_init_verbs },
14764                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14765                 .dac_nids = alc861vd_dac_nids,
14766                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14767                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14768                 .channel_mode = alc861vd_3stack_2ch_modes,
14769                 .input_mux = &alc861vd_capture_source,
14770         },
14771         [ALC861VD_6ST_DIG] = {
14772                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14773                 .init_verbs = { alc861vd_volume_init_verbs,
14774                                 alc861vd_6stack_init_verbs },
14775                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14776                 .dac_nids = alc861vd_dac_nids,
14777                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14778                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14779                 .channel_mode = alc861vd_6stack_modes,
14780                 .input_mux = &alc861vd_capture_source,
14781         },
14782         [ALC861VD_LENOVO] = {
14783                 .mixers = { alc861vd_lenovo_mixer },
14784                 .init_verbs = { alc861vd_volume_init_verbs,
14785                                 alc861vd_3stack_init_verbs,
14786                                 alc861vd_eapd_verbs,
14787                                 alc861vd_lenovo_unsol_verbs },
14788                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14789                 .dac_nids = alc660vd_dac_nids,
14790                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14791                 .channel_mode = alc861vd_3stack_2ch_modes,
14792                 .input_mux = &alc861vd_capture_source,
14793                 .unsol_event = alc861vd_lenovo_unsol_event,
14794                 .init_hook = alc861vd_lenovo_automute,
14795         },
14796         [ALC861VD_DALLAS] = {
14797                 .mixers = { alc861vd_dallas_mixer },
14798                 .init_verbs = { alc861vd_dallas_verbs },
14799                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14800                 .dac_nids = alc861vd_dac_nids,
14801                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14802                 .channel_mode = alc861vd_3stack_2ch_modes,
14803                 .input_mux = &alc861vd_dallas_capture_source,
14804                 .unsol_event = alc861vd_dallas_unsol_event,
14805                 .init_hook = alc861vd_dallas_automute,
14806         },
14807         [ALC861VD_HP] = {
14808                 .mixers = { alc861vd_hp_mixer },
14809                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14810                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14811                 .dac_nids = alc861vd_dac_nids,
14812                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14813                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14814                 .channel_mode = alc861vd_3stack_2ch_modes,
14815                 .input_mux = &alc861vd_hp_capture_source,
14816                 .unsol_event = alc861vd_dallas_unsol_event,
14817                 .init_hook = alc861vd_dallas_automute,
14818         },
14819         [ALC660VD_ASUS_V1S] = {
14820                 .mixers = { alc861vd_lenovo_mixer },
14821                 .init_verbs = { alc861vd_volume_init_verbs,
14822                                 alc861vd_3stack_init_verbs,
14823                                 alc861vd_eapd_verbs,
14824                                 alc861vd_lenovo_unsol_verbs },
14825                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14826                 .dac_nids = alc660vd_dac_nids,
14827                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14828                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14829                 .channel_mode = alc861vd_3stack_2ch_modes,
14830                 .input_mux = &alc861vd_capture_source,
14831                 .unsol_event = alc861vd_lenovo_unsol_event,
14832                 .init_hook = alc861vd_lenovo_automute,
14833         },
14834 };
14835
14836 /*
14837  * BIOS auto configuration
14838  */
14839 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14840                                 hda_nid_t nid, int pin_type, int dac_idx)
14841 {
14842         alc_set_pin_output(codec, nid, pin_type);
14843 }
14844
14845 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14846 {
14847         struct alc_spec *spec = codec->spec;
14848         int i;
14849
14850         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14851         for (i = 0; i <= HDA_SIDE; i++) {
14852                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14853                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14854                 if (nid)
14855                         alc861vd_auto_set_output_and_unmute(codec, nid,
14856                                                             pin_type, i);
14857         }
14858 }
14859
14860
14861 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14862 {
14863         struct alc_spec *spec = codec->spec;
14864         hda_nid_t pin;
14865
14866         pin = spec->autocfg.hp_pins[0];
14867         if (pin) /* connect to front and  use dac 0 */
14868                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14869         pin = spec->autocfg.speaker_pins[0];
14870         if (pin)
14871                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14872 }
14873
14874 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
14875 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
14876
14877 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14878 {
14879         struct alc_spec *spec = codec->spec;
14880         int i;
14881
14882         for (i = 0; i < AUTO_PIN_LAST; i++) {
14883                 hda_nid_t nid = spec->autocfg.input_pins[i];
14884                 if (alc861vd_is_input_pin(nid)) {
14885                         alc_set_input_pin(codec, nid, i);
14886                         if (nid != ALC861VD_PIN_CD_NID &&
14887                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
14888                                 snd_hda_codec_write(codec, nid, 0,
14889                                                 AC_VERB_SET_AMP_GAIN_MUTE,
14890                                                 AMP_OUT_MUTE);
14891                 }
14892         }
14893 }
14894
14895 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
14896
14897 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
14898 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
14899
14900 /* add playback controls from the parsed DAC table */
14901 /* Based on ALC880 version. But ALC861VD has separate,
14902  * different NIDs for mute/unmute switch and volume control */
14903 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14904                                              const struct auto_pin_cfg *cfg)
14905 {
14906         char name[32];
14907         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14908         hda_nid_t nid_v, nid_s;
14909         int i, err;
14910
14911         for (i = 0; i < cfg->line_outs; i++) {
14912                 if (!spec->multiout.dac_nids[i])
14913                         continue;
14914                 nid_v = alc861vd_idx_to_mixer_vol(
14915                                 alc880_dac_to_idx(
14916                                         spec->multiout.dac_nids[i]));
14917                 nid_s = alc861vd_idx_to_mixer_switch(
14918                                 alc880_dac_to_idx(
14919                                         spec->multiout.dac_nids[i]));
14920
14921                 if (i == 2) {
14922                         /* Center/LFE */
14923                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14924                                           "Center Playback Volume",
14925                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14926                                                               HDA_OUTPUT));
14927                         if (err < 0)
14928                                 return err;
14929                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14930                                           "LFE Playback Volume",
14931                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14932                                                               HDA_OUTPUT));
14933                         if (err < 0)
14934                                 return err;
14935                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14936                                           "Center Playback Switch",
14937                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
14938                                                               HDA_INPUT));
14939                         if (err < 0)
14940                                 return err;
14941                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14942                                           "LFE Playback Switch",
14943                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
14944                                                               HDA_INPUT));
14945                         if (err < 0)
14946                                 return err;
14947                 } else {
14948                         sprintf(name, "%s Playback Volume", chname[i]);
14949                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14950                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
14951                                                               HDA_OUTPUT));
14952                         if (err < 0)
14953                                 return err;
14954                         sprintf(name, "%s Playback Switch", chname[i]);
14955                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14956                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
14957                                                               HDA_INPUT));
14958                         if (err < 0)
14959                                 return err;
14960                 }
14961         }
14962         return 0;
14963 }
14964
14965 /* add playback controls for speaker and HP outputs */
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_extra_out(struct alc_spec *spec,
14969                                         hda_nid_t pin, const char *pfx)
14970 {
14971         hda_nid_t nid_v, nid_s;
14972         int err;
14973         char name[32];
14974
14975         if (!pin)
14976                 return 0;
14977
14978         if (alc880_is_fixed_pin(pin)) {
14979                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14980                 /* specify the DAC as the extra output */
14981                 if (!spec->multiout.hp_nid)
14982                         spec->multiout.hp_nid = nid_v;
14983                 else
14984                         spec->multiout.extra_out_nid[0] = nid_v;
14985                 /* control HP volume/switch on the output mixer amp */
14986                 nid_v = alc861vd_idx_to_mixer_vol(
14987                                 alc880_fixed_pin_idx(pin));
14988                 nid_s = alc861vd_idx_to_mixer_switch(
14989                                 alc880_fixed_pin_idx(pin));
14990
14991                 sprintf(name, "%s Playback Volume", pfx);
14992                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14993                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
14994                 if (err < 0)
14995                         return err;
14996                 sprintf(name, "%s Playback Switch", pfx);
14997                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14998                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
14999                 if (err < 0)
15000                         return err;
15001         } else if (alc880_is_multi_pin(pin)) {
15002                 /* set manual connection */
15003                 /* we have only a switch on HP-out PIN */
15004                 sprintf(name, "%s Playback Switch", pfx);
15005                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
15006                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15007                 if (err < 0)
15008                         return err;
15009         }
15010         return 0;
15011 }
15012
15013 /* parse the BIOS configuration and set up the alc_spec
15014  * return 1 if successful, 0 if the proper config is not found,
15015  * or a negative error code
15016  * Based on ALC880 version - had to change it to override
15017  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15018 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15019 {
15020         struct alc_spec *spec = codec->spec;
15021         int err;
15022         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15023
15024         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15025                                            alc861vd_ignore);
15026         if (err < 0)
15027                 return err;
15028         if (!spec->autocfg.line_outs)
15029                 return 0; /* can't find valid BIOS pin config */
15030
15031         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15032         if (err < 0)
15033                 return err;
15034         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15035         if (err < 0)
15036                 return err;
15037         err = alc861vd_auto_create_extra_out(spec,
15038                                              spec->autocfg.speaker_pins[0],
15039                                              "Speaker");
15040         if (err < 0)
15041                 return err;
15042         err = alc861vd_auto_create_extra_out(spec,
15043                                              spec->autocfg.hp_pins[0],
15044                                              "Headphone");
15045         if (err < 0)
15046                 return err;
15047         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
15048         if (err < 0)
15049                 return err;
15050
15051         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15052
15053         if (spec->autocfg.dig_outs)
15054                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15055
15056         if (spec->kctls.list)
15057                 add_mixer(spec, spec->kctls.list);
15058
15059         add_verb(spec, alc861vd_volume_init_verbs);
15060
15061         spec->num_mux_defs = 1;
15062         spec->input_mux = &spec->private_imux[0];
15063
15064         err = alc_auto_add_mic_boost(codec);
15065         if (err < 0)
15066                 return err;
15067
15068         return 1;
15069 }
15070
15071 /* additional initialization for auto-configuration model */
15072 static void alc861vd_auto_init(struct hda_codec *codec)
15073 {
15074         struct alc_spec *spec = codec->spec;
15075         alc861vd_auto_init_multi_out(codec);
15076         alc861vd_auto_init_hp_out(codec);
15077         alc861vd_auto_init_analog_input(codec);
15078         alc861vd_auto_init_input_src(codec);
15079         if (spec->unsol_event)
15080                 alc_inithook(codec);
15081 }
15082
15083 static int patch_alc861vd(struct hda_codec *codec)
15084 {
15085         struct alc_spec *spec;
15086         int err, board_config;
15087
15088         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15089         if (spec == NULL)
15090                 return -ENOMEM;
15091
15092         codec->spec = spec;
15093
15094         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15095                                                   alc861vd_models,
15096                                                   alc861vd_cfg_tbl);
15097
15098         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15099                 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
15100                         "ALC861VD, trying auto-probe from BIOS...\n");
15101                 board_config = ALC861VD_AUTO;
15102         }
15103
15104         if (board_config == ALC861VD_AUTO) {
15105                 /* automatic parse from the BIOS config */
15106                 err = alc861vd_parse_auto_config(codec);
15107                 if (err < 0) {
15108                         alc_free(codec);
15109                         return err;
15110                 } else if (!err) {
15111                         printk(KERN_INFO
15112                                "hda_codec: Cannot set up configuration "
15113                                "from BIOS.  Using base mode...\n");
15114                         board_config = ALC861VD_3ST;
15115                 }
15116         }
15117
15118         err = snd_hda_attach_beep_device(codec, 0x23);
15119         if (err < 0) {
15120                 alc_free(codec);
15121                 return err;
15122         }
15123
15124         if (board_config != ALC861VD_AUTO)
15125                 setup_preset(spec, &alc861vd_presets[board_config]);
15126
15127         if (codec->vendor_id == 0x10ec0660) {
15128                 spec->stream_name_analog = "ALC660-VD Analog";
15129                 spec->stream_name_digital = "ALC660-VD Digital";
15130                 /* always turn on EAPD */
15131                 add_verb(spec, alc660vd_eapd_verbs);
15132         } else {
15133                 spec->stream_name_analog = "ALC861VD Analog";
15134                 spec->stream_name_digital = "ALC861VD Digital";
15135         }
15136
15137         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15138         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15139
15140         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15141         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15142
15143         spec->adc_nids = alc861vd_adc_nids;
15144         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15145         spec->capsrc_nids = alc861vd_capsrc_nids;
15146         spec->capture_style = CAPT_MIX;
15147
15148         set_capture_mixer(spec);
15149         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15150
15151         spec->vmaster_nid = 0x02;
15152
15153         codec->patch_ops = alc_patch_ops;
15154
15155         if (board_config == ALC861VD_AUTO)
15156                 spec->init_hook = alc861vd_auto_init;
15157 #ifdef CONFIG_SND_HDA_POWER_SAVE
15158         if (!spec->loopback.amplist)
15159                 spec->loopback.amplist = alc861vd_loopbacks;
15160 #endif
15161         codec->proc_widget_hook = print_realtek_coef;
15162
15163         return 0;
15164 }
15165
15166 /*
15167  * ALC662 support
15168  *
15169  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15170  * configuration.  Each pin widget can choose any input DACs and a mixer.
15171  * Each ADC is connected from a mixer of all inputs.  This makes possible
15172  * 6-channel independent captures.
15173  *
15174  * In addition, an independent DAC for the multi-playback (not used in this
15175  * driver yet).
15176  */
15177 #define ALC662_DIGOUT_NID       0x06
15178 #define ALC662_DIGIN_NID        0x0a
15179
15180 static hda_nid_t alc662_dac_nids[4] = {
15181         /* front, rear, clfe, rear_surr */
15182         0x02, 0x03, 0x04
15183 };
15184
15185 static hda_nid_t alc662_adc_nids[1] = {
15186         /* ADC1-2 */
15187         0x09,
15188 };
15189
15190 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
15191
15192 /* input MUX */
15193 /* FIXME: should be a matrix-type input source selection */
15194 static struct hda_input_mux alc662_capture_source = {
15195         .num_items = 4,
15196         .items = {
15197                 { "Mic", 0x0 },
15198                 { "Front Mic", 0x1 },
15199                 { "Line", 0x2 },
15200                 { "CD", 0x4 },
15201         },
15202 };
15203
15204 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15205         .num_items = 2,
15206         .items = {
15207                 { "Mic", 0x1 },
15208                 { "Line", 0x2 },
15209         },
15210 };
15211
15212 static struct hda_input_mux alc662_eeepc_capture_source = {
15213         .num_items = 2,
15214         .items = {
15215                 { "i-Mic", 0x1 },
15216                 { "e-Mic", 0x0 },
15217         },
15218 };
15219
15220 static struct hda_input_mux alc663_capture_source = {
15221         .num_items = 3,
15222         .items = {
15223                 { "Mic", 0x0 },
15224                 { "Front Mic", 0x1 },
15225                 { "Line", 0x2 },
15226         },
15227 };
15228
15229 static struct hda_input_mux alc663_m51va_capture_source = {
15230         .num_items = 2,
15231         .items = {
15232                 { "Ext-Mic", 0x0 },
15233                 { "D-Mic", 0x9 },
15234         },
15235 };
15236
15237 /*
15238  * 2ch mode
15239  */
15240 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15241         { 2, NULL }
15242 };
15243
15244 /*
15245  * 2ch mode
15246  */
15247 static struct hda_verb alc662_3ST_ch2_init[] = {
15248         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15249         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15250         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15251         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15252         { } /* end */
15253 };
15254
15255 /*
15256  * 6ch mode
15257  */
15258 static struct hda_verb alc662_3ST_ch6_init[] = {
15259         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15260         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15261         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15262         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15263         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15264         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15265         { } /* end */
15266 };
15267
15268 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15269         { 2, alc662_3ST_ch2_init },
15270         { 6, alc662_3ST_ch6_init },
15271 };
15272
15273 /*
15274  * 2ch mode
15275  */
15276 static struct hda_verb alc662_sixstack_ch6_init[] = {
15277         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15278         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15279         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15280         { } /* end */
15281 };
15282
15283 /*
15284  * 6ch mode
15285  */
15286 static struct hda_verb alc662_sixstack_ch8_init[] = {
15287         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15288         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15289         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15290         { } /* end */
15291 };
15292
15293 static struct hda_channel_mode alc662_5stack_modes[2] = {
15294         { 2, alc662_sixstack_ch6_init },
15295         { 6, alc662_sixstack_ch8_init },
15296 };
15297
15298 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15299  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15300  */
15301
15302 static struct snd_kcontrol_new alc662_base_mixer[] = {
15303         /* output mixer control */
15304         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
15305         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15306         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
15307         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15308         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15309         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15310         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15311         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15312         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15313
15314         /*Input mixer control */
15315         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
15316         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
15317         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
15318         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
15319         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
15320         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
15321         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
15322         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
15323         { } /* end */
15324 };
15325
15326 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
15327         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15328         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15329         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15330         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15331         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15332         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15333         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15334         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15335         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15336         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15337         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15338         { } /* end */
15339 };
15340
15341 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
15342         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15343         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15344         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15345         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15346         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15347         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15348         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15349         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15350         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15351         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15352         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15353         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15354         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15355         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15356         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15357         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15358         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15359         { } /* end */
15360 };
15361
15362 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
15363         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15364         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
15365         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15366         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
15367         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15368         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15369         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15370         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15371         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15372         { } /* end */
15373 };
15374
15375 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
15376         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15377
15378         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15379         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15380
15381         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
15382         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15383         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15384
15385         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15386         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15387         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15388         { } /* end */
15389 };
15390
15391 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
15392         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15393         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15394         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15395         HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
15396         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15397         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15398         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
15399         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
15400         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15401         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
15402         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15403         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15404         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15405         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15406         { } /* end */
15407 };
15408
15409 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
15410         .ops = &snd_hda_bind_vol,
15411         .values = {
15412                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15413                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
15414                 0
15415         },
15416 };
15417
15418 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
15419         .ops = &snd_hda_bind_sw,
15420         .values = {
15421                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15422                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15423                 0
15424         },
15425 };
15426
15427 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
15428         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15429         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
15430         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15431         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15432         { } /* end */
15433 };
15434
15435 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
15436         .ops = &snd_hda_bind_sw,
15437         .values = {
15438                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15439                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15440                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15441                 0
15442         },
15443 };
15444
15445 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
15446         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15447         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
15448         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15449         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15450         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15451         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15452
15453         { } /* end */
15454 };
15455
15456 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
15457         .ops = &snd_hda_bind_sw,
15458         .values = {
15459                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15460                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15461                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15462                 0
15463         },
15464 };
15465
15466 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
15467         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15468         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
15469         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15470         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15471         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15472         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15473         { } /* end */
15474 };
15475
15476 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
15477         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15478         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15479         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15480         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15481         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15482         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15483         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15484         { } /* end */
15485 };
15486
15487 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
15488         .ops = &snd_hda_bind_vol,
15489         .values = {
15490                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15491                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
15492                 0
15493         },
15494 };
15495
15496 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
15497         .ops = &snd_hda_bind_sw,
15498         .values = {
15499                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15500                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
15501                 0
15502         },
15503 };
15504
15505 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
15506         HDA_BIND_VOL("Master Playback Volume",
15507                                 &alc663_asus_two_bind_master_vol),
15508         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15509         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15510         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15511         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15512         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15513         { } /* end */
15514 };
15515
15516 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
15517         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15518         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15519         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15520         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15521         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15522         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15523         { } /* end */
15524 };
15525
15526 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
15527         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15528         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15529         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15530         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15531         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15532
15533         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15534         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15535         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15536         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15537         { } /* end */
15538 };
15539
15540 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
15541         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15542         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15543         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15544
15545         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15546         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15547         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15548         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15549         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15550         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15551         { } /* end */
15552 };
15553
15554 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
15555         {
15556                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15557                 .name = "Channel Mode",
15558                 .info = alc_ch_mode_info,
15559                 .get = alc_ch_mode_get,
15560                 .put = alc_ch_mode_put,
15561         },
15562         { } /* end */
15563 };
15564
15565 static struct hda_verb alc662_init_verbs[] = {
15566         /* ADC: mute amp left and right */
15567         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15568         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15569         /* Front mixer: unmute input/output amp left and right (volume = 0) */
15570
15571         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15572         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15573         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15574         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15575         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15576
15577         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15578         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15579         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15580         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15581         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15582         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15583
15584         /* Front Pin: output 0 (0x0c) */
15585         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15586         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15587
15588         /* Rear Pin: output 1 (0x0d) */
15589         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15590         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15591
15592         /* CLFE Pin: output 2 (0x0e) */
15593         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15594         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15595
15596         /* Mic (rear) pin: input vref at 80% */
15597         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15598         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15599         /* Front Mic pin: input vref at 80% */
15600         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15601         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15602         /* Line In pin: input */
15603         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15604         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15605         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15606         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15607         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15608         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15609         /* CD pin widget for input */
15610         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15611
15612         /* FIXME: use matrix-type input source selection */
15613         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15614         /* Input mixer */
15615         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15616         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15617         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15618         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15619
15620         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15621         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15622         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15623         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15624
15625         /* always trun on EAPD */
15626         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15627         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15628
15629         { }
15630 };
15631
15632 static struct hda_verb alc662_sue_init_verbs[] = {
15633         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15634         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15635         {}
15636 };
15637
15638 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
15639         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15640         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15641         {}
15642 };
15643
15644 /* Set Unsolicited Event*/
15645 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15646         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15647         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15648         {}
15649 };
15650
15651 /*
15652  * generic initialization of ADC, input mixers and output mixers
15653  */
15654 static struct hda_verb alc662_auto_init_verbs[] = {
15655         /*
15656          * Unmute ADC and set the default input to mic-in
15657          */
15658         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15659         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15660
15661         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15662          * mixer widget
15663          * Note: PASD motherboards uses the Line In 2 as the input for front
15664          * panel mic (mic 2)
15665          */
15666         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15667         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15668         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15669         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15670         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15671         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15672
15673         /*
15674          * Set up output mixers (0x0c - 0x0f)
15675          */
15676         /* set vol=0 to output mixers */
15677         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15678         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15679         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15680
15681         /* set up input amps for analog loopback */
15682         /* Amp Indices: DAC = 0, mixer = 1 */
15683         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15684         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15685         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15686         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15687         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15688         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15689
15690
15691         /* FIXME: use matrix-type input source selection */
15692         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15693         /* Input mixer */
15694         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15695         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15696         { }
15697 };
15698
15699 /* additional verbs for ALC663 */
15700 static struct hda_verb alc663_auto_init_verbs[] = {
15701         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15702         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15703         { }
15704 };
15705
15706 static struct hda_verb alc663_m51va_init_verbs[] = {
15707         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15708         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15709         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15710         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15711         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15712         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15713         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15714         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15715         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15716         {}
15717 };
15718
15719 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15720         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15721         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15722         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15723         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15724         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15725         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15726         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15727         {}
15728 };
15729
15730 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15731         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15732         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15733         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15734         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15735         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15736         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15737         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15738         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15739         {}
15740 };
15741
15742 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15743         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15744         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15745         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15746         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15747         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15748         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15749         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15750         {}
15751 };
15752
15753 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15754         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15755         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15756         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15757         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15758         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15759         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15760         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15761         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15762         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15763         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15764         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15765         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15766         {}
15767 };
15768
15769 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15770         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15771         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15772         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15773         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15774         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15775         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15776         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15777         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15778         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15779         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15780         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15781         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15782         {}
15783 };
15784
15785 static struct hda_verb alc663_g71v_init_verbs[] = {
15786         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15787         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15788         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15789
15790         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15791         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15792         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15793
15794         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15795         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15796         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15797         {}
15798 };
15799
15800 static struct hda_verb alc663_g50v_init_verbs[] = {
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, 0x00},  /* Headphone */
15804
15805         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15806         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15807         {}
15808 };
15809
15810 static struct hda_verb alc662_ecs_init_verbs[] = {
15811         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15812         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15813         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15814         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15815         {}
15816 };
15817
15818 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15819         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15820         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15821         { } /* end */
15822 };
15823
15824 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15825 {
15826         unsigned int present;
15827         unsigned char bits;
15828
15829         present = snd_hda_codec_read(codec, 0x14, 0,
15830                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15831         bits = present ? HDA_AMP_MUTE : 0;
15832         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15833                                  HDA_AMP_MUTE, bits);
15834 }
15835
15836 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15837 {
15838         unsigned int present;
15839         unsigned char bits;
15840
15841         present = snd_hda_codec_read(codec, 0x1b, 0,
15842                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15843         bits = present ? HDA_AMP_MUTE : 0;
15844         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15845                                  HDA_AMP_MUTE, bits);
15846         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15847                                  HDA_AMP_MUTE, bits);
15848 }
15849
15850 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15851                                            unsigned int res)
15852 {
15853         if ((res >> 26) == ALC880_HP_EVENT)
15854                 alc662_lenovo_101e_all_automute(codec);
15855         if ((res >> 26) == ALC880_FRONT_EVENT)
15856                 alc662_lenovo_101e_ispeaker_automute(codec);
15857 }
15858
15859 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15860 {
15861         unsigned int present;
15862
15863         present = snd_hda_codec_read(codec, 0x18, 0,
15864                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15865         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15866                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15867         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15868                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15869         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15870                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15871         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15872                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15873 }
15874
15875 /* unsolicited event for HP jack sensing */
15876 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
15877                                      unsigned int res)
15878 {
15879         if ((res >> 26) == ALC880_HP_EVENT)
15880                 alc262_hippo1_automute( codec );
15881
15882         if ((res >> 26) == ALC880_MIC_EVENT)
15883                 alc662_eeepc_mic_automute(codec);
15884 }
15885
15886 static void alc662_eeepc_inithook(struct hda_codec *codec)
15887 {
15888         alc262_hippo1_automute( codec );
15889         alc662_eeepc_mic_automute(codec);
15890 }
15891
15892 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
15893 {
15894         unsigned int mute;
15895         unsigned int present;
15896
15897         snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
15898         present = snd_hda_codec_read(codec, 0x14, 0,
15899                                      AC_VERB_GET_PIN_SENSE, 0);
15900         present = (present & 0x80000000) != 0;
15901         if (present) {
15902                 /* mute internal speaker */
15903                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15904                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
15905         } else {
15906                 /* unmute internal speaker if necessary */
15907                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
15908                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15909                                         HDA_AMP_MUTE, mute);
15910         }
15911 }
15912
15913 /* unsolicited event for HP jack sensing */
15914 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
15915                                           unsigned int res)
15916 {
15917         if ((res >> 26) == ALC880_HP_EVENT)
15918                 alc662_eeepc_ep20_automute(codec);
15919 }
15920
15921 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
15922 {
15923         alc662_eeepc_ep20_automute(codec);
15924 }
15925
15926 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
15927 {
15928         unsigned int present;
15929         unsigned char bits;
15930
15931         present = snd_hda_codec_read(codec, 0x21, 0,
15932                         AC_VERB_GET_PIN_SENSE, 0)
15933                         & AC_PINSENSE_PRESENCE;
15934         bits = present ? HDA_AMP_MUTE : 0;
15935         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15936                                 AMP_IN_MUTE(0), bits);
15937         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15938                                 AMP_IN_MUTE(0), bits);
15939 }
15940
15941 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
15942 {
15943         unsigned int present;
15944         unsigned char bits;
15945
15946         present = snd_hda_codec_read(codec, 0x21, 0,
15947                         AC_VERB_GET_PIN_SENSE, 0)
15948                         & AC_PINSENSE_PRESENCE;
15949         bits = present ? HDA_AMP_MUTE : 0;
15950         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15951                                 AMP_IN_MUTE(0), bits);
15952         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15953                                 AMP_IN_MUTE(0), bits);
15954         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15955                                 AMP_IN_MUTE(0), bits);
15956         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15957                                 AMP_IN_MUTE(0), bits);
15958 }
15959
15960 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
15961 {
15962         unsigned int present;
15963         unsigned char bits;
15964
15965         present = snd_hda_codec_read(codec, 0x15, 0,
15966                         AC_VERB_GET_PIN_SENSE, 0)
15967                         & AC_PINSENSE_PRESENCE;
15968         bits = present ? HDA_AMP_MUTE : 0;
15969         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15970                                 AMP_IN_MUTE(0), bits);
15971         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15972                                 AMP_IN_MUTE(0), bits);
15973         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15974                                 AMP_IN_MUTE(0), bits);
15975         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15976                                 AMP_IN_MUTE(0), bits);
15977 }
15978
15979 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
15980 {
15981         unsigned int present;
15982         unsigned char bits;
15983
15984         present = snd_hda_codec_read(codec, 0x1b, 0,
15985                         AC_VERB_GET_PIN_SENSE, 0)
15986                         & AC_PINSENSE_PRESENCE;
15987         bits = present ? 0 : PIN_OUT;
15988         snd_hda_codec_write(codec, 0x14, 0,
15989                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
15990 }
15991
15992 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
15993 {
15994         unsigned int present1, present2;
15995
15996         present1 = snd_hda_codec_read(codec, 0x21, 0,
15997                         AC_VERB_GET_PIN_SENSE, 0)
15998                         & AC_PINSENSE_PRESENCE;
15999         present2 = snd_hda_codec_read(codec, 0x15, 0,
16000                         AC_VERB_GET_PIN_SENSE, 0)
16001                         & AC_PINSENSE_PRESENCE;
16002
16003         if (present1 || present2) {
16004                 snd_hda_codec_write_cache(codec, 0x14, 0,
16005                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16006         } else {
16007                 snd_hda_codec_write_cache(codec, 0x14, 0,
16008                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16009         }
16010 }
16011
16012 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16013 {
16014         unsigned int present1, present2;
16015
16016         present1 = snd_hda_codec_read(codec, 0x1b, 0,
16017                                 AC_VERB_GET_PIN_SENSE, 0)
16018                                 & AC_PINSENSE_PRESENCE;
16019         present2 = snd_hda_codec_read(codec, 0x15, 0,
16020                                 AC_VERB_GET_PIN_SENSE, 0)
16021                                 & AC_PINSENSE_PRESENCE;
16022
16023         if (present1 || present2) {
16024                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16025                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16026                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16027                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16028         } else {
16029                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16030                                 AMP_IN_MUTE(0), 0);
16031                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16032                                 AMP_IN_MUTE(0), 0);
16033         }
16034 }
16035
16036 static void alc663_m51va_mic_automute(struct hda_codec *codec)
16037 {
16038         unsigned int present;
16039
16040         present = snd_hda_codec_read(codec, 0x18, 0,
16041                         AC_VERB_GET_PIN_SENSE, 0)
16042                         & AC_PINSENSE_PRESENCE;
16043         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16044                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16045         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16046                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16047         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16048                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16049         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16050                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16051 }
16052
16053 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16054                                            unsigned int res)
16055 {
16056         switch (res >> 26) {
16057         case ALC880_HP_EVENT:
16058                 alc663_m51va_speaker_automute(codec);
16059                 break;
16060         case ALC880_MIC_EVENT:
16061                 alc663_m51va_mic_automute(codec);
16062                 break;
16063         }
16064 }
16065
16066 static void alc663_m51va_inithook(struct hda_codec *codec)
16067 {
16068         alc663_m51va_speaker_automute(codec);
16069         alc663_m51va_mic_automute(codec);
16070 }
16071
16072 /* ***************** Mode1 ******************************/
16073 static void alc663_mode1_unsol_event(struct hda_codec *codec,
16074                                            unsigned int res)
16075 {
16076         switch (res >> 26) {
16077         case ALC880_HP_EVENT:
16078                 alc663_m51va_speaker_automute(codec);
16079                 break;
16080         case ALC880_MIC_EVENT:
16081                 alc662_eeepc_mic_automute(codec);
16082                 break;
16083         }
16084 }
16085
16086 static void alc663_mode1_inithook(struct hda_codec *codec)
16087 {
16088         alc663_m51va_speaker_automute(codec);
16089         alc662_eeepc_mic_automute(codec);
16090 }
16091 /* ***************** Mode2 ******************************/
16092 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16093                                            unsigned int res)
16094 {
16095         switch (res >> 26) {
16096         case ALC880_HP_EVENT:
16097                 alc662_f5z_speaker_automute(codec);
16098                 break;
16099         case ALC880_MIC_EVENT:
16100                 alc662_eeepc_mic_automute(codec);
16101                 break;
16102         }
16103 }
16104
16105 static void alc662_mode2_inithook(struct hda_codec *codec)
16106 {
16107         alc662_f5z_speaker_automute(codec);
16108         alc662_eeepc_mic_automute(codec);
16109 }
16110 /* ***************** Mode3 ******************************/
16111 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16112                                            unsigned int res)
16113 {
16114         switch (res >> 26) {
16115         case ALC880_HP_EVENT:
16116                 alc663_two_hp_m1_speaker_automute(codec);
16117                 break;
16118         case ALC880_MIC_EVENT:
16119                 alc662_eeepc_mic_automute(codec);
16120                 break;
16121         }
16122 }
16123
16124 static void alc663_mode3_inithook(struct hda_codec *codec)
16125 {
16126         alc663_two_hp_m1_speaker_automute(codec);
16127         alc662_eeepc_mic_automute(codec);
16128 }
16129 /* ***************** Mode4 ******************************/
16130 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16131                                            unsigned int res)
16132 {
16133         switch (res >> 26) {
16134         case ALC880_HP_EVENT:
16135                 alc663_21jd_two_speaker_automute(codec);
16136                 break;
16137         case ALC880_MIC_EVENT:
16138                 alc662_eeepc_mic_automute(codec);
16139                 break;
16140         }
16141 }
16142
16143 static void alc663_mode4_inithook(struct hda_codec *codec)
16144 {
16145         alc663_21jd_two_speaker_automute(codec);
16146         alc662_eeepc_mic_automute(codec);
16147 }
16148 /* ***************** Mode5 ******************************/
16149 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16150                                            unsigned int res)
16151 {
16152         switch (res >> 26) {
16153         case ALC880_HP_EVENT:
16154                 alc663_15jd_two_speaker_automute(codec);
16155                 break;
16156         case ALC880_MIC_EVENT:
16157                 alc662_eeepc_mic_automute(codec);
16158                 break;
16159         }
16160 }
16161
16162 static void alc663_mode5_inithook(struct hda_codec *codec)
16163 {
16164         alc663_15jd_two_speaker_automute(codec);
16165         alc662_eeepc_mic_automute(codec);
16166 }
16167 /* ***************** Mode6 ******************************/
16168 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16169                                            unsigned int res)
16170 {
16171         switch (res >> 26) {
16172         case ALC880_HP_EVENT:
16173                 alc663_two_hp_m2_speaker_automute(codec);
16174                 break;
16175         case ALC880_MIC_EVENT:
16176                 alc662_eeepc_mic_automute(codec);
16177                 break;
16178         }
16179 }
16180
16181 static void alc663_mode6_inithook(struct hda_codec *codec)
16182 {
16183         alc663_two_hp_m2_speaker_automute(codec);
16184         alc662_eeepc_mic_automute(codec);
16185 }
16186
16187 static void alc663_g71v_hp_automute(struct hda_codec *codec)
16188 {
16189         unsigned int present;
16190         unsigned char bits;
16191
16192         present = snd_hda_codec_read(codec, 0x21, 0,
16193                                      AC_VERB_GET_PIN_SENSE, 0)
16194                 & AC_PINSENSE_PRESENCE;
16195         bits = present ? HDA_AMP_MUTE : 0;
16196         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16197                                  HDA_AMP_MUTE, bits);
16198         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16199                                  HDA_AMP_MUTE, bits);
16200 }
16201
16202 static void alc663_g71v_front_automute(struct hda_codec *codec)
16203 {
16204         unsigned int present;
16205         unsigned char bits;
16206
16207         present = snd_hda_codec_read(codec, 0x15, 0,
16208                                      AC_VERB_GET_PIN_SENSE, 0)
16209                 & AC_PINSENSE_PRESENCE;
16210         bits = present ? HDA_AMP_MUTE : 0;
16211         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16212                                  HDA_AMP_MUTE, bits);
16213 }
16214
16215 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16216                                            unsigned int res)
16217 {
16218         switch (res >> 26) {
16219         case ALC880_HP_EVENT:
16220                 alc663_g71v_hp_automute(codec);
16221                 break;
16222         case ALC880_FRONT_EVENT:
16223                 alc663_g71v_front_automute(codec);
16224                 break;
16225         case ALC880_MIC_EVENT:
16226                 alc662_eeepc_mic_automute(codec);
16227                 break;
16228         }
16229 }
16230
16231 static void alc663_g71v_inithook(struct hda_codec *codec)
16232 {
16233         alc663_g71v_front_automute(codec);
16234         alc663_g71v_hp_automute(codec);
16235         alc662_eeepc_mic_automute(codec);
16236 }
16237
16238 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16239                                            unsigned int res)
16240 {
16241         switch (res >> 26) {
16242         case ALC880_HP_EVENT:
16243                 alc663_m51va_speaker_automute(codec);
16244                 break;
16245         case ALC880_MIC_EVENT:
16246                 alc662_eeepc_mic_automute(codec);
16247                 break;
16248         }
16249 }
16250
16251 static void alc663_g50v_inithook(struct hda_codec *codec)
16252 {
16253         alc663_m51va_speaker_automute(codec);
16254         alc662_eeepc_mic_automute(codec);
16255 }
16256
16257 /* bind hp and internal speaker mute (with plug check) */
16258 static int alc662_ecs_master_sw_put(struct snd_kcontrol *kcontrol,
16259                                      struct snd_ctl_elem_value *ucontrol)
16260 {
16261         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
16262         long *valp = ucontrol->value.integer.value;
16263         int change;
16264
16265         change = snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
16266                                           HDA_AMP_MUTE,
16267                                           valp[0] ? 0 : HDA_AMP_MUTE);
16268         change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
16269                                            HDA_AMP_MUTE,
16270                                            valp[1] ? 0 : HDA_AMP_MUTE);
16271         if (change)
16272                 alc262_hippo1_automute(codec);
16273         return change;
16274 }
16275
16276 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16277         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16278         {
16279                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16280                 .name = "Master Playback Switch",
16281                 .info = snd_hda_mixer_amp_switch_info,
16282                 .get = snd_hda_mixer_amp_switch_get,
16283                 .put = alc662_ecs_master_sw_put,
16284                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16285         },
16286
16287         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16288         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16289         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16290
16291         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16292         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16293         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16294         { } /* end */
16295 };
16296
16297 #ifdef CONFIG_SND_HDA_POWER_SAVE
16298 #define alc662_loopbacks        alc880_loopbacks
16299 #endif
16300
16301
16302 /* pcm configuration: identiacal with ALC880 */
16303 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
16304 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
16305 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
16306 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
16307
16308 /*
16309  * configuration and preset
16310  */
16311 static const char *alc662_models[ALC662_MODEL_LAST] = {
16312         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
16313         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
16314         [ALC662_3ST_6ch]        = "3stack-6ch",
16315         [ALC662_5ST_DIG]        = "6stack-dig",
16316         [ALC662_LENOVO_101E]    = "lenovo-101e",
16317         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
16318         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
16319         [ALC662_ECS] = "ecs",
16320         [ALC663_ASUS_M51VA] = "m51va",
16321         [ALC663_ASUS_G71V] = "g71v",
16322         [ALC663_ASUS_H13] = "h13",
16323         [ALC663_ASUS_G50V] = "g50v",
16324         [ALC663_ASUS_MODE1] = "asus-mode1",
16325         [ALC662_ASUS_MODE2] = "asus-mode2",
16326         [ALC663_ASUS_MODE3] = "asus-mode3",
16327         [ALC663_ASUS_MODE4] = "asus-mode4",
16328         [ALC663_ASUS_MODE5] = "asus-mode5",
16329         [ALC663_ASUS_MODE6] = "asus-mode6",
16330         [ALC662_AUTO]           = "auto",
16331 };
16332
16333 static struct snd_pci_quirk alc662_cfg_tbl[] = {
16334         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
16335         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
16336         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
16337         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
16338         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
16339         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
16340         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
16341         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
16342         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
16343         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
16344         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
16345         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
16346         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
16347         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
16348         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
16349         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
16350         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
16351         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
16352         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
16353         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
16354         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
16355         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
16356         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
16357         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
16358         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
16359         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
16360         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
16361         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
16362         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
16363         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
16364         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
16365         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
16366         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
16367         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
16368         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
16369         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
16370         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
16371         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
16372         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
16373         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
16374                       ALC662_3ST_6ch_DIG),
16375         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
16376                       ALC662_3ST_6ch_DIG),
16377         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
16378         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
16379         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
16380                                         ALC662_3ST_6ch_DIG),
16381         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
16382                            ALC663_ASUS_H13),
16383         {}
16384 };
16385
16386 static struct alc_config_preset alc662_presets[] = {
16387         [ALC662_3ST_2ch_DIG] = {
16388                 .mixers = { alc662_3ST_2ch_mixer },
16389                 .init_verbs = { alc662_init_verbs },
16390                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16391                 .dac_nids = alc662_dac_nids,
16392                 .dig_out_nid = ALC662_DIGOUT_NID,
16393                 .dig_in_nid = ALC662_DIGIN_NID,
16394                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16395                 .channel_mode = alc662_3ST_2ch_modes,
16396                 .input_mux = &alc662_capture_source,
16397         },
16398         [ALC662_3ST_6ch_DIG] = {
16399                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16400                 .init_verbs = { alc662_init_verbs },
16401                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16402                 .dac_nids = alc662_dac_nids,
16403                 .dig_out_nid = ALC662_DIGOUT_NID,
16404                 .dig_in_nid = ALC662_DIGIN_NID,
16405                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16406                 .channel_mode = alc662_3ST_6ch_modes,
16407                 .need_dac_fix = 1,
16408                 .input_mux = &alc662_capture_source,
16409         },
16410         [ALC662_3ST_6ch] = {
16411                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16412                 .init_verbs = { alc662_init_verbs },
16413                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16414                 .dac_nids = alc662_dac_nids,
16415                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16416                 .channel_mode = alc662_3ST_6ch_modes,
16417                 .need_dac_fix = 1,
16418                 .input_mux = &alc662_capture_source,
16419         },
16420         [ALC662_5ST_DIG] = {
16421                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
16422                 .init_verbs = { alc662_init_verbs },
16423                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16424                 .dac_nids = alc662_dac_nids,
16425                 .dig_out_nid = ALC662_DIGOUT_NID,
16426                 .dig_in_nid = ALC662_DIGIN_NID,
16427                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
16428                 .channel_mode = alc662_5stack_modes,
16429                 .input_mux = &alc662_capture_source,
16430         },
16431         [ALC662_LENOVO_101E] = {
16432                 .mixers = { alc662_lenovo_101e_mixer },
16433                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
16434                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16435                 .dac_nids = alc662_dac_nids,
16436                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16437                 .channel_mode = alc662_3ST_2ch_modes,
16438                 .input_mux = &alc662_lenovo_101e_capture_source,
16439                 .unsol_event = alc662_lenovo_101e_unsol_event,
16440                 .init_hook = alc662_lenovo_101e_all_automute,
16441         },
16442         [ALC662_ASUS_EEEPC_P701] = {
16443                 .mixers = { alc662_eeepc_p701_mixer },
16444                 .init_verbs = { alc662_init_verbs,
16445                                 alc662_eeepc_sue_init_verbs },
16446                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16447                 .dac_nids = alc662_dac_nids,
16448                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16449                 .channel_mode = alc662_3ST_2ch_modes,
16450                 .input_mux = &alc662_eeepc_capture_source,
16451                 .unsol_event = alc662_eeepc_unsol_event,
16452                 .init_hook = alc662_eeepc_inithook,
16453         },
16454         [ALC662_ASUS_EEEPC_EP20] = {
16455                 .mixers = { alc662_eeepc_ep20_mixer,
16456                             alc662_chmode_mixer },
16457                 .init_verbs = { alc662_init_verbs,
16458                                 alc662_eeepc_ep20_sue_init_verbs },
16459                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16460                 .dac_nids = alc662_dac_nids,
16461                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16462                 .channel_mode = alc662_3ST_6ch_modes,
16463                 .input_mux = &alc662_lenovo_101e_capture_source,
16464                 .unsol_event = alc662_eeepc_ep20_unsol_event,
16465                 .init_hook = alc662_eeepc_ep20_inithook,
16466         },
16467         [ALC662_ECS] = {
16468                 .mixers = { alc662_ecs_mixer },
16469                 .init_verbs = { alc662_init_verbs,
16470                                 alc662_ecs_init_verbs },
16471                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16472                 .dac_nids = alc662_dac_nids,
16473                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16474                 .channel_mode = alc662_3ST_2ch_modes,
16475                 .input_mux = &alc662_eeepc_capture_source,
16476                 .unsol_event = alc662_eeepc_unsol_event,
16477                 .init_hook = alc662_eeepc_inithook,
16478         },
16479         [ALC663_ASUS_M51VA] = {
16480                 .mixers = { alc663_m51va_mixer },
16481                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16482                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16483                 .dac_nids = alc662_dac_nids,
16484                 .dig_out_nid = ALC662_DIGOUT_NID,
16485                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16486                 .channel_mode = alc662_3ST_2ch_modes,
16487                 .input_mux = &alc663_m51va_capture_source,
16488                 .unsol_event = alc663_m51va_unsol_event,
16489                 .init_hook = alc663_m51va_inithook,
16490         },
16491         [ALC663_ASUS_G71V] = {
16492                 .mixers = { alc663_g71v_mixer },
16493                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
16494                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16495                 .dac_nids = alc662_dac_nids,
16496                 .dig_out_nid = ALC662_DIGOUT_NID,
16497                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16498                 .channel_mode = alc662_3ST_2ch_modes,
16499                 .input_mux = &alc662_eeepc_capture_source,
16500                 .unsol_event = alc663_g71v_unsol_event,
16501                 .init_hook = alc663_g71v_inithook,
16502         },
16503         [ALC663_ASUS_H13] = {
16504                 .mixers = { alc663_m51va_mixer },
16505                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16506                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16507                 .dac_nids = alc662_dac_nids,
16508                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16509                 .channel_mode = alc662_3ST_2ch_modes,
16510                 .input_mux = &alc663_m51va_capture_source,
16511                 .unsol_event = alc663_m51va_unsol_event,
16512                 .init_hook = alc663_m51va_inithook,
16513         },
16514         [ALC663_ASUS_G50V] = {
16515                 .mixers = { alc663_g50v_mixer },
16516                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
16517                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16518                 .dac_nids = alc662_dac_nids,
16519                 .dig_out_nid = ALC662_DIGOUT_NID,
16520                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16521                 .channel_mode = alc662_3ST_6ch_modes,
16522                 .input_mux = &alc663_capture_source,
16523                 .unsol_event = alc663_g50v_unsol_event,
16524                 .init_hook = alc663_g50v_inithook,
16525         },
16526         [ALC663_ASUS_MODE1] = {
16527                 .mixers = { alc663_m51va_mixer },
16528                 .cap_mixer = alc662_auto_capture_mixer,
16529                 .init_verbs = { alc662_init_verbs,
16530                                 alc663_21jd_amic_init_verbs },
16531                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16532                 .hp_nid = 0x03,
16533                 .dac_nids = alc662_dac_nids,
16534                 .dig_out_nid = ALC662_DIGOUT_NID,
16535                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16536                 .channel_mode = alc662_3ST_2ch_modes,
16537                 .input_mux = &alc662_eeepc_capture_source,
16538                 .unsol_event = alc663_mode1_unsol_event,
16539                 .init_hook = alc663_mode1_inithook,
16540         },
16541         [ALC662_ASUS_MODE2] = {
16542                 .mixers = { alc662_1bjd_mixer },
16543                 .cap_mixer = alc662_auto_capture_mixer,
16544                 .init_verbs = { alc662_init_verbs,
16545                                 alc662_1bjd_amic_init_verbs },
16546                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16547                 .dac_nids = alc662_dac_nids,
16548                 .dig_out_nid = ALC662_DIGOUT_NID,
16549                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16550                 .channel_mode = alc662_3ST_2ch_modes,
16551                 .input_mux = &alc662_eeepc_capture_source,
16552                 .unsol_event = alc662_mode2_unsol_event,
16553                 .init_hook = alc662_mode2_inithook,
16554         },
16555         [ALC663_ASUS_MODE3] = {
16556                 .mixers = { alc663_two_hp_m1_mixer },
16557                 .cap_mixer = alc662_auto_capture_mixer,
16558                 .init_verbs = { alc662_init_verbs,
16559                                 alc663_two_hp_amic_m1_init_verbs },
16560                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16561                 .hp_nid = 0x03,
16562                 .dac_nids = alc662_dac_nids,
16563                 .dig_out_nid = ALC662_DIGOUT_NID,
16564                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16565                 .channel_mode = alc662_3ST_2ch_modes,
16566                 .input_mux = &alc662_eeepc_capture_source,
16567                 .unsol_event = alc663_mode3_unsol_event,
16568                 .init_hook = alc663_mode3_inithook,
16569         },
16570         [ALC663_ASUS_MODE4] = {
16571                 .mixers = { alc663_asus_21jd_clfe_mixer },
16572                 .cap_mixer = alc662_auto_capture_mixer,
16573                 .init_verbs = { alc662_init_verbs,
16574                                 alc663_21jd_amic_init_verbs},
16575                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16576                 .hp_nid = 0x03,
16577                 .dac_nids = alc662_dac_nids,
16578                 .dig_out_nid = ALC662_DIGOUT_NID,
16579                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16580                 .channel_mode = alc662_3ST_2ch_modes,
16581                 .input_mux = &alc662_eeepc_capture_source,
16582                 .unsol_event = alc663_mode4_unsol_event,
16583                 .init_hook = alc663_mode4_inithook,
16584         },
16585         [ALC663_ASUS_MODE5] = {
16586                 .mixers = { alc663_asus_15jd_clfe_mixer },
16587                 .cap_mixer = alc662_auto_capture_mixer,
16588                 .init_verbs = { alc662_init_verbs,
16589                                 alc663_15jd_amic_init_verbs },
16590                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16591                 .hp_nid = 0x03,
16592                 .dac_nids = alc662_dac_nids,
16593                 .dig_out_nid = ALC662_DIGOUT_NID,
16594                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16595                 .channel_mode = alc662_3ST_2ch_modes,
16596                 .input_mux = &alc662_eeepc_capture_source,
16597                 .unsol_event = alc663_mode5_unsol_event,
16598                 .init_hook = alc663_mode5_inithook,
16599         },
16600         [ALC663_ASUS_MODE6] = {
16601                 .mixers = { alc663_two_hp_m2_mixer },
16602                 .cap_mixer = alc662_auto_capture_mixer,
16603                 .init_verbs = { alc662_init_verbs,
16604                                 alc663_two_hp_amic_m2_init_verbs },
16605                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16606                 .hp_nid = 0x03,
16607                 .dac_nids = alc662_dac_nids,
16608                 .dig_out_nid = ALC662_DIGOUT_NID,
16609                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16610                 .channel_mode = alc662_3ST_2ch_modes,
16611                 .input_mux = &alc662_eeepc_capture_source,
16612                 .unsol_event = alc663_mode6_unsol_event,
16613                 .init_hook = alc663_mode6_inithook,
16614         },
16615 };
16616
16617
16618 /*
16619  * BIOS auto configuration
16620  */
16621
16622 /* add playback controls from the parsed DAC table */
16623 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
16624                                              const struct auto_pin_cfg *cfg)
16625 {
16626         char name[32];
16627         static const char *chname[4] = {
16628                 "Front", "Surround", NULL /*CLFE*/, "Side"
16629         };
16630         hda_nid_t nid;
16631         int i, err;
16632
16633         for (i = 0; i < cfg->line_outs; i++) {
16634                 if (!spec->multiout.dac_nids[i])
16635                         continue;
16636                 nid = alc880_idx_to_dac(i);
16637                 if (i == 2) {
16638                         /* Center/LFE */
16639                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16640                                           "Center Playback Volume",
16641                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16642                                                               HDA_OUTPUT));
16643                         if (err < 0)
16644                                 return err;
16645                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16646                                           "LFE Playback Volume",
16647                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16648                                                               HDA_OUTPUT));
16649                         if (err < 0)
16650                                 return err;
16651                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16652                                           "Center Playback Switch",
16653                                           HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16654                                                               HDA_INPUT));
16655                         if (err < 0)
16656                                 return err;
16657                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16658                                           "LFE Playback Switch",
16659                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16660                                                               HDA_INPUT));
16661                         if (err < 0)
16662                                 return err;
16663                 } else {
16664                         sprintf(name, "%s Playback Volume", chname[i]);
16665                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16666                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16667                                                               HDA_OUTPUT));
16668                         if (err < 0)
16669                                 return err;
16670                         sprintf(name, "%s Playback Switch", chname[i]);
16671                         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16672                                 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16673                                                     3, 0, HDA_INPUT));
16674                         if (err < 0)
16675                                 return err;
16676                 }
16677         }
16678         return 0;
16679 }
16680
16681 /* add playback controls for speaker and HP outputs */
16682 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16683                                         const char *pfx)
16684 {
16685         hda_nid_t nid;
16686         int err;
16687         char name[32];
16688
16689         if (!pin)
16690                 return 0;
16691
16692         if (pin == 0x17) {
16693                 /* ALC663 has a mono output pin on 0x17 */
16694                 sprintf(name, "%s Playback Switch", pfx);
16695                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16696                                   HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16697                 return err;
16698         }
16699
16700         if (alc880_is_fixed_pin(pin)) {
16701                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16702                 /* printk(KERN_DEBUG "DAC nid=%x\n",nid); */
16703                 /* specify the DAC as the extra output */
16704                 if (!spec->multiout.hp_nid)
16705                         spec->multiout.hp_nid = nid;
16706                 else
16707                         spec->multiout.extra_out_nid[0] = nid;
16708                 /* control HP volume/switch on the output mixer amp */
16709                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16710                 sprintf(name, "%s Playback Volume", pfx);
16711                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16712                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16713                 if (err < 0)
16714                         return err;
16715                 sprintf(name, "%s Playback Switch", pfx);
16716                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16717                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16718                 if (err < 0)
16719                         return err;
16720         } else if (alc880_is_multi_pin(pin)) {
16721                 /* set manual connection */
16722                 /* we have only a switch on HP-out PIN */
16723                 sprintf(name, "%s Playback Switch", pfx);
16724                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16725                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16726                 if (err < 0)
16727                         return err;
16728         }
16729         return 0;
16730 }
16731
16732 /* return the index of the src widget from the connection list of the nid.
16733  * return -1 if not found
16734  */
16735 static int alc662_input_pin_idx(struct hda_codec *codec, hda_nid_t nid,
16736                                 hda_nid_t src)
16737 {
16738         hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
16739         int i, conns;
16740
16741         conns = snd_hda_get_connections(codec, nid, conn_list,
16742                                         ARRAY_SIZE(conn_list));
16743         if (conns < 0)
16744                 return -1;
16745         for (i = 0; i < conns; i++)
16746                 if (conn_list[i] == src)
16747                         return i;
16748         return -1;
16749 }
16750
16751 static int alc662_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
16752 {
16753         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
16754         return (pincap & AC_PINCAP_IN) != 0;
16755 }
16756
16757 /* create playback/capture controls for input pins */
16758 static int alc662_auto_create_analog_input_ctls(struct hda_codec *codec,
16759                                                 const struct auto_pin_cfg *cfg)
16760 {
16761         struct alc_spec *spec = codec->spec;
16762         struct hda_input_mux *imux = &spec->private_imux[0];
16763         int i, err, idx;
16764
16765         for (i = 0; i < AUTO_PIN_LAST; i++) {
16766                 if (alc662_is_input_pin(codec, cfg->input_pins[i])) {
16767                         idx = alc662_input_pin_idx(codec, 0x0b,
16768                                                    cfg->input_pins[i]);
16769                         if (idx >= 0) {
16770                                 err = new_analog_input(spec, cfg->input_pins[i],
16771                                                        auto_pin_cfg_labels[i],
16772                                                        idx, 0x0b);
16773                                 if (err < 0)
16774                                         return err;
16775                         }
16776                         idx = alc662_input_pin_idx(codec, 0x22,
16777                                                    cfg->input_pins[i]);
16778                         if (idx >= 0) {
16779                                 imux->items[imux->num_items].label =
16780                                         auto_pin_cfg_labels[i];
16781                                 imux->items[imux->num_items].index = idx;
16782                                 imux->num_items++;
16783                         }
16784                 }
16785         }
16786         return 0;
16787 }
16788
16789 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16790                                               hda_nid_t nid, int pin_type,
16791                                               int dac_idx)
16792 {
16793         alc_set_pin_output(codec, nid, pin_type);
16794         /* need the manual connection? */
16795         if (alc880_is_multi_pin(nid)) {
16796                 struct alc_spec *spec = codec->spec;
16797                 int idx = alc880_multi_pin_idx(nid);
16798                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16799                                     AC_VERB_SET_CONNECT_SEL,
16800                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16801         }
16802 }
16803
16804 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16805 {
16806         struct alc_spec *spec = codec->spec;
16807         int i;
16808
16809         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
16810         for (i = 0; i <= HDA_SIDE; i++) {
16811                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16812                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16813                 if (nid)
16814                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16815                                                           i);
16816         }
16817 }
16818
16819 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16820 {
16821         struct alc_spec *spec = codec->spec;
16822         hda_nid_t pin;
16823
16824         pin = spec->autocfg.hp_pins[0];
16825         if (pin) /* connect to front */
16826                 /* use dac 0 */
16827                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16828         pin = spec->autocfg.speaker_pins[0];
16829         if (pin)
16830                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16831 }
16832
16833 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
16834
16835 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16836 {
16837         struct alc_spec *spec = codec->spec;
16838         int i;
16839
16840         for (i = 0; i < AUTO_PIN_LAST; i++) {
16841                 hda_nid_t nid = spec->autocfg.input_pins[i];
16842                 if (alc662_is_input_pin(codec, nid)) {
16843                         alc_set_input_pin(codec, nid, i);
16844                         if (nid != ALC662_PIN_CD_NID &&
16845                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16846                                 snd_hda_codec_write(codec, nid, 0,
16847                                                     AC_VERB_SET_AMP_GAIN_MUTE,
16848                                                     AMP_OUT_MUTE);
16849                 }
16850         }
16851 }
16852
16853 #define alc662_auto_init_input_src      alc882_auto_init_input_src
16854
16855 static int alc662_parse_auto_config(struct hda_codec *codec)
16856 {
16857         struct alc_spec *spec = codec->spec;
16858         int err;
16859         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
16860
16861         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16862                                            alc662_ignore);
16863         if (err < 0)
16864                 return err;
16865         if (!spec->autocfg.line_outs)
16866                 return 0; /* can't find valid BIOS pin config */
16867
16868         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16869         if (err < 0)
16870                 return err;
16871         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
16872         if (err < 0)
16873                 return err;
16874         err = alc662_auto_create_extra_out(spec,
16875                                            spec->autocfg.speaker_pins[0],
16876                                            "Speaker");
16877         if (err < 0)
16878                 return err;
16879         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
16880                                            "Headphone");
16881         if (err < 0)
16882                 return err;
16883         err = alc662_auto_create_analog_input_ctls(codec, &spec->autocfg);
16884         if (err < 0)
16885                 return err;
16886
16887         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16888
16889         if (spec->autocfg.dig_outs)
16890                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
16891
16892         if (spec->kctls.list)
16893                 add_mixer(spec, spec->kctls.list);
16894
16895         spec->num_mux_defs = 1;
16896         spec->input_mux = &spec->private_imux[0];
16897
16898         add_verb(spec, alc662_auto_init_verbs);
16899         if (codec->vendor_id == 0x10ec0663)
16900                 add_verb(spec, alc663_auto_init_verbs);
16901
16902         err = alc_auto_add_mic_boost(codec);
16903         if (err < 0)
16904                 return err;
16905
16906         return 1;
16907 }
16908
16909 /* additional initialization for auto-configuration model */
16910 static void alc662_auto_init(struct hda_codec *codec)
16911 {
16912         struct alc_spec *spec = codec->spec;
16913         alc662_auto_init_multi_out(codec);
16914         alc662_auto_init_hp_out(codec);
16915         alc662_auto_init_analog_input(codec);
16916         alc662_auto_init_input_src(codec);
16917         if (spec->unsol_event)
16918                 alc_inithook(codec);
16919 }
16920
16921 static int patch_alc662(struct hda_codec *codec)
16922 {
16923         struct alc_spec *spec;
16924         int err, board_config;
16925
16926         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16927         if (!spec)
16928                 return -ENOMEM;
16929
16930         codec->spec = spec;
16931
16932         alc_fix_pll_init(codec, 0x20, 0x04, 15);
16933
16934         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
16935                                                   alc662_models,
16936                                                   alc662_cfg_tbl);
16937         if (board_config < 0) {
16938                 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
16939                        "trying auto-probe from BIOS...\n");
16940                 board_config = ALC662_AUTO;
16941         }
16942
16943         if (board_config == ALC662_AUTO) {
16944                 /* automatic parse from the BIOS config */
16945                 err = alc662_parse_auto_config(codec);
16946                 if (err < 0) {
16947                         alc_free(codec);
16948                         return err;
16949                 } else if (!err) {
16950                         printk(KERN_INFO
16951                                "hda_codec: Cannot set up configuration "
16952                                "from BIOS.  Using base mode...\n");
16953                         board_config = ALC662_3ST_2ch_DIG;
16954                 }
16955         }
16956
16957         err = snd_hda_attach_beep_device(codec, 0x1);
16958         if (err < 0) {
16959                 alc_free(codec);
16960                 return err;
16961         }
16962
16963         if (board_config != ALC662_AUTO)
16964                 setup_preset(spec, &alc662_presets[board_config]);
16965
16966         if (codec->vendor_id == 0x10ec0663) {
16967                 spec->stream_name_analog = "ALC663 Analog";
16968                 spec->stream_name_digital = "ALC663 Digital";
16969         } else if (codec->vendor_id == 0x10ec0272) {
16970                 spec->stream_name_analog = "ALC272 Analog";
16971                 spec->stream_name_digital = "ALC272 Digital";
16972         } else {
16973                 spec->stream_name_analog = "ALC662 Analog";
16974                 spec->stream_name_digital = "ALC662 Digital";
16975         }
16976
16977         spec->stream_analog_playback = &alc662_pcm_analog_playback;
16978         spec->stream_analog_capture = &alc662_pcm_analog_capture;
16979
16980         spec->stream_digital_playback = &alc662_pcm_digital_playback;
16981         spec->stream_digital_capture = &alc662_pcm_digital_capture;
16982
16983         spec->adc_nids = alc662_adc_nids;
16984         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
16985         spec->capsrc_nids = alc662_capsrc_nids;
16986         spec->capture_style = CAPT_MIX;
16987
16988         if (!spec->cap_mixer)
16989                 set_capture_mixer(spec);
16990         if (codec->vendor_id == 0x10ec0662)
16991                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
16992         else
16993                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
16994
16995         spec->vmaster_nid = 0x02;
16996
16997         codec->patch_ops = alc_patch_ops;
16998         if (board_config == ALC662_AUTO)
16999                 spec->init_hook = alc662_auto_init;
17000 #ifdef CONFIG_SND_HDA_POWER_SAVE
17001         if (!spec->loopback.amplist)
17002                 spec->loopback.amplist = alc662_loopbacks;
17003 #endif
17004         codec->proc_widget_hook = print_realtek_coef;
17005
17006         return 0;
17007 }
17008
17009 /*
17010  * patch entries
17011  */
17012 static struct hda_codec_preset snd_hda_preset_realtek[] = {
17013         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
17014         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
17015         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
17016         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
17017         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
17018         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
17019         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
17020           .patch = patch_alc861 },
17021         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
17022         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
17023         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
17024         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
17025           .patch = patch_alc883 },
17026         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
17027           .patch = patch_alc662 },
17028         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
17029         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
17030         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
17031         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
17032         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
17033           .patch = patch_alc882 }, /* should be patch_alc883() in future */
17034         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
17035           .patch = patch_alc882 }, /* should be patch_alc883() in future */
17036         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
17037         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
17038         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
17039           .patch = patch_alc883 },
17040         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
17041         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
17042         {} /* terminator */
17043 };
17044
17045 MODULE_ALIAS("snd-hda-codec-id:10ec*");
17046
17047 MODULE_LICENSE("GPL");
17048 MODULE_DESCRIPTION("Realtek HD-audio codec");
17049
17050 static struct hda_codec_preset_list realtek_list = {
17051         .preset = snd_hda_preset_realtek,
17052         .owner = THIS_MODULE,
17053 };
17054
17055 static int __init patch_realtek_init(void)
17056 {
17057         return snd_hda_add_codec_preset(&realtek_list);
17058 }
17059
17060 static void __exit patch_realtek_exit(void)
17061 {
17062         snd_hda_delete_codec_preset(&realtek_list);
17063 }
17064
17065 module_init(patch_realtek_init)
17066 module_exit(patch_realtek_exit)