sound/pci/hda/patch_realtek.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for ALC 260/880/882 codecs
   5  *
   6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   7  *                    PeiSen Hou <pshou@realtek.com.tw>
   8  *                    Takashi Iwai <tiwai@suse.de>
   9  *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
  10  *
  11  *  This driver is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This driver is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/slab.h>
  29 #include <linux/pci.h>
  30 #include <sound/core.h>
  31 #include "hda_codec.h"
  32 #include "hda_local.h"
  33 #include "hda_beep.h"
  34
  35 #define ALC880_FRONT_EVENT              0x01
  36 #define ALC880_DCVOL_EVENT              0x02
  37 #define ALC880_HP_EVENT                 0x04
  38 #define ALC880_MIC_EVENT                0x08
  39
  40 /* ALC880 board config type */
  41 enum {
  42         ALC880_3ST,
  43         ALC880_3ST_DIG,
  44         ALC880_5ST,
  45         ALC880_5ST_DIG,
  46         ALC880_W810,
  47         ALC880_Z71V,
  48         ALC880_6ST,
  49         ALC880_6ST_DIG,
  50         ALC880_F1734,
  51         ALC880_ASUS,
  52         ALC880_ASUS_DIG,
  53         ALC880_ASUS_W1V,
  54         ALC880_ASUS_DIG2,
  55         ALC880_FUJITSU,
  56         ALC880_UNIWILL_DIG,
  57         ALC880_UNIWILL,
  58         ALC880_UNIWILL_P53,
  59         ALC880_CLEVO,
  60         ALC880_TCL_S700,
  61         ALC880_LG,
  62         ALC880_LG_LW,
  63         ALC880_MEDION_RIM,
  64 #ifdef CONFIG_SND_DEBUG
  65         ALC880_TEST,
  66 #endif
  67         ALC880_AUTO,
  68         ALC880_MODEL_LAST /* last tag */
  69 };
  70
  71 /* ALC260 models */
  72 enum {
  73         ALC260_BASIC,
  74         ALC260_HP,
  75         ALC260_HP_DC7600,
  76         ALC260_HP_3013,
  77         ALC260_FUJITSU_S702X,
  78         ALC260_ACER,
  79         ALC260_WILL,
  80         ALC260_REPLACER_672V,
  81         ALC260_FAVORIT100,
  82 #ifdef CONFIG_SND_DEBUG
  83         ALC260_TEST,
  84 #endif
  85         ALC260_AUTO,
  86         ALC260_MODEL_LAST /* last tag */
  87 };
  88
  89 /* ALC262 models */
  90 enum {
  91         ALC262_BASIC,
  92         ALC262_HIPPO,
  93         ALC262_HIPPO_1,
  94         ALC262_FUJITSU,
  95         ALC262_HP_BPC,
  96         ALC262_HP_BPC_D7000_WL,
  97         ALC262_HP_BPC_D7000_WF,
  98         ALC262_HP_TC_T5735,
  99         ALC262_HP_RP5700,
 100         ALC262_BENQ_ED8,
 101         ALC262_SONY_ASSAMD,
 102         ALC262_BENQ_T31,
 103         ALC262_ULTRA,
 104         ALC262_LENOVO_3000,
 105         ALC262_NEC,
 106         ALC262_TOSHIBA_S06,
 107         ALC262_TOSHIBA_RX1,
 108         ALC262_TYAN,
 109         ALC262_AUTO,
 110         ALC262_MODEL_LAST /* last tag */
 111 };
 112
 113 /* ALC268 models */
 114 enum {
 115         ALC267_QUANTA_IL1,
 116         ALC268_3ST,
 117         ALC268_TOSHIBA,
 118         ALC268_ACER,
 119         ALC268_ACER_DMIC,
 120         ALC268_ACER_ASPIRE_ONE,
 121         ALC268_DELL,
 122         ALC268_ZEPTO,
 123 #ifdef CONFIG_SND_DEBUG
 124         ALC268_TEST,
 125 #endif
 126         ALC268_AUTO,
 127         ALC268_MODEL_LAST /* last tag */
 128 };
 129
 130 /* ALC269 models */
 131 enum {
 132         ALC269_BASIC,
 133         ALC269_QUANTA_FL1,
 134         ALC269_ASUS_EEEPC_P703,
 135         ALC269_ASUS_EEEPC_P901,
 136         ALC269_FUJITSU,
 137         ALC269_LIFEBOOK,
 138         ALC269_AUTO,
 139         ALC269_MODEL_LAST /* last tag */
 140 };
 141
 142 /* ALC861 models */
 143 enum {
 144         ALC861_3ST,
 145         ALC660_3ST,
 146         ALC861_3ST_DIG,
 147         ALC861_6ST_DIG,
 148         ALC861_UNIWILL_M31,
 149         ALC861_TOSHIBA,
 150         ALC861_ASUS,
 151         ALC861_ASUS_LAPTOP,
 152         ALC861_AUTO,
 153         ALC861_MODEL_LAST,
 154 };
 155
 156 /* ALC861-VD models */
 157 enum {
 158         ALC660VD_3ST,
 159         ALC660VD_3ST_DIG,
 160         ALC660VD_ASUS_V1S,
 161         ALC861VD_3ST,
 162         ALC861VD_3ST_DIG,
 163         ALC861VD_6ST_DIG,
 164         ALC861VD_LENOVO,
 165         ALC861VD_DALLAS,
 166         ALC861VD_HP,
 167         ALC861VD_AUTO,
 168         ALC861VD_MODEL_LAST,
 169 };
 170
 171 /* ALC662 models */
 172 enum {
 173         ALC662_3ST_2ch_DIG,
 174         ALC662_3ST_6ch_DIG,
 175         ALC662_3ST_6ch,
 176         ALC662_5ST_DIG,
 177         ALC662_LENOVO_101E,
 178         ALC662_ASUS_EEEPC_P701,
 179         ALC662_ASUS_EEEPC_EP20,
 180         ALC663_ASUS_M51VA,
 181         ALC663_ASUS_G71V,
 182         ALC663_ASUS_H13,
 183         ALC663_ASUS_G50V,
 184         ALC662_ECS,
 185         ALC663_ASUS_MODE1,
 186         ALC662_ASUS_MODE2,
 187         ALC663_ASUS_MODE3,
 188         ALC663_ASUS_MODE4,
 189         ALC663_ASUS_MODE5,
 190         ALC663_ASUS_MODE6,
 191         ALC272_DELL,
 192         ALC272_DELL_ZM1,
 193         ALC272_SAMSUNG_NC10,
 194         ALC662_AUTO,
 195         ALC662_MODEL_LAST,
 196 };
 197
 198 /* ALC882 models */
 199 enum {
 200         ALC882_3ST_DIG,
 201         ALC882_6ST_DIG,
 202         ALC882_ARIMA,
 203         ALC882_W2JC,
 204         ALC882_TARGA,
 205         ALC882_ASUS_A7J,
 206         ALC882_ASUS_A7M,
 207         ALC885_MACPRO,
 208         ALC885_MBP3,
 209         ALC885_MB5,
 210         ALC885_IMAC24,
 211         ALC882_AUTO,
 212         ALC882_MODEL_LAST,
 213 };
 214
 215 /* ALC883 models */
 216 enum {
 217         ALC883_3ST_2ch_DIG,
 218         ALC883_3ST_6ch_DIG,
 219         ALC883_3ST_6ch,
 220         ALC883_6ST_DIG,
 221         ALC883_TARGA_DIG,
 222         ALC883_TARGA_2ch_DIG,
 223         ALC883_ACER,
 224         ALC883_ACER_ASPIRE,
 225         ALC888_ACER_ASPIRE_4930G,
 226         ALC883_MEDION,
 227         ALC883_MEDION_MD2,
 228         ALC883_LAPTOP_EAPD,
 229         ALC883_LENOVO_101E_2ch,
 230         ALC883_LENOVO_NB0763,
 231         ALC888_LENOVO_MS7195_DIG,
 232         ALC888_LENOVO_SKY,
 233         ALC883_HAIER_W66,
 234         ALC888_3ST_HP,
 235         ALC888_6ST_DELL,
 236         ALC883_MITAC,
 237         ALC883_CLEVO_M720,
 238         ALC883_FUJITSU_PI2515,
 239         ALC888_FUJITSU_XA3530,
 240         ALC883_3ST_6ch_INTEL,
 241         ALC888_ASUS_M90V,
 242         ALC888_ASUS_EEE1601,
 243         ALC1200_ASUS_P5Q,
 244         ALC883_AUTO,
 245         ALC883_MODEL_LAST,
 246 };
 247
 248 /* styles of capture selection */
 249 enum {
 250         CAPT_MUX = 0,   /* only mux based */
 251         CAPT_MIX,       /* only mixer based */
 252         CAPT_1MUX_MIX,  /* first mux and other mixers */
 253 };
 254
 255 /* for GPIO Poll */
 256 #define GPIO_MASK       0x03
 257
 258 /* extra amp-initialization sequence types */
 259 enum {
 260         ALC_INIT_NONE,
 261         ALC_INIT_DEFAULT,
 262         ALC_INIT_GPIO1,
 263         ALC_INIT_GPIO2,
 264         ALC_INIT_GPIO3,
 265 };
 266
 267 struct alc_spec {
 268         /* codec parameterization */
 269         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 270         unsigned int num_mixers;
 271         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 272         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 273
 274         const struct hda_verb *init_verbs[5];   /* initialization verbs
 275                                                  * don't forget NULL
 276                                                  * termination!
 277                                                  */
 278         unsigned int num_init_verbs;
 279
 280         char stream_name_analog[16];    /* analog PCM stream */
 281         struct hda_pcm_stream *stream_analog_playback;
 282         struct hda_pcm_stream *stream_analog_capture;
 283         struct hda_pcm_stream *stream_analog_alt_playback;
 284         struct hda_pcm_stream *stream_analog_alt_capture;
 285
 286         char stream_name_digital[16];   /* digital PCM stream */
 287         struct hda_pcm_stream *stream_digital_playback;
 288         struct hda_pcm_stream *stream_digital_capture;
 289
 290         /* playback */
 291         struct hda_multi_out multiout;  /* playback set-up
 292                                          * max_channels, dacs must be set
 293                                          * dig_out_nid and hp_nid are optional
 294                                          */
 295         hda_nid_t alt_dac_nid;
 296         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 297         int dig_out_type;
 298
 299         /* capture */
 300         unsigned int num_adc_nids;
 301         hda_nid_t *adc_nids;
 302         hda_nid_t *capsrc_nids;
 303         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 304         int capture_style;              /* capture style (CAPT_*) */
 305
 306         /* capture source */
 307         unsigned int num_mux_defs;
 308         const struct hda_input_mux *input_mux;
 309         unsigned int cur_mux[3];
 310
 311         /* channel model */
 312         const struct hda_channel_mode *channel_mode;
 313         int num_channel_mode;
 314         int need_dac_fix;
 315
 316         /* PCM information */
 317         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 318
 319         /* dynamic controls, init_verbs and input_mux */
 320         struct auto_pin_cfg autocfg;
 321         struct snd_array kctls;
 322         struct hda_input_mux private_imux[3];
 323         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 324
 325         /* hooks */
 326         void (*init_hook)(struct hda_codec *codec);
 327         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 328
 329         /* for pin sensing */
 330         unsigned int sense_updated: 1;
 331         unsigned int jack_present: 1;
 332         unsigned int master_sw: 1;
 333
 334         /* other flags */
 335         unsigned int no_analog :1; /* digital I/O only */
 336         int init_amp;
 337
 338         /* for virtual master */
 339         hda_nid_t vmaster_nid;
 340 #ifdef CONFIG_SND_HDA_POWER_SAVE
 341         struct hda_loopback_check loopback;
 342 #endif
 343
 344         /* for PLL fix */
 345         hda_nid_t pll_nid;
 346         unsigned int pll_coef_idx, pll_coef_bit;
 347 };
 348
 349 /*
 350  * configuration template - to be copied to the spec instance
 351  */
 352 struct alc_config_preset {
 353         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 354                                              * with spec
 355                                              */
 356         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 357         const struct hda_verb *init_verbs[5];
 358         unsigned int num_dacs;
 359         hda_nid_t *dac_nids;
 360         hda_nid_t dig_out_nid;          /* optional */
 361         hda_nid_t hp_nid;               /* optional */
 362         hda_nid_t *slave_dig_outs;
 363         unsigned int num_adc_nids;
 364         hda_nid_t *adc_nids;
 365         hda_nid_t *capsrc_nids;
 366         hda_nid_t dig_in_nid;
 367         unsigned int num_channel_mode;
 368         const struct hda_channel_mode *channel_mode;
 369         int need_dac_fix;
 370         unsigned int num_mux_defs;
 371         const struct hda_input_mux *input_mux;
 372         void (*unsol_event)(struct hda_codec *, unsigned int);
 373         void (*init_hook)(struct hda_codec *);
 374 #ifdef CONFIG_SND_HDA_POWER_SAVE
 375         struct hda_amp_list *loopbacks;
 376 #endif
 377 };
 378
 379
 380 /*
 381  * input MUX handling
 382  */
 383 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 384                              struct snd_ctl_elem_info *uinfo)
 385 {
 386         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 387         struct alc_spec *spec = codec->spec;
 388         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 389         if (mux_idx >= spec->num_mux_defs)
 390                 mux_idx = 0;
 391         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 392 }
 393
 394 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 395                             struct snd_ctl_elem_value *ucontrol)
 396 {
 397         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 398         struct alc_spec *spec = codec->spec;
 399         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 400
 401         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 402         return 0;
 403 }
 404
 405 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 406                             struct snd_ctl_elem_value *ucontrol)
 407 {
 408         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 409         struct alc_spec *spec = codec->spec;
 410         const struct hda_input_mux *imux;
 411         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 412         unsigned int mux_idx;
 413         hda_nid_t nid = spec->capsrc_nids ?
 414                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 415
 416         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 417         imux = &spec->input_mux[mux_idx];
 418
 419         if (spec->capture_style &&
 420             !(spec->capture_style == CAPT_1MUX_MIX && !adc_idx)) {
 421                 /* Matrix-mixer style (e.g. ALC882) */
 422                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 423                 unsigned int i, idx;
 424
 425                 idx = ucontrol->value.enumerated.item[0];
 426                 if (idx >= imux->num_items)
 427                         idx = imux->num_items - 1;
 428                 if (*cur_val == idx)
 429                         return 0;
 430                 for (i = 0; i < imux->num_items; i++) {
 431                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 432                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 433                                                  imux->items[i].index,
 434                                                  HDA_AMP_MUTE, v);
 435                 }
 436                 *cur_val = idx;
 437                 return 1;
 438         } else {
 439                 /* MUX style (e.g. ALC880) */
 440                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 441                                              &spec->cur_mux[adc_idx]);
 442         }
 443 }
 444
 445 /*
 446  * channel mode setting
 447  */
 448 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 449                             struct snd_ctl_elem_info *uinfo)
 450 {
 451         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 452         struct alc_spec *spec = codec->spec;
 453         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 454                                     spec->num_channel_mode);
 455 }
 456
 457 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 458                            struct snd_ctl_elem_value *ucontrol)
 459 {
 460         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 461         struct alc_spec *spec = codec->spec;
 462         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 463                                    spec->num_channel_mode,
 464                                    spec->multiout.max_channels);
 465 }
 466
 467 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 468                            struct snd_ctl_elem_value *ucontrol)
 469 {
 470         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 471         struct alc_spec *spec = codec->spec;
 472         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 473                                       spec->num_channel_mode,
 474                                       &spec->multiout.max_channels);
 475         if (err >= 0 && spec->need_dac_fix)
 476                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 477         return err;
 478 }
 479
 480 /*
 481  * Control the mode of pin widget settings via the mixer.  "pc" is used
 482  * instead of "%" to avoid consequences of accidently treating the % as
 483  * being part of a format specifier.  Maximum allowed length of a value is
 484  * 63 characters plus NULL terminator.
 485  *
 486  * Note: some retasking pin complexes seem to ignore requests for input
 487  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 488  * are requested.  Therefore order this list so that this behaviour will not
 489  * cause problems when mixer clients move through the enum sequentially.
 490  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 491  * March 2006.
 492  */
 493 static char *alc_pin_mode_names[] = {
 494         "Mic 50pc bias", "Mic 80pc bias",
 495         "Line in", "Line out", "Headphone out",
 496 };
 497 static unsigned char alc_pin_mode_values[] = {
 498         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 499 };
 500 /* The control can present all 5 options, or it can limit the options based
 501  * in the pin being assumed to be exclusively an input or an output pin.  In
 502  * addition, "input" pins may or may not process the mic bias option
 503  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 504  * accept requests for bias as of chip versions up to March 2006) and/or
 505  * wiring in the computer.
 506  */
 507 #define ALC_PIN_DIR_IN              0x00
 508 #define ALC_PIN_DIR_OUT             0x01
 509 #define ALC_PIN_DIR_INOUT           0x02
 510 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 511 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 512
 513 /* Info about the pin modes supported by the different pin direction modes.
 514  * For each direction the minimum and maximum values are given.
 515  */
 516 static signed char alc_pin_mode_dir_info[5][2] = {
 517         { 0, 2 },    /* ALC_PIN_DIR_IN */
 518         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 519         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 520         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 521         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 522 };
 523 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 524 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 525 #define alc_pin_mode_n_items(_dir) \
 526         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 527
 528 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 529                              struct snd_ctl_elem_info *uinfo)
 530 {
 531         unsigned int item_num = uinfo->value.enumerated.item;
 532         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 533
 534         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 535         uinfo->count = 1;
 536         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 537
 538         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 539                 item_num = alc_pin_mode_min(dir);
 540         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 541         return 0;
 542 }
 543
 544 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 545                             struct snd_ctl_elem_value *ucontrol)
 546 {
 547         unsigned int i;
 548         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 549         hda_nid_t nid = kcontrol->private_value & 0xffff;
 550         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 551         long *valp = ucontrol->value.integer.value;
 552         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 553                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 554                                                  0x00);
 555
 556         /* Find enumerated value for current pinctl setting */
 557         i = alc_pin_mode_min(dir);
 558         while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
 559                 i++;
 560         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 561         return 0;
 562 }
 563
 564 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 565                             struct snd_ctl_elem_value *ucontrol)
 566 {
 567         signed int change;
 568         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 569         hda_nid_t nid = kcontrol->private_value & 0xffff;
 570         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 571         long val = *ucontrol->value.integer.value;
 572         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 573                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 574                                                  0x00);
 575
 576         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 577                 val = alc_pin_mode_min(dir);
 578
 579         change = pinctl != alc_pin_mode_values[val];
 580         if (change) {
 581                 /* Set pin mode to that requested */
 582                 snd_hda_codec_write_cache(codec, nid, 0,
 583                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 584                                           alc_pin_mode_values[val]);
 585
 586                 /* Also enable the retasking pin's input/output as required
 587                  * for the requested pin mode.  Enum values of 2 or less are
 588                  * input modes.
 589                  *
 590                  * Dynamically switching the input/output buffers probably
 591                  * reduces noise slightly (particularly on input) so we'll
 592                  * do it.  However, having both input and output buffers
 593                  * enabled simultaneously doesn't seem to be problematic if
 594                  * this turns out to be necessary in the future.
 595                  */
 596                 if (val <= 2) {
 597                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 598                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 599                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 600                                                  HDA_AMP_MUTE, 0);
 601                 } else {
 602                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 603                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 604                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 605                                                  HDA_AMP_MUTE, 0);
 606                 }
 607         }
 608         return change;
 609 }
 610
 611 #define ALC_PIN_MODE(xname, nid, dir) \
 612         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 613           .info = alc_pin_mode_info, \
 614           .get = alc_pin_mode_get, \
 615           .put = alc_pin_mode_put, \
 616           .private_value = nid | (dir<<16) }
 617
 618 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 619  * together using a mask with more than one bit set.  This control is
 620  * currently used only by the ALC260 test model.  At this stage they are not
 621  * needed for any "production" models.
 622  */
 623 #ifdef CONFIG_SND_DEBUG
 624 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 625
 626 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 627                              struct snd_ctl_elem_value *ucontrol)
 628 {
 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 *valp = ucontrol->value.integer.value;
 633         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 634                                               AC_VERB_GET_GPIO_DATA, 0x00);
 635
 636         *valp = (val & mask) != 0;
 637         return 0;
 638 }
 639 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 640                              struct snd_ctl_elem_value *ucontrol)
 641 {
 642         signed int change;
 643         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 644         hda_nid_t nid = kcontrol->private_value & 0xffff;
 645         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 646         long val = *ucontrol->value.integer.value;
 647         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 648                                                     AC_VERB_GET_GPIO_DATA,
 649                                                     0x00);
 650
 651         /* Set/unset the masked GPIO bit(s) as needed */
 652         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 653         if (val == 0)
 654                 gpio_data &= ~mask;
 655         else
 656                 gpio_data |= mask;
 657         snd_hda_codec_write_cache(codec, nid, 0,
 658                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 659
 660         return change;
 661 }
 662 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 663         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 664           .info = alc_gpio_data_info, \
 665           .get = alc_gpio_data_get, \
 666           .put = alc_gpio_data_put, \
 667           .private_value = nid | (mask<<16) }
 668 #endif   /* CONFIG_SND_DEBUG */
 669
 670 /* A switch control to allow the enabling of the digital IO pins on the
 671  * ALC260.  This is incredibly simplistic; the intention of this control is
 672  * to provide something in the test model allowing digital outputs to be
 673  * identified if present.  If models are found which can utilise these
 674  * outputs a more complete mixer control can be devised for those models if
 675  * necessary.
 676  */
 677 #ifdef CONFIG_SND_DEBUG
 678 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 679
 680 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 681                               struct snd_ctl_elem_value *ucontrol)
 682 {
 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 *valp = ucontrol->value.integer.value;
 687         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 688                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 689
 690         *valp = (val & mask) != 0;
 691         return 0;
 692 }
 693 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 694                               struct snd_ctl_elem_value *ucontrol)
 695 {
 696         signed int change;
 697         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 698         hda_nid_t nid = kcontrol->private_value & 0xffff;
 699         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 700         long val = *ucontrol->value.integer.value;
 701         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 702                                                     AC_VERB_GET_DIGI_CONVERT_1,
 703                                                     0x00);
 704
 705         /* Set/unset the masked control bit(s) as needed */
 706         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 707         if (val==0)
 708                 ctrl_data &= ~mask;
 709         else
 710                 ctrl_data |= mask;
 711         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 712                                   ctrl_data);
 713
 714         return change;
 715 }
 716 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 717         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 718           .info = alc_spdif_ctrl_info, \
 719           .get = alc_spdif_ctrl_get, \
 720           .put = alc_spdif_ctrl_put, \
 721           .private_value = nid | (mask<<16) }
 722 #endif   /* CONFIG_SND_DEBUG */
 723
 724 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 725  * Again, this is only used in the ALC26x test models to help identify when
 726  * the EAPD line must be asserted for features to work.
 727  */
 728 #ifdef CONFIG_SND_DEBUG
 729 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 730
 731 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 732                               struct snd_ctl_elem_value *ucontrol)
 733 {
 734         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 735         hda_nid_t nid = kcontrol->private_value & 0xffff;
 736         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 737         long *valp = ucontrol->value.integer.value;
 738         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 739                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 740
 741         *valp = (val & mask) != 0;
 742         return 0;
 743 }
 744
 745 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 746                               struct snd_ctl_elem_value *ucontrol)
 747 {
 748         int change;
 749         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 750         hda_nid_t nid = kcontrol->private_value & 0xffff;
 751         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 752         long val = *ucontrol->value.integer.value;
 753         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 754                                                     AC_VERB_GET_EAPD_BTLENABLE,
 755                                                     0x00);
 756
 757         /* Set/unset the masked control bit(s) as needed */
 758         change = (!val ? 0 : mask) != (ctrl_data & mask);
 759         if (!val)
 760                 ctrl_data &= ~mask;
 761         else
 762                 ctrl_data |= mask;
 763         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 764                                   ctrl_data);
 765
 766         return change;
 767 }
 768
 769 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 770         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 771           .info = alc_eapd_ctrl_info, \
 772           .get = alc_eapd_ctrl_get, \
 773           .put = alc_eapd_ctrl_put, \
 774           .private_value = nid | (mask<<16) }
 775 #endif   /* CONFIG_SND_DEBUG */
 776
 777 /*
 778  * set up the input pin config (depending on the given auto-pin type)
 779  */
 780 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 781                               int auto_pin_type)
 782 {
 783         unsigned int val = PIN_IN;
 784
 785         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 786                 unsigned int pincap;
 787                 pincap = snd_hda_query_pin_caps(codec, nid);
 788                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 789                 if (pincap & AC_PINCAP_VREF_80)
 790                         val = PIN_VREF80;
 791         }
 792         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 793 }
 794
 795 /*
 796  */
 797 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 798 {
 799         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 800                 return;
 801         spec->mixers[spec->num_mixers++] = mix;
 802 }
 803
 804 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 805 {
 806         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 807                 return;
 808         spec->init_verbs[spec->num_init_verbs++] = verb;
 809 }
 810
 811 #ifdef CONFIG_PROC_FS
 812 /*
 813  * hook for proc
 814  */
 815 static void print_realtek_coef(struct snd_info_buffer *buffer,
 816                                struct hda_codec *codec, hda_nid_t nid)
 817 {
 818         int coeff;
 819
 820         if (nid != 0x20)
 821                 return;
 822         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 823         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 824         coeff = snd_hda_codec_read(codec, nid, 0,
 825                                    AC_VERB_GET_COEF_INDEX, 0);
 826         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 827 }
 828 #else
 829 #define print_realtek_coef      NULL
 830 #endif
 831
 832 /*
 833  * set up from the preset table
 834  */
 835 static void setup_preset(struct alc_spec *spec,
 836                          const struct alc_config_preset *preset)
 837 {
 838         int i;
 839
 840         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 841                 add_mixer(spec, preset->mixers[i]);
 842         spec->cap_mixer = preset->cap_mixer;
 843         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 844              i++)
 845                 add_verb(spec, preset->init_verbs[i]);
 846
 847         spec->channel_mode = preset->channel_mode;
 848         spec->num_channel_mode = preset->num_channel_mode;
 849         spec->need_dac_fix = preset->need_dac_fix;
 850
 851         spec->multiout.max_channels = spec->channel_mode[0].channels;
 852
 853         spec->multiout.num_dacs = preset->num_dacs;
 854         spec->multiout.dac_nids = preset->dac_nids;
 855         spec->multiout.dig_out_nid = preset->dig_out_nid;
 856         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 857         spec->multiout.hp_nid = preset->hp_nid;
 858
 859         spec->num_mux_defs = preset->num_mux_defs;
 860         if (!spec->num_mux_defs)
 861                 spec->num_mux_defs = 1;
 862         spec->input_mux = preset->input_mux;
 863
 864         spec->num_adc_nids = preset->num_adc_nids;
 865         spec->adc_nids = preset->adc_nids;
 866         spec->capsrc_nids = preset->capsrc_nids;
 867         spec->dig_in_nid = preset->dig_in_nid;
 868
 869         spec->unsol_event = preset->unsol_event;
 870         spec->init_hook = preset->init_hook;
 871 #ifdef CONFIG_SND_HDA_POWER_SAVE
 872         spec->loopback.amplist = preset->loopbacks;
 873 #endif
 874 }
 875
 876 /* Enable GPIO mask and set output */
 877 static struct hda_verb alc_gpio1_init_verbs[] = {
 878         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 879         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 880         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 881         { }
 882 };
 883
 884 static struct hda_verb alc_gpio2_init_verbs[] = {
 885         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 886         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 887         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 888         { }
 889 };
 890
 891 static struct hda_verb alc_gpio3_init_verbs[] = {
 892         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 893         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 894         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 895         { }
 896 };
 897
 898 /*
 899  * Fix hardware PLL issue
 900  * On some codecs, the analog PLL gating control must be off while
 901  * the default value is 1.
 902  */
 903 static void alc_fix_pll(struct hda_codec *codec)
 904 {
 905         struct alc_spec *spec = codec->spec;
 906         unsigned int val;
 907
 908         if (!spec->pll_nid)
 909                 return;
 910         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 911                             spec->pll_coef_idx);
 912         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 913                                  AC_VERB_GET_PROC_COEF, 0);
 914         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 915                             spec->pll_coef_idx);
 916         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 917                             val & ~(1 << spec->pll_coef_bit));
 918 }
 919
 920 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 921                              unsigned int coef_idx, unsigned int coef_bit)
 922 {
 923         struct alc_spec *spec = codec->spec;
 924         spec->pll_nid = nid;
 925         spec->pll_coef_idx = coef_idx;
 926         spec->pll_coef_bit = coef_bit;
 927         alc_fix_pll(codec);
 928 }
 929
 930 static void alc_automute_pin(struct hda_codec *codec)
 931 {
 932         struct alc_spec *spec = codec->spec;
 933         unsigned int present;
 934         unsigned int nid = spec->autocfg.hp_pins[0];
 935         int i;
 936
 937         /* need to execute and sync at first */
 938         snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 939         present = snd_hda_codec_read(codec, nid, 0,
 940                                      AC_VERB_GET_PIN_SENSE, 0);
 941         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
 942         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
 943                 nid = spec->autocfg.speaker_pins[i];
 944                 if (!nid)
 945                         break;
 946                 snd_hda_codec_write(codec, nid, 0,
 947                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 948                                     spec->jack_present ? 0 : PIN_OUT);
 949         }
 950 }
 951
 952 #if 0 /* it's broken in some acses -- temporarily disabled */
 953 static void alc_mic_automute(struct hda_codec *codec)
 954 {
 955         struct alc_spec *spec = codec->spec;
 956         unsigned int present;
 957         unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
 958         unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
 959         unsigned int mix_nid = spec->capsrc_nids[0];
 960         unsigned int capsrc_idx_mic, capsrc_idx_fmic;
 961
 962         capsrc_idx_mic = mic_nid - 0x18;
 963         capsrc_idx_fmic = fmic_nid - 0x18;
 964         present = snd_hda_codec_read(codec, mic_nid, 0,
 965                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 966         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 967                     0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
 968         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 969                     0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
 970         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
 971                          HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 972 }
 973 #else
 974 #define alc_mic_automute(codec) do {} while(0) /* NOP */
 975 #endif /* disabled */
 976
 977 /* unsolicited event for HP jack sensing */
 978 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 979 {
 980         if (codec->vendor_id == 0x10ec0880)
 981                 res >>= 28;
 982         else
 983                 res >>= 26;
 984         switch (res) {
 985         case ALC880_HP_EVENT:
 986                 alc_automute_pin(codec);
 987                 break;
 988         case ALC880_MIC_EVENT:
 989                 alc_mic_automute(codec);
 990                 break;
 991         }
 992 }
 993
 994 static void alc_inithook(struct hda_codec *codec)
 995 {
 996         alc_automute_pin(codec);
 997         alc_mic_automute(codec);
 998 }
 999
1000 /* additional initialization for ALC888 variants */
1001 static void alc888_coef_init(struct hda_codec *codec)
1002 {
1003         unsigned int tmp;
1004
1005         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1006         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1007         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1008         if ((tmp & 0xf0) == 0x20)
1009                 /* alc888S-VC */
1010                 snd_hda_codec_read(codec, 0x20, 0,
1011                                    AC_VERB_SET_PROC_COEF, 0x830);
1012          else
1013                  /* alc888-VB */
1014                  snd_hda_codec_read(codec, 0x20, 0,
1015                                     AC_VERB_SET_PROC_COEF, 0x3030);
1016 }
1017
1018 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1019 {
1020         unsigned int tmp;
1021
1022         switch (type) {
1023         case ALC_INIT_GPIO1:
1024                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1025                 break;
1026         case ALC_INIT_GPIO2:
1027                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1028                 break;
1029         case ALC_INIT_GPIO3:
1030                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1031                 break;
1032         case ALC_INIT_DEFAULT:
1033                 switch (codec->vendor_id) {
1034                 case 0x10ec0260:
1035                         snd_hda_codec_write(codec, 0x0f, 0,
1036                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1037                         snd_hda_codec_write(codec, 0x10, 0,
1038                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1039                         break;
1040                 case 0x10ec0262:
1041                 case 0x10ec0267:
1042                 case 0x10ec0268:
1043                 case 0x10ec0269:
1044                 case 0x10ec0272:
1045                 case 0x10ec0660:
1046                 case 0x10ec0662:
1047                 case 0x10ec0663:
1048                 case 0x10ec0862:
1049                 case 0x10ec0889:
1050                         snd_hda_codec_write(codec, 0x14, 0,
1051                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1052                         snd_hda_codec_write(codec, 0x15, 0,
1053                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1054                         break;
1055                 }
1056                 switch (codec->vendor_id) {
1057                 case 0x10ec0260:
1058                         snd_hda_codec_write(codec, 0x1a, 0,
1059                                             AC_VERB_SET_COEF_INDEX, 7);
1060                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1061                                                  AC_VERB_GET_PROC_COEF, 0);
1062                         snd_hda_codec_write(codec, 0x1a, 0,
1063                                             AC_VERB_SET_COEF_INDEX, 7);
1064                         snd_hda_codec_write(codec, 0x1a, 0,
1065                                             AC_VERB_SET_PROC_COEF,
1066                                             tmp | 0x2010);
1067                         break;
1068                 case 0x10ec0262:
1069                 case 0x10ec0880:
1070                 case 0x10ec0882:
1071                 case 0x10ec0883:
1072                 case 0x10ec0885:
1073                 case 0x10ec0887:
1074                 case 0x10ec0889:
1075                         snd_hda_codec_write(codec, 0x20, 0,
1076                                             AC_VERB_SET_COEF_INDEX, 7);
1077                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1078                                                  AC_VERB_GET_PROC_COEF, 0);
1079                         snd_hda_codec_write(codec, 0x20, 0,
1080                                             AC_VERB_SET_COEF_INDEX, 7);
1081                         snd_hda_codec_write(codec, 0x20, 0,
1082                                             AC_VERB_SET_PROC_COEF,
1083                                             tmp | 0x2010);
1084                         break;
1085                 case 0x10ec0888:
1086                         alc888_coef_init(codec);
1087                         break;
1088                 case 0x10ec0267:
1089                 case 0x10ec0268:
1090                         snd_hda_codec_write(codec, 0x20, 0,
1091                                             AC_VERB_SET_COEF_INDEX, 7);
1092                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1093                                                  AC_VERB_GET_PROC_COEF, 0);
1094                         snd_hda_codec_write(codec, 0x20, 0,
1095                                             AC_VERB_SET_COEF_INDEX, 7);
1096                         snd_hda_codec_write(codec, 0x20, 0,
1097                                             AC_VERB_SET_PROC_COEF,
1098                                             tmp | 0x3000);
1099                         break;
1100                 }
1101                 break;
1102         }
1103 }
1104
1105 static void alc_init_auto_hp(struct hda_codec *codec)
1106 {
1107         struct alc_spec *spec = codec->spec;
1108
1109         if (!spec->autocfg.hp_pins[0])
1110                 return;
1111
1112         if (!spec->autocfg.speaker_pins[0]) {
1113                 if (spec->autocfg.line_out_pins[0] &&
1114                     spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1115                         spec->autocfg.speaker_pins[0] =
1116                                 spec->autocfg.line_out_pins[0];
1117                 else
1118                         return;
1119         }
1120
1121         snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1122                     spec->autocfg.hp_pins[0]);
1123         snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1124                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1125                                   AC_USRSP_EN | ALC880_HP_EVENT);
1126         spec->unsol_event = alc_sku_unsol_event;
1127 }
1128
1129 /* check subsystem ID and set up device-specific initialization;
1130  * return 1 if initialized, 0 if invalid SSID
1131  */
1132 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1133  *      31 ~ 16 :       Manufacture ID
1134  *      15 ~ 8  :       SKU ID
1135  *      7  ~ 0  :       Assembly ID
1136  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1137  */
1138 static int alc_subsystem_id(struct hda_codec *codec,
1139                             hda_nid_t porta, hda_nid_t porte,
1140                             hda_nid_t portd)
1141 {
1142         unsigned int ass, tmp, i;
1143         unsigned nid;
1144         struct alc_spec *spec = codec->spec;
1145
1146         ass = codec->subsystem_id & 0xffff;
1147         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1148                 goto do_sku;
1149
1150         /* invalid SSID, check the special NID pin defcfg instead */
1151         /*
1152          * 31~30        : port conetcivity
1153          * 29~21        : reserve
1154          * 20           : PCBEEP input
1155          * 19~16        : Check sum (15:1)
1156          * 15~1         : Custom
1157          * 0            : override
1158         */
1159         nid = 0x1d;
1160         if (codec->vendor_id == 0x10ec0260)
1161                 nid = 0x17;
1162         ass = snd_hda_codec_get_pincfg(codec, nid);
1163         snd_printd("realtek: No valid SSID, "
1164                    "checking pincfg 0x%08x for NID 0x%x\n",
1165                    ass, nid);
1166         if (!(ass & 1) && !(ass & 0x100000))
1167                 return 0;
1168         if ((ass >> 30) != 1)   /* no physical connection */
1169                 return 0;
1170
1171         /* check sum */
1172         tmp = 0;
1173         for (i = 1; i < 16; i++) {
1174                 if ((ass >> i) & 1)
1175                         tmp++;
1176         }
1177         if (((ass >> 16) & 0xf) != tmp)
1178                 return 0;
1179 do_sku:
1180         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1181                    ass & 0xffff, codec->vendor_id);
1182         /*
1183          * 0 : override
1184          * 1 :  Swap Jack
1185          * 2 : 0 --> Desktop, 1 --> Laptop
1186          * 3~5 : External Amplifier control
1187          * 7~6 : Reserved
1188         */
1189         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1190         switch (tmp) {
1191         case 1:
1192                 spec->init_amp = ALC_INIT_GPIO1;
1193                 break;
1194         case 3:
1195                 spec->init_amp = ALC_INIT_GPIO2;
1196                 break;
1197         case 7:
1198                 spec->init_amp = ALC_INIT_GPIO3;
1199                 break;
1200         case 5:
1201                 spec->init_amp = ALC_INIT_DEFAULT;
1202                 break;
1203         }
1204
1205         /* is laptop or Desktop and enable the function "Mute internal speaker
1206          * when the external headphone out jack is plugged"
1207          */
1208         if (!(ass & 0x8000))
1209                 return 1;
1210         /*
1211          * 10~8 : Jack location
1212          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1213          * 14~13: Resvered
1214          * 15   : 1 --> enable the function "Mute internal speaker
1215          *              when the external headphone out jack is plugged"
1216          */
1217         if (!spec->autocfg.hp_pins[0]) {
1218                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1219                 if (tmp == 0)
1220                         spec->autocfg.hp_pins[0] = porta;
1221                 else if (tmp == 1)
1222                         spec->autocfg.hp_pins[0] = porte;
1223                 else if (tmp == 2)
1224                         spec->autocfg.hp_pins[0] = portd;
1225                 else
1226                         return 1;
1227         }
1228
1229         alc_init_auto_hp(codec);
1230         return 1;
1231 }
1232
1233 static void alc_ssid_check(struct hda_codec *codec,
1234                            hda_nid_t porta, hda_nid_t porte, hda_nid_t portd)
1235 {
1236         if (!alc_subsystem_id(codec, porta, porte, portd)) {
1237                 struct alc_spec *spec = codec->spec;
1238                 snd_printd("realtek: "
1239                            "Enable default setup for auto mode as fallback\n");
1240                 spec->init_amp = ALC_INIT_DEFAULT;
1241                 alc_init_auto_hp(codec);
1242         }
1243 }
1244
1245 /*
1246  * Fix-up pin default configurations
1247  */
1248
1249 struct alc_pincfg {
1250         hda_nid_t nid;
1251         u32 val;
1252 };
1253
1254 static void alc_fix_pincfg(struct hda_codec *codec,
1255                            const struct snd_pci_quirk *quirk,
1256                            const struct alc_pincfg **pinfix)
1257 {
1258         const struct alc_pincfg *cfg;
1259
1260         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1261         if (!quirk)
1262                 return;
1263
1264         cfg = pinfix[quirk->value];
1265         for (; cfg->nid; cfg++)
1266                 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1267 }
1268
1269 /*
1270  * ALC888
1271  */
1272
1273 /*
1274  * 2ch mode
1275  */
1276 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1277 /* Mic-in jack as mic in */
1278         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1279         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1280 /* Line-in jack as Line in */
1281         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1282         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1283 /* Line-Out as Front */
1284         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1285         { } /* end */
1286 };
1287
1288 /*
1289  * 4ch mode
1290  */
1291 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1292 /* Mic-in jack as mic in */
1293         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1294         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1295 /* Line-in jack as Surround */
1296         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1297         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1298 /* Line-Out as Front */
1299         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1300         { } /* end */
1301 };
1302
1303 /*
1304  * 6ch mode
1305  */
1306 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1307 /* Mic-in jack as CLFE */
1308         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1309         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1310 /* Line-in jack as Surround */
1311         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1312         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1313 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1314         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1315         { } /* end */
1316 };
1317
1318 /*
1319  * 8ch mode
1320  */
1321 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1322 /* Mic-in jack as CLFE */
1323         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1324         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1325 /* Line-in jack as Surround */
1326         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1327         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1328 /* Line-Out as Side */
1329         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1330         { } /* end */
1331 };
1332
1333 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1334         { 2, alc888_4ST_ch2_intel_init },
1335         { 4, alc888_4ST_ch4_intel_init },
1336         { 6, alc888_4ST_ch6_intel_init },
1337         { 8, alc888_4ST_ch8_intel_init },
1338 };
1339
1340 /*
1341  * ALC888 Fujitsu Siemens Amillo xa3530
1342  */
1343
1344 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1345 /* Front Mic: set to PIN_IN (empty by default) */
1346         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1347 /* Connect Internal HP to Front */
1348         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1349         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1350         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1351 /* Connect Bass HP to Front */
1352         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1353         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1354         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1355 /* Connect Line-Out side jack (SPDIF) to Side */
1356         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1357         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1358         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1359 /* Connect Mic jack to CLFE */
1360         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1361         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1362         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1363 /* Connect Line-in jack to Surround */
1364         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1365         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1366         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1367 /* Connect HP out jack to Front */
1368         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1369         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1370         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1371 /* Enable unsolicited event for HP jack and Line-out jack */
1372         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1373         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1374         {}
1375 };
1376
1377 static void alc_automute_amp(struct hda_codec *codec)
1378 {
1379         struct alc_spec *spec = codec->spec;
1380         unsigned int val, mute;
1381         hda_nid_t nid;
1382         int i;
1383
1384         spec->jack_present = 0;
1385         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1386                 nid = spec->autocfg.hp_pins[i];
1387                 if (!nid)
1388                         break;
1389                 val = snd_hda_codec_read(codec, nid, 0,
1390                                          AC_VERB_GET_PIN_SENSE, 0);
1391                 if (val & AC_PINSENSE_PRESENCE) {
1392                         spec->jack_present = 1;
1393                         break;
1394                 }
1395         }
1396
1397         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1398         /* Toggle internal speakers muting */
1399         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1400                 nid = spec->autocfg.speaker_pins[i];
1401                 if (!nid)
1402                         break;
1403                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1404                                          HDA_AMP_MUTE, mute);
1405         }
1406 }
1407
1408 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1409                                          unsigned int res)
1410 {
1411         if (codec->vendor_id == 0x10ec0880)
1412                 res >>= 28;
1413         else
1414                 res >>= 26;
1415         if (res == ALC880_HP_EVENT)
1416                 alc_automute_amp(codec);
1417 }
1418
1419 static void alc888_fujitsu_xa3530_init_hook(struct hda_codec *codec)
1420 {
1421         struct alc_spec *spec = codec->spec;
1422
1423         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1424         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1425         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1426         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1427         alc_automute_amp(codec);
1428 }
1429
1430 /*
1431  * ALC888 Acer Aspire 4930G model
1432  */
1433
1434 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1435 /* Front Mic: set to PIN_IN (empty by default) */
1436         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1437 /* Unselect Front Mic by default in input mixer 3 */
1438         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1439 /* Enable unsolicited event for HP jack */
1440         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1441 /* Connect Internal HP to front */
1442         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1443         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1444         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1445 /* Connect HP out to front */
1446         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1447         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1448         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1449         { }
1450 };
1451
1452 static struct hda_input_mux alc888_2_capture_sources[2] = {
1453         /* Front mic only available on one ADC */
1454         {
1455                 .num_items = 4,
1456                 .items = {
1457                         { "Mic", 0x0 },
1458                         { "Line", 0x2 },
1459                         { "CD", 0x4 },
1460                         { "Front Mic", 0xb },
1461                 },
1462         },
1463         {
1464                 .num_items = 3,
1465                 .items = {
1466                         { "Mic", 0x0 },
1467                         { "Line", 0x2 },
1468                         { "CD", 0x4 },
1469                 },
1470         }
1471 };
1472
1473 static struct snd_kcontrol_new alc888_base_mixer[] = {
1474         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1475         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1476         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1477         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1478         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1479                 HDA_OUTPUT),
1480         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1481         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1482         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1483         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1484         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1485         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1486         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1487         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1488         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1489         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1490         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1491         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1492         { } /* end */
1493 };
1494
1495 static void alc888_acer_aspire_4930g_init_hook(struct hda_codec *codec)
1496 {
1497         struct alc_spec *spec = codec->spec;
1498
1499         spec->autocfg.hp_pins[0] = 0x15;
1500         spec->autocfg.speaker_pins[0] = 0x14;
1501         alc_automute_amp(codec);
1502 }
1503
1504 /*
1505  * ALC880 3-stack model
1506  *
1507  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1508  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1509  *                 F-Mic = 0x1b, HP = 0x19
1510  */
1511
1512 static hda_nid_t alc880_dac_nids[4] = {
1513         /* front, rear, clfe, rear_surr */
1514         0x02, 0x05, 0x04, 0x03
1515 };
1516
1517 static hda_nid_t alc880_adc_nids[3] = {
1518         /* ADC0-2 */
1519         0x07, 0x08, 0x09,
1520 };
1521
1522 /* The datasheet says the node 0x07 is connected from inputs,
1523  * but it shows zero connection in the real implementation on some devices.
1524  * Note: this is a 915GAV bug, fixed on 915GLV
1525  */
1526 static hda_nid_t alc880_adc_nids_alt[2] = {
1527         /* ADC1-2 */
1528         0x08, 0x09,
1529 };
1530
1531 #define ALC880_DIGOUT_NID       0x06
1532 #define ALC880_DIGIN_NID        0x0a
1533
1534 static struct hda_input_mux alc880_capture_source = {
1535         .num_items = 4,
1536         .items = {
1537                 { "Mic", 0x0 },
1538                 { "Front Mic", 0x3 },
1539                 { "Line", 0x2 },
1540                 { "CD", 0x4 },
1541         },
1542 };
1543
1544 /* channel source setting (2/6 channel selection for 3-stack) */
1545 /* 2ch mode */
1546 static struct hda_verb alc880_threestack_ch2_init[] = {
1547         /* set line-in to input, mute it */
1548         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1549         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1550         /* set mic-in to input vref 80%, mute it */
1551         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1552         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1553         { } /* end */
1554 };
1555
1556 /* 6ch mode */
1557 static struct hda_verb alc880_threestack_ch6_init[] = {
1558         /* set line-in to output, unmute it */
1559         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1560         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1561         /* set mic-in to output, unmute it */
1562         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1563         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1564         { } /* end */
1565 };
1566
1567 static struct hda_channel_mode alc880_threestack_modes[2] = {
1568         { 2, alc880_threestack_ch2_init },
1569         { 6, alc880_threestack_ch6_init },
1570 };
1571
1572 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1573         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1574         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1575         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1576         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1577         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1578         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1579         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1580         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1581         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1582         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1583         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1584         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1585         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1586         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1587         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1588         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1589         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1590         {
1591                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1592                 .name = "Channel Mode",
1593                 .info = alc_ch_mode_info,
1594                 .get = alc_ch_mode_get,
1595                 .put = alc_ch_mode_put,
1596         },
1597         { } /* end */
1598 };
1599
1600 /* capture mixer elements */
1601 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1602                             struct snd_ctl_elem_info *uinfo)
1603 {
1604         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1605         struct alc_spec *spec = codec->spec;
1606         int err;
1607
1608         mutex_lock(&codec->control_mutex);
1609         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1610                                                       HDA_INPUT);
1611         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1612         mutex_unlock(&codec->control_mutex);
1613         return err;
1614 }
1615
1616 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1617                            unsigned int size, unsigned int __user *tlv)
1618 {
1619         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1620         struct alc_spec *spec = codec->spec;
1621         int err;
1622
1623         mutex_lock(&codec->control_mutex);
1624         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1625                                                       HDA_INPUT);
1626         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1627         mutex_unlock(&codec->control_mutex);
1628         return err;
1629 }
1630
1631 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1632                              struct snd_ctl_elem_value *ucontrol);
1633
1634 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1635                                  struct snd_ctl_elem_value *ucontrol,
1636                                  getput_call_t func)
1637 {
1638         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1639         struct alc_spec *spec = codec->spec;
1640         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1641         int err;
1642
1643         mutex_lock(&codec->control_mutex);
1644         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1645                                                       3, 0, HDA_INPUT);
1646         err = func(kcontrol, ucontrol);
1647         mutex_unlock(&codec->control_mutex);
1648         return err;
1649 }
1650
1651 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1652                            struct snd_ctl_elem_value *ucontrol)
1653 {
1654         return alc_cap_getput_caller(kcontrol, ucontrol,
1655                                      snd_hda_mixer_amp_volume_get);
1656 }
1657
1658 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1659                            struct snd_ctl_elem_value *ucontrol)
1660 {
1661         return alc_cap_getput_caller(kcontrol, ucontrol,
1662                                      snd_hda_mixer_amp_volume_put);
1663 }
1664
1665 /* capture mixer elements */
1666 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1667
1668 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1669                           struct snd_ctl_elem_value *ucontrol)
1670 {
1671         return alc_cap_getput_caller(kcontrol, ucontrol,
1672                                      snd_hda_mixer_amp_switch_get);
1673 }
1674
1675 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1676                           struct snd_ctl_elem_value *ucontrol)
1677 {
1678         return alc_cap_getput_caller(kcontrol, ucontrol,
1679                                      snd_hda_mixer_amp_switch_put);
1680 }
1681
1682 #define _DEFINE_CAPMIX(num) \
1683         { \
1684                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1685                 .name = "Capture Switch", \
1686                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1687                 .count = num, \
1688                 .info = alc_cap_sw_info, \
1689                 .get = alc_cap_sw_get, \
1690                 .put = alc_cap_sw_put, \
1691         }, \
1692         { \
1693                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1694                 .name = "Capture Volume", \
1695                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1696                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1697                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1698                 .count = num, \
1699                 .info = alc_cap_vol_info, \
1700                 .get = alc_cap_vol_get, \
1701                 .put = alc_cap_vol_put, \
1702                 .tlv = { .c = alc_cap_vol_tlv }, \
1703         }
1704
1705 #define _DEFINE_CAPSRC(num) \
1706         { \
1707                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1708                 /* .name = "Capture Source", */ \
1709                 .name = "Input Source", \
1710                 .count = num, \
1711                 .info = alc_mux_enum_info, \
1712                 .get = alc_mux_enum_get, \
1713                 .put = alc_mux_enum_put, \
1714         }
1715
1716 #define DEFINE_CAPMIX(num) \
1717 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1718         _DEFINE_CAPMIX(num),                                  \
1719         _DEFINE_CAPSRC(num),                                  \
1720         { } /* end */                                         \
1721 }
1722
1723 #define DEFINE_CAPMIX_NOSRC(num) \
1724 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1725         _DEFINE_CAPMIX(num),                                        \
1726         { } /* end */                                               \
1727 }
1728
1729 /* up to three ADCs */
1730 DEFINE_CAPMIX(1);
1731 DEFINE_CAPMIX(2);
1732 DEFINE_CAPMIX(3);
1733 DEFINE_CAPMIX_NOSRC(1);
1734 DEFINE_CAPMIX_NOSRC(2);
1735 DEFINE_CAPMIX_NOSRC(3);
1736
1737 /*
1738  * ALC880 5-stack model
1739  *
1740  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1741  *      Side = 0x02 (0xd)
1742  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1743  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1744  */
1745
1746 /* additional mixers to alc880_three_stack_mixer */
1747 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1748         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1749         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1750         { } /* end */
1751 };
1752
1753 /* channel source setting (6/8 channel selection for 5-stack) */
1754 /* 6ch mode */
1755 static struct hda_verb alc880_fivestack_ch6_init[] = {
1756         /* set line-in to input, mute it */
1757         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1758         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1759         { } /* end */
1760 };
1761
1762 /* 8ch mode */
1763 static struct hda_verb alc880_fivestack_ch8_init[] = {
1764         /* set line-in to output, unmute it */
1765         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1766         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1767         { } /* end */
1768 };
1769
1770 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1771         { 6, alc880_fivestack_ch6_init },
1772         { 8, alc880_fivestack_ch8_init },
1773 };
1774
1775
1776 /*
1777  * ALC880 6-stack model
1778  *
1779  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1780  *      Side = 0x05 (0x0f)
1781  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1782  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1783  */
1784
1785 static hda_nid_t alc880_6st_dac_nids[4] = {
1786         /* front, rear, clfe, rear_surr */
1787         0x02, 0x03, 0x04, 0x05
1788 };
1789
1790 static struct hda_input_mux alc880_6stack_capture_source = {
1791         .num_items = 4,
1792         .items = {
1793                 { "Mic", 0x0 },
1794                 { "Front Mic", 0x1 },
1795                 { "Line", 0x2 },
1796                 { "CD", 0x4 },
1797         },
1798 };
1799
1800 /* fixed 8-channels */
1801 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1802         { 8, NULL },
1803 };
1804
1805 static struct snd_kcontrol_new alc880_six_stack_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("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1809         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1810         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1811         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1812         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1813         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1814         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1815         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1816         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1817         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1818         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1819         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1820         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1821         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1822         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1823         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1824         {
1825                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1826                 .name = "Channel Mode",
1827                 .info = alc_ch_mode_info,
1828                 .get = alc_ch_mode_get,
1829                 .put = alc_ch_mode_put,
1830         },
1831         { } /* end */
1832 };
1833
1834
1835 /*
1836  * ALC880 W810 model
1837  *
1838  * W810 has rear IO for:
1839  * Front (DAC 02)
1840  * Surround (DAC 03)
1841  * Center/LFE (DAC 04)
1842  * Digital out (06)
1843  *
1844  * The system also has a pair of internal speakers, and a headphone jack.
1845  * These are both connected to Line2 on the codec, hence to DAC 02.
1846  *
1847  * There is a variable resistor to control the speaker or headphone
1848  * volume. This is a hardware-only device without a software API.
1849  *
1850  * Plugging headphones in will disable the internal speakers. This is
1851  * implemented in hardware, not via the driver using jack sense. In
1852  * a similar fashion, plugging into the rear socket marked "front" will
1853  * disable both the speakers and headphones.
1854  *
1855  * For input, there's a microphone jack, and an "audio in" jack.
1856  * These may not do anything useful with this driver yet, because I
1857  * haven't setup any initialization verbs for these yet...
1858  */
1859
1860 static hda_nid_t alc880_w810_dac_nids[3] = {
1861         /* front, rear/surround, clfe */
1862         0x02, 0x03, 0x04
1863 };
1864
1865 /* fixed 6 channels */
1866 static struct hda_channel_mode alc880_w810_modes[1] = {
1867         { 6, NULL }
1868 };
1869
1870 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1871 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1872         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1873         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1874         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1875         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1876         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1877         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1878         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1879         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1880         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1881         { } /* end */
1882 };
1883
1884
1885 /*
1886  * Z710V model
1887  *
1888  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1889  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1890  *                 Line = 0x1a
1891  */
1892
1893 static hda_nid_t alc880_z71v_dac_nids[1] = {
1894         0x02
1895 };
1896 #define ALC880_Z71V_HP_DAC      0x03
1897
1898 /* fixed 2 channels */
1899 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1900         { 2, NULL }
1901 };
1902
1903 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1904         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1905         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1906         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1907         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1908         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1909         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1910         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1911         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1912         { } /* end */
1913 };
1914
1915
1916 /*
1917  * ALC880 F1734 model
1918  *
1919  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1920  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1921  */
1922
1923 static hda_nid_t alc880_f1734_dac_nids[1] = {
1924         0x03
1925 };
1926 #define ALC880_F1734_HP_DAC     0x02
1927
1928 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1929         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1930         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1931         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1932         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1933         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1934         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1935         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1936         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1937         { } /* end */
1938 };
1939
1940 static struct hda_input_mux alc880_f1734_capture_source = {
1941         .num_items = 2,
1942         .items = {
1943                 { "Mic", 0x1 },
1944                 { "CD", 0x4 },
1945         },
1946 };
1947
1948
1949 /*
1950  * ALC880 ASUS model
1951  *
1952  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1953  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1954  *  Mic = 0x18, Line = 0x1a
1955  */
1956
1957 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
1958 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
1959
1960 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1961         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1962         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1963         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1964         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1965         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1966         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1967         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1968         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1969         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1970         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1971         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1972         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1973         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1974         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1975         {
1976                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1977                 .name = "Channel Mode",
1978                 .info = alc_ch_mode_info,
1979                 .get = alc_ch_mode_get,
1980                 .put = alc_ch_mode_put,
1981         },
1982         { } /* end */
1983 };
1984
1985 /*
1986  * ALC880 ASUS W1V model
1987  *
1988  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1989  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1990  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1991  */
1992
1993 /* additional mixers to alc880_asus_mixer */
1994 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1995         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1996         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1997         { } /* end */
1998 };
1999
2000 /* TCL S700 */
2001 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2002         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2003         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2004         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2005         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2006         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2007         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2008         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2009         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2010         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2011         { } /* end */
2012 };
2013
2014 /* Uniwill */
2015 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2016         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2017         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2018         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2019         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2020         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2021         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2022         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2023         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2024         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2025         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2026         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2027         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2028         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2029         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2030         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2031         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2032         {
2033                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2034                 .name = "Channel Mode",
2035                 .info = alc_ch_mode_info,
2036                 .get = alc_ch_mode_get,
2037                 .put = alc_ch_mode_put,
2038         },
2039         { } /* end */
2040 };
2041
2042 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2043         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2044         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2045         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2046         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2047         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2048         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2049         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2050         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2051         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2052         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2053         { } /* end */
2054 };
2055
2056 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2057         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2058         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2059         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2060         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2061         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2062         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2063         { } /* end */
2064 };
2065
2066 /*
2067  * virtual master controls
2068  */
2069
2070 /*
2071  * slave controls for virtual master
2072  */
2073 static const char *alc_slave_vols[] = {
2074         "Front Playback Volume",
2075         "Surround Playback Volume",
2076         "Center Playback Volume",
2077         "LFE Playback Volume",
2078         "Side Playback Volume",
2079         "Headphone Playback Volume",
2080         "Speaker Playback Volume",
2081         "Mono Playback Volume",
2082         "Line-Out Playback Volume",
2083         "PCM Playback Volume",
2084         NULL,
2085 };
2086
2087 static const char *alc_slave_sws[] = {
2088         "Front Playback Switch",
2089         "Surround Playback Switch",
2090         "Center Playback Switch",
2091         "LFE Playback Switch",
2092         "Side Playback Switch",
2093         "Headphone Playback Switch",
2094         "Speaker Playback Switch",
2095         "Mono Playback Switch",
2096         "IEC958 Playback Switch",
2097         NULL,
2098 };
2099
2100 /*
2101  * build control elements
2102  */
2103
2104 static void alc_free_kctls(struct hda_codec *codec);
2105
2106 /* additional beep mixers; the actual parameters are overwritten at build */
2107 static struct snd_kcontrol_new alc_beep_mixer[] = {
2108         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2109         HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
2110         { } /* end */
2111 };
2112
2113 static int alc_build_controls(struct hda_codec *codec)
2114 {
2115         struct alc_spec *spec = codec->spec;
2116         int err;
2117         int i;
2118
2119         for (i = 0; i < spec->num_mixers; i++) {
2120                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2121                 if (err < 0)
2122                         return err;
2123         }
2124         if (spec->cap_mixer) {
2125                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2126                 if (err < 0)
2127                         return err;
2128         }
2129         if (spec->multiout.dig_out_nid) {
2130                 err = snd_hda_create_spdif_out_ctls(codec,
2131                                                     spec->multiout.dig_out_nid);
2132                 if (err < 0)
2133                         return err;
2134                 if (!spec->no_analog) {
2135                         err = snd_hda_create_spdif_share_sw(codec,
2136                                                             &spec->multiout);
2137                         if (err < 0)
2138                                 return err;
2139                         spec->multiout.share_spdif = 1;
2140                 }
2141         }
2142         if (spec->dig_in_nid) {
2143                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2144                 if (err < 0)
2145                         return err;
2146         }
2147
2148         /* create beep controls if needed */
2149         if (spec->beep_amp) {
2150                 struct snd_kcontrol_new *knew;
2151                 for (knew = alc_beep_mixer; knew->name; knew++) {
2152                         struct snd_kcontrol *kctl;
2153                         kctl = snd_ctl_new1(knew, codec);
2154                         if (!kctl)
2155                                 return -ENOMEM;
2156                         kctl->private_value = spec->beep_amp;
2157                         err = snd_hda_ctl_add(codec, kctl);
2158                         if (err < 0)
2159                                 return err;
2160                 }
2161         }
2162
2163         /* if we have no master control, let's create it */
2164         if (!spec->no_analog &&
2165             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2166                 unsigned int vmaster_tlv[4];
2167                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2168                                         HDA_OUTPUT, vmaster_tlv);
2169                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2170                                           vmaster_tlv, alc_slave_vols);
2171                 if (err < 0)
2172                         return err;
2173         }
2174         if (!spec->no_analog &&
2175             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2176                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2177                                           NULL, alc_slave_sws);
2178                 if (err < 0)
2179                         return err;
2180         }
2181
2182         alc_free_kctls(codec); /* no longer needed */
2183         return 0;
2184 }
2185
2186
2187 /*
2188  * initialize the codec volumes, etc
2189  */
2190
2191 /*
2192  * generic initialization of ADC, input mixers and output mixers
2193  */
2194 static struct hda_verb alc880_volume_init_verbs[] = {
2195         /*
2196          * Unmute ADC0-2 and set the default input to mic-in
2197          */
2198         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2199         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2200         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2201         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2202         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2203         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2204
2205         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2206          * mixer widget
2207          * Note: PASD motherboards uses the Line In 2 as the input for front
2208          * panel mic (mic 2)
2209          */
2210         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2211         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2212         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2213         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2214         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2215         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2216         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2217         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2218
2219         /*
2220          * Set up output mixers (0x0c - 0x0f)
2221          */
2222         /* set vol=0 to output mixers */
2223         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2224         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2225         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2226         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2227         /* set up input amps for analog loopback */
2228         /* Amp Indices: DAC = 0, mixer = 1 */
2229         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2230         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2231         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2232         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2233         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2234         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2235         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2236         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2237
2238         { }
2239 };
2240
2241 /*
2242  * 3-stack pin configuration:
2243  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2244  */
2245 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2246         /*
2247          * preset connection lists of input pins
2248          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2249          */
2250         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2251         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2252         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2253
2254         /*
2255          * Set pin mode and muting
2256          */
2257         /* set front pin widgets 0x14 for output */
2258         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2259         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2260         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2261         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2262         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2263         /* Mic2 (as headphone out) for HP output */
2264         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2265         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2266         /* Line In pin widget for input */
2267         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2268         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2269         /* Line2 (as front mic) pin widget for input and vref at 80% */
2270         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2271         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2272         /* CD pin widget for input */
2273         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2274
2275         { }
2276 };
2277
2278 /*
2279  * 5-stack pin configuration:
2280  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2281  * line-in/side = 0x1a, f-mic = 0x1b
2282  */
2283 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2284         /*
2285          * preset connection lists of input pins
2286          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2287          */
2288         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2289         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2290
2291         /*
2292          * Set pin mode and muting
2293          */
2294         /* set pin widgets 0x14-0x17 for output */
2295         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2296         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2297         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2298         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2299         /* unmute pins for output (no gain on this amp) */
2300         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2301         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2302         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2303         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2304
2305         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2306         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2307         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2308         /* Mic2 (as headphone out) for HP output */
2309         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2310         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2311         /* Line In pin widget for input */
2312         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2313         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2314         /* Line2 (as front mic) pin widget for input and vref at 80% */
2315         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2316         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2317         /* CD pin widget for input */
2318         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2319
2320         { }
2321 };
2322
2323 /*
2324  * W810 pin configuration:
2325  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2326  */
2327 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2328         /* hphone/speaker input selector: front DAC */
2329         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2330
2331         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2332         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2333         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2334         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2335         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2336         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2337
2338         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2339         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2340
2341         { }
2342 };
2343
2344 /*
2345  * Z71V pin configuration:
2346  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2347  */
2348 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2349         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2350         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2351         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2352         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2353
2354         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2355         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2356         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2357         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2358
2359         { }
2360 };
2361
2362 /*
2363  * 6-stack pin configuration:
2364  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2365  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2366  */
2367 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2368         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2369
2370         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2371         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2372         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2373         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2374         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2375         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2376         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2377         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2378
2379         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2380         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2381         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2382         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2383         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2384         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2385         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2386         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2387         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2388
2389         { }
2390 };
2391
2392 /*
2393  * Uniwill pin configuration:
2394  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2395  * line = 0x1a
2396  */
2397 static struct hda_verb alc880_uniwill_init_verbs[] = {
2398         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2399
2400         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2401         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2402         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2403         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2404         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2405         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2406         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2407         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2408         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2409         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2410         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2411         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2412         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2413         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2414
2415         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2416         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2417         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2418         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2419         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2420         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2421         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2422         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2423         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2424
2425         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2426         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2427
2428         { }
2429 };
2430
2431 /*
2432 * Uniwill P53
2433 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2434  */
2435 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2436         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2437
2438         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2439         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2440         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2441         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2442         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2443         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2444         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2445         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2446         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2447         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2448         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2449         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2450
2451         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2452         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2453         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2454         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2455         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2456         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2457
2458         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2459         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2460
2461         { }
2462 };
2463
2464 static struct hda_verb alc880_beep_init_verbs[] = {
2465         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2466         { }
2467 };
2468
2469 /* auto-toggle front mic */
2470 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2471 {
2472         unsigned int present;
2473         unsigned char bits;
2474
2475         present = snd_hda_codec_read(codec, 0x18, 0,
2476                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2477         bits = present ? HDA_AMP_MUTE : 0;
2478         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2479 }
2480
2481 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2482 {
2483         struct alc_spec *spec = codec->spec;
2484
2485         spec->autocfg.hp_pins[0] = 0x14;
2486         spec->autocfg.speaker_pins[0] = 0x15;
2487         spec->autocfg.speaker_pins[0] = 0x16;
2488         alc_automute_amp(codec);
2489         alc880_uniwill_mic_automute(codec);
2490 }
2491
2492 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2493                                        unsigned int res)
2494 {
2495         /* Looks like the unsol event is incompatible with the standard
2496          * definition.  4bit tag is placed at 28 bit!
2497          */
2498         switch (res >> 28) {
2499         case ALC880_MIC_EVENT:
2500                 alc880_uniwill_mic_automute(codec);
2501                 break;
2502         default:
2503                 alc_automute_amp_unsol_event(codec, res);
2504                 break;
2505         }
2506 }
2507
2508 static void alc880_uniwill_p53_init_hook(struct hda_codec *codec)
2509 {
2510         struct alc_spec *spec = codec->spec;
2511
2512         spec->autocfg.hp_pins[0] = 0x14;
2513         spec->autocfg.speaker_pins[0] = 0x15;
2514         alc_automute_amp(codec);
2515 }
2516
2517 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2518 {
2519         unsigned int present;
2520
2521         present = snd_hda_codec_read(codec, 0x21, 0,
2522                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2523         present &= HDA_AMP_VOLMASK;
2524         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2525                                  HDA_AMP_VOLMASK, present);
2526         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2527                                  HDA_AMP_VOLMASK, present);
2528 }
2529
2530 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2531                                            unsigned int res)
2532 {
2533         /* Looks like the unsol event is incompatible with the standard
2534          * definition.  4bit tag is placed at 28 bit!
2535          */
2536         if ((res >> 28) == ALC880_DCVOL_EVENT)
2537                 alc880_uniwill_p53_dcvol_automute(codec);
2538         else
2539                 alc_automute_amp_unsol_event(codec, res);
2540 }
2541
2542 /*
2543  * F1734 pin configuration:
2544  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2545  */
2546 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2547         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2548         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2549         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2550         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2551         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2552
2553         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2554         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2555         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2556         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2557
2558         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2559         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2560         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2561         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2562         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2563         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2564         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2565         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2566         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2567
2568         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2569         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2570
2571         { }
2572 };
2573
2574 /*
2575  * ASUS pin configuration:
2576  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2577  */
2578 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2579         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2580         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2581         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2582         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2583
2584         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2585         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2586         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2587         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2588         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2589         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2590         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2591         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2592
2593         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2594         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2595         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2596         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2597         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2598         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2599         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2600         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2601         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2602
2603         { }
2604 };
2605
2606 /* Enable GPIO mask and set output */
2607 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2608 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2609
2610 /* Clevo m520g init */
2611 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2612         /* headphone output */
2613         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2614         /* line-out */
2615         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2616         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2617         /* Line-in */
2618         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2619         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2620         /* CD */
2621         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2622         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2623         /* Mic1 (rear panel) */
2624         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2625         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2626         /* Mic2 (front panel) */
2627         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2628         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2629         /* headphone */
2630         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2631         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2632         /* change to EAPD mode */
2633         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2634         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2635
2636         { }
2637 };
2638
2639 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2640         /* change to EAPD mode */
2641         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2642         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2643
2644         /* Headphone output */
2645         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2646         /* Front output*/
2647         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2648         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2649
2650         /* Line In pin widget for input */
2651         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2652         /* CD pin widget for input */
2653         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2654         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2655         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2656
2657         /* change to EAPD mode */
2658         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2659         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2660
2661         { }
2662 };
2663
2664 /*
2665  * LG m1 express dual
2666  *
2667  * Pin assignment:
2668  *   Rear Line-In/Out (blue): 0x14
2669  *   Build-in Mic-In: 0x15
2670  *   Speaker-out: 0x17
2671  *   HP-Out (green): 0x1b
2672  *   Mic-In/Out (red): 0x19
2673  *   SPDIF-Out: 0x1e
2674  */
2675
2676 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2677 static hda_nid_t alc880_lg_dac_nids[3] = {
2678         0x05, 0x02, 0x03
2679 };
2680
2681 /* seems analog CD is not working */
2682 static struct hda_input_mux alc880_lg_capture_source = {
2683         .num_items = 3,
2684         .items = {
2685                 { "Mic", 0x1 },
2686                 { "Line", 0x5 },
2687                 { "Internal Mic", 0x6 },
2688         },
2689 };
2690
2691 /* 2,4,6 channel modes */
2692 static struct hda_verb alc880_lg_ch2_init[] = {
2693         /* set line-in and mic-in to input */
2694         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2695         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2696         { }
2697 };
2698
2699 static struct hda_verb alc880_lg_ch4_init[] = {
2700         /* set line-in to out and mic-in to input */
2701         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2702         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2703         { }
2704 };
2705
2706 static struct hda_verb alc880_lg_ch6_init[] = {
2707         /* set line-in and mic-in to output */
2708         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2709         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2710         { }
2711 };
2712
2713 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2714         { 2, alc880_lg_ch2_init },
2715         { 4, alc880_lg_ch4_init },
2716         { 6, alc880_lg_ch6_init },
2717 };
2718
2719 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2720         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2721         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2722         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2723         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2724         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2725         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2726         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2727         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2728         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2729         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2730         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2731         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2732         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2733         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2734         {
2735                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2736                 .name = "Channel Mode",
2737                 .info = alc_ch_mode_info,
2738                 .get = alc_ch_mode_get,
2739                 .put = alc_ch_mode_put,
2740         },
2741         { } /* end */
2742 };
2743
2744 static struct hda_verb alc880_lg_init_verbs[] = {
2745         /* set capture source to mic-in */
2746         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2747         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2748         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2749         /* mute all amp mixer inputs */
2750         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2751         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2752         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2753         /* line-in to input */
2754         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2755         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2756         /* built-in mic */
2757         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2758         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2759         /* speaker-out */
2760         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2761         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2762         /* mic-in to input */
2763         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2764         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2765         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2766         /* HP-out */
2767         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2768         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2769         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2770         /* jack sense */
2771         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2772         { }
2773 };
2774
2775 /* toggle speaker-output according to the hp-jack state */
2776 static void alc880_lg_init_hook(struct hda_codec *codec)
2777 {
2778         struct alc_spec *spec = codec->spec;
2779
2780         spec->autocfg.hp_pins[0] = 0x1b;
2781         spec->autocfg.speaker_pins[0] = 0x17;
2782         alc_automute_amp(codec);
2783 }
2784
2785 /*
2786  * LG LW20
2787  *
2788  * Pin assignment:
2789  *   Speaker-out: 0x14
2790  *   Mic-In: 0x18
2791  *   Built-in Mic-In: 0x19
2792  *   Line-In: 0x1b
2793  *   HP-Out: 0x1a
2794  *   SPDIF-Out: 0x1e
2795  */
2796
2797 static struct hda_input_mux alc880_lg_lw_capture_source = {
2798         .num_items = 3,
2799         .items = {
2800                 { "Mic", 0x0 },
2801                 { "Internal Mic", 0x1 },
2802                 { "Line In", 0x2 },
2803         },
2804 };
2805
2806 #define alc880_lg_lw_modes alc880_threestack_modes
2807
2808 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2809         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2810         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2811         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2812         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2813         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2814         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2815         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2816         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2817         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2818         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2819         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2820         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2821         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2822         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2823         {
2824                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2825                 .name = "Channel Mode",
2826                 .info = alc_ch_mode_info,
2827                 .get = alc_ch_mode_get,
2828                 .put = alc_ch_mode_put,
2829         },
2830         { } /* end */
2831 };
2832
2833 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2834         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2835         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2836         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2837
2838         /* set capture source to mic-in */
2839         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2840         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2841         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2842         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2843         /* speaker-out */
2844         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2845         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2846         /* HP-out */
2847         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2848         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2849         /* mic-in to input */
2850         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2851         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2852         /* built-in mic */
2853         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2854         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2855         /* jack sense */
2856         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2857         { }
2858 };
2859
2860 /* toggle speaker-output according to the hp-jack state */
2861 static void alc880_lg_lw_init_hook(struct hda_codec *codec)
2862 {
2863         struct alc_spec *spec = codec->spec;
2864
2865         spec->autocfg.hp_pins[0] = 0x1b;
2866         spec->autocfg.speaker_pins[0] = 0x14;
2867         alc_automute_amp(codec);
2868 }
2869
2870 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2871         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2872         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2873         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2874         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2875         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2876         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2877         { } /* end */
2878 };
2879
2880 static struct hda_input_mux alc880_medion_rim_capture_source = {
2881         .num_items = 2,
2882         .items = {
2883                 { "Mic", 0x0 },
2884                 { "Internal Mic", 0x1 },
2885         },
2886 };
2887
2888 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2889         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2890
2891         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2892         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2893
2894         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2895         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2896         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2897         /* Mic2 (as headphone out) for HP output */
2898         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2899         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2900         /* Internal Speaker */
2901         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2902         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2903
2904         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2905         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2906
2907         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2908         { }
2909 };
2910
2911 /* toggle speaker-output according to the hp-jack state */
2912 static void alc880_medion_rim_automute(struct hda_codec *codec)
2913 {
2914         struct alc_spec *spec = codec->spec;
2915         alc_automute_amp(codec);
2916         /* toggle EAPD */
2917         if (spec->jack_present)
2918                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2919         else
2920                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2921 }
2922
2923 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2924                                           unsigned int res)
2925 {
2926         /* Looks like the unsol event is incompatible with the standard
2927          * definition.  4bit tag is placed at 28 bit!
2928          */
2929         if ((res >> 28) == ALC880_HP_EVENT)
2930                 alc880_medion_rim_automute(codec);
2931 }
2932
2933 static void alc880_medion_rim_init_hook(struct hda_codec *codec)
2934 {
2935         struct alc_spec *spec = codec->spec;
2936
2937         spec->autocfg.hp_pins[0] = 0x14;
2938         spec->autocfg.speaker_pins[0] = 0x1b;
2939         alc880_medion_rim_automute(codec);
2940 }
2941
2942 #ifdef CONFIG_SND_HDA_POWER_SAVE
2943 static struct hda_amp_list alc880_loopbacks[] = {
2944         { 0x0b, HDA_INPUT, 0 },
2945         { 0x0b, HDA_INPUT, 1 },
2946         { 0x0b, HDA_INPUT, 2 },
2947         { 0x0b, HDA_INPUT, 3 },
2948         { 0x0b, HDA_INPUT, 4 },
2949         { } /* end */
2950 };
2951
2952 static struct hda_amp_list alc880_lg_loopbacks[] = {
2953         { 0x0b, HDA_INPUT, 1 },
2954         { 0x0b, HDA_INPUT, 6 },
2955         { 0x0b, HDA_INPUT, 7 },
2956         { } /* end */
2957 };
2958 #endif
2959
2960 /*
2961  * Common callbacks
2962  */
2963
2964 static int alc_init(struct hda_codec *codec)
2965 {
2966         struct alc_spec *spec = codec->spec;
2967         unsigned int i;
2968
2969         alc_fix_pll(codec);
2970         alc_auto_init_amp(codec, spec->init_amp);
2971
2972         for (i = 0; i < spec->num_init_verbs; i++)
2973                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2974
2975         if (spec->init_hook)
2976                 spec->init_hook(codec);
2977
2978         return 0;
2979 }
2980
2981 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2982 {
2983         struct alc_spec *spec = codec->spec;
2984
2985         if (spec->unsol_event)
2986                 spec->unsol_event(codec, res);
2987 }
2988
2989 #ifdef CONFIG_SND_HDA_POWER_SAVE
2990 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2991 {
2992         struct alc_spec *spec = codec->spec;
2993         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2994 }
2995 #endif
2996
2997 /*
2998  * Analog playback callbacks
2999  */
3000 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3001                                     struct hda_codec *codec,
3002                                     struct snd_pcm_substream *substream)
3003 {
3004         struct alc_spec *spec = codec->spec;
3005         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3006                                              hinfo);
3007 }
3008
3009 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3010                                        struct hda_codec *codec,
3011                                        unsigned int stream_tag,
3012                                        unsigned int format,
3013                                        struct snd_pcm_substream *substream)
3014 {
3015         struct alc_spec *spec = codec->spec;
3016         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3017                                                 stream_tag, format, substream);
3018 }
3019
3020 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3021                                        struct hda_codec *codec,
3022                                        struct snd_pcm_substream *substream)
3023 {
3024         struct alc_spec *spec = codec->spec;
3025         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3026 }
3027
3028 /*
3029  * Digital out
3030  */
3031 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3032                                         struct hda_codec *codec,
3033                                         struct snd_pcm_substream *substream)
3034 {
3035         struct alc_spec *spec = codec->spec;
3036         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3037 }
3038
3039 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3040                                            struct hda_codec *codec,
3041                                            unsigned int stream_tag,
3042                                            unsigned int format,
3043                                            struct snd_pcm_substream *substream)
3044 {
3045         struct alc_spec *spec = codec->spec;
3046         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3047                                              stream_tag, format, substream);
3048 }
3049
3050 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3051                                            struct hda_codec *codec,
3052                                            struct snd_pcm_substream *substream)
3053 {
3054         struct alc_spec *spec = codec->spec;
3055         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3056 }
3057
3058 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3059                                          struct hda_codec *codec,
3060                                          struct snd_pcm_substream *substream)
3061 {
3062         struct alc_spec *spec = codec->spec;
3063         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3064 }
3065
3066 /*
3067  * Analog capture
3068  */
3069 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3070                                       struct hda_codec *codec,
3071                                       unsigned int stream_tag,
3072                                       unsigned int format,
3073                                       struct snd_pcm_substream *substream)
3074 {
3075         struct alc_spec *spec = codec->spec;
3076
3077         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3078                                    stream_tag, 0, format);
3079         return 0;
3080 }
3081
3082 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3083                                       struct hda_codec *codec,
3084                                       struct snd_pcm_substream *substream)
3085 {
3086         struct alc_spec *spec = codec->spec;
3087
3088         snd_hda_codec_cleanup_stream(codec,
3089                                      spec->adc_nids[substream->number + 1]);
3090         return 0;
3091 }
3092
3093
3094 /*
3095  */
3096 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3097         .substreams = 1,
3098         .channels_min = 2,
3099         .channels_max = 8,
3100         /* NID is set in alc_build_pcms */
3101         .ops = {
3102                 .open = alc880_playback_pcm_open,
3103                 .prepare = alc880_playback_pcm_prepare,
3104                 .cleanup = alc880_playback_pcm_cleanup
3105         },
3106 };
3107
3108 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3109         .substreams = 1,
3110         .channels_min = 2,
3111         .channels_max = 2,
3112         /* NID is set in alc_build_pcms */
3113 };
3114
3115 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3116         .substreams = 1,
3117         .channels_min = 2,
3118         .channels_max = 2,
3119         /* NID is set in alc_build_pcms */
3120 };
3121
3122 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3123         .substreams = 2, /* can be overridden */
3124         .channels_min = 2,
3125         .channels_max = 2,
3126         /* NID is set in alc_build_pcms */
3127         .ops = {
3128                 .prepare = alc880_alt_capture_pcm_prepare,
3129                 .cleanup = alc880_alt_capture_pcm_cleanup
3130         },
3131 };
3132
3133 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3134         .substreams = 1,
3135         .channels_min = 2,
3136         .channels_max = 2,
3137         /* NID is set in alc_build_pcms */
3138         .ops = {
3139                 .open = alc880_dig_playback_pcm_open,
3140                 .close = alc880_dig_playback_pcm_close,
3141                 .prepare = alc880_dig_playback_pcm_prepare,
3142                 .cleanup = alc880_dig_playback_pcm_cleanup
3143         },
3144 };
3145
3146 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3147         .substreams = 1,
3148         .channels_min = 2,
3149         .channels_max = 2,
3150         /* NID is set in alc_build_pcms */
3151 };
3152
3153 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3154 static struct hda_pcm_stream alc_pcm_null_stream = {
3155         .substreams = 0,
3156         .channels_min = 0,
3157         .channels_max = 0,
3158 };
3159
3160 static int alc_build_pcms(struct hda_codec *codec)
3161 {
3162         struct alc_spec *spec = codec->spec;
3163         struct hda_pcm *info = spec->pcm_rec;
3164         int i;
3165
3166         codec->num_pcms = 1;
3167         codec->pcm_info = info;
3168
3169         if (spec->no_analog)
3170                 goto skip_analog;
3171
3172         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3173                  "%s Analog", codec->chip_name);
3174         info->name = spec->stream_name_analog;
3175
3176         if (spec->stream_analog_playback) {
3177                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3178                         return -EINVAL;
3179                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3180                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3181         }
3182         if (spec->stream_analog_capture) {
3183                 if (snd_BUG_ON(!spec->adc_nids))
3184                         return -EINVAL;
3185                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3186                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3187         }
3188
3189         if (spec->channel_mode) {
3190                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3191                 for (i = 0; i < spec->num_channel_mode; i++) {
3192                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3193                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3194                         }
3195                 }
3196         }
3197
3198  skip_analog:
3199         /* SPDIF for stream index #1 */
3200         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3201                 snprintf(spec->stream_name_digital,
3202                          sizeof(spec->stream_name_digital),
3203                          "%s Digital", codec->chip_name);
3204                 codec->num_pcms = 2;
3205                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3206                 info = spec->pcm_rec + 1;
3207                 info->name = spec->stream_name_digital;
3208                 if (spec->dig_out_type)
3209                         info->pcm_type = spec->dig_out_type;
3210                 else
3211                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3212                 if (spec->multiout.dig_out_nid &&
3213                     spec->stream_digital_playback) {
3214                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3215                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3216                 }
3217                 if (spec->dig_in_nid &&
3218                     spec->stream_digital_capture) {
3219                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3220                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3221                 }
3222                 /* FIXME: do we need this for all Realtek codec models? */
3223                 codec->spdif_status_reset = 1;
3224         }
3225
3226         if (spec->no_analog)
3227                 return 0;
3228
3229         /* If the use of more than one ADC is requested for the current
3230          * model, configure a second analog capture-only PCM.
3231          */
3232         /* Additional Analaog capture for index #2 */
3233         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3234             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3235                 codec->num_pcms = 3;
3236                 info = spec->pcm_rec + 2;
3237                 info->name = spec->stream_name_analog;
3238                 if (spec->alt_dac_nid) {
3239                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3240                                 *spec->stream_analog_alt_playback;
3241                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3242                                 spec->alt_dac_nid;
3243                 } else {
3244                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3245                                 alc_pcm_null_stream;
3246                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3247                 }
3248                 if (spec->num_adc_nids > 1) {
3249                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3250                                 *spec->stream_analog_alt_capture;
3251                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3252                                 spec->adc_nids[1];
3253                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3254                                 spec->num_adc_nids - 1;
3255                 } else {
3256                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3257                                 alc_pcm_null_stream;
3258                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3259                 }
3260         }
3261
3262         return 0;
3263 }
3264
3265 static void alc_free_kctls(struct hda_codec *codec)
3266 {
3267         struct alc_spec *spec = codec->spec;
3268
3269         if (spec->kctls.list) {
3270                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3271                 int i;
3272                 for (i = 0; i < spec->kctls.used; i++)
3273                         kfree(kctl[i].name);
3274         }
3275         snd_array_free(&spec->kctls);
3276 }
3277
3278 static void alc_free(struct hda_codec *codec)
3279 {
3280         struct alc_spec *spec = codec->spec;
3281
3282         if (!spec)
3283                 return;
3284
3285         alc_free_kctls(codec);
3286         kfree(spec);
3287         snd_hda_detach_beep_device(codec);
3288 }
3289
3290 #ifdef SND_HDA_NEEDS_RESUME
3291 static int alc_resume(struct hda_codec *codec)
3292 {
3293         codec->patch_ops.init(codec);
3294         snd_hda_codec_resume_amp(codec);
3295         snd_hda_codec_resume_cache(codec);
3296         return 0;
3297 }
3298 #endif
3299
3300 /*
3301  */
3302 static struct hda_codec_ops alc_patch_ops = {
3303         .build_controls = alc_build_controls,
3304         .build_pcms = alc_build_pcms,
3305         .init = alc_init,
3306         .free = alc_free,
3307         .unsol_event = alc_unsol_event,
3308 #ifdef SND_HDA_NEEDS_RESUME
3309         .resume = alc_resume,
3310 #endif
3311 #ifdef CONFIG_SND_HDA_POWER_SAVE
3312         .check_power_status = alc_check_power_status,
3313 #endif
3314 };
3315
3316
3317 /*
3318  * Test configuration for debugging
3319  *
3320  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3321  * enum controls.
3322  */
3323 #ifdef CONFIG_SND_DEBUG
3324 static hda_nid_t alc880_test_dac_nids[4] = {
3325         0x02, 0x03, 0x04, 0x05
3326 };
3327
3328 static struct hda_input_mux alc880_test_capture_source = {
3329         .num_items = 7,
3330         .items = {
3331                 { "In-1", 0x0 },
3332                 { "In-2", 0x1 },
3333                 { "In-3", 0x2 },
3334                 { "In-4", 0x3 },
3335                 { "CD", 0x4 },
3336                 { "Front", 0x5 },
3337                 { "Surround", 0x6 },
3338         },
3339 };
3340
3341 static struct hda_channel_mode alc880_test_modes[4] = {
3342         { 2, NULL },
3343         { 4, NULL },
3344         { 6, NULL },
3345         { 8, NULL },
3346 };
3347
3348 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3349                                  struct snd_ctl_elem_info *uinfo)
3350 {
3351         static char *texts[] = {
3352                 "N/A", "Line Out", "HP Out",
3353                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3354         };
3355         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3356         uinfo->count = 1;
3357         uinfo->value.enumerated.items = 8;
3358         if (uinfo->value.enumerated.item >= 8)
3359                 uinfo->value.enumerated.item = 7;
3360         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3361         return 0;
3362 }
3363
3364 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3365                                 struct snd_ctl_elem_value *ucontrol)
3366 {
3367         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3368         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3369         unsigned int pin_ctl, item = 0;
3370
3371         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3372                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3373         if (pin_ctl & AC_PINCTL_OUT_EN) {
3374                 if (pin_ctl & AC_PINCTL_HP_EN)
3375                         item = 2;
3376                 else
3377                         item = 1;
3378         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3379                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3380                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3381                 case AC_PINCTL_VREF_50:  item = 4; break;
3382                 case AC_PINCTL_VREF_GRD: item = 5; break;
3383                 case AC_PINCTL_VREF_80:  item = 6; break;
3384                 case AC_PINCTL_VREF_100: item = 7; break;
3385                 }
3386         }
3387         ucontrol->value.enumerated.item[0] = item;
3388         return 0;
3389 }
3390
3391 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3392                                 struct snd_ctl_elem_value *ucontrol)
3393 {
3394         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3395         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3396         static unsigned int ctls[] = {
3397                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3398                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3399                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3400                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3401                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3402                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3403         };
3404         unsigned int old_ctl, new_ctl;
3405
3406         old_ctl = snd_hda_codec_read(codec, nid, 0,
3407                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3408         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3409         if (old_ctl != new_ctl) {
3410                 int val;
3411                 snd_hda_codec_write_cache(codec, nid, 0,
3412                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3413                                           new_ctl);
3414                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3415                         HDA_AMP_MUTE : 0;
3416                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3417                                          HDA_AMP_MUTE, val);
3418                 return 1;
3419         }
3420         return 0;
3421 }
3422
3423 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3424                                  struct snd_ctl_elem_info *uinfo)
3425 {
3426         static char *texts[] = {
3427                 "Front", "Surround", "CLFE", "Side"
3428         };
3429         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3430         uinfo->count = 1;
3431         uinfo->value.enumerated.items = 4;
3432         if (uinfo->value.enumerated.item >= 4)
3433                 uinfo->value.enumerated.item = 3;
3434         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3435         return 0;
3436 }
3437
3438 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3439                                 struct snd_ctl_elem_value *ucontrol)
3440 {
3441         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3442         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3443         unsigned int sel;
3444
3445         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3446         ucontrol->value.enumerated.item[0] = sel & 3;
3447         return 0;
3448 }
3449
3450 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3451                                 struct snd_ctl_elem_value *ucontrol)
3452 {
3453         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3454         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3455         unsigned int sel;
3456
3457         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3458         if (ucontrol->value.enumerated.item[0] != sel) {
3459                 sel = ucontrol->value.enumerated.item[0] & 3;
3460                 snd_hda_codec_write_cache(codec, nid, 0,
3461                                           AC_VERB_SET_CONNECT_SEL, sel);
3462                 return 1;
3463         }
3464         return 0;
3465 }
3466
3467 #define PIN_CTL_TEST(xname,nid) {                       \
3468                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3469                         .name = xname,                 \
3470                         .info = alc_test_pin_ctl_info, \
3471                         .get = alc_test_pin_ctl_get,   \
3472                         .put = alc_test_pin_ctl_put,   \
3473                         .private_value = nid           \
3474                         }
3475
3476 #define PIN_SRC_TEST(xname,nid) {                       \
3477                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3478                         .name = xname,                 \
3479                         .info = alc_test_pin_src_info, \
3480                         .get = alc_test_pin_src_get,   \
3481                         .put = alc_test_pin_src_put,   \
3482                         .private_value = nid           \
3483                         }
3484
3485 static struct snd_kcontrol_new alc880_test_mixer[] = {
3486         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3487         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3488         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3489         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3490         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3491         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3492         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3493         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3494         PIN_CTL_TEST("Front Pin Mode", 0x14),
3495         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3496         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3497         PIN_CTL_TEST("Side Pin Mode", 0x17),
3498         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3499         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3500         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3501         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3502         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3503         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3504         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3505         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3506         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3507         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3508         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3509         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3510         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3511         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3512         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3513         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3514         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3515         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3516         {
3517                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3518                 .name = "Channel Mode",
3519                 .info = alc_ch_mode_info,
3520                 .get = alc_ch_mode_get,
3521                 .put = alc_ch_mode_put,
3522         },
3523         { } /* end */
3524 };
3525
3526 static struct hda_verb alc880_test_init_verbs[] = {
3527         /* Unmute inputs of 0x0c - 0x0f */
3528         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3529         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3530         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3531         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3532         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3533         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3534         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3535         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3536         /* Vol output for 0x0c-0x0f */
3537         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3538         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3539         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3540         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3541         /* Set output pins 0x14-0x17 */
3542         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3543         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3544         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3545         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3546         /* Unmute output pins 0x14-0x17 */
3547         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3548         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3549         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3550         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3551         /* Set input pins 0x18-0x1c */
3552         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3553         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3554         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3555         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3556         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3557         /* Mute input pins 0x18-0x1b */
3558         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3559         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3560         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3561         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3562         /* ADC set up */
3563         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3564         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3565         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3566         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3567         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3568         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3569         /* Analog input/passthru */
3570         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3571         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3572         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3573         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3574         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3575         { }
3576 };
3577 #endif
3578
3579 /*
3580  */
3581
3582 static const char *alc880_models[ALC880_MODEL_LAST] = {
3583         [ALC880_3ST]            = "3stack",
3584         [ALC880_TCL_S700]       = "tcl",
3585         [ALC880_3ST_DIG]        = "3stack-digout",
3586         [ALC880_CLEVO]          = "clevo",
3587         [ALC880_5ST]            = "5stack",
3588         [ALC880_5ST_DIG]        = "5stack-digout",
3589         [ALC880_W810]           = "w810",
3590         [ALC880_Z71V]           = "z71v",
3591         [ALC880_6ST]            = "6stack",
3592         [ALC880_6ST_DIG]        = "6stack-digout",
3593         [ALC880_ASUS]           = "asus",
3594         [ALC880_ASUS_W1V]       = "asus-w1v",
3595         [ALC880_ASUS_DIG]       = "asus-dig",
3596         [ALC880_ASUS_DIG2]      = "asus-dig2",
3597         [ALC880_UNIWILL_DIG]    = "uniwill",
3598         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3599         [ALC880_FUJITSU]        = "fujitsu",
3600         [ALC880_F1734]          = "F1734",
3601         [ALC880_LG]             = "lg",
3602         [ALC880_LG_LW]          = "lg-lw",
3603         [ALC880_MEDION_RIM]     = "medion",
3604 #ifdef CONFIG_SND_DEBUG
3605         [ALC880_TEST]           = "test",
3606 #endif
3607         [ALC880_AUTO]           = "auto",
3608 };
3609
3610 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3611         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3612         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3613         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3614         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3615         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3616         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3617         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3618         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3619         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3620         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3621         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3622         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3623         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3624         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3625         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3626         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3627         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3628         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3629         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3630         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3631         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3632         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3633         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3634         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3635         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3636         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
3637         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3638         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3639         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3640         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3641         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3642         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3643         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3644         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3645         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3646         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3647         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3648         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3649         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3650         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3651         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3652         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3653         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3654         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3655         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3656         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3657         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3658         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3659         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3660         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3661         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3662         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3663         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3664         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3665         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3666         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3667         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3668         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3669         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3670         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3671         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3672         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3673         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3674         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3675         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3676         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3677         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3678         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3679         /* default Intel */
3680         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
3681         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3682         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3683         {}
3684 };
3685
3686 /*
3687  * ALC880 codec presets
3688  */
3689 static struct alc_config_preset alc880_presets[] = {
3690         [ALC880_3ST] = {
3691                 .mixers = { alc880_three_stack_mixer },
3692                 .init_verbs = { alc880_volume_init_verbs,
3693                                 alc880_pin_3stack_init_verbs },
3694                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3695                 .dac_nids = alc880_dac_nids,
3696                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3697                 .channel_mode = alc880_threestack_modes,
3698                 .need_dac_fix = 1,
3699                 .input_mux = &alc880_capture_source,
3700         },
3701         [ALC880_3ST_DIG] = {
3702                 .mixers = { alc880_three_stack_mixer },
3703                 .init_verbs = { alc880_volume_init_verbs,
3704                                 alc880_pin_3stack_init_verbs },
3705                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3706                 .dac_nids = alc880_dac_nids,
3707                 .dig_out_nid = ALC880_DIGOUT_NID,
3708                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3709                 .channel_mode = alc880_threestack_modes,
3710                 .need_dac_fix = 1,
3711                 .input_mux = &alc880_capture_source,
3712         },
3713         [ALC880_TCL_S700] = {
3714                 .mixers = { alc880_tcl_s700_mixer },
3715                 .init_verbs = { alc880_volume_init_verbs,
3716                                 alc880_pin_tcl_S700_init_verbs,
3717                                 alc880_gpio2_init_verbs },
3718                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3719                 .dac_nids = alc880_dac_nids,
3720                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
3721                 .num_adc_nids = 1, /* single ADC */
3722                 .hp_nid = 0x03,
3723                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3724                 .channel_mode = alc880_2_jack_modes,
3725                 .input_mux = &alc880_capture_source,
3726         },
3727         [ALC880_5ST] = {
3728                 .mixers = { alc880_three_stack_mixer,
3729                             alc880_five_stack_mixer},
3730                 .init_verbs = { alc880_volume_init_verbs,
3731                                 alc880_pin_5stack_init_verbs },
3732                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3733                 .dac_nids = alc880_dac_nids,
3734                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3735                 .channel_mode = alc880_fivestack_modes,
3736                 .input_mux = &alc880_capture_source,
3737         },
3738         [ALC880_5ST_DIG] = {
3739                 .mixers = { alc880_three_stack_mixer,
3740                             alc880_five_stack_mixer },
3741                 .init_verbs = { alc880_volume_init_verbs,
3742                                 alc880_pin_5stack_init_verbs },
3743                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3744                 .dac_nids = alc880_dac_nids,
3745                 .dig_out_nid = ALC880_DIGOUT_NID,
3746                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3747                 .channel_mode = alc880_fivestack_modes,
3748                 .input_mux = &alc880_capture_source,
3749         },
3750         [ALC880_6ST] = {
3751                 .mixers = { alc880_six_stack_mixer },
3752                 .init_verbs = { alc880_volume_init_verbs,
3753                                 alc880_pin_6stack_init_verbs },
3754                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3755                 .dac_nids = alc880_6st_dac_nids,
3756                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3757                 .channel_mode = alc880_sixstack_modes,
3758                 .input_mux = &alc880_6stack_capture_source,
3759         },
3760         [ALC880_6ST_DIG] = {
3761                 .mixers = { alc880_six_stack_mixer },
3762                 .init_verbs = { alc880_volume_init_verbs,
3763                                 alc880_pin_6stack_init_verbs },
3764                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3765                 .dac_nids = alc880_6st_dac_nids,
3766                 .dig_out_nid = ALC880_DIGOUT_NID,
3767                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3768                 .channel_mode = alc880_sixstack_modes,
3769                 .input_mux = &alc880_6stack_capture_source,
3770         },
3771         [ALC880_W810] = {
3772                 .mixers = { alc880_w810_base_mixer },
3773                 .init_verbs = { alc880_volume_init_verbs,
3774                                 alc880_pin_w810_init_verbs,
3775                                 alc880_gpio2_init_verbs },
3776                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3777                 .dac_nids = alc880_w810_dac_nids,
3778                 .dig_out_nid = ALC880_DIGOUT_NID,
3779                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3780                 .channel_mode = alc880_w810_modes,
3781                 .input_mux = &alc880_capture_source,
3782         },
3783         [ALC880_Z71V] = {
3784                 .mixers = { alc880_z71v_mixer },
3785                 .init_verbs = { alc880_volume_init_verbs,
3786                                 alc880_pin_z71v_init_verbs },
3787                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3788                 .dac_nids = alc880_z71v_dac_nids,
3789                 .dig_out_nid = ALC880_DIGOUT_NID,
3790                 .hp_nid = 0x03,
3791                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3792                 .channel_mode = alc880_2_jack_modes,
3793                 .input_mux = &alc880_capture_source,
3794         },
3795         [ALC880_F1734] = {
3796                 .mixers = { alc880_f1734_mixer },
3797                 .init_verbs = { alc880_volume_init_verbs,
3798                                 alc880_pin_f1734_init_verbs },
3799                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3800                 .dac_nids = alc880_f1734_dac_nids,
3801                 .hp_nid = 0x02,
3802                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3803                 .channel_mode = alc880_2_jack_modes,
3804                 .input_mux = &alc880_f1734_capture_source,
3805                 .unsol_event = alc880_uniwill_p53_unsol_event,
3806                 .init_hook = alc880_uniwill_p53_init_hook,
3807         },
3808         [ALC880_ASUS] = {
3809                 .mixers = { alc880_asus_mixer },
3810                 .init_verbs = { alc880_volume_init_verbs,
3811                                 alc880_pin_asus_init_verbs,
3812                                 alc880_gpio1_init_verbs },
3813                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3814                 .dac_nids = alc880_asus_dac_nids,
3815                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3816                 .channel_mode = alc880_asus_modes,
3817                 .need_dac_fix = 1,
3818                 .input_mux = &alc880_capture_source,
3819         },
3820         [ALC880_ASUS_DIG] = {
3821                 .mixers = { alc880_asus_mixer },
3822                 .init_verbs = { alc880_volume_init_verbs,
3823                                 alc880_pin_asus_init_verbs,
3824                                 alc880_gpio1_init_verbs },
3825                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3826                 .dac_nids = alc880_asus_dac_nids,
3827                 .dig_out_nid = ALC880_DIGOUT_NID,
3828                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3829                 .channel_mode = alc880_asus_modes,
3830                 .need_dac_fix = 1,
3831                 .input_mux = &alc880_capture_source,
3832         },
3833         [ALC880_ASUS_DIG2] = {
3834                 .mixers = { alc880_asus_mixer },
3835                 .init_verbs = { alc880_volume_init_verbs,
3836                                 alc880_pin_asus_init_verbs,
3837                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
3838                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3839                 .dac_nids = alc880_asus_dac_nids,
3840                 .dig_out_nid = ALC880_DIGOUT_NID,
3841                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3842                 .channel_mode = alc880_asus_modes,
3843                 .need_dac_fix = 1,
3844                 .input_mux = &alc880_capture_source,
3845         },
3846         [ALC880_ASUS_W1V] = {
3847                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3848                 .init_verbs = { alc880_volume_init_verbs,
3849                                 alc880_pin_asus_init_verbs,
3850                                 alc880_gpio1_init_verbs },
3851                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3852                 .dac_nids = alc880_asus_dac_nids,
3853                 .dig_out_nid = ALC880_DIGOUT_NID,
3854                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3855                 .channel_mode = alc880_asus_modes,
3856                 .need_dac_fix = 1,
3857                 .input_mux = &alc880_capture_source,
3858         },
3859         [ALC880_UNIWILL_DIG] = {
3860                 .mixers = { alc880_asus_mixer },
3861                 .init_verbs = { alc880_volume_init_verbs,
3862                                 alc880_pin_asus_init_verbs },
3863                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3864                 .dac_nids = alc880_asus_dac_nids,
3865                 .dig_out_nid = ALC880_DIGOUT_NID,
3866                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3867                 .channel_mode = alc880_asus_modes,
3868                 .need_dac_fix = 1,
3869                 .input_mux = &alc880_capture_source,
3870         },
3871         [ALC880_UNIWILL] = {
3872                 .mixers = { alc880_uniwill_mixer },
3873                 .init_verbs = { alc880_volume_init_verbs,
3874                                 alc880_uniwill_init_verbs },
3875                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3876                 .dac_nids = alc880_asus_dac_nids,
3877                 .dig_out_nid = ALC880_DIGOUT_NID,
3878                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3879                 .channel_mode = alc880_threestack_modes,
3880                 .need_dac_fix = 1,
3881                 .input_mux = &alc880_capture_source,
3882                 .unsol_event = alc880_uniwill_unsol_event,
3883                 .init_hook = alc880_uniwill_init_hook,
3884         },
3885         [ALC880_UNIWILL_P53] = {
3886                 .mixers = { alc880_uniwill_p53_mixer },
3887                 .init_verbs = { alc880_volume_init_verbs,
3888                                 alc880_uniwill_p53_init_verbs },
3889                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3890                 .dac_nids = alc880_asus_dac_nids,
3891                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3892                 .channel_mode = alc880_threestack_modes,
3893                 .input_mux = &alc880_capture_source,
3894                 .unsol_event = alc880_uniwill_p53_unsol_event,
3895                 .init_hook = alc880_uniwill_p53_init_hook,
3896         },
3897         [ALC880_FUJITSU] = {
3898                 .mixers = { alc880_fujitsu_mixer },
3899                 .init_verbs = { alc880_volume_init_verbs,
3900                                 alc880_uniwill_p53_init_verbs,
3901                                 alc880_beep_init_verbs },
3902                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3903                 .dac_nids = alc880_dac_nids,
3904                 .dig_out_nid = ALC880_DIGOUT_NID,
3905                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3906                 .channel_mode = alc880_2_jack_modes,
3907                 .input_mux = &alc880_capture_source,
3908                 .unsol_event = alc880_uniwill_p53_unsol_event,
3909                 .init_hook = alc880_uniwill_p53_init_hook,
3910         },
3911         [ALC880_CLEVO] = {
3912                 .mixers = { alc880_three_stack_mixer },
3913                 .init_verbs = { alc880_volume_init_verbs,
3914                                 alc880_pin_clevo_init_verbs },
3915                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3916                 .dac_nids = alc880_dac_nids,
3917                 .hp_nid = 0x03,
3918                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3919                 .channel_mode = alc880_threestack_modes,
3920                 .need_dac_fix = 1,
3921                 .input_mux = &alc880_capture_source,
3922         },
3923         [ALC880_LG] = {
3924                 .mixers = { alc880_lg_mixer },
3925                 .init_verbs = { alc880_volume_init_verbs,
3926                                 alc880_lg_init_verbs },
3927                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3928                 .dac_nids = alc880_lg_dac_nids,
3929                 .dig_out_nid = ALC880_DIGOUT_NID,
3930                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3931                 .channel_mode = alc880_lg_ch_modes,
3932                 .need_dac_fix = 1,
3933                 .input_mux = &alc880_lg_capture_source,
3934                 .unsol_event = alc_automute_amp_unsol_event,
3935                 .init_hook = alc880_lg_init_hook,
3936 #ifdef CONFIG_SND_HDA_POWER_SAVE
3937                 .loopbacks = alc880_lg_loopbacks,
3938 #endif
3939         },
3940         [ALC880_LG_LW] = {
3941                 .mixers = { alc880_lg_lw_mixer },
3942                 .init_verbs = { alc880_volume_init_verbs,
3943                                 alc880_lg_lw_init_verbs },
3944                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3945                 .dac_nids = alc880_dac_nids,
3946                 .dig_out_nid = ALC880_DIGOUT_NID,
3947                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3948                 .channel_mode = alc880_lg_lw_modes,
3949                 .input_mux = &alc880_lg_lw_capture_source,
3950                 .unsol_event = alc_automute_amp_unsol_event,
3951                 .init_hook = alc880_lg_lw_init_hook,
3952         },
3953         [ALC880_MEDION_RIM] = {
3954                 .mixers = { alc880_medion_rim_mixer },
3955                 .init_verbs = { alc880_volume_init_verbs,
3956                                 alc880_medion_rim_init_verbs,
3957                                 alc_gpio2_init_verbs },
3958                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3959                 .dac_nids = alc880_dac_nids,
3960                 .dig_out_nid = ALC880_DIGOUT_NID,
3961                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3962                 .channel_mode = alc880_2_jack_modes,
3963                 .input_mux = &alc880_medion_rim_capture_source,
3964                 .unsol_event = alc880_medion_rim_unsol_event,
3965                 .init_hook = alc880_medion_rim_init_hook,
3966         },
3967 #ifdef CONFIG_SND_DEBUG
3968         [ALC880_TEST] = {
3969                 .mixers = { alc880_test_mixer },
3970                 .init_verbs = { alc880_test_init_verbs },
3971                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3972                 .dac_nids = alc880_test_dac_nids,
3973                 .dig_out_nid = ALC880_DIGOUT_NID,
3974                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3975                 .channel_mode = alc880_test_modes,
3976                 .input_mux = &alc880_test_capture_source,
3977         },
3978 #endif
3979 };
3980
3981 /*
3982  * Automatic parse of I/O pins from the BIOS configuration
3983  */
3984
3985 enum {
3986         ALC_CTL_WIDGET_VOL,
3987         ALC_CTL_WIDGET_MUTE,
3988         ALC_CTL_BIND_MUTE,
3989 };
3990 static struct snd_kcontrol_new alc880_control_templates[] = {
3991         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3992         HDA_CODEC_MUTE(NULL, 0, 0, 0),
3993         HDA_BIND_MUTE(NULL, 0, 0, 0),
3994 };
3995
3996 /* add dynamic controls */
3997 static int add_control(struct alc_spec *spec, int type, const char *name,
3998                        unsigned long val)
3999 {
4000         struct snd_kcontrol_new *knew;
4001
4002         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4003         knew = snd_array_new(&spec->kctls);
4004         if (!knew)
4005                 return -ENOMEM;
4006         *knew = alc880_control_templates[type];
4007         knew->name = kstrdup(name, GFP_KERNEL);
4008         if (!knew->name)
4009                 return -ENOMEM;
4010         knew->private_value = val;
4011         return 0;
4012 }
4013
4014 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4015 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4016 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4017 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4018 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
4019 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
4020 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4021 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4022 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4023 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4024 #define ALC880_PIN_CD_NID               0x1c
4025
4026 /* fill in the dac_nids table from the parsed pin configuration */
4027 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4028                                      const struct auto_pin_cfg *cfg)
4029 {
4030         hda_nid_t nid;
4031         int assigned[4];
4032         int i, j;
4033
4034         memset(assigned, 0, sizeof(assigned));
4035         spec->multiout.dac_nids = spec->private_dac_nids;
4036
4037         /* check the pins hardwired to audio widget */
4038         for (i = 0; i < cfg->line_outs; i++) {
4039                 nid = cfg->line_out_pins[i];
4040                 if (alc880_is_fixed_pin(nid)) {
4041                         int idx = alc880_fixed_pin_idx(nid);
4042                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4043                         assigned[idx] = 1;
4044                 }
4045         }
4046         /* left pins can be connect to any audio widget */
4047         for (i = 0; i < cfg->line_outs; i++) {
4048                 nid = cfg->line_out_pins[i];
4049                 if (alc880_is_fixed_pin(nid))
4050                         continue;
4051                 /* search for an empty channel */
4052                 for (j = 0; j < cfg->line_outs; j++) {
4053                         if (!assigned[j]) {
4054                                 spec->multiout.dac_nids[i] =
4055                                         alc880_idx_to_dac(j);
4056                                 assigned[j] = 1;
4057                                 break;
4058                         }
4059                 }
4060         }
4061         spec->multiout.num_dacs = cfg->line_outs;
4062         return 0;
4063 }
4064
4065 /* add playback controls from the parsed DAC table */
4066 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4067                                              const struct auto_pin_cfg *cfg)
4068 {
4069         char name[32];
4070         static const char *chname[4] = {
4071                 "Front", "Surround", NULL /*CLFE*/, "Side"
4072         };
4073         hda_nid_t nid;
4074         int i, err;
4075
4076         for (i = 0; i < cfg->line_outs; i++) {
4077                 if (!spec->multiout.dac_nids[i])
4078                         continue;
4079                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4080                 if (i == 2) {
4081                         /* Center/LFE */
4082                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4083                                           "Center Playback Volume",
4084                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4085                                                               HDA_OUTPUT));
4086                         if (err < 0)
4087                                 return err;
4088                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4089                                           "LFE Playback Volume",
4090                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4091                                                               HDA_OUTPUT));
4092                         if (err < 0)
4093                                 return err;
4094                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4095                                           "Center Playback Switch",
4096                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4097                                                               HDA_INPUT));
4098                         if (err < 0)
4099                                 return err;
4100                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4101                                           "LFE Playback Switch",
4102                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4103                                                               HDA_INPUT));
4104                         if (err < 0)
4105                                 return err;
4106                 } else {
4107                         sprintf(name, "%s Playback Volume", chname[i]);
4108                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4109                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4110                                                               HDA_OUTPUT));
4111                         if (err < 0)
4112                                 return err;
4113                         sprintf(name, "%s Playback Switch", chname[i]);
4114                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4115                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4116                                                               HDA_INPUT));
4117                         if (err < 0)
4118                                 return err;
4119                 }
4120         }
4121         return 0;
4122 }
4123
4124 /* add playback controls for speaker and HP outputs */
4125 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4126                                         const char *pfx)
4127 {
4128         hda_nid_t nid;
4129         int err;
4130         char name[32];
4131
4132         if (!pin)
4133                 return 0;
4134
4135         if (alc880_is_fixed_pin(pin)) {
4136                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4137                 /* specify the DAC as the extra output */
4138                 if (!spec->multiout.hp_nid)
4139                         spec->multiout.hp_nid = nid;
4140                 else
4141                         spec->multiout.extra_out_nid[0] = nid;
4142                 /* control HP volume/switch on the output mixer amp */
4143                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4144                 sprintf(name, "%s Playback Volume", pfx);
4145                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4146                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4147                 if (err < 0)
4148                         return err;
4149                 sprintf(name, "%s Playback Switch", pfx);
4150                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4151                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4152                 if (err < 0)
4153                         return err;
4154         } else if (alc880_is_multi_pin(pin)) {
4155                 /* set manual connection */
4156                 /* we have only a switch on HP-out PIN */
4157                 sprintf(name, "%s Playback Switch", pfx);
4158                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4159                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4160                 if (err < 0)
4161                         return err;
4162         }
4163         return 0;
4164 }
4165
4166 /* create input playback/capture controls for the given pin */
4167 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4168                             const char *ctlname,
4169                             int idx, hda_nid_t mix_nid)
4170 {
4171         char name[32];
4172         int err;
4173
4174         sprintf(name, "%s Playback Volume", ctlname);
4175         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4176                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4177         if (err < 0)
4178                 return err;
4179         sprintf(name, "%s Playback Switch", ctlname);
4180         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4181                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4182         if (err < 0)
4183                 return err;
4184         return 0;
4185 }
4186
4187 /* create playback/capture controls for input pins */
4188 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
4189                                                 const struct auto_pin_cfg *cfg)
4190 {
4191         struct hda_input_mux *imux = &spec->private_imux[0];
4192         int i, err, idx;
4193
4194         for (i = 0; i < AUTO_PIN_LAST; i++) {
4195                 if (alc880_is_input_pin(cfg->input_pins[i])) {
4196                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
4197                         err = new_analog_input(spec, cfg->input_pins[i],
4198                                                auto_pin_cfg_labels[i],
4199                                                idx, 0x0b);
4200                         if (err < 0)
4201                                 return err;
4202                         imux->items[imux->num_items].label =
4203                                 auto_pin_cfg_labels[i];
4204                         imux->items[imux->num_items].index =
4205                                 alc880_input_pin_idx(cfg->input_pins[i]);
4206                         imux->num_items++;
4207                 }
4208         }
4209         return 0;
4210 }
4211
4212 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4213                                unsigned int pin_type)
4214 {
4215         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4216                             pin_type);
4217         /* unmute pin */
4218         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4219                             AMP_OUT_UNMUTE);
4220 }
4221
4222 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4223                                               hda_nid_t nid, int pin_type,
4224                                               int dac_idx)
4225 {
4226         alc_set_pin_output(codec, nid, pin_type);
4227         /* need the manual connection? */
4228         if (alc880_is_multi_pin(nid)) {
4229                 struct alc_spec *spec = codec->spec;
4230                 int idx = alc880_multi_pin_idx(nid);
4231                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4232                                     AC_VERB_SET_CONNECT_SEL,
4233                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4234         }
4235 }
4236
4237 static int get_pin_type(int line_out_type)
4238 {
4239         if (line_out_type == AUTO_PIN_HP_OUT)
4240                 return PIN_HP;
4241         else
4242                 return PIN_OUT;
4243 }
4244
4245 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4246 {
4247         struct alc_spec *spec = codec->spec;
4248         int i;
4249
4250         for (i = 0; i < spec->autocfg.line_outs; i++) {
4251                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4252                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4253                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4254         }
4255 }
4256
4257 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4258 {
4259         struct alc_spec *spec = codec->spec;
4260         hda_nid_t pin;
4261
4262         pin = spec->autocfg.speaker_pins[0];
4263         if (pin) /* connect to front */
4264                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4265         pin = spec->autocfg.hp_pins[0];
4266         if (pin) /* connect to front */
4267                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4268 }
4269
4270 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4271 {
4272         struct alc_spec *spec = codec->spec;
4273         int i;
4274
4275         for (i = 0; i < AUTO_PIN_LAST; i++) {
4276                 hda_nid_t nid = spec->autocfg.input_pins[i];
4277                 if (alc880_is_input_pin(nid)) {
4278                         alc_set_input_pin(codec, nid, i);
4279                         if (nid != ALC880_PIN_CD_NID &&
4280                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4281                                 snd_hda_codec_write(codec, nid, 0,
4282                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4283                                                     AMP_OUT_MUTE);
4284                 }
4285         }
4286 }
4287
4288 /* parse the BIOS configuration and set up the alc_spec */
4289 /* return 1 if successful, 0 if the proper config is not found,
4290  * or a negative error code
4291  */
4292 static int alc880_parse_auto_config(struct hda_codec *codec)
4293 {
4294         struct alc_spec *spec = codec->spec;
4295         int i, err;
4296         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4297
4298         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4299                                            alc880_ignore);
4300         if (err < 0)
4301                 return err;
4302         if (!spec->autocfg.line_outs)
4303                 return 0; /* can't find valid BIOS pin config */
4304
4305         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4306         if (err < 0)
4307                 return err;
4308         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4309         if (err < 0)
4310                 return err;
4311         err = alc880_auto_create_extra_out(spec,
4312                                            spec->autocfg.speaker_pins[0],
4313                                            "Speaker");
4314         if (err < 0)
4315                 return err;
4316         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4317                                            "Headphone");
4318         if (err < 0)
4319                 return err;
4320         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
4321         if (err < 0)
4322                 return err;
4323
4324         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4325
4326         /* check multiple SPDIF-out (for recent codecs) */
4327         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4328                 hda_nid_t dig_nid;
4329                 err = snd_hda_get_connections(codec,
4330                                               spec->autocfg.dig_out_pins[i],
4331                                               &dig_nid, 1);
4332                 if (err < 0)
4333                         continue;
4334                 if (!i)
4335                         spec->multiout.dig_out_nid = dig_nid;
4336                 else {
4337                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4338                         spec->slave_dig_outs[i - 1] = dig_nid;
4339                         if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
4340                                 break;
4341                 }
4342         }
4343         if (spec->autocfg.dig_in_pin)
4344                 spec->dig_in_nid = ALC880_DIGIN_NID;
4345
4346         if (spec->kctls.list)
4347                 add_mixer(spec, spec->kctls.list);
4348
4349         add_verb(spec, alc880_volume_init_verbs);
4350
4351         spec->num_mux_defs = 1;
4352         spec->input_mux = &spec->private_imux[0];
4353
4354         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
4355
4356         return 1;
4357 }
4358
4359 /* additional initialization for auto-configuration model */
4360 static void alc880_auto_init(struct hda_codec *codec)
4361 {
4362         struct alc_spec *spec = codec->spec;
4363         alc880_auto_init_multi_out(codec);
4364         alc880_auto_init_extra_out(codec);
4365         alc880_auto_init_analog_input(codec);
4366         if (spec->unsol_event)
4367                 alc_inithook(codec);
4368 }
4369
4370 static void set_capture_mixer(struct alc_spec *spec)
4371 {
4372         static struct snd_kcontrol_new *caps[2][3] = {
4373                 { alc_capture_mixer_nosrc1,
4374                   alc_capture_mixer_nosrc2,
4375                   alc_capture_mixer_nosrc3 },
4376                 { alc_capture_mixer1,
4377                   alc_capture_mixer2,
4378                   alc_capture_mixer3 },
4379         };
4380         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4381                 int mux;
4382                 if (spec->input_mux && spec->input_mux->num_items > 1)
4383                         mux = 1;
4384                 else
4385                         mux = 0;
4386                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4387         }
4388 }
4389
4390 #define set_beep_amp(spec, nid, idx, dir) \
4391         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4392
4393 /*
4394  * OK, here we have finally the patch for ALC880
4395  */
4396
4397 static int patch_alc880(struct hda_codec *codec)
4398 {
4399         struct alc_spec *spec;
4400         int board_config;
4401         int err;
4402
4403         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4404         if (spec == NULL)
4405                 return -ENOMEM;
4406
4407         codec->spec = spec;
4408
4409         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4410                                                   alc880_models,
4411                                                   alc880_cfg_tbl);
4412         if (board_config < 0) {
4413                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
4414                        "trying auto-probe from BIOS...\n", codec->chip_name);
4415                 board_config = ALC880_AUTO;
4416         }
4417
4418         if (board_config == ALC880_AUTO) {
4419                 /* automatic parse from the BIOS config */
4420                 err = alc880_parse_auto_config(codec);
4421                 if (err < 0) {
4422                         alc_free(codec);
4423                         return err;
4424                 } else if (!err) {
4425                         printk(KERN_INFO
4426                                "hda_codec: Cannot set up configuration "
4427                                "from BIOS.  Using 3-stack mode...\n");
4428                         board_config = ALC880_3ST;
4429                 }
4430         }
4431
4432         err = snd_hda_attach_beep_device(codec, 0x1);
4433         if (err < 0) {
4434                 alc_free(codec);
4435                 return err;
4436         }
4437
4438         if (board_config != ALC880_AUTO)
4439                 setup_preset(spec, &alc880_presets[board_config]);
4440
4441         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4442         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4443         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4444
4445         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4446         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4447
4448         if (!spec->adc_nids && spec->input_mux) {
4449                 /* check whether NID 0x07 is valid */
4450                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4451                 /* get type */
4452                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
4453                 if (wcap != AC_WID_AUD_IN) {
4454                         spec->adc_nids = alc880_adc_nids_alt;
4455                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4456                 } else {
4457                         spec->adc_nids = alc880_adc_nids;
4458                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4459                 }
4460         }
4461         set_capture_mixer(spec);
4462         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4463
4464         spec->vmaster_nid = 0x0c;
4465
4466         codec->patch_ops = alc_patch_ops;
4467         if (board_config == ALC880_AUTO)
4468                 spec->init_hook = alc880_auto_init;
4469 #ifdef CONFIG_SND_HDA_POWER_SAVE
4470         if (!spec->loopback.amplist)
4471                 spec->loopback.amplist = alc880_loopbacks;
4472 #endif
4473         codec->proc_widget_hook = print_realtek_coef;
4474
4475         return 0;
4476 }
4477
4478
4479 /*
4480  * ALC260 support
4481  */
4482
4483 static hda_nid_t alc260_dac_nids[1] = {
4484         /* front */
4485         0x02,
4486 };
4487
4488 static hda_nid_t alc260_adc_nids[1] = {
4489         /* ADC0 */
4490         0x04,
4491 };
4492
4493 static hda_nid_t alc260_adc_nids_alt[1] = {
4494         /* ADC1 */
4495         0x05,
4496 };
4497
4498 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4499  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4500  */
4501 static hda_nid_t alc260_dual_adc_nids[2] = {
4502         /* ADC0, ADC1 */
4503         0x04, 0x05
4504 };
4505
4506 #define ALC260_DIGOUT_NID       0x03
4507 #define ALC260_DIGIN_NID        0x06
4508
4509 static struct hda_input_mux alc260_capture_source = {
4510         .num_items = 4,
4511         .items = {
4512                 { "Mic", 0x0 },
4513                 { "Front Mic", 0x1 },
4514                 { "Line", 0x2 },
4515                 { "CD", 0x4 },
4516         },
4517 };
4518
4519 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4520  * headphone jack and the internal CD lines since these are the only pins at
4521  * which audio can appear.  For flexibility, also allow the option of
4522  * recording the mixer output on the second ADC (ADC0 doesn't have a
4523  * connection to the mixer output).
4524  */
4525 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4526         {
4527                 .num_items = 3,
4528                 .items = {
4529                         { "Mic/Line", 0x0 },
4530                         { "CD", 0x4 },
4531                         { "Headphone", 0x2 },
4532                 },
4533         },
4534         {
4535                 .num_items = 4,
4536                 .items = {
4537                         { "Mic/Line", 0x0 },
4538                         { "CD", 0x4 },
4539                         { "Headphone", 0x2 },
4540                         { "Mixer", 0x5 },
4541                 },
4542         },
4543
4544 };
4545
4546 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4547  * the Fujitsu S702x, but jacks are marked differently.
4548  */
4549 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4550         {
4551                 .num_items = 4,
4552                 .items = {
4553                         { "Mic", 0x0 },
4554                         { "Line", 0x2 },
4555                         { "CD", 0x4 },
4556                         { "Headphone", 0x5 },
4557                 },
4558         },
4559         {
4560                 .num_items = 5,
4561                 .items = {
4562                         { "Mic", 0x0 },
4563                         { "Line", 0x2 },
4564                         { "CD", 0x4 },
4565                         { "Headphone", 0x6 },
4566                         { "Mixer", 0x5 },
4567                 },
4568         },
4569 };
4570
4571 /* Maxdata Favorit 100XS */
4572 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
4573         {
4574                 .num_items = 2,
4575                 .items = {
4576                         { "Line/Mic", 0x0 },
4577                         { "CD", 0x4 },
4578                 },
4579         },
4580         {
4581                 .num_items = 3,
4582                 .items = {
4583                         { "Line/Mic", 0x0 },
4584                         { "CD", 0x4 },
4585                         { "Mixer", 0x5 },
4586                 },
4587         },
4588 };
4589
4590 /*
4591  * This is just place-holder, so there's something for alc_build_pcms to look
4592  * at when it calculates the maximum number of channels. ALC260 has no mixer
4593  * element which allows changing the channel mode, so the verb list is
4594  * never used.
4595  */
4596 static struct hda_channel_mode alc260_modes[1] = {
4597         { 2, NULL },
4598 };
4599
4600
4601 /* Mixer combinations
4602  *
4603  * basic: base_output + input + pc_beep + capture
4604  * HP: base_output + input + capture_alt
4605  * HP_3013: hp_3013 + input + capture
4606  * fujitsu: fujitsu + capture
4607  * acer: acer + capture
4608  */
4609
4610 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4611         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4612         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4613         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4614         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4615         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4616         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4617         { } /* end */
4618 };
4619
4620 static struct snd_kcontrol_new alc260_input_mixer[] = {
4621         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4622         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4623         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4624         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4625         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4626         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4627         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4628         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4629         { } /* end */
4630 };
4631
4632 /* update HP, line and mono out pins according to the master switch */
4633 static void alc260_hp_master_update(struct hda_codec *codec,
4634                                     hda_nid_t hp, hda_nid_t line,
4635                                     hda_nid_t mono)
4636 {
4637         struct alc_spec *spec = codec->spec;
4638         unsigned int val = spec->master_sw ? PIN_HP : 0;
4639         /* change HP and line-out pins */
4640         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4641                             val);
4642         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4643                             val);
4644         /* mono (speaker) depending on the HP jack sense */
4645         val = (val && !spec->jack_present) ? PIN_OUT : 0;
4646         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4647                             val);
4648 }
4649
4650 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4651                                    struct snd_ctl_elem_value *ucontrol)
4652 {
4653         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4654         struct alc_spec *spec = codec->spec;
4655         *ucontrol->value.integer.value = spec->master_sw;
4656         return 0;
4657 }
4658
4659 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4660                                    struct snd_ctl_elem_value *ucontrol)
4661 {
4662         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4663         struct alc_spec *spec = codec->spec;
4664         int val = !!*ucontrol->value.integer.value;
4665         hda_nid_t hp, line, mono;
4666
4667         if (val == spec->master_sw)
4668                 return 0;
4669         spec->master_sw = val;
4670         hp = (kcontrol->private_value >> 16) & 0xff;
4671         line = (kcontrol->private_value >> 8) & 0xff;
4672         mono = kcontrol->private_value & 0xff;
4673         alc260_hp_master_update(codec, hp, line, mono);
4674         return 1;
4675 }
4676
4677 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4678         {
4679                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4680                 .name = "Master Playback Switch",
4681                 .info = snd_ctl_boolean_mono_info,
4682                 .get = alc260_hp_master_sw_get,
4683                 .put = alc260_hp_master_sw_put,
4684                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4685         },
4686         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4687         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4688         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4689         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4690         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4691                               HDA_OUTPUT),
4692         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4693         { } /* end */
4694 };
4695
4696 static struct hda_verb alc260_hp_unsol_verbs[] = {
4697         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4698         {},
4699 };
4700
4701 static void alc260_hp_automute(struct hda_codec *codec)
4702 {
4703         struct alc_spec *spec = codec->spec;
4704         unsigned int present;
4705
4706         present = snd_hda_codec_read(codec, 0x10, 0,
4707                                      AC_VERB_GET_PIN_SENSE, 0);
4708         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4709         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4710 }
4711
4712 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4713 {
4714         if ((res >> 26) == ALC880_HP_EVENT)
4715                 alc260_hp_automute(codec);
4716 }
4717
4718 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4719         {
4720                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4721                 .name = "Master Playback Switch",
4722                 .info = snd_ctl_boolean_mono_info,
4723                 .get = alc260_hp_master_sw_get,
4724                 .put = alc260_hp_master_sw_put,
4725                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
4726         },
4727         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4728         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4729         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4730         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4731         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4732         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4733         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4734         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4735         { } /* end */
4736 };
4737
4738 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4739         .ops = &snd_hda_bind_vol,
4740         .values = {
4741                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4742                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4743                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4744                 0
4745         },
4746 };
4747
4748 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4749         .ops = &snd_hda_bind_sw,
4750         .values = {
4751                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4752                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4753                 0
4754         },
4755 };
4756
4757 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4758         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4759         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4760         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4761         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4762         { } /* end */
4763 };
4764
4765 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4766         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4767         {},
4768 };
4769
4770 static void alc260_hp_3013_automute(struct hda_codec *codec)
4771 {
4772         struct alc_spec *spec = codec->spec;
4773         unsigned int present;
4774
4775         present = snd_hda_codec_read(codec, 0x15, 0,
4776                                      AC_VERB_GET_PIN_SENSE, 0);
4777         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4778         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
4779 }
4780
4781 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4782                                        unsigned int res)
4783 {
4784         if ((res >> 26) == ALC880_HP_EVENT)
4785                 alc260_hp_3013_automute(codec);
4786 }
4787
4788 static void alc260_hp_3012_automute(struct hda_codec *codec)
4789 {
4790         unsigned int present, bits;
4791
4792         present = snd_hda_codec_read(codec, 0x10, 0,
4793                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4794
4795         bits = present ? 0 : PIN_OUT;
4796         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4797                             bits);
4798         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4799                             bits);
4800         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4801                             bits);
4802 }
4803
4804 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4805                                        unsigned int res)
4806 {
4807         if ((res >> 26) == ALC880_HP_EVENT)
4808                 alc260_hp_3012_automute(codec);
4809 }
4810
4811 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
4812  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
4813  */
4814 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4815         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4816         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4817         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4818         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4819         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4820         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4821         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4822         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4823         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4824         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4825         { } /* end */
4826 };
4827
4828 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
4829  * versions of the ALC260 don't act on requests to enable mic bias from NID
4830  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
4831  * datasheet doesn't mention this restriction.  At this stage it's not clear
4832  * whether this behaviour is intentional or is a hardware bug in chip
4833  * revisions available in early 2006.  Therefore for now allow the
4834  * "Headphone Jack Mode" control to span all choices, but if it turns out
4835  * that the lack of mic bias for this NID is intentional we could change the
4836  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4837  *
4838  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4839  * don't appear to make the mic bias available from the "line" jack, even
4840  * though the NID used for this jack (0x14) can supply it.  The theory is
4841  * that perhaps Acer have included blocking capacitors between the ALC260
4842  * and the output jack.  If this turns out to be the case for all such
4843  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4844  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4845  *
4846  * The C20x Tablet series have a mono internal speaker which is controlled
4847  * via the chip's Mono sum widget and pin complex, so include the necessary
4848  * controls for such models.  On models without a "mono speaker" the control
4849  * won't do anything.
4850  */
4851 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4852         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4853         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4854         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4855         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4856                               HDA_OUTPUT),
4857         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4858                            HDA_INPUT),
4859         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4860         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4861         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4862         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4863         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4864         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4865         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4866         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4867         { } /* end */
4868 };
4869
4870 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
4871  */
4872 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
4873         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4874         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4875         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4876         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4877         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4878         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4879         { } /* end */
4880 };
4881
4882 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4883  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
4884  */
4885 static struct snd_kcontrol_new alc260_will_mixer[] = {
4886         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4887         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4888         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4889         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4890         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4891         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4892         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4893         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4894         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4895         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4896         { } /* end */
4897 };
4898
4899 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4900  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4901  */
4902 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4903         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4904         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4905         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4906         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4907         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4908         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4909         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4910         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4911         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4912         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4913         { } /* end */
4914 };
4915
4916 /*
4917  * initialization verbs
4918  */
4919 static struct hda_verb alc260_init_verbs[] = {
4920         /* Line In pin widget for input */
4921         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4922         /* CD pin widget for input */
4923         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4924         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4925         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4926         /* Mic2 (front panel) pin widget for input and vref at 80% */
4927         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4928         /* LINE-2 is used for line-out in rear */
4929         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4930         /* select line-out */
4931         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4932         /* LINE-OUT pin */
4933         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4934         /* enable HP */
4935         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4936         /* enable Mono */
4937         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4938         /* mute capture amp left and right */
4939         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4940         /* set connection select to line in (default select for this ADC) */
4941         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4942         /* mute capture amp left and right */
4943         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4944         /* set connection select to line in (default select for this ADC) */
4945         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4946         /* set vol=0 Line-Out mixer amp left and right */
4947         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4948         /* unmute pin widget amp left and right (no gain on this amp) */
4949         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4950         /* set vol=0 HP mixer amp left and right */
4951         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4952         /* unmute pin widget amp left and right (no gain on this amp) */
4953         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4954         /* set vol=0 Mono mixer amp left and right */
4955         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4956         /* unmute pin widget amp left and right (no gain on this amp) */
4957         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4958         /* unmute LINE-2 out pin */
4959         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4960         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4961          * Line In 2 = 0x03
4962          */
4963         /* mute analog inputs */
4964         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4965         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4966         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4967         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4968         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4969         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4970         /* mute Front out path */
4971         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4972         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4973         /* mute Headphone out path */
4974         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4975         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4976         /* mute Mono out path */
4977         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4978         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4979         { }
4980 };
4981
4982 #if 0 /* should be identical with alc260_init_verbs? */
4983 static struct hda_verb alc260_hp_init_verbs[] = {
4984         /* Headphone and output */
4985         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4986         /* mono output */
4987         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4988         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4989         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4990         /* Mic2 (front panel) pin widget for input and vref at 80% */
4991         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4992         /* Line In pin widget for input */
4993         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4994         /* Line-2 pin widget for output */
4995         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4996         /* CD pin widget for input */
4997         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4998         /* unmute amp left and right */
4999         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5000         /* set connection select to line in (default select for this ADC) */
5001         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5002         /* unmute Line-Out mixer amp left and right (volume = 0) */
5003         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5004         /* mute pin widget amp left and right (no gain on this amp) */
5005         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5006         /* unmute HP mixer amp left and right (volume = 0) */
5007         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5008         /* mute pin widget amp left and right (no gain on this amp) */
5009         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5010         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5011          * Line In 2 = 0x03
5012          */
5013         /* mute analog inputs */
5014         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5015         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5016         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5017         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5018         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5019         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5020         /* Unmute Front out path */
5021         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5022         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5023         /* Unmute Headphone out path */
5024         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5025         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5026         /* Unmute Mono out path */
5027         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5028         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5029         { }
5030 };
5031 #endif
5032
5033 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5034         /* Line out and output */
5035         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5036         /* mono output */
5037         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5038         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5039         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5040         /* Mic2 (front panel) pin widget for input and vref at 80% */
5041         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5042         /* Line In pin widget for input */
5043         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5044         /* Headphone pin widget for output */
5045         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5046         /* CD pin widget for input */
5047         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5048         /* unmute amp left and right */
5049         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5050         /* set connection select to line in (default select for this ADC) */
5051         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5052         /* unmute Line-Out mixer amp left and right (volume = 0) */
5053         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5054         /* mute pin widget amp left and right (no gain on this amp) */
5055         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5056         /* unmute HP mixer amp left and right (volume = 0) */
5057         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5058         /* mute pin widget amp left and right (no gain on this amp) */
5059         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5060         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5061          * Line In 2 = 0x03
5062          */
5063         /* mute analog inputs */
5064         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5065         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5066         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5067         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5068         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5069         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5070         /* Unmute Front out path */
5071         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5072         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5073         /* Unmute Headphone out path */
5074         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5075         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5076         /* Unmute Mono out path */
5077         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5078         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5079         { }
5080 };
5081
5082 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5083  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5084  * audio = 0x16, internal speaker = 0x10.
5085  */
5086 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5087         /* Disable all GPIOs */
5088         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5089         /* Internal speaker is connected to headphone pin */
5090         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5091         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5092         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5093         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5094         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5095         /* Ensure all other unused pins are disabled and muted. */
5096         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5097         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5098         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5099         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5100         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5101         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5102         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5103         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5104
5105         /* Disable digital (SPDIF) pins */
5106         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5107         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5108
5109         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5110          * when acting as an output.
5111          */
5112         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5113
5114         /* Start with output sum widgets muted and their output gains at min */
5115         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5116         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5117         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5118         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5119         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5120         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5121         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5122         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5123         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5124
5125         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5126         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5127         /* Unmute Line1 pin widget output buffer since it starts as an output.
5128          * If the pin mode is changed by the user the pin mode control will
5129          * take care of enabling the pin's input/output buffers as needed.
5130          * Therefore there's no need to enable the input buffer at this
5131          * stage.
5132          */
5133         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5134         /* Unmute input buffer of pin widget used for Line-in (no equiv
5135          * mixer ctrl)
5136          */
5137         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5138
5139         /* Mute capture amp left and right */
5140         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5141         /* Set ADC connection select to match default mixer setting - line
5142          * in (on mic1 pin)
5143          */
5144         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5145
5146         /* Do the same for the second ADC: mute capture input amp and
5147          * set ADC connection to line in (on mic1 pin)
5148          */
5149         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5150         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5151
5152         /* Mute all inputs to mixer widget (even unconnected ones) */
5153         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5154         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5155         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5156         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5157         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5158         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5159         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5160         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5161
5162         { }
5163 };
5164
5165 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5166  * similar laptops (adapted from Fujitsu init verbs).
5167  */
5168 static struct hda_verb alc260_acer_init_verbs[] = {
5169         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5170          * the headphone jack.  Turn this on and rely on the standard mute
5171          * methods whenever the user wants to turn these outputs off.
5172          */
5173         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5174         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5175         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5176         /* Internal speaker/Headphone jack is connected to Line-out pin */
5177         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5178         /* Internal microphone/Mic jack is connected to Mic1 pin */
5179         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5180         /* Line In jack is connected to Line1 pin */
5181         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5182         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5183         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5184         /* Ensure all other unused pins are disabled and muted. */
5185         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5186         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5187         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5188         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5189         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5190         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5191         /* Disable digital (SPDIF) pins */
5192         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5193         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5194
5195         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5196          * bus when acting as outputs.
5197          */
5198         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5199         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5200
5201         /* Start with output sum widgets muted and their output gains at min */
5202         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5203         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5204         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5205         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5206         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5207         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5208         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5209         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5210         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5211
5212         /* Unmute Line-out pin widget amp left and right
5213          * (no equiv mixer ctrl)
5214          */
5215         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5216         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5217         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5218         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5219          * inputs. If the pin mode is changed by the user the pin mode control
5220          * will take care of enabling the pin's input/output buffers as needed.
5221          * Therefore there's no need to enable the input buffer at this
5222          * stage.
5223          */
5224         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5225         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5226
5227         /* Mute capture amp left and right */
5228         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5229         /* Set ADC connection select to match default mixer setting - mic
5230          * (on mic1 pin)
5231          */
5232         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5233
5234         /* Do similar with the second ADC: mute capture input amp and
5235          * set ADC connection to mic to match ALSA's default state.
5236          */
5237         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5238         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5239
5240         /* Mute all inputs to mixer widget (even unconnected ones) */
5241         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5242         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5243         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5244         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5245         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5246         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5247         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5248         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5249
5250         { }
5251 };
5252
5253 /* Initialisation sequence for Maxdata Favorit 100XS
5254  * (adapted from Acer init verbs).
5255  */
5256 static struct hda_verb alc260_favorit100_init_verbs[] = {
5257         /* GPIO 0 enables the output jack.
5258          * Turn this on and rely on the standard mute
5259          * methods whenever the user wants to turn these outputs off.
5260          */
5261         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5262         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5263         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5264         /* Line/Mic input jack is connected to Mic1 pin */
5265         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5266         /* Ensure all other unused pins are disabled and muted. */
5267         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5268         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5269         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5270         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5271         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5272         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5273         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5274         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5275         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5276         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5277         /* Disable digital (SPDIF) pins */
5278         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5279         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5280
5281         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5282          * bus when acting as outputs.
5283          */
5284         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5285         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5286
5287         /* Start with output sum widgets muted and their output gains at min */
5288         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5289         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5290         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5291         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5292         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5293         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5294         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5295         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5296         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5297
5298         /* Unmute Line-out pin widget amp left and right
5299          * (no equiv mixer ctrl)
5300          */
5301         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5302         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5303          * inputs. If the pin mode is changed by the user the pin mode control
5304          * will take care of enabling the pin's input/output buffers as needed.
5305          * Therefore there's no need to enable the input buffer at this
5306          * stage.
5307          */
5308         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5309
5310         /* Mute capture amp left and right */
5311         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5312         /* Set ADC connection select to match default mixer setting - mic
5313          * (on mic1 pin)
5314          */
5315         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5316
5317         /* Do similar with the second ADC: mute capture input amp and
5318          * set ADC connection to mic to match ALSA's default state.
5319          */
5320         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5321         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5322
5323         /* Mute all inputs to mixer widget (even unconnected ones) */
5324         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5325         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5326         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5327         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5328         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5329         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5330         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5331         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5332
5333         { }
5334 };
5335
5336 static struct hda_verb alc260_will_verbs[] = {
5337         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5338         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5339         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5340         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5341         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5342         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5343         {}
5344 };
5345
5346 static struct hda_verb alc260_replacer_672v_verbs[] = {
5347         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5348         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5349         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5350
5351         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5352         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5353         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5354
5355         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5356         {}
5357 };
5358
5359 /* toggle speaker-output according to the hp-jack state */
5360 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5361 {
5362         unsigned int present;
5363
5364         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5365         present = snd_hda_codec_read(codec, 0x0f, 0,
5366                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5367         if (present) {
5368                 snd_hda_codec_write_cache(codec, 0x01, 0,
5369                                           AC_VERB_SET_GPIO_DATA, 1);
5370                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5371                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5372                                           PIN_HP);
5373         } else {
5374                 snd_hda_codec_write_cache(codec, 0x01, 0,
5375                                           AC_VERB_SET_GPIO_DATA, 0);
5376                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5377                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5378                                           PIN_OUT);
5379         }
5380 }
5381
5382 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5383                                        unsigned int res)
5384 {
5385         if ((res >> 26) == ALC880_HP_EVENT)
5386                 alc260_replacer_672v_automute(codec);
5387 }
5388
5389 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5390         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5391         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5392         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5393         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5394         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5395         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5396         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5397         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5398         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5399         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5400         {}
5401 };
5402
5403 /* Test configuration for debugging, modelled after the ALC880 test
5404  * configuration.
5405  */
5406 #ifdef CONFIG_SND_DEBUG
5407 static hda_nid_t alc260_test_dac_nids[1] = {
5408         0x02,
5409 };
5410 static hda_nid_t alc260_test_adc_nids[2] = {
5411         0x04, 0x05,
5412 };
5413 /* For testing the ALC260, each input MUX needs its own definition since
5414  * the signal assignments are different.  This assumes that the first ADC
5415  * is NID 0x04.
5416  */
5417 static struct hda_input_mux alc260_test_capture_sources[2] = {
5418         {
5419                 .num_items = 7,
5420                 .items = {
5421                         { "MIC1 pin", 0x0 },
5422                         { "MIC2 pin", 0x1 },
5423                         { "LINE1 pin", 0x2 },
5424                         { "LINE2 pin", 0x3 },
5425                         { "CD pin", 0x4 },
5426                         { "LINE-OUT pin", 0x5 },
5427                         { "HP-OUT pin", 0x6 },
5428                 },
5429         },
5430         {
5431                 .num_items = 8,
5432                 .items = {
5433                         { "MIC1 pin", 0x0 },
5434                         { "MIC2 pin", 0x1 },
5435                         { "LINE1 pin", 0x2 },
5436                         { "LINE2 pin", 0x3 },
5437                         { "CD pin", 0x4 },
5438                         { "Mixer", 0x5 },
5439                         { "LINE-OUT pin", 0x6 },
5440                         { "HP-OUT pin", 0x7 },
5441                 },
5442         },
5443 };
5444 static struct snd_kcontrol_new alc260_test_mixer[] = {
5445         /* Output driver widgets */
5446         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5447         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5448         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5449         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5450         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5451         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5452
5453         /* Modes for retasking pin widgets
5454          * Note: the ALC260 doesn't seem to act on requests to enable mic
5455          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5456          * mention this restriction.  At this stage it's not clear whether
5457          * this behaviour is intentional or is a hardware bug in chip
5458          * revisions available at least up until early 2006.  Therefore for
5459          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5460          * choices, but if it turns out that the lack of mic bias for these
5461          * NIDs is intentional we could change their modes from
5462          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5463          */
5464         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5465         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5466         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5467         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5468         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5469         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5470
5471         /* Loopback mixer controls */
5472         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5473         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5474         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5475         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5476         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5477         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5478         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5479         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5480         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5481         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5482         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5483         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5484         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5485         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5486
5487         /* Controls for GPIO pins, assuming they are configured as outputs */
5488         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5489         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5490         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5491         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5492
5493         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5494          * is ambigious as to which NID is which; testing on laptops which
5495          * make this output available should provide clarification.
5496          */
5497         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5498         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5499
5500         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5501          * this output to turn on an external amplifier.
5502          */
5503         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5504         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5505
5506         { } /* end */
5507 };
5508 static struct hda_verb alc260_test_init_verbs[] = {
5509         /* Enable all GPIOs as outputs with an initial value of 0 */
5510         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5511         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5512         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5513
5514         /* Enable retasking pins as output, initially without power amp */
5515         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5516         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5517         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5518         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5519         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5520         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5521
5522         /* Disable digital (SPDIF) pins initially, but users can enable
5523          * them via a mixer switch.  In the case of SPDIF-out, this initverb
5524          * payload also sets the generation to 0, output to be in "consumer"
5525          * PCM format, copyright asserted, no pre-emphasis and no validity
5526          * control.
5527          */
5528         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5529         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5530
5531         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5532          * OUT1 sum bus when acting as an output.
5533          */
5534         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5535         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5536         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5537         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5538
5539         /* Start with output sum widgets muted and their output gains at min */
5540         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5541         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5542         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5543         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5544         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5545         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5546         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5547         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5548         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5549
5550         /* Unmute retasking pin widget output buffers since the default
5551          * state appears to be output.  As the pin mode is changed by the
5552          * user the pin mode control will take care of enabling the pin's
5553          * input/output buffers as needed.
5554          */
5555         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5556         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5557         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5558         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5559         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5560         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5561         /* Also unmute the mono-out pin widget */
5562         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5563
5564         /* Mute capture amp left and right */
5565         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5566         /* Set ADC connection select to match default mixer setting (mic1
5567          * pin)
5568          */
5569         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5570
5571         /* Do the same for the second ADC: mute capture input amp and
5572          * set ADC connection to mic1 pin
5573          */
5574         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5575         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5576
5577         /* Mute all inputs to mixer widget (even unconnected ones) */
5578         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5579         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5580         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5581         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5582         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5583         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5584         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5585         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5586
5587         { }
5588 };
5589 #endif
5590
5591 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
5592 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
5593
5594 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
5595 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
5596
5597 /*
5598  * for BIOS auto-configuration
5599  */
5600
5601 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5602                                         const char *pfx, int *vol_bits)
5603 {
5604         hda_nid_t nid_vol;
5605         unsigned long vol_val, sw_val;
5606         char name[32];
5607         int err;
5608
5609         if (nid >= 0x0f && nid < 0x11) {
5610                 nid_vol = nid - 0x7;
5611                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5612                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5613         } else if (nid == 0x11) {
5614                 nid_vol = nid - 0x7;
5615                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5616                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5617         } else if (nid >= 0x12 && nid <= 0x15) {
5618                 nid_vol = 0x08;
5619                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5620                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5621         } else
5622                 return 0; /* N/A */
5623
5624         if (!(*vol_bits & (1 << nid_vol))) {
5625                 /* first control for the volume widget */
5626                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5627                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5628                 if (err < 0)
5629                         return err;
5630                 *vol_bits |= (1 << nid_vol);
5631         }
5632         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5633         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5634         if (err < 0)
5635                 return err;
5636         return 1;
5637 }
5638
5639 /* add playback controls from the parsed DAC table */
5640 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5641                                              const struct auto_pin_cfg *cfg)
5642 {
5643         hda_nid_t nid;
5644         int err;
5645         int vols = 0;
5646
5647         spec->multiout.num_dacs = 1;
5648         spec->multiout.dac_nids = spec->private_dac_nids;
5649         spec->multiout.dac_nids[0] = 0x02;
5650
5651         nid = cfg->line_out_pins[0];
5652         if (nid) {
5653                 err = alc260_add_playback_controls(spec, nid, "Front", &vols);
5654                 if (err < 0)
5655                         return err;
5656         }
5657
5658         nid = cfg->speaker_pins[0];
5659         if (nid) {
5660                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
5661                 if (err < 0)
5662                         return err;
5663         }
5664
5665         nid = cfg->hp_pins[0];
5666         if (nid) {
5667                 err = alc260_add_playback_controls(spec, nid, "Headphone",
5668                                                    &vols);
5669                 if (err < 0)
5670                         return err;
5671         }
5672         return 0;
5673 }
5674
5675 /* create playback/capture controls for input pins */
5676 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5677                                                 const struct auto_pin_cfg *cfg)
5678 {
5679         struct hda_input_mux *imux = &spec->private_imux[0];
5680         int i, err, idx;
5681
5682         for (i = 0; i < AUTO_PIN_LAST; i++) {
5683                 if (cfg->input_pins[i] >= 0x12) {
5684                         idx = cfg->input_pins[i] - 0x12;
5685                         err = new_analog_input(spec, cfg->input_pins[i],
5686                                                auto_pin_cfg_labels[i], idx,
5687                                                0x07);
5688                         if (err < 0)
5689                                 return err;
5690                         imux->items[imux->num_items].label =
5691                                 auto_pin_cfg_labels[i];
5692                         imux->items[imux->num_items].index = idx;
5693                         imux->num_items++;
5694                 }
5695                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5696                         idx = cfg->input_pins[i] - 0x09;
5697                         err = new_analog_input(spec, cfg->input_pins[i],
5698                                                auto_pin_cfg_labels[i], idx,
5699                                                0x07);
5700                         if (err < 0)
5701                                 return err;
5702                         imux->items[imux->num_items].label =
5703                                 auto_pin_cfg_labels[i];
5704                         imux->items[imux->num_items].index = idx;
5705                         imux->num_items++;
5706                 }
5707         }
5708         return 0;
5709 }
5710
5711 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5712                                               hda_nid_t nid, int pin_type,
5713                                               int sel_idx)
5714 {
5715         alc_set_pin_output(codec, nid, pin_type);
5716         /* need the manual connection? */
5717         if (nid >= 0x12) {
5718                 int idx = nid - 0x12;
5719                 snd_hda_codec_write(codec, idx + 0x0b, 0,
5720                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
5721         }
5722 }
5723
5724 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5725 {
5726         struct alc_spec *spec = codec->spec;
5727         hda_nid_t nid;
5728
5729         nid = spec->autocfg.line_out_pins[0];
5730         if (nid) {
5731                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5732                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5733         }
5734
5735         nid = spec->autocfg.speaker_pins[0];
5736         if (nid)
5737                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5738
5739         nid = spec->autocfg.hp_pins[0];
5740         if (nid)
5741                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5742 }
5743
5744 #define ALC260_PIN_CD_NID               0x16
5745 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5746 {
5747         struct alc_spec *spec = codec->spec;
5748         int i;
5749
5750         for (i = 0; i < AUTO_PIN_LAST; i++) {
5751                 hda_nid_t nid = spec->autocfg.input_pins[i];
5752                 if (nid >= 0x12) {
5753                         alc_set_input_pin(codec, nid, i);
5754                         if (nid != ALC260_PIN_CD_NID &&
5755                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5756                                 snd_hda_codec_write(codec, nid, 0,
5757                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5758                                                     AMP_OUT_MUTE);
5759                 }
5760         }
5761 }
5762
5763 /*
5764  * generic initialization of ADC, input mixers and output mixers
5765  */
5766 static struct hda_verb alc260_volume_init_verbs[] = {
5767         /*
5768          * Unmute ADC0-1 and set the default input to mic-in
5769          */
5770         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5771         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5772         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5773         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5774
5775         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5776          * mixer widget
5777          * Note: PASD motherboards uses the Line In 2 as the input for
5778          * front panel mic (mic 2)
5779          */
5780         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5781         /* mute analog inputs */
5782         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5783         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5784         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5785         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5786         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5787
5788         /*
5789          * Set up output mixers (0x08 - 0x0a)
5790          */
5791         /* set vol=0 to output mixers */
5792         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5793         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5794         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5795         /* set up input amps for analog loopback */
5796         /* Amp Indices: DAC = 0, mixer = 1 */
5797         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5798         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5799         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5800         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5801         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5802         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5803
5804         { }
5805 };
5806
5807 static int alc260_parse_auto_config(struct hda_codec *codec)
5808 {
5809         struct alc_spec *spec = codec->spec;
5810         int err;
5811         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5812
5813         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5814                                            alc260_ignore);
5815         if (err < 0)
5816                 return err;
5817         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5818         if (err < 0)
5819                 return err;
5820         if (!spec->kctls.list)
5821                 return 0; /* can't find valid BIOS pin config */
5822         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5823         if (err < 0)
5824                 return err;
5825
5826         spec->multiout.max_channels = 2;
5827
5828         if (spec->autocfg.dig_outs)
5829                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5830         if (spec->kctls.list)
5831                 add_mixer(spec, spec->kctls.list);
5832
5833         add_verb(spec, alc260_volume_init_verbs);
5834
5835         spec->num_mux_defs = 1;
5836         spec->input_mux = &spec->private_imux[0];
5837
5838         alc_ssid_check(codec, 0x10, 0x15, 0x0f);
5839
5840         return 1;
5841 }
5842
5843 /* additional initialization for auto-configuration model */
5844 static void alc260_auto_init(struct hda_codec *codec)
5845 {
5846         struct alc_spec *spec = codec->spec;
5847         alc260_auto_init_multi_out(codec);
5848         alc260_auto_init_analog_input(codec);
5849         if (spec->unsol_event)
5850                 alc_inithook(codec);
5851 }
5852
5853 #ifdef CONFIG_SND_HDA_POWER_SAVE
5854 static struct hda_amp_list alc260_loopbacks[] = {
5855         { 0x07, HDA_INPUT, 0 },
5856         { 0x07, HDA_INPUT, 1 },
5857         { 0x07, HDA_INPUT, 2 },
5858         { 0x07, HDA_INPUT, 3 },
5859         { 0x07, HDA_INPUT, 4 },
5860         { } /* end */
5861 };
5862 #endif
5863
5864 /*
5865  * ALC260 configurations
5866  */
5867 static const char *alc260_models[ALC260_MODEL_LAST] = {
5868         [ALC260_BASIC]          = "basic",
5869         [ALC260_HP]             = "hp",
5870         [ALC260_HP_3013]        = "hp-3013",
5871         [ALC260_HP_DC7600]      = "hp-dc7600",
5872         [ALC260_FUJITSU_S702X]  = "fujitsu",
5873         [ALC260_ACER]           = "acer",
5874         [ALC260_WILL]           = "will",
5875         [ALC260_REPLACER_672V]  = "replacer",
5876         [ALC260_FAVORIT100]     = "favorit100",
5877 #ifdef CONFIG_SND_DEBUG
5878         [ALC260_TEST]           = "test",
5879 #endif
5880         [ALC260_AUTO]           = "auto",
5881 };
5882
5883 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5884         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5885         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5886         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
5887         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5888         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5889         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5890         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
5891         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
5892         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5893         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5894         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5895         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5896         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5897         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5898         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5899         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5900         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5901         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5902         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5903         {}
5904 };
5905
5906 static struct alc_config_preset alc260_presets[] = {
5907         [ALC260_BASIC] = {
5908                 .mixers = { alc260_base_output_mixer,
5909                             alc260_input_mixer },
5910                 .init_verbs = { alc260_init_verbs },
5911                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5912                 .dac_nids = alc260_dac_nids,
5913                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5914                 .adc_nids = alc260_adc_nids,
5915                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5916                 .channel_mode = alc260_modes,
5917                 .input_mux = &alc260_capture_source,
5918         },
5919         [ALC260_HP] = {
5920                 .mixers = { alc260_hp_output_mixer,
5921                             alc260_input_mixer },
5922                 .init_verbs = { alc260_init_verbs,
5923                                 alc260_hp_unsol_verbs },
5924                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5925                 .dac_nids = alc260_dac_nids,
5926                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5927                 .adc_nids = alc260_adc_nids_alt,
5928                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5929                 .channel_mode = alc260_modes,
5930                 .input_mux = &alc260_capture_source,
5931                 .unsol_event = alc260_hp_unsol_event,
5932                 .init_hook = alc260_hp_automute,
5933         },
5934         [ALC260_HP_DC7600] = {
5935                 .mixers = { alc260_hp_dc7600_mixer,
5936                             alc260_input_mixer },
5937                 .init_verbs = { alc260_init_verbs,
5938                                 alc260_hp_dc7600_verbs },
5939                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5940                 .dac_nids = alc260_dac_nids,
5941                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5942                 .adc_nids = alc260_adc_nids_alt,
5943                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5944                 .channel_mode = alc260_modes,
5945                 .input_mux = &alc260_capture_source,
5946                 .unsol_event = alc260_hp_3012_unsol_event,
5947                 .init_hook = alc260_hp_3012_automute,
5948         },
5949         [ALC260_HP_3013] = {
5950                 .mixers = { alc260_hp_3013_mixer,
5951                             alc260_input_mixer },
5952                 .init_verbs = { alc260_hp_3013_init_verbs,
5953                                 alc260_hp_3013_unsol_verbs },
5954                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5955                 .dac_nids = alc260_dac_nids,
5956                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5957                 .adc_nids = alc260_adc_nids_alt,
5958                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5959                 .channel_mode = alc260_modes,
5960                 .input_mux = &alc260_capture_source,
5961                 .unsol_event = alc260_hp_3013_unsol_event,
5962                 .init_hook = alc260_hp_3013_automute,
5963         },
5964         [ALC260_FUJITSU_S702X] = {
5965                 .mixers = { alc260_fujitsu_mixer },
5966                 .init_verbs = { alc260_fujitsu_init_verbs },
5967                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5968                 .dac_nids = alc260_dac_nids,
5969                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5970                 .adc_nids = alc260_dual_adc_nids,
5971                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5972                 .channel_mode = alc260_modes,
5973                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5974                 .input_mux = alc260_fujitsu_capture_sources,
5975         },
5976         [ALC260_ACER] = {
5977                 .mixers = { alc260_acer_mixer },
5978                 .init_verbs = { alc260_acer_init_verbs },
5979                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5980                 .dac_nids = alc260_dac_nids,
5981                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5982                 .adc_nids = alc260_dual_adc_nids,
5983                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5984                 .channel_mode = alc260_modes,
5985                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5986                 .input_mux = alc260_acer_capture_sources,
5987         },
5988         [ALC260_FAVORIT100] = {
5989                 .mixers = { alc260_favorit100_mixer },
5990                 .init_verbs = { alc260_favorit100_init_verbs },
5991                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5992                 .dac_nids = alc260_dac_nids,
5993                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5994                 .adc_nids = alc260_dual_adc_nids,
5995                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5996                 .channel_mode = alc260_modes,
5997                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
5998                 .input_mux = alc260_favorit100_capture_sources,
5999         },
6000         [ALC260_WILL] = {
6001                 .mixers = { alc260_will_mixer },
6002                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
6003                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6004                 .dac_nids = alc260_dac_nids,
6005                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6006                 .adc_nids = alc260_adc_nids,
6007                 .dig_out_nid = ALC260_DIGOUT_NID,
6008                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6009                 .channel_mode = alc260_modes,
6010                 .input_mux = &alc260_capture_source,
6011         },
6012         [ALC260_REPLACER_672V] = {
6013                 .mixers = { alc260_replacer_672v_mixer },
6014                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6015                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6016                 .dac_nids = alc260_dac_nids,
6017                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6018                 .adc_nids = alc260_adc_nids,
6019                 .dig_out_nid = ALC260_DIGOUT_NID,
6020                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6021                 .channel_mode = alc260_modes,
6022                 .input_mux = &alc260_capture_source,
6023                 .unsol_event = alc260_replacer_672v_unsol_event,
6024                 .init_hook = alc260_replacer_672v_automute,
6025         },
6026 #ifdef CONFIG_SND_DEBUG
6027         [ALC260_TEST] = {
6028                 .mixers = { alc260_test_mixer },
6029                 .init_verbs = { alc260_test_init_verbs },
6030                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6031                 .dac_nids = alc260_test_dac_nids,
6032                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6033                 .adc_nids = alc260_test_adc_nids,
6034                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6035                 .channel_mode = alc260_modes,
6036                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6037                 .input_mux = alc260_test_capture_sources,
6038         },
6039 #endif
6040 };
6041
6042 static int patch_alc260(struct hda_codec *codec)
6043 {
6044         struct alc_spec *spec;
6045         int err, board_config;
6046
6047         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6048         if (spec == NULL)
6049                 return -ENOMEM;
6050
6051         codec->spec = spec;
6052
6053         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6054                                                   alc260_models,
6055                                                   alc260_cfg_tbl);
6056         if (board_config < 0) {
6057                 snd_printd(KERN_INFO "hda_codec: Unknown model for %s, "
6058                            "trying auto-probe from BIOS...\n",
6059                            codec->chip_name);
6060                 board_config = ALC260_AUTO;
6061         }
6062
6063         if (board_config == ALC260_AUTO) {
6064                 /* automatic parse from the BIOS config */
6065                 err = alc260_parse_auto_config(codec);
6066                 if (err < 0) {
6067                         alc_free(codec);
6068                         return err;
6069                 } else if (!err) {
6070                         printk(KERN_INFO
6071                                "hda_codec: Cannot set up configuration "
6072                                "from BIOS.  Using base mode...\n");
6073                         board_config = ALC260_BASIC;
6074                 }
6075         }
6076
6077         err = snd_hda_attach_beep_device(codec, 0x1);
6078         if (err < 0) {
6079                 alc_free(codec);
6080                 return err;
6081         }
6082
6083         if (board_config != ALC260_AUTO)
6084                 setup_preset(spec, &alc260_presets[board_config]);
6085
6086         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6087         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6088
6089         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6090         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6091
6092         if (!spec->adc_nids && spec->input_mux) {
6093                 /* check whether NID 0x04 is valid */
6094                 unsigned int wcap = get_wcaps(codec, 0x04);
6095                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6096                 /* get type */
6097                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6098                         spec->adc_nids = alc260_adc_nids_alt;
6099                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6100                 } else {
6101                         spec->adc_nids = alc260_adc_nids;
6102                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6103                 }
6104         }
6105         set_capture_mixer(spec);
6106         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6107
6108         spec->vmaster_nid = 0x08;
6109
6110         codec->patch_ops = alc_patch_ops;
6111         if (board_config == ALC260_AUTO)
6112                 spec->init_hook = alc260_auto_init;
6113 #ifdef CONFIG_SND_HDA_POWER_SAVE
6114         if (!spec->loopback.amplist)
6115                 spec->loopback.amplist = alc260_loopbacks;
6116 #endif
6117         codec->proc_widget_hook = print_realtek_coef;
6118
6119         return 0;
6120 }
6121
6122
6123 /*
6124  * ALC882 support
6125  *
6126  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6127  * configuration.  Each pin widget can choose any input DACs and a mixer.
6128  * Each ADC is connected from a mixer of all inputs.  This makes possible
6129  * 6-channel independent captures.
6130  *
6131  * In addition, an independent DAC for the multi-playback (not used in this
6132  * driver yet).
6133  */
6134 #define ALC882_DIGOUT_NID       0x06
6135 #define ALC882_DIGIN_NID        0x0a
6136
6137 static struct hda_channel_mode alc882_ch_modes[1] = {
6138         { 8, NULL }
6139 };
6140
6141 static hda_nid_t alc882_dac_nids[4] = {
6142         /* front, rear, clfe, rear_surr */
6143         0x02, 0x03, 0x04, 0x05
6144 };
6145
6146 /* identical with ALC880 */
6147 #define alc882_adc_nids         alc880_adc_nids
6148 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6149
6150 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6151 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6152
6153 /* input MUX */
6154 /* FIXME: should be a matrix-type input source selection */
6155
6156 static struct hda_input_mux alc882_capture_source = {
6157         .num_items = 4,
6158         .items = {
6159                 { "Mic", 0x0 },
6160                 { "Front Mic", 0x1 },
6161                 { "Line", 0x2 },
6162                 { "CD", 0x4 },
6163         },
6164 };
6165
6166 static struct hda_input_mux mb5_capture_source = {
6167         .num_items = 3,
6168         .items = {
6169                 { "Mic", 0x1 },
6170                 { "Line", 0x2 },
6171                 { "CD", 0x4 },
6172         },
6173 };
6174
6175 /*
6176  * 2ch mode
6177  */
6178 static struct hda_verb alc882_3ST_ch2_init[] = {
6179         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6180         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6181         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6182         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6183         { } /* end */
6184 };
6185
6186 /*
6187  * 6ch mode
6188  */
6189 static struct hda_verb alc882_3ST_ch6_init[] = {
6190         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6191         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6192         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6193         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6194         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6195         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6196         { } /* end */
6197 };
6198
6199 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
6200         { 2, alc882_3ST_ch2_init },
6201         { 6, alc882_3ST_ch6_init },
6202 };
6203
6204 /*
6205  * 6ch mode
6206  */
6207 static struct hda_verb alc882_sixstack_ch6_init[] = {
6208         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6209         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6210         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6211         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6212         { } /* end */
6213 };
6214
6215 /*
6216  * 8ch mode
6217  */
6218 static struct hda_verb alc882_sixstack_ch8_init[] = {
6219         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6220         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6221         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6222         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6223         { } /* end */
6224 };
6225
6226 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6227         { 6, alc882_sixstack_ch6_init },
6228         { 8, alc882_sixstack_ch8_init },
6229 };
6230
6231 /*
6232  * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
6233  */
6234
6235 /*
6236  * 2ch mode
6237  */
6238 static struct hda_verb alc885_mbp_ch2_init[] = {
6239         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6240         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6241         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6242         { } /* end */
6243 };
6244
6245 /*
6246  * 6ch mode
6247  */
6248 static struct hda_verb alc885_mbp_ch6_init[] = {
6249         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6250         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6251         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6252         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6253         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6254         { } /* end */
6255 };
6256
6257 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
6258         { 2, alc885_mbp_ch2_init },
6259         { 6, alc885_mbp_ch6_init },
6260 };
6261
6262
6263 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6264  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6265  */
6266 static struct snd_kcontrol_new alc882_base_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_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6270         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6271         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6272         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6273         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6274         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6275         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6276         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6277         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6278         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6279         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6280         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6281         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6282         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6283         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6284         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6285         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6286         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6287         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6288         { } /* end */
6289 };
6290
6291 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
6292         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6293         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6294         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
6295         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6296         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6297         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6298         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
6299         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
6300         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
6301         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
6302         { } /* end */
6303 };
6304
6305 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
6306         HDA_CODEC_VOLUME("Front Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6307         HDA_BIND_MUTE   ("Front Playback Switch", 0x0d, 0x02, HDA_INPUT),
6308         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6309         HDA_BIND_MUTE   ("Line-Out Playback Switch", 0x0c, 0x02, HDA_INPUT),
6310         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6311         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6312         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
6313         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
6314         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
6315         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
6316         { } /* end */
6317 };
6318 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
6319         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6320         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6321         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6322         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6323         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6324         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6325         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6326         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6327         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6328         { } /* end */
6329 };
6330
6331 static struct snd_kcontrol_new alc882_targa_mixer[] = {
6332         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6333         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6334         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6335         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6336         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6337         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6338         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6339         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6340         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6341         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6342         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6343         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6344         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6345         { } /* end */
6346 };
6347
6348 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
6349  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
6350  */
6351 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
6352         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6353         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6354         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6355         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
6356         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6357         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6358         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6359         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6360         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
6361         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
6362         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6363         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6364         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6365         { } /* end */
6366 };
6367
6368 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
6369         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6370         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6371         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6372         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6373         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6374         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6375         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6376         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6377         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6378         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6379         { } /* end */
6380 };
6381
6382 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
6383         {
6384                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6385                 .name = "Channel Mode",
6386                 .info = alc_ch_mode_info,
6387                 .get = alc_ch_mode_get,
6388                 .put = alc_ch_mode_put,
6389         },
6390         { } /* end */
6391 };
6392
6393 static struct hda_verb alc882_init_verbs[] = {
6394         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6395         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6396         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6397         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6398         /* Rear mixer */
6399         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6400         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6401         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6402         /* CLFE mixer */
6403         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6404         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6405         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6406         /* Side mixer */
6407         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6408         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6409         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6410
6411         /* Front Pin: output 0 (0x0c) */
6412         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6413         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6414         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6415         /* Rear Pin: output 1 (0x0d) */
6416         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6417         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6418         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6419         /* CLFE Pin: output 2 (0x0e) */
6420         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6421         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6422         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
6423         /* Side Pin: output 3 (0x0f) */
6424         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6425         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6426         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
6427         /* Mic (rear) pin: input vref at 80% */
6428         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6429         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6430         /* Front Mic pin: input vref at 80% */
6431         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6432         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6433         /* Line In pin: input */
6434         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6435         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6436         /* Line-2 In: Headphone output (output 0 - 0x0c) */
6437         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6438         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6439         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
6440         /* CD pin widget for input */
6441         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6442
6443         /* FIXME: use matrix-type input source selection */
6444         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6445         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6446         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6447         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6448         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6449         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6450         /* Input mixer2 */
6451         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6452         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6453         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6454         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6455         /* Input mixer3 */
6456         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6457         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6458         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6459         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6460         /* ADC1: mute amp left and right */
6461         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6462         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6463         /* ADC2: mute amp left and right */
6464         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6465         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6466         /* ADC3: mute amp left and right */
6467         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6468         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6469
6470         { }
6471 };
6472
6473 static struct hda_verb alc882_eapd_verbs[] = {
6474         /* change to EAPD mode */
6475         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6476         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
6477         { }
6478 };
6479
6480 /* Mac Pro test */
6481 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
6482         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6483         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6484         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
6485         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
6486         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
6487         /* FIXME: this looks suspicious...
6488         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
6489         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
6490         */
6491         { } /* end */
6492 };
6493
6494 static struct hda_verb alc882_macpro_init_verbs[] = {
6495         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6496         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6497         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6498         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6499         /* Front Pin: output 0 (0x0c) */
6500         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6501         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6502         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6503         /* Front Mic pin: input vref at 80% */
6504         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6505         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6506         /* Speaker:  output */
6507         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6508         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6509         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
6510         /* Headphone output (output 0 - 0x0c) */
6511         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6512         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6513         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6514
6515         /* FIXME: use matrix-type input source selection */
6516         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6517         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6518         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6519         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6520         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6521         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6522         /* Input mixer2 */
6523         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6524         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6525         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6526         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6527         /* Input mixer3 */
6528         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6529         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6530         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6531         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6532         /* ADC1: mute amp left and right */
6533         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6534         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6535         /* ADC2: mute amp left and right */
6536         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6537         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6538         /* ADC3: mute amp left and right */
6539         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6540         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6541
6542         { }
6543 };
6544
6545 /* Macbook 5,1 */
6546 static struct hda_verb alc885_mb5_init_verbs[] = {
6547         /* Front mixer */
6548         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6549         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6550         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6551         /* LineOut mixer */
6552         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6553         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6554         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6555         /* Front Pin: output 0 (0x0d) */
6556         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
6557         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6558         {0x18, AC_VERB_SET_CONNECT_SEL, 0x01},
6559         /* HP Pin: output 0 (0x0c) */
6560         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6561         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6562         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6563         /* Front Mic pin: input vref at 80% */
6564         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6565         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6566         /* Line In pin */
6567         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6568         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6569
6570         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6571         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6572         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6573         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6574         { }
6575 };
6576
6577 /* Macbook Pro rev3 */
6578 static struct hda_verb alc885_mbp3_init_verbs[] = {
6579         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6580         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6581         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6582         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6583         /* Rear mixer */
6584         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6585         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6586         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6587         /* Front Pin: output 0 (0x0c) */
6588         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6589         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6590         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6591         /* HP Pin: output 0 (0x0d) */
6592         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
6593         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6594         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6595         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6596         /* Mic (rear) pin: input vref at 80% */
6597         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6598         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6599         /* Front Mic pin: input vref at 80% */
6600         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6601         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6602         /* Line In pin: use output 1 when in LineOut mode */
6603         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6604         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6605         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
6606
6607         /* FIXME: use matrix-type input source selection */
6608         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6609         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6610         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6611         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6612         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6613         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6614         /* Input mixer2 */
6615         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6616         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6617         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6618         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6619         /* Input mixer3 */
6620         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6621         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6622         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6623         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6624         /* ADC1: mute amp left and right */
6625         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6626         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6627         /* ADC2: mute amp left and right */
6628         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6629         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6630         /* ADC3: mute amp left and right */
6631         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6632         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6633
6634         { }
6635 };
6636
6637 /* iMac 24 mixer. */
6638 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
6639         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6640         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
6641         { } /* end */
6642 };
6643
6644 /* iMac 24 init verbs. */
6645 static struct hda_verb alc885_imac24_init_verbs[] = {
6646         /* Internal speakers: output 0 (0x0c) */
6647         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6648         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6649         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6650         /* Internal speakers: output 0 (0x0c) */
6651         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6652         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6653         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
6654         /* Headphone: output 0 (0x0c) */
6655         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6656         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6657         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6658         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6659         /* Front Mic: input vref at 80% */
6660         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6661         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6662         { }
6663 };
6664
6665 /* Toggle speaker-output according to the hp-jack state */
6666 static void alc885_imac24_automute_init_hook(struct hda_codec *codec)
6667 {
6668         struct alc_spec *spec = codec->spec;
6669
6670         spec->autocfg.hp_pins[0] = 0x14;
6671         spec->autocfg.speaker_pins[0] = 0x18;
6672         spec->autocfg.speaker_pins[1] = 0x1a;
6673         alc_automute_amp(codec);
6674 }
6675
6676 static void alc885_mbp3_init_hook(struct hda_codec *codec)
6677 {
6678         struct alc_spec *spec = codec->spec;
6679
6680         spec->autocfg.hp_pins[0] = 0x15;
6681         spec->autocfg.speaker_pins[0] = 0x14;
6682         alc_automute_amp(codec);
6683 }
6684
6685
6686 static struct hda_verb alc882_targa_verbs[] = {
6687         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6688         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6689
6690         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6691         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6692
6693         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6694         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6695         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6696
6697         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6698         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6699         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
6700         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
6701         { } /* end */
6702 };
6703
6704 /* toggle speaker-output according to the hp-jack state */
6705 static void alc882_targa_automute(struct hda_codec *codec)
6706 {
6707         struct alc_spec *spec = codec->spec;
6708         alc_automute_amp(codec);
6709         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
6710                                   spec->jack_present ? 1 : 3);
6711 }
6712
6713 static void alc882_targa_init_hook(struct hda_codec *codec)
6714 {
6715         struct alc_spec *spec = codec->spec;
6716
6717         spec->autocfg.hp_pins[0] = 0x14;
6718         spec->autocfg.speaker_pins[0] = 0x1b;
6719         alc882_targa_automute(codec);
6720 }
6721
6722 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
6723 {
6724         if ((res >> 26) == ALC880_HP_EVENT)
6725                 alc882_targa_automute(codec);
6726 }
6727
6728 static struct hda_verb alc882_asus_a7j_verbs[] = {
6729         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6730         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6731
6732         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6733         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6734         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6735
6736         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6737         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6738         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6739
6740         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6741         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6742         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6743         { } /* end */
6744 };
6745
6746 static struct hda_verb alc882_asus_a7m_verbs[] = {
6747         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6748         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6749
6750         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6751         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6752         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6753
6754         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6755         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6756         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6757
6758         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6759         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6760         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6761         { } /* end */
6762 };
6763
6764 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
6765 {
6766         unsigned int gpiostate, gpiomask, gpiodir;
6767
6768         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
6769                                        AC_VERB_GET_GPIO_DATA, 0);
6770
6771         if (!muted)
6772                 gpiostate |= (1 << pin);
6773         else
6774                 gpiostate &= ~(1 << pin);
6775
6776         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
6777                                       AC_VERB_GET_GPIO_MASK, 0);
6778         gpiomask |= (1 << pin);
6779
6780         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
6781                                      AC_VERB_GET_GPIO_DIRECTION, 0);
6782         gpiodir |= (1 << pin);
6783
6784
6785         snd_hda_codec_write(codec, codec->afg, 0,
6786                             AC_VERB_SET_GPIO_MASK, gpiomask);
6787         snd_hda_codec_write(codec, codec->afg, 0,
6788                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
6789
6790         msleep(1);
6791
6792         snd_hda_codec_write(codec, codec->afg, 0,
6793                             AC_VERB_SET_GPIO_DATA, gpiostate);
6794 }
6795
6796 /* set up GPIO at initialization */
6797 static void alc885_macpro_init_hook(struct hda_codec *codec)
6798 {
6799         alc882_gpio_mute(codec, 0, 0);
6800         alc882_gpio_mute(codec, 1, 0);
6801 }
6802
6803 /* set up GPIO and update auto-muting at initialization */
6804 static void alc885_imac24_init_hook(struct hda_codec *codec)
6805 {
6806         alc885_macpro_init_hook(codec);
6807         alc885_imac24_automute_init_hook(codec);
6808 }
6809
6810 /*
6811  * generic initialization of ADC, input mixers and output mixers
6812  */
6813 static struct hda_verb alc882_auto_init_verbs[] = {
6814         /*
6815          * Unmute ADC0-2 and set the default input to mic-in
6816          */
6817         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6818         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6819         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6820         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6821         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6822         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6823
6824         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6825          * mixer widget
6826          * Note: PASD motherboards uses the Line In 2 as the input for
6827          * front panel mic (mic 2)
6828          */
6829         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6830         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6831         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6832         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6833         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6834         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6835
6836         /*
6837          * Set up output mixers (0x0c - 0x0f)
6838          */
6839         /* set vol=0 to output mixers */
6840         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6841         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6842         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6843         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6844         /* set up input amps for analog loopback */
6845         /* Amp Indices: DAC = 0, mixer = 1 */
6846         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6847         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6848         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6849         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6850         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6851         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6852         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6853         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6854         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6855         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6856
6857         /* FIXME: use matrix-type input source selection */
6858         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6859         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6860         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6861         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6862         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6863         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6864         /* Input mixer2 */
6865         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6866         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6867         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6868         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6869         /* Input mixer3 */
6870         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6871         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6872         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6873         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6874
6875         { }
6876 };
6877
6878 #ifdef CONFIG_SND_HDA_POWER_SAVE
6879 #define alc882_loopbacks        alc880_loopbacks
6880 #endif
6881
6882 /* pcm configuration: identiacal with ALC880 */
6883 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
6884 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
6885 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
6886 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
6887
6888 /*
6889  * configuration and preset
6890  */
6891 static const char *alc882_models[ALC882_MODEL_LAST] = {
6892         [ALC882_3ST_DIG]        = "3stack-dig",
6893         [ALC882_6ST_DIG]        = "6stack-dig",
6894         [ALC882_ARIMA]          = "arima",
6895         [ALC882_W2JC]           = "w2jc",
6896         [ALC882_TARGA]          = "targa",
6897         [ALC882_ASUS_A7J]       = "asus-a7j",
6898         [ALC882_ASUS_A7M]       = "asus-a7m",
6899         [ALC885_MACPRO]         = "macpro",
6900         [ALC885_MB5]            = "mb5",
6901         [ALC885_MBP3]           = "mbp3",
6902         [ALC885_IMAC24]         = "imac24",
6903         [ALC882_AUTO]           = "auto",
6904 };
6905
6906 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6907         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6908         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6909         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6910         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6911         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6912         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6913         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6914         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6915         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6916         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
6917         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6918         SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6919         {}
6920 };
6921
6922 static struct alc_config_preset alc882_presets[] = {
6923         [ALC882_3ST_DIG] = {
6924                 .mixers = { alc882_base_mixer },
6925                 .init_verbs = { alc882_init_verbs },
6926                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6927                 .dac_nids = alc882_dac_nids,
6928                 .dig_out_nid = ALC882_DIGOUT_NID,
6929                 .dig_in_nid = ALC882_DIGIN_NID,
6930                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6931                 .channel_mode = alc882_ch_modes,
6932                 .need_dac_fix = 1,
6933                 .input_mux = &alc882_capture_source,
6934         },
6935         [ALC882_6ST_DIG] = {
6936                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6937                 .init_verbs = { alc882_init_verbs },
6938                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6939                 .dac_nids = alc882_dac_nids,
6940                 .dig_out_nid = ALC882_DIGOUT_NID,
6941                 .dig_in_nid = ALC882_DIGIN_NID,
6942                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6943                 .channel_mode = alc882_sixstack_modes,
6944                 .input_mux = &alc882_capture_source,
6945         },
6946         [ALC882_ARIMA] = {
6947                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6948                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
6949                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6950                 .dac_nids = alc882_dac_nids,
6951                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6952                 .channel_mode = alc882_sixstack_modes,
6953                 .input_mux = &alc882_capture_source,
6954         },
6955         [ALC882_W2JC] = {
6956                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
6957                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6958                                 alc880_gpio1_init_verbs },
6959                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6960                 .dac_nids = alc882_dac_nids,
6961                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6962                 .channel_mode = alc880_threestack_modes,
6963                 .need_dac_fix = 1,
6964                 .input_mux = &alc882_capture_source,
6965                 .dig_out_nid = ALC882_DIGOUT_NID,
6966         },
6967         [ALC885_MBP3] = {
6968                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
6969                 .init_verbs = { alc885_mbp3_init_verbs,
6970                                 alc880_gpio1_init_verbs },
6971                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6972                 .dac_nids = alc882_dac_nids,
6973                 .channel_mode = alc885_mbp_6ch_modes,
6974                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6975                 .input_mux = &alc882_capture_source,
6976                 .dig_out_nid = ALC882_DIGOUT_NID,
6977                 .dig_in_nid = ALC882_DIGIN_NID,
6978                 .unsol_event = alc_automute_amp_unsol_event,
6979                 .init_hook = alc885_mbp3_init_hook,
6980         },
6981         [ALC885_MB5] = {
6982                 .mixers = { alc885_mb5_mixer },
6983                 .init_verbs = { alc885_mb5_init_verbs,
6984                                 alc880_gpio1_init_verbs },
6985                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6986                 .dac_nids = alc882_dac_nids,
6987                 .channel_mode = alc885_mbp_6ch_modes,
6988                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6989                 .input_mux = &mb5_capture_source,
6990                 .dig_out_nid = ALC882_DIGOUT_NID,
6991                 .dig_in_nid = ALC882_DIGIN_NID,
6992         },
6993         [ALC885_MACPRO] = {
6994                 .mixers = { alc882_macpro_mixer },
6995                 .init_verbs = { alc882_macpro_init_verbs },
6996                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6997                 .dac_nids = alc882_dac_nids,
6998                 .dig_out_nid = ALC882_DIGOUT_NID,
6999                 .dig_in_nid = ALC882_DIGIN_NID,
7000                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
7001                 .channel_mode = alc882_ch_modes,
7002                 .input_mux = &alc882_capture_source,
7003                 .init_hook = alc885_macpro_init_hook,
7004         },
7005         [ALC885_IMAC24] = {
7006                 .mixers = { alc885_imac24_mixer },
7007                 .init_verbs = { alc885_imac24_init_verbs },
7008                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
7009                 .dac_nids = alc882_dac_nids,
7010                 .dig_out_nid = ALC882_DIGOUT_NID,
7011                 .dig_in_nid = ALC882_DIGIN_NID,
7012                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
7013                 .channel_mode = alc882_ch_modes,
7014                 .input_mux = &alc882_capture_source,
7015                 .unsol_event = alc_automute_amp_unsol_event,
7016                 .init_hook = alc885_imac24_init_hook,
7017         },
7018         [ALC882_TARGA] = {
7019                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
7020                 .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
7021                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
7022                 .dac_nids = alc882_dac_nids,
7023                 .dig_out_nid = ALC882_DIGOUT_NID,
7024                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
7025                 .adc_nids = alc882_adc_nids,
7026                 .capsrc_nids = alc882_capsrc_nids,
7027                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
7028                 .channel_mode = alc882_3ST_6ch_modes,
7029                 .need_dac_fix = 1,
7030                 .input_mux = &alc882_capture_source,
7031                 .unsol_event = alc882_targa_unsol_event,
7032                 .init_hook = alc882_targa_init_hook,
7033         },
7034         [ALC882_ASUS_A7J] = {
7035                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
7036                 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
7037                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
7038                 .dac_nids = alc882_dac_nids,
7039                 .dig_out_nid = ALC882_DIGOUT_NID,
7040                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
7041                 .adc_nids = alc882_adc_nids,
7042                 .capsrc_nids = alc882_capsrc_nids,
7043                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
7044                 .channel_mode = alc882_3ST_6ch_modes,
7045                 .need_dac_fix = 1,
7046                 .input_mux = &alc882_capture_source,
7047         },
7048         [ALC882_ASUS_A7M] = {
7049                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
7050                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
7051                                 alc880_gpio1_init_verbs,
7052                                 alc882_asus_a7m_verbs },
7053                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
7054                 .dac_nids = alc882_dac_nids,
7055                 .dig_out_nid = ALC882_DIGOUT_NID,
7056                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
7057                 .channel_mode = alc880_threestack_modes,
7058                 .need_dac_fix = 1,
7059                 .input_mux = &alc882_capture_source,
7060         },
7061 };
7062
7063
7064 /*
7065  * Pin config fixes
7066  */
7067 enum {
7068         PINFIX_ABIT_AW9D_MAX
7069 };
7070
7071 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
7072         { 0x15, 0x01080104 }, /* side */
7073         { 0x16, 0x01011012 }, /* rear */
7074         { 0x17, 0x01016011 }, /* clfe */
7075         { }
7076 };
7077
7078 static const struct alc_pincfg *alc882_pin_fixes[] = {
7079         [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
7080 };
7081
7082 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
7083         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
7084         {}
7085 };
7086
7087 /*
7088  * BIOS auto configuration
7089  */
7090 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
7091                                               hda_nid_t nid, int pin_type,
7092                                               int dac_idx)
7093 {
7094         /* set as output */
7095         struct alc_spec *spec = codec->spec;
7096         int idx;
7097
7098         alc_set_pin_output(codec, nid, pin_type);
7099         if (spec->multiout.dac_nids[dac_idx] == 0x25)
7100                 idx = 4;
7101         else
7102                 idx = spec->multiout.dac_nids[dac_idx] - 2;
7103         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
7104
7105 }
7106
7107 static void alc882_auto_init_multi_out(struct hda_codec *codec)
7108 {
7109         struct alc_spec *spec = codec->spec;
7110         int i;
7111
7112         for (i = 0; i <= HDA_SIDE; i++) {
7113                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
7114                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
7115                 if (nid)
7116                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
7117                                                           i);
7118         }
7119 }
7120
7121 static void alc882_auto_init_hp_out(struct hda_codec *codec)
7122 {
7123         struct alc_spec *spec = codec->spec;
7124         hda_nid_t pin;
7125
7126         pin = spec->autocfg.hp_pins[0];
7127         if (pin) /* connect to front */
7128                 /* use dac 0 */
7129                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
7130         pin = spec->autocfg.speaker_pins[0];
7131         if (pin)
7132                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
7133 }
7134
7135 #define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
7136 #define ALC882_PIN_CD_NID               ALC880_PIN_CD_NID
7137
7138 static void alc882_auto_init_analog_input(struct hda_codec *codec)
7139 {
7140         struct alc_spec *spec = codec->spec;
7141         int i;
7142
7143         for (i = 0; i < AUTO_PIN_LAST; i++) {
7144                 hda_nid_t nid = spec->autocfg.input_pins[i];
7145                 if (!nid)
7146                         continue;
7147                 alc_set_input_pin(codec, nid, AUTO_PIN_FRONT_MIC /*i*/);
7148                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
7149                         snd_hda_codec_write(codec, nid, 0,
7150                                             AC_VERB_SET_AMP_GAIN_MUTE,
7151                                             AMP_OUT_MUTE);
7152         }
7153 }
7154
7155 static void alc882_auto_init_input_src(struct hda_codec *codec)
7156 {
7157         struct alc_spec *spec = codec->spec;
7158         int c;
7159
7160         for (c = 0; c < spec->num_adc_nids; c++) {
7161                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
7162                 hda_nid_t nid = spec->capsrc_nids[c];
7163                 unsigned int mux_idx;
7164                 const struct hda_input_mux *imux;
7165                 int conns, mute, idx, item;
7166
7167                 conns = snd_hda_get_connections(codec, nid, conn_list,
7168                                                 ARRAY_SIZE(conn_list));
7169                 if (conns < 0)
7170                         continue;
7171                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
7172                 imux = &spec->input_mux[mux_idx];
7173                 for (idx = 0; idx < conns; idx++) {
7174                         /* if the current connection is the selected one,
7175                          * unmute it as default - otherwise mute it
7176                          */
7177                         mute = AMP_IN_MUTE(idx);
7178                         for (item = 0; item < imux->num_items; item++) {
7179                                 if (imux->items[item].index == idx) {
7180                                         if (spec->cur_mux[c] == item)
7181                                                 mute = AMP_IN_UNMUTE(idx);
7182                                         break;
7183                                 }
7184                         }
7185                         /* check if we have a selector or mixer
7186                          * we could check for the widget type instead, but
7187                          * just check for Amp-In presence (in case of mixer
7188                          * without amp-in there is something wrong, this
7189                          * function shouldn't be used or capsrc nid is wrong)
7190                          */
7191                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
7192                                 snd_hda_codec_write(codec, nid, 0,
7193                                                     AC_VERB_SET_AMP_GAIN_MUTE,
7194                                                     mute);
7195                         else if (mute != AMP_IN_MUTE(idx))
7196                                 snd_hda_codec_write(codec, nid, 0,
7197                                                     AC_VERB_SET_CONNECT_SEL,
7198                                                     idx);
7199                 }
7200         }
7201 }
7202
7203 /* add mic boosts if needed */
7204 static int alc_auto_add_mic_boost(struct hda_codec *codec)
7205 {
7206         struct alc_spec *spec = codec->spec;
7207         int err;
7208         hda_nid_t nid;
7209
7210         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
7211         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
7212                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
7213                                   "Mic Boost",
7214                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
7215                 if (err < 0)
7216                         return err;
7217         }
7218         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
7219         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
7220                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
7221                                   "Front Mic Boost",
7222                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
7223                 if (err < 0)
7224                         return err;
7225         }
7226         return 0;
7227 }
7228
7229 /* almost identical with ALC880 parser... */
7230 static int alc882_parse_auto_config(struct hda_codec *codec)
7231 {
7232         struct alc_spec *spec = codec->spec;
7233         int err = alc880_parse_auto_config(codec);
7234
7235         if (err < 0)
7236                 return err;
7237         else if (!err)
7238                 return 0; /* no config found */
7239
7240         err = alc_auto_add_mic_boost(codec);
7241         if (err < 0)
7242                 return err;
7243
7244         /* hack - override the init verbs */
7245         spec->init_verbs[0] = alc882_auto_init_verbs;
7246
7247         return 1; /* config found */
7248 }
7249
7250 /* additional initialization for auto-configuration model */
7251 static void alc882_auto_init(struct hda_codec *codec)
7252 {
7253         struct alc_spec *spec = codec->spec;
7254         alc882_auto_init_multi_out(codec);
7255         alc882_auto_init_hp_out(codec);
7256         alc882_auto_init_analog_input(codec);
7257         alc882_auto_init_input_src(codec);
7258         if (spec->unsol_event)
7259                 alc_inithook(codec);
7260 }
7261
7262 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
7263
7264 static int patch_alc882(struct hda_codec *codec)
7265 {
7266         struct alc_spec *spec;
7267         int err, board_config;
7268
7269         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7270         if (spec == NULL)
7271                 return -ENOMEM;
7272
7273         codec->spec = spec;
7274
7275         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
7276                                                   alc882_models,
7277                                                   alc882_cfg_tbl);
7278
7279         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
7280                 /* Pick up systems that don't supply PCI SSID */
7281                 switch (codec->subsystem_id) {
7282                 case 0x106b0c00: /* Mac Pro */
7283                         board_config = ALC885_MACPRO;
7284                         break;
7285                 case 0x106b1000: /* iMac 24 */
7286                 case 0x106b2800: /* AppleTV */
7287                 case 0x106b3e00: /* iMac 24 Aluminium */
7288                         board_config = ALC885_IMAC24;
7289                         break;
7290                 case 0x106b00a0: /* MacBookPro3,1 - Another revision */
7291                 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
7292                 case 0x106b00a4: /* MacbookPro4,1 */
7293                 case 0x106b2c00: /* Macbook Pro rev3 */
7294                 case 0x106b3600: /* Macbook 3.1 */
7295                 case 0x106b3800: /* MacbookPro4,1 - latter revision */
7296                         board_config = ALC885_MBP3;
7297                         break;
7298                 case 0x106b3f00: /* Macbook 5,1 */
7299                 case 0x106b4000: /* Macbook Pro 5,1 - FIXME: HP jack sense
7300                                   *   seems not working, so apparently
7301                                   *   no perfect solution yet
7302                                   */
7303                         board_config = ALC885_MB5;
7304                         break;
7305                 default:
7306                         /* ALC889A is handled better as ALC888-compatible */
7307                         if (codec->revision_id == 0x100101 ||
7308                             codec->revision_id == 0x100103) {
7309                                 alc_free(codec);
7310                                 return patch_alc883(codec);
7311                         }
7312                         printk(KERN_INFO "hda_codec: Unknown model for %s, "
7313                                "trying auto-probe from BIOS...\n",
7314                                codec->chip_name);
7315                         board_config = ALC882_AUTO;
7316                 }
7317         }
7318
7319         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
7320
7321         if (board_config == ALC882_AUTO) {
7322                 /* automatic parse from the BIOS config */
7323                 err = alc882_parse_auto_config(codec);
7324                 if (err < 0) {
7325                         alc_free(codec);
7326                         return err;
7327                 } else if (!err) {
7328                         printk(KERN_INFO
7329                                "hda_codec: Cannot set up configuration "
7330                                "from BIOS.  Using base mode...\n");
7331                         board_config = ALC882_3ST_DIG;
7332                 }
7333         }
7334
7335         err = snd_hda_attach_beep_device(codec, 0x1);
7336         if (err < 0) {
7337                 alc_free(codec);
7338                 return err;
7339         }
7340
7341         if (board_config != ALC882_AUTO)
7342                 setup_preset(spec, &alc882_presets[board_config]);
7343
7344         spec->stream_analog_playback = &alc882_pcm_analog_playback;
7345         spec->stream_analog_capture = &alc882_pcm_analog_capture;
7346         /* FIXME: setup DAC5 */
7347         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
7348         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
7349
7350         spec->stream_digital_playback = &alc882_pcm_digital_playback;
7351         spec->stream_digital_capture = &alc882_pcm_digital_capture;
7352
7353         spec->capture_style = CAPT_MIX; /* matrix-style capture */
7354         if (!spec->adc_nids && spec->input_mux) {
7355                 /* check whether NID 0x07 is valid */
7356                 unsigned int wcap = get_wcaps(codec, 0x07);
7357                 /* get type */
7358                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
7359                 if (wcap != AC_WID_AUD_IN) {
7360                         spec->adc_nids = alc882_adc_nids_alt;
7361                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
7362                         spec->capsrc_nids = alc882_capsrc_nids_alt;
7363                 } else {
7364                         spec->adc_nids = alc882_adc_nids;
7365                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
7366                         spec->capsrc_nids = alc882_capsrc_nids;
7367                 }
7368         }
7369         set_capture_mixer(spec);
7370         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
7371
7372         spec->vmaster_nid = 0x0c;
7373
7374         codec->patch_ops = alc_patch_ops;
7375         if (board_config == ALC882_AUTO)
7376                 spec->init_hook = alc882_auto_init;
7377 #ifdef CONFIG_SND_HDA_POWER_SAVE
7378         if (!spec->loopback.amplist)
7379                 spec->loopback.amplist = alc882_loopbacks;
7380 #endif
7381         codec->proc_widget_hook = print_realtek_coef;
7382
7383         return 0;
7384 }
7385
7386 /*
7387  * ALC883 support
7388  *
7389  * ALC883 is almost identical with ALC880 but has cleaner and more flexible
7390  * configuration.  Each pin widget can choose any input DACs and a mixer.
7391  * Each ADC is connected from a mixer of all inputs.  This makes possible
7392  * 6-channel independent captures.
7393  *
7394  * In addition, an independent DAC for the multi-playback (not used in this
7395  * driver yet).
7396  */
7397 #define ALC883_DIGOUT_NID       0x06
7398 #define ALC883_DIGIN_NID        0x0a
7399
7400 #define ALC1200_DIGOUT_NID      0x10
7401
7402 static hda_nid_t alc883_dac_nids[4] = {
7403         /* front, rear, clfe, rear_surr */
7404         0x02, 0x03, 0x04, 0x05
7405 };
7406
7407 static hda_nid_t alc883_adc_nids[2] = {
7408         /* ADC1-2 */
7409         0x08, 0x09,
7410 };
7411
7412 static hda_nid_t alc883_adc_nids_alt[1] = {
7413         /* ADC1 */
7414         0x08,
7415 };
7416
7417 static hda_nid_t alc883_adc_nids_rev[2] = {
7418         /* ADC2-1 */
7419         0x09, 0x08
7420 };
7421
7422 #define alc889_adc_nids         alc880_adc_nids
7423
7424 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
7425
7426 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7427
7428 #define alc889_capsrc_nids      alc882_capsrc_nids
7429
7430 /* input MUX */
7431 /* FIXME: should be a matrix-type input source selection */
7432
7433 static struct hda_input_mux alc883_capture_source = {
7434         .num_items = 4,
7435         .items = {
7436                 { "Mic", 0x0 },
7437                 { "Front Mic", 0x1 },
7438                 { "Line", 0x2 },
7439                 { "CD", 0x4 },
7440         },
7441 };
7442
7443 static struct hda_input_mux alc883_3stack_6ch_intel = {
7444         .num_items = 4,
7445         .items = {
7446                 { "Mic", 0x1 },
7447                 { "Front Mic", 0x0 },
7448                 { "Line", 0x2 },
7449                 { "CD", 0x4 },
7450         },
7451 };
7452
7453 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7454         .num_items = 2,
7455         .items = {
7456                 { "Mic", 0x1 },
7457                 { "Line", 0x2 },
7458         },
7459 };
7460
7461 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7462         .num_items = 4,
7463         .items = {
7464                 { "Mic", 0x0 },
7465                 { "iMic", 0x1 },
7466                 { "Line", 0x2 },
7467                 { "CD", 0x4 },
7468         },
7469 };
7470
7471 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7472         .num_items = 2,
7473         .items = {
7474                 { "Mic", 0x0 },
7475                 { "Int Mic", 0x1 },
7476         },
7477 };
7478
7479 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7480         .num_items = 3,
7481         .items = {
7482                 { "Mic", 0x0 },
7483                 { "Front Mic", 0x1 },
7484                 { "Line", 0x4 },
7485         },
7486 };
7487
7488 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7489         .num_items = 2,
7490         .items = {
7491                 { "Mic", 0x0 },
7492                 { "Line", 0x2 },
7493         },
7494 };
7495
7496 /*
7497  * 2ch mode
7498  */
7499 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7500         { 2, NULL }
7501 };
7502
7503 /*
7504  * 2ch mode
7505  */
7506 static struct hda_verb alc883_3ST_ch2_init[] = {
7507         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7508         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7509         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7510         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7511         { } /* end */
7512 };
7513
7514 /*
7515  * 4ch mode
7516  */
7517 static struct hda_verb alc883_3ST_ch4_init[] = {
7518         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7519         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7520         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7521         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7522         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7523         { } /* end */
7524 };
7525
7526 /*
7527  * 6ch mode
7528  */
7529 static struct hda_verb alc883_3ST_ch6_init[] = {
7530         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7531         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7532         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7533         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7534         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7535         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7536         { } /* end */
7537 };
7538
7539 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
7540         { 2, alc883_3ST_ch2_init },
7541         { 4, alc883_3ST_ch4_init },
7542         { 6, alc883_3ST_ch6_init },
7543 };
7544
7545 /*
7546  * 2ch mode
7547  */
7548 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7549         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7550         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7551         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7552         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7553         { } /* end */
7554 };
7555
7556 /*
7557  * 4ch mode
7558  */
7559 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7560         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7561         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7562         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7563         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7564         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7565         { } /* end */
7566 };
7567
7568 /*
7569  * 6ch mode
7570  */
7571 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7572         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7573         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7574         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7575         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7576         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7577         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7578         { } /* end */
7579 };
7580
7581 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7582         { 2, alc883_3ST_ch2_intel_init },
7583         { 4, alc883_3ST_ch4_intel_init },
7584         { 6, alc883_3ST_ch6_intel_init },
7585 };
7586
7587 /*
7588  * 6ch mode
7589  */
7590 static struct hda_verb alc883_sixstack_ch6_init[] = {
7591         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7592         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7593         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7594         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7595         { } /* end */
7596 };
7597
7598 /*
7599  * 8ch mode
7600  */
7601 static struct hda_verb alc883_sixstack_ch8_init[] = {
7602         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7603         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7604         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7605         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7606         { } /* end */
7607 };
7608
7609 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7610         { 6, alc883_sixstack_ch6_init },
7611         { 8, alc883_sixstack_ch8_init },
7612 };
7613
7614 static struct hda_verb alc883_medion_eapd_verbs[] = {
7615         /* eanable EAPD on medion laptop */
7616         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7617         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7618         { }
7619 };
7620
7621 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7622  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7623  */
7624
7625 static struct snd_kcontrol_new alc883_base_mixer[] = {
7626         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7627         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7628         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7629         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7630         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7631         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7632         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7633         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7634         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7635         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7636         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7637         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7638         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7639         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7640         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7641         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7642         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7643         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7644         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7645         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7646         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7647         { } /* end */
7648 };
7649
7650 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7651         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7652         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7653         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7654         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7655         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7656         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7657         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7658         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7659         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7660         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7661         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7662         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7663         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7664         { } /* end */
7665 };
7666
7667 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7668         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7669         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7670         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7671         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7672         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7673         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7674         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7675         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7676         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7677         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7678         { } /* end */
7679 };
7680
7681 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7682         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7683         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7684         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7685         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7686         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7687         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7688         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7689         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7690         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7691         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7692         { } /* end */
7693 };
7694
7695 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7696         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7697         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7698         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7699         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7700         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7701         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7702         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7703         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7704         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7705         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7706         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7707         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7708         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7709         { } /* end */
7710 };
7711
7712 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7713         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7714         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7715         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7716         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7717         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7718         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7719         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7720         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7721         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7722         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7723         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7724         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7725         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7726         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7727         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7728         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7729         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7730         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7731         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7732         { } /* end */
7733 };
7734
7735 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7736         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7737         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7738         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7739         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7740         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7741                               HDA_OUTPUT),
7742         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7743         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7744         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7745         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7746         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7747         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7748         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7749         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7750         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7751         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7752         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7753         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7754         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7755         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7756         { } /* end */
7757 };
7758
7759 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7760         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7761         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7762         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7763         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7764         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7765         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7766         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7767         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7768         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7769         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7770         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7771         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7772         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7773         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7774         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7775         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7776         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7777         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7778         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7779         { } /* end */
7780 };
7781
7782 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7783         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7784         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7785         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7786         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7787         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7788         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7789         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7790         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7791         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7792         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7793         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7794         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7795         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7796         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7797         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7798         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7799         { } /* end */
7800 };
7801
7802 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7803         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7804         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7805         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7806         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7807         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7808         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7809         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7810         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7811         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7812         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7813         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7814         { } /* end */
7815 };
7816
7817 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7818         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7819         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7820         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7821         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7822         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7823         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7824         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7825         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7826         { } /* end */
7827 };
7828
7829 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7830         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7831         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7832         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7833         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7834         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7835         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7836         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7837         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7838         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7839         { } /* end */
7840 };
7841
7842 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7843         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7844         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7845         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7846         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7847         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7848         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7849         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7850         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7851         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7852         { } /* end */
7853 };
7854
7855 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7856         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7857         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7858         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7859         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7860         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7861         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7862         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7863         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7864         { } /* end */
7865 };
7866
7867 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7868         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7869         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7870         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7871         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7872         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7873                                                 0x0d, 1, 0x0, HDA_OUTPUT),
7874         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7875         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7876         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7877         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7878         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7879         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7880         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7881         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7882         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7883         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7884         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7885         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7886         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7887         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7888         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7889         { } /* end */
7890 };
7891
7892 static struct hda_bind_ctls alc883_bind_cap_vol = {
7893         .ops = &snd_hda_bind_vol,
7894         .values = {
7895                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7896                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7897                 0
7898         },
7899 };
7900
7901 static struct hda_bind_ctls alc883_bind_cap_switch = {
7902         .ops = &snd_hda_bind_sw,
7903         .values = {
7904                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7905                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7906                 0
7907         },
7908 };
7909
7910 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
7911         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7912         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7913         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7914         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7915         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7916         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7917         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7918         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7919         { } /* end */
7920 };
7921
7922 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
7923         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
7924         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
7925         {
7926                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7927                 /* .name = "Capture Source", */
7928                 .name = "Input Source",
7929                 .count = 1,
7930                 .info = alc_mux_enum_info,
7931                 .get = alc_mux_enum_get,
7932                 .put = alc_mux_enum_put,
7933         },
7934         { } /* end */
7935 };
7936
7937 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7938         {
7939                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7940                 .name = "Channel Mode",
7941                 .info = alc_ch_mode_info,
7942                 .get = alc_ch_mode_get,
7943                 .put = alc_ch_mode_put,
7944         },
7945         { } /* end */
7946 };
7947
7948 static struct hda_verb alc883_init_verbs[] = {
7949         /* ADC1: mute amp left and right */
7950         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7951         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7952         /* ADC2: mute amp left and right */
7953         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7954         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7955         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7956         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7957         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7958         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7959         /* Rear mixer */
7960         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7961         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7962         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7963         /* CLFE mixer */
7964         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7965         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7966         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7967         /* Side mixer */
7968         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7969         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7970         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7971
7972         /* mute analog input loopbacks */
7973         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7974         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7975         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7976         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7977         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7978
7979         /* Front Pin: output 0 (0x0c) */
7980         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7981         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7982         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7983         /* Rear Pin: output 1 (0x0d) */
7984         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7985         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7986         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7987         /* CLFE Pin: output 2 (0x0e) */
7988         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7989         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7990         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7991         /* Side Pin: output 3 (0x0f) */
7992         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7993         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7994         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7995         /* Mic (rear) pin: input vref at 80% */
7996         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7997         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7998         /* Front Mic pin: input vref at 80% */
7999         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8000         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8001         /* Line In pin: input */
8002         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8003         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8004         /* Line-2 In: Headphone output (output 0 - 0x0c) */
8005         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8006         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8007         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8008         /* CD pin widget for input */
8009         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8010
8011         /* FIXME: use matrix-type input source selection */
8012         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8013         /* Input mixer2 */
8014         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8015         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8016         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8017         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8018         /* Input mixer3 */
8019         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8020         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8021         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8022         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8023         { }
8024 };
8025
8026 /* toggle speaker-output according to the hp-jack state */
8027 static void alc883_mitac_init_hook(struct hda_codec *codec)
8028 {
8029         struct alc_spec *spec = codec->spec;
8030
8031         spec->autocfg.hp_pins[0] = 0x15;
8032         spec->autocfg.speaker_pins[0] = 0x14;
8033         spec->autocfg.speaker_pins[1] = 0x17;
8034         alc_automute_amp(codec);
8035 }
8036
8037 /* auto-toggle front mic */
8038 /*
8039 static void alc883_mitac_mic_automute(struct hda_codec *codec)
8040 {
8041         unsigned int present;
8042         unsigned char bits;
8043
8044         present = snd_hda_codec_read(codec, 0x18, 0,
8045                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8046         bits = present ? HDA_AMP_MUTE : 0;
8047         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
8048 }
8049 */
8050
8051 static struct hda_verb alc883_mitac_verbs[] = {
8052         /* HP */
8053         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8054         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8055         /* Subwoofer */
8056         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8057         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8058
8059         /* enable unsolicited event */
8060         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8061         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8062
8063         { } /* end */
8064 };
8065
8066 static struct hda_verb alc883_clevo_m720_verbs[] = {
8067         /* HP */
8068         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8069         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8070         /* Int speaker */
8071         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
8072         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8073
8074         /* enable unsolicited event */
8075         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8076         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8077
8078         { } /* end */
8079 };
8080
8081 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8082         /* HP */
8083         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8084         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8085         /* Subwoofer */
8086         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8087         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8088
8089         /* enable unsolicited event */
8090         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8091
8092         { } /* end */
8093 };
8094
8095 static struct hda_verb alc883_tagra_verbs[] = {
8096         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8097         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8098
8099         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8100         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8101
8102         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8103         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8104         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8105
8106         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8107         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
8108         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
8109         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
8110
8111         { } /* end */
8112 };
8113
8114 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8115         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8116         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8117         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8118         { } /* end */
8119 };
8120
8121 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8122         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8123         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8124         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8125         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8126         { } /* end */
8127 };
8128
8129 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8130         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8131         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8132         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8133         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8134         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8135         { } /* end */
8136 };
8137
8138 static struct hda_verb alc883_haier_w66_verbs[] = {
8139         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8140         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8141
8142         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8143
8144         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8145         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8146         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8147         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8148         { } /* end */
8149 };
8150
8151 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8152         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8153         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8154         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8155         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8156         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8157         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8158         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8159         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8160         { } /* end */
8161 };
8162
8163 static struct hda_verb alc888_6st_dell_verbs[] = {
8164         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8165         { }
8166 };
8167
8168 static void alc888_3st_hp_init_hook(struct hda_codec *codec)
8169 {
8170         struct alc_spec *spec = codec->spec;
8171
8172         spec->autocfg.hp_pins[0] = 0x1b;
8173         spec->autocfg.speaker_pins[0] = 0x14;
8174         spec->autocfg.speaker_pins[1] = 0x16;
8175         spec->autocfg.speaker_pins[2] = 0x18;
8176         alc_automute_amp(codec);
8177 }
8178
8179 static struct hda_verb alc888_3st_hp_verbs[] = {
8180         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8181         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8182         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8183         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8184         { } /* end */
8185 };
8186
8187 /*
8188  * 2ch mode
8189  */
8190 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8191         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8192         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8193         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8194         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8195         { } /* end */
8196 };
8197
8198 /*
8199  * 4ch mode
8200  */
8201 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8202         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8203         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8204         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8205         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8206         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8207         { } /* end */
8208 };
8209
8210 /*
8211  * 6ch mode
8212  */
8213 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8214         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8215         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8216         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8217         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8218         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8219         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8220         { } /* end */
8221 };
8222
8223 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8224         { 2, alc888_3st_hp_2ch_init },
8225         { 4, alc888_3st_hp_4ch_init },
8226         { 6, alc888_3st_hp_6ch_init },
8227 };
8228
8229 /* toggle front-jack and RCA according to the hp-jack state */
8230 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8231 {
8232         unsigned int present;
8233
8234         present = snd_hda_codec_read(codec, 0x1b, 0,
8235                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8236         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8237                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8238         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8239                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8240 }
8241
8242 /* toggle RCA according to the front-jack state */
8243 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8244 {
8245         unsigned int present;
8246
8247         present = snd_hda_codec_read(codec, 0x14, 0,
8248                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8249         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8250                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8251 }
8252
8253 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8254                                              unsigned int res)
8255 {
8256         if ((res >> 26) == ALC880_HP_EVENT)
8257                 alc888_lenovo_ms7195_front_automute(codec);
8258         if ((res >> 26) == ALC880_FRONT_EVENT)
8259                 alc888_lenovo_ms7195_rca_automute(codec);
8260 }
8261
8262 static struct hda_verb alc883_medion_md2_verbs[] = {
8263         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8264         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8265
8266         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8267
8268         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8269         { } /* end */
8270 };
8271
8272 /* toggle speaker-output according to the hp-jack state */
8273 static void alc883_medion_md2_init_hook(struct hda_codec *codec)
8274 {
8275         struct alc_spec *spec = codec->spec;
8276
8277         spec->autocfg.hp_pins[0] = 0x14;
8278         spec->autocfg.speaker_pins[0] = 0x15;
8279         alc_automute_amp(codec);
8280 }
8281
8282 /* toggle speaker-output according to the hp-jack state */
8283 #define alc883_tagra_init_hook          alc882_targa_init_hook
8284 #define alc883_tagra_unsol_event        alc882_targa_unsol_event
8285
8286 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8287 {
8288         unsigned int present;
8289
8290         present = snd_hda_codec_read(codec, 0x18, 0,
8291                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8292         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8293                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8294 }
8295
8296 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8297 {
8298         struct alc_spec *spec = codec->spec;
8299
8300         spec->autocfg.hp_pins[0] = 0x15;
8301         spec->autocfg.speaker_pins[0] = 0x14;
8302         alc_automute_amp(codec);
8303         alc883_clevo_m720_mic_automute(codec);
8304 }
8305
8306 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8307                                            unsigned int res)
8308 {
8309         switch (res >> 26) {
8310         case ALC880_MIC_EVENT:
8311                 alc883_clevo_m720_mic_automute(codec);
8312                 break;
8313         default:
8314                 alc_automute_amp_unsol_event(codec, res);
8315                 break;
8316         }
8317 }
8318
8319 /* toggle speaker-output according to the hp-jack state */
8320 static void alc883_2ch_fujitsu_pi2515_init_hook(struct hda_codec *codec)
8321 {
8322         struct alc_spec *spec = codec->spec;
8323
8324         spec->autocfg.hp_pins[0] = 0x14;
8325         spec->autocfg.speaker_pins[0] = 0x15;
8326         alc_automute_amp(codec);
8327 }
8328
8329 static void alc883_haier_w66_init_hook(struct hda_codec *codec)
8330 {
8331         struct alc_spec *spec = codec->spec;
8332
8333         spec->autocfg.hp_pins[0] = 0x1b;
8334         spec->autocfg.speaker_pins[0] = 0x14;
8335         alc_automute_amp(codec);
8336 }
8337
8338 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8339 {
8340         unsigned int present;
8341         unsigned char bits;
8342
8343         present = snd_hda_codec_read(codec, 0x14, 0,
8344                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8345         bits = present ? HDA_AMP_MUTE : 0;
8346         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8347                                  HDA_AMP_MUTE, bits);
8348 }
8349
8350 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8351 {
8352         unsigned int present;
8353         unsigned char bits;
8354
8355         present = snd_hda_codec_read(codec, 0x1b, 0,
8356                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8357         bits = present ? HDA_AMP_MUTE : 0;
8358         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8359                                  HDA_AMP_MUTE, bits);
8360         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8361                                  HDA_AMP_MUTE, bits);
8362 }
8363
8364 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8365                                            unsigned int res)
8366 {
8367         if ((res >> 26) == ALC880_HP_EVENT)
8368                 alc883_lenovo_101e_all_automute(codec);
8369         if ((res >> 26) == ALC880_FRONT_EVENT)
8370                 alc883_lenovo_101e_ispeaker_automute(codec);
8371 }
8372
8373 /* toggle speaker-output according to the hp-jack state */
8374 static void alc883_acer_aspire_init_hook(struct hda_codec *codec)
8375 {
8376         struct alc_spec *spec = codec->spec;
8377
8378         spec->autocfg.hp_pins[0] = 0x14;
8379         spec->autocfg.speaker_pins[0] = 0x15;
8380         spec->autocfg.speaker_pins[1] = 0x16;
8381         alc_automute_amp(codec);
8382 }
8383
8384 static struct hda_verb alc883_acer_eapd_verbs[] = {
8385         /* HP Pin: output 0 (0x0c) */
8386         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8387         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8388         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8389         /* Front Pin: output 0 (0x0c) */
8390         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8391         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8392         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8393         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8394         /* eanable EAPD on medion laptop */
8395         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8396         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8397         /* enable unsolicited event */
8398         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8399         { }
8400 };
8401
8402 static void alc888_6st_dell_init_hook(struct hda_codec *codec)
8403 {
8404         struct alc_spec *spec = codec->spec;
8405
8406         spec->autocfg.hp_pins[0] = 0x1b;
8407         spec->autocfg.speaker_pins[0] = 0x14;
8408         spec->autocfg.speaker_pins[1] = 0x15;
8409         spec->autocfg.speaker_pins[2] = 0x16;
8410         spec->autocfg.speaker_pins[3] = 0x17;
8411         alc_automute_amp(codec);
8412 }
8413
8414 static void alc888_lenovo_sky_init_hook(struct hda_codec *codec)
8415 {
8416         struct alc_spec *spec = codec->spec;
8417
8418         spec->autocfg.hp_pins[0] = 0x1b;
8419         spec->autocfg.speaker_pins[0] = 0x14;
8420         spec->autocfg.speaker_pins[1] = 0x15;
8421         spec->autocfg.speaker_pins[2] = 0x16;
8422         spec->autocfg.speaker_pins[3] = 0x17;
8423         spec->autocfg.speaker_pins[4] = 0x1a;
8424         alc_automute_amp(codec);
8425 }
8426
8427 /*
8428  * generic initialization of ADC, input mixers and output mixers
8429  */
8430 static struct hda_verb alc883_auto_init_verbs[] = {
8431         /*
8432          * Unmute ADC0-2 and set the default input to mic-in
8433          */
8434         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8435         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8436         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8437         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8438
8439         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8440          * mixer widget
8441          * Note: PASD motherboards uses the Line In 2 as the input for
8442          * front panel mic (mic 2)
8443          */
8444         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8445         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8446         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8447         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8448         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8449         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8450
8451         /*
8452          * Set up output mixers (0x0c - 0x0f)
8453          */
8454         /* set vol=0 to output mixers */
8455         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8456         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8457         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8458         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8459         /* set up input amps for analog loopback */
8460         /* Amp Indices: DAC = 0, mixer = 1 */
8461         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8462         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8463         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8464         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8465         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8466         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8467         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8468         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8469         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8470         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8471
8472         /* FIXME: use matrix-type input source selection */
8473         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8474         /* Input mixer1 */
8475         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8476         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8477         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8478         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8479         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8480         /* Input mixer2 */
8481         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8482         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8483         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8484         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8485         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8486
8487         { }
8488 };
8489
8490 static struct hda_verb alc888_asus_m90v_verbs[] = {
8491         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8492         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8493         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8494         /* enable unsolicited event */
8495         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8496         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8497         { } /* end */
8498 };
8499
8500 static void alc883_nb_mic_automute(struct hda_codec *codec)
8501 {
8502         unsigned int present;
8503
8504         present = snd_hda_codec_read(codec, 0x18, 0,
8505                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8506         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8507                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8508         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8509                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8510 }
8511
8512 static void alc883_M90V_init_hook(struct hda_codec *codec)
8513 {
8514         struct alc_spec *spec = codec->spec;
8515
8516         spec->autocfg.hp_pins[0] = 0x1b;
8517         spec->autocfg.speaker_pins[0] = 0x14;
8518         spec->autocfg.speaker_pins[1] = 0x15;
8519         spec->autocfg.speaker_pins[2] = 0x16;
8520         alc_automute_pin(codec);
8521 }
8522
8523 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8524                                            unsigned int res)
8525 {
8526         switch (res >> 26) {
8527         case ALC880_MIC_EVENT:
8528                 alc883_nb_mic_automute(codec);
8529                 break;
8530         default:
8531                 alc_sku_unsol_event(codec, res);
8532                 break;
8533         }
8534 }
8535
8536 static void alc883_mode2_inithook(struct hda_codec *codec)
8537 {
8538         alc883_M90V_init_hook(codec);
8539         alc883_nb_mic_automute(codec);
8540 }
8541
8542 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8543         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8544         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8545         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8546         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8547         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8548         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8549         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8550         /* enable unsolicited event */
8551         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8552         { } /* end */
8553 };
8554
8555 static void alc883_eee1601_inithook(struct hda_codec *codec)
8556 {
8557         struct alc_spec *spec = codec->spec;
8558
8559         spec->autocfg.hp_pins[0] = 0x14;
8560         spec->autocfg.speaker_pins[0] = 0x1b;
8561         alc_automute_pin(codec);
8562 }
8563
8564 #ifdef CONFIG_SND_HDA_POWER_SAVE
8565 #define alc883_loopbacks        alc880_loopbacks
8566 #endif
8567
8568 /* pcm configuration: identiacal with ALC880 */
8569 #define alc883_pcm_analog_playback      alc880_pcm_analog_playback
8570 #define alc883_pcm_analog_capture       alc880_pcm_analog_capture
8571 #define alc883_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
8572 #define alc883_pcm_digital_playback     alc880_pcm_digital_playback
8573 #define alc883_pcm_digital_capture      alc880_pcm_digital_capture
8574
8575 /*
8576  * configuration and preset
8577  */
8578 static const char *alc883_models[ALC883_MODEL_LAST] = {
8579         [ALC883_3ST_2ch_DIG]    = "3stack-dig",
8580         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8581         [ALC883_3ST_6ch]        = "3stack-6ch",
8582         [ALC883_6ST_DIG]        = "6stack-dig",
8583         [ALC883_TARGA_DIG]      = "targa-dig",
8584         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8585         [ALC883_ACER]           = "acer",
8586         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8587         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8588         [ALC883_MEDION]         = "medion",
8589         [ALC883_MEDION_MD2]     = "medion-md2",
8590         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8591         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8592         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8593         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8594         [ALC888_LENOVO_SKY] = "lenovo-sky",
8595         [ALC883_HAIER_W66]      = "haier-w66",
8596         [ALC888_3ST_HP]         = "3stack-hp",
8597         [ALC888_6ST_DELL]       = "6stack-dell",
8598         [ALC883_MITAC]          = "mitac",
8599         [ALC883_CLEVO_M720]     = "clevo-m720",
8600         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8601         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8602         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8603         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8604         [ALC883_AUTO]           = "auto",
8605 };
8606
8607 static struct snd_pci_quirk alc883_cfg_tbl[] = {
8608         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
8609         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8610         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8611         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
8612         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8613         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8614         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8615         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8616                 ALC888_ACER_ASPIRE_4930G),
8617         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8618                 ALC888_ACER_ASPIRE_4930G),
8619         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC883_AUTO),
8620         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC883_AUTO),
8621         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8622                 ALC888_ACER_ASPIRE_4930G),
8623         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8624                 ALC888_ACER_ASPIRE_4930G),
8625         /* default Acer -- disabled as it causes more problems.
8626          *    model=auto should work fine now
8627          */
8628         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
8629         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8630         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8631         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8632         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8633         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8634         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8635         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
8636         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8637         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8638         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8639         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8640         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8641         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8642         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
8643         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8644         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8645         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8646         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8647         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8648         SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
8649         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8650         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8651         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8652         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8653         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8654         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8655         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8656         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8657         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8658         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8659         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8660         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8661         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8662         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8663         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8664         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8665         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8666         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8667         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8668         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8669         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8670         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8671         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8672         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8673         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8674         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8675         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
8676         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8677         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8678         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
8679                       ALC883_FUJITSU_PI2515),
8680         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
8681                 ALC888_FUJITSU_XA3530),
8682         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8683         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8684         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8685         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8686         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8687         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8688         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
8689         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8690         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8691         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8692         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8693         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
8694         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL),
8695         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8696         {}
8697 };
8698
8699 static hda_nid_t alc883_slave_dig_outs[] = {
8700         ALC1200_DIGOUT_NID, 0,
8701 };
8702
8703 static hda_nid_t alc1200_slave_dig_outs[] = {
8704         ALC883_DIGOUT_NID, 0,
8705 };
8706
8707 static struct alc_config_preset alc883_presets[] = {
8708         [ALC883_3ST_2ch_DIG] = {
8709                 .mixers = { alc883_3ST_2ch_mixer },
8710                 .init_verbs = { alc883_init_verbs },
8711                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8712                 .dac_nids = alc883_dac_nids,
8713                 .dig_out_nid = ALC883_DIGOUT_NID,
8714                 .dig_in_nid = ALC883_DIGIN_NID,
8715                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8716                 .channel_mode = alc883_3ST_2ch_modes,
8717                 .input_mux = &alc883_capture_source,
8718         },
8719         [ALC883_3ST_6ch_DIG] = {
8720                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8721                 .init_verbs = { alc883_init_verbs },
8722                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8723                 .dac_nids = alc883_dac_nids,
8724                 .dig_out_nid = ALC883_DIGOUT_NID,
8725                 .dig_in_nid = ALC883_DIGIN_NID,
8726                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8727                 .channel_mode = alc883_3ST_6ch_modes,
8728                 .need_dac_fix = 1,
8729                 .input_mux = &alc883_capture_source,
8730         },
8731         [ALC883_3ST_6ch] = {
8732                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8733                 .init_verbs = { alc883_init_verbs },
8734                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8735                 .dac_nids = alc883_dac_nids,
8736                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8737                 .channel_mode = alc883_3ST_6ch_modes,
8738                 .need_dac_fix = 1,
8739                 .input_mux = &alc883_capture_source,
8740         },
8741         [ALC883_3ST_6ch_INTEL] = {
8742                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8743                 .init_verbs = { alc883_init_verbs },
8744                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8745                 .dac_nids = alc883_dac_nids,
8746                 .dig_out_nid = ALC883_DIGOUT_NID,
8747                 .dig_in_nid = ALC883_DIGIN_NID,
8748                 .slave_dig_outs = alc883_slave_dig_outs,
8749                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8750                 .channel_mode = alc883_3ST_6ch_intel_modes,
8751                 .need_dac_fix = 1,
8752                 .input_mux = &alc883_3stack_6ch_intel,
8753         },
8754         [ALC883_6ST_DIG] = {
8755                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8756                 .init_verbs = { alc883_init_verbs },
8757                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8758                 .dac_nids = alc883_dac_nids,
8759                 .dig_out_nid = ALC883_DIGOUT_NID,
8760                 .dig_in_nid = ALC883_DIGIN_NID,
8761                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8762                 .channel_mode = alc883_sixstack_modes,
8763                 .input_mux = &alc883_capture_source,
8764         },
8765         [ALC883_TARGA_DIG] = {
8766                 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8767                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8768                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8769                 .dac_nids = alc883_dac_nids,
8770                 .dig_out_nid = ALC883_DIGOUT_NID,
8771                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8772                 .channel_mode = alc883_3ST_6ch_modes,
8773                 .need_dac_fix = 1,
8774                 .input_mux = &alc883_capture_source,
8775                 .unsol_event = alc883_tagra_unsol_event,
8776                 .init_hook = alc883_tagra_init_hook,
8777         },
8778         [ALC883_TARGA_2ch_DIG] = {
8779                 .mixers = { alc883_tagra_2ch_mixer},
8780                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8781                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8782                 .dac_nids = alc883_dac_nids,
8783                 .adc_nids = alc883_adc_nids_alt,
8784                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8785                 .dig_out_nid = ALC883_DIGOUT_NID,
8786                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8787                 .channel_mode = alc883_3ST_2ch_modes,
8788                 .input_mux = &alc883_capture_source,
8789                 .unsol_event = alc883_tagra_unsol_event,
8790                 .init_hook = alc883_tagra_init_hook,
8791         },
8792         [ALC883_ACER] = {
8793                 .mixers = { alc883_base_mixer },
8794                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8795                  * and the headphone jack.  Turn this on and rely on the
8796                  * standard mute methods whenever the user wants to turn
8797                  * these outputs off.
8798                  */
8799                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8800                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8801                 .dac_nids = alc883_dac_nids,
8802                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8803                 .channel_mode = alc883_3ST_2ch_modes,
8804                 .input_mux = &alc883_capture_source,
8805         },
8806         [ALC883_ACER_ASPIRE] = {
8807                 .mixers = { alc883_acer_aspire_mixer },
8808                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8809                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8810                 .dac_nids = alc883_dac_nids,
8811                 .dig_out_nid = ALC883_DIGOUT_NID,
8812                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8813                 .channel_mode = alc883_3ST_2ch_modes,
8814                 .input_mux = &alc883_capture_source,
8815                 .unsol_event = alc_automute_amp_unsol_event,
8816                 .init_hook = alc883_acer_aspire_init_hook,
8817         },
8818         [ALC888_ACER_ASPIRE_4930G] = {
8819                 .mixers = { alc888_base_mixer,
8820                                 alc883_chmode_mixer },
8821                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
8822                                 alc888_acer_aspire_4930g_verbs },
8823                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8824                 .dac_nids = alc883_dac_nids,
8825                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8826                 .adc_nids = alc883_adc_nids_rev,
8827                 .capsrc_nids = alc883_capsrc_nids_rev,
8828                 .dig_out_nid = ALC883_DIGOUT_NID,
8829                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8830                 .channel_mode = alc883_3ST_6ch_modes,
8831                 .need_dac_fix = 1,
8832                 .num_mux_defs =
8833                         ARRAY_SIZE(alc888_2_capture_sources),
8834                 .input_mux = alc888_2_capture_sources,
8835                 .unsol_event = alc_automute_amp_unsol_event,
8836                 .init_hook = alc888_acer_aspire_4930g_init_hook,
8837         },
8838         [ALC883_MEDION] = {
8839                 .mixers = { alc883_fivestack_mixer,
8840                             alc883_chmode_mixer },
8841                 .init_verbs = { alc883_init_verbs,
8842                                 alc883_medion_eapd_verbs },
8843                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8844                 .dac_nids = alc883_dac_nids,
8845                 .adc_nids = alc883_adc_nids_alt,
8846                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8847                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8848                 .channel_mode = alc883_sixstack_modes,
8849                 .input_mux = &alc883_capture_source,
8850         },
8851         [ALC883_MEDION_MD2] = {
8852                 .mixers = { alc883_medion_md2_mixer},
8853                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8854                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8855                 .dac_nids = alc883_dac_nids,
8856                 .dig_out_nid = ALC883_DIGOUT_NID,
8857                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8858                 .channel_mode = alc883_3ST_2ch_modes,
8859                 .input_mux = &alc883_capture_source,
8860                 .unsol_event = alc_automute_amp_unsol_event,
8861                 .init_hook = alc883_medion_md2_init_hook,
8862         },
8863         [ALC883_LAPTOP_EAPD] = {
8864                 .mixers = { alc883_base_mixer },
8865                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8866                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8867                 .dac_nids = alc883_dac_nids,
8868                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8869                 .channel_mode = alc883_3ST_2ch_modes,
8870                 .input_mux = &alc883_capture_source,
8871         },
8872         [ALC883_CLEVO_M720] = {
8873                 .mixers = { alc883_clevo_m720_mixer },
8874                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8875                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8876                 .dac_nids = alc883_dac_nids,
8877                 .dig_out_nid = ALC883_DIGOUT_NID,
8878                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8879                 .channel_mode = alc883_3ST_2ch_modes,
8880                 .input_mux = &alc883_capture_source,
8881                 .unsol_event = alc883_clevo_m720_unsol_event,
8882                 .init_hook = alc883_clevo_m720_init_hook,
8883         },
8884         [ALC883_LENOVO_101E_2ch] = {
8885                 .mixers = { alc883_lenovo_101e_2ch_mixer},
8886                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8887                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8888                 .dac_nids = alc883_dac_nids,
8889                 .adc_nids = alc883_adc_nids_alt,
8890                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8891                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8892                 .channel_mode = alc883_3ST_2ch_modes,
8893                 .input_mux = &alc883_lenovo_101e_capture_source,
8894                 .unsol_event = alc883_lenovo_101e_unsol_event,
8895                 .init_hook = alc883_lenovo_101e_all_automute,
8896         },
8897         [ALC883_LENOVO_NB0763] = {
8898                 .mixers = { alc883_lenovo_nb0763_mixer },
8899                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8900                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8901                 .dac_nids = alc883_dac_nids,
8902                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8903                 .channel_mode = alc883_3ST_2ch_modes,
8904                 .need_dac_fix = 1,
8905                 .input_mux = &alc883_lenovo_nb0763_capture_source,
8906                 .unsol_event = alc_automute_amp_unsol_event,
8907                 .init_hook = alc883_medion_md2_init_hook,
8908         },
8909         [ALC888_LENOVO_MS7195_DIG] = {
8910                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8911                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8912                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8913                 .dac_nids = alc883_dac_nids,
8914                 .dig_out_nid = ALC883_DIGOUT_NID,
8915                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8916                 .channel_mode = alc883_3ST_6ch_modes,
8917                 .need_dac_fix = 1,
8918                 .input_mux = &alc883_capture_source,
8919                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
8920                 .init_hook = alc888_lenovo_ms7195_front_automute,
8921         },
8922         [ALC883_HAIER_W66] = {
8923                 .mixers = { alc883_tagra_2ch_mixer},
8924                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8925                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8926                 .dac_nids = alc883_dac_nids,
8927                 .dig_out_nid = ALC883_DIGOUT_NID,
8928                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8929                 .channel_mode = alc883_3ST_2ch_modes,
8930                 .input_mux = &alc883_capture_source,
8931                 .unsol_event = alc_automute_amp_unsol_event,
8932                 .init_hook = alc883_haier_w66_init_hook,
8933         },
8934         [ALC888_3ST_HP] = {
8935                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8936                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
8937                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8938                 .dac_nids = alc883_dac_nids,
8939                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
8940                 .channel_mode = alc888_3st_hp_modes,
8941                 .need_dac_fix = 1,
8942                 .input_mux = &alc883_capture_source,
8943                 .unsol_event = alc_automute_amp_unsol_event,
8944                 .init_hook = alc888_3st_hp_init_hook,
8945         },
8946         [ALC888_6ST_DELL] = {
8947                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8948                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
8949                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8950                 .dac_nids = alc883_dac_nids,
8951                 .dig_out_nid = ALC883_DIGOUT_NID,
8952                 .dig_in_nid = ALC883_DIGIN_NID,
8953                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8954                 .channel_mode = alc883_sixstack_modes,
8955                 .input_mux = &alc883_capture_source,
8956                 .unsol_event = alc_automute_amp_unsol_event,
8957                 .init_hook = alc888_6st_dell_init_hook,
8958         },
8959         [ALC883_MITAC] = {
8960                 .mixers = { alc883_mitac_mixer },
8961                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
8962                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8963                 .dac_nids = alc883_dac_nids,
8964                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8965                 .channel_mode = alc883_3ST_2ch_modes,
8966                 .input_mux = &alc883_capture_source,
8967                 .unsol_event = alc_automute_amp_unsol_event,
8968                 .init_hook = alc883_mitac_init_hook,
8969         },
8970         [ALC883_FUJITSU_PI2515] = {
8971                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
8972                 .init_verbs = { alc883_init_verbs,
8973                                 alc883_2ch_fujitsu_pi2515_verbs},
8974                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8975                 .dac_nids = alc883_dac_nids,
8976                 .dig_out_nid = ALC883_DIGOUT_NID,
8977                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8978                 .channel_mode = alc883_3ST_2ch_modes,
8979                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8980                 .unsol_event = alc_automute_amp_unsol_event,
8981                 .init_hook = alc883_2ch_fujitsu_pi2515_init_hook,
8982         },
8983         [ALC888_FUJITSU_XA3530] = {
8984                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
8985                 .init_verbs = { alc883_init_verbs,
8986                         alc888_fujitsu_xa3530_verbs },
8987                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8988                 .dac_nids = alc883_dac_nids,
8989                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8990                 .adc_nids = alc883_adc_nids_rev,
8991                 .capsrc_nids = alc883_capsrc_nids_rev,
8992                 .dig_out_nid = ALC883_DIGOUT_NID,
8993                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
8994                 .channel_mode = alc888_4ST_8ch_intel_modes,
8995                 .num_mux_defs =
8996                         ARRAY_SIZE(alc888_2_capture_sources),
8997                 .input_mux = alc888_2_capture_sources,
8998                 .unsol_event = alc_automute_amp_unsol_event,
8999                 .init_hook = alc888_fujitsu_xa3530_init_hook,
9000         },
9001         [ALC888_LENOVO_SKY] = {
9002                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9003                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9004                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9005                 .dac_nids = alc883_dac_nids,
9006                 .dig_out_nid = ALC883_DIGOUT_NID,
9007                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9008                 .channel_mode = alc883_sixstack_modes,
9009                 .need_dac_fix = 1,
9010                 .input_mux = &alc883_lenovo_sky_capture_source,
9011                 .unsol_event = alc_automute_amp_unsol_event,
9012                 .init_hook = alc888_lenovo_sky_init_hook,
9013         },
9014         [ALC888_ASUS_M90V] = {
9015                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9016                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9017                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9018                 .dac_nids = alc883_dac_nids,
9019                 .dig_out_nid = ALC883_DIGOUT_NID,
9020                 .dig_in_nid = ALC883_DIGIN_NID,
9021                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9022                 .channel_mode = alc883_3ST_6ch_modes,
9023                 .need_dac_fix = 1,
9024                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9025                 .unsol_event = alc883_mode2_unsol_event,
9026                 .init_hook = alc883_mode2_inithook,
9027         },
9028         [ALC888_ASUS_EEE1601] = {
9029                 .mixers = { alc883_asus_eee1601_mixer },
9030                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
9031                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9032                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9033                 .dac_nids = alc883_dac_nids,
9034                 .dig_out_nid = ALC883_DIGOUT_NID,
9035                 .dig_in_nid = ALC883_DIGIN_NID,
9036                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9037                 .channel_mode = alc883_3ST_2ch_modes,
9038                 .need_dac_fix = 1,
9039                 .input_mux = &alc883_asus_eee1601_capture_source,
9040                 .unsol_event = alc_sku_unsol_event,
9041                 .init_hook = alc883_eee1601_inithook,
9042         },
9043         [ALC1200_ASUS_P5Q] = {
9044                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9045                 .init_verbs = { alc883_init_verbs },
9046                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9047                 .dac_nids = alc883_dac_nids,
9048                 .dig_out_nid = ALC1200_DIGOUT_NID,
9049                 .dig_in_nid = ALC883_DIGIN_NID,
9050                 .slave_dig_outs = alc1200_slave_dig_outs,
9051                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9052                 .channel_mode = alc883_sixstack_modes,
9053                 .input_mux = &alc883_capture_source,
9054         },
9055 };
9056
9057
9058 /*
9059  * BIOS auto configuration
9060  */
9061 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
9062                                               hda_nid_t nid, int pin_type,
9063                                               int dac_idx)
9064 {
9065         /* set as output */
9066         struct alc_spec *spec = codec->spec;
9067         int idx;
9068
9069         alc_set_pin_output(codec, nid, pin_type);
9070         if (spec->multiout.dac_nids[dac_idx] == 0x25)
9071                 idx = 4;
9072         else
9073                 idx = spec->multiout.dac_nids[dac_idx] - 2;
9074         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9075
9076 }
9077
9078 static void alc883_auto_init_multi_out(struct hda_codec *codec)
9079 {
9080         struct alc_spec *spec = codec->spec;
9081         int i;
9082
9083         for (i = 0; i <= HDA_SIDE; i++) {
9084                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9085                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
9086                 if (nid)
9087                         alc883_auto_set_output_and_unmute(codec, nid, pin_type,
9088                                                           i);
9089         }
9090 }
9091
9092 static void alc883_auto_init_hp_out(struct hda_codec *codec)
9093 {
9094         struct alc_spec *spec = codec->spec;
9095         hda_nid_t pin;
9096
9097         pin = spec->autocfg.hp_pins[0];
9098         if (pin) /* connect to front */
9099                 /* use dac 0 */
9100                 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9101         pin = spec->autocfg.speaker_pins[0];
9102         if (pin)
9103                 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9104 }
9105
9106 #define alc883_is_input_pin(nid)        alc880_is_input_pin(nid)
9107 #define ALC883_PIN_CD_NID               ALC880_PIN_CD_NID
9108
9109 static void alc883_auto_init_analog_input(struct hda_codec *codec)
9110 {
9111         struct alc_spec *spec = codec->spec;
9112         int i;
9113
9114         for (i = 0; i < AUTO_PIN_LAST; i++) {
9115                 hda_nid_t nid = spec->autocfg.input_pins[i];
9116                 if (alc883_is_input_pin(nid)) {
9117                         alc_set_input_pin(codec, nid, i);
9118                         if (nid != ALC883_PIN_CD_NID &&
9119                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
9120                                 snd_hda_codec_write(codec, nid, 0,
9121                                                     AC_VERB_SET_AMP_GAIN_MUTE,
9122                                                     AMP_OUT_MUTE);
9123                 }
9124         }
9125 }
9126
9127 #define alc883_auto_init_input_src      alc882_auto_init_input_src
9128
9129 /* almost identical with ALC880 parser... */
9130 static int alc883_parse_auto_config(struct hda_codec *codec)
9131 {
9132         struct alc_spec *spec = codec->spec;
9133         int err = alc880_parse_auto_config(codec);
9134         struct auto_pin_cfg *cfg = &spec->autocfg;
9135         int i;
9136
9137         if (err < 0)
9138                 return err;
9139         else if (!err)
9140                 return 0; /* no config found */
9141
9142         err = alc_auto_add_mic_boost(codec);
9143         if (err < 0)
9144                 return err;
9145
9146         /* hack - override the init verbs */
9147         spec->init_verbs[0] = alc883_auto_init_verbs;
9148
9149         /* setup input_mux for ALC889 */
9150         if (codec->vendor_id == 0x10ec0889) {
9151                 /* digital-mic input pin is excluded in alc880_auto_create..()
9152                  * because it's under 0x18
9153                  */
9154                 if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
9155                     cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
9156                         struct hda_input_mux *imux = &spec->private_imux[0];
9157                         for (i = 1; i < 3; i++)
9158                                 memcpy(&spec->private_imux[i],
9159                                        &spec->private_imux[0],
9160                                        sizeof(spec->private_imux[0]));
9161                         imux->items[imux->num_items].label = "Int DMic";
9162                         imux->items[imux->num_items].index = 0x0b;
9163                         imux->num_items++;
9164                         spec->num_mux_defs = 3;
9165                         spec->input_mux = spec->private_imux;
9166                 }
9167         }
9168
9169         return 1; /* config found */
9170 }
9171
9172 /* additional initialization for auto-configuration model */
9173 static void alc883_auto_init(struct hda_codec *codec)
9174 {
9175         struct alc_spec *spec = codec->spec;
9176         alc883_auto_init_multi_out(codec);
9177         alc883_auto_init_hp_out(codec);
9178         alc883_auto_init_analog_input(codec);
9179         alc883_auto_init_input_src(codec);
9180         if (spec->unsol_event)
9181                 alc_inithook(codec);
9182 }
9183
9184 static int patch_alc883(struct hda_codec *codec)
9185 {
9186         struct alc_spec *spec;
9187         int err, board_config;
9188
9189         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9190         if (spec == NULL)
9191                 return -ENOMEM;
9192
9193         codec->spec = spec;
9194
9195         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9196
9197         board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
9198                                                   alc883_models,
9199                                                   alc883_cfg_tbl);
9200         if (board_config < 0) {
9201                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
9202                        "trying auto-probe from BIOS...\n", codec->chip_name);
9203                 board_config = ALC883_AUTO;
9204         }
9205
9206         if (board_config == ALC883_AUTO) {
9207                 /* automatic parse from the BIOS config */
9208                 err = alc883_parse_auto_config(codec);
9209                 if (err < 0) {
9210                         alc_free(codec);
9211                         return err;
9212                 } else if (!err) {
9213                         printk(KERN_INFO
9214                                "hda_codec: Cannot set up configuration "
9215                                "from BIOS.  Using base mode...\n");
9216                         board_config = ALC883_3ST_2ch_DIG;
9217                 }
9218         }
9219
9220         err = snd_hda_attach_beep_device(codec, 0x1);
9221         if (err < 0) {
9222                 alc_free(codec);
9223                 return err;
9224         }
9225
9226         if (board_config != ALC883_AUTO)
9227                 setup_preset(spec, &alc883_presets[board_config]);
9228
9229         switch (codec->vendor_id) {
9230         case 0x10ec0888:
9231                 if (!spec->num_adc_nids) {
9232                         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9233                         spec->adc_nids = alc883_adc_nids;
9234                 }
9235                 if (!spec->capsrc_nids)
9236                         spec->capsrc_nids = alc883_capsrc_nids;
9237                 spec->capture_style = CAPT_MIX; /* matrix-style capture */
9238                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
9239                 break;
9240         case 0x10ec0889:
9241                 if (!spec->num_adc_nids) {
9242                         spec->num_adc_nids = ARRAY_SIZE(alc889_adc_nids);
9243                         spec->adc_nids = alc889_adc_nids;
9244                 }
9245                 if (!spec->capsrc_nids)
9246                         spec->capsrc_nids = alc889_capsrc_nids;
9247                 spec->capture_style = CAPT_1MUX_MIX; /* 1mux/Nmix-style
9248                                                         capture */
9249                 break;
9250         default:
9251                 if (!spec->num_adc_nids) {
9252                         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9253                         spec->adc_nids = alc883_adc_nids;
9254                 }
9255                 if (!spec->capsrc_nids)
9256                         spec->capsrc_nids = alc883_capsrc_nids;
9257                 spec->capture_style = CAPT_MIX; /* matrix-style capture */
9258                 break;
9259         }
9260
9261         spec->stream_analog_playback = &alc883_pcm_analog_playback;
9262         spec->stream_analog_capture = &alc883_pcm_analog_capture;
9263         spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
9264
9265         spec->stream_digital_playback = &alc883_pcm_digital_playback;
9266         spec->stream_digital_capture = &alc883_pcm_digital_capture;
9267
9268         if (!spec->cap_mixer)
9269                 set_capture_mixer(spec);
9270         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9271
9272         spec->vmaster_nid = 0x0c;
9273
9274         codec->patch_ops = alc_patch_ops;
9275         if (board_config == ALC883_AUTO)
9276                 spec->init_hook = alc883_auto_init;
9277
9278 #ifdef CONFIG_SND_HDA_POWER_SAVE
9279         if (!spec->loopback.amplist)
9280                 spec->loopback.amplist = alc883_loopbacks;
9281 #endif
9282         codec->proc_widget_hook = print_realtek_coef;
9283
9284         return 0;
9285 }
9286
9287 /*
9288  * ALC262 support
9289  */
9290
9291 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
9292 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
9293
9294 #define alc262_dac_nids         alc260_dac_nids
9295 #define alc262_adc_nids         alc882_adc_nids
9296 #define alc262_adc_nids_alt     alc882_adc_nids_alt
9297 #define alc262_capsrc_nids      alc882_capsrc_nids
9298 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
9299
9300 #define alc262_modes            alc260_modes
9301 #define alc262_capture_source   alc882_capture_source
9302
9303 static hda_nid_t alc262_dmic_adc_nids[1] = {
9304         /* ADC0 */
9305         0x09
9306 };
9307
9308 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
9309
9310 static struct snd_kcontrol_new alc262_base_mixer[] = {
9311         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9312         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9313         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9314         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9315         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9316         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9317         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9318         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9319         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9320         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9321         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9322         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9323         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
9324         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9325         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9326         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
9327         { } /* end */
9328 };
9329
9330 /* update HP, line and mono-out pins according to the master switch */
9331 static void alc262_hp_master_update(struct hda_codec *codec)
9332 {
9333         struct alc_spec *spec = codec->spec;
9334         int val = spec->master_sw;
9335
9336         /* HP & line-out */
9337         snd_hda_codec_write_cache(codec, 0x1b, 0,
9338                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9339                                   val ? PIN_HP : 0);
9340         snd_hda_codec_write_cache(codec, 0x15, 0,
9341                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9342                                   val ? PIN_HP : 0);
9343         /* mono (speaker) depending on the HP jack sense */
9344         val = val && !spec->jack_present;
9345         snd_hda_codec_write_cache(codec, 0x16, 0,
9346                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9347                                   val ? PIN_OUT : 0);
9348 }
9349
9350 static void alc262_hp_bpc_automute(struct hda_codec *codec)
9351 {
9352         struct alc_spec *spec = codec->spec;
9353         unsigned int presence;
9354         presence = snd_hda_codec_read(codec, 0x1b, 0,
9355                                       AC_VERB_GET_PIN_SENSE, 0);
9356         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9357         alc262_hp_master_update(codec);
9358 }
9359
9360 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
9361 {
9362         if ((res >> 26) != ALC880_HP_EVENT)
9363                 return;
9364         alc262_hp_bpc_automute(codec);
9365 }
9366
9367 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
9368 {
9369         struct alc_spec *spec = codec->spec;
9370         unsigned int presence;
9371         presence = snd_hda_codec_read(codec, 0x15, 0,
9372                                       AC_VERB_GET_PIN_SENSE, 0);
9373         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9374         alc262_hp_master_update(codec);
9375 }
9376
9377 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
9378                                            unsigned int res)
9379 {
9380         if ((res >> 26) != ALC880_HP_EVENT)
9381                 return;
9382         alc262_hp_wildwest_automute(codec);
9383 }
9384
9385 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
9386
9387 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9388                                    struct snd_ctl_elem_value *ucontrol)
9389 {
9390         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9391         struct alc_spec *spec = codec->spec;
9392         int val = !!*ucontrol->value.integer.value;
9393
9394         if (val == spec->master_sw)
9395                 return 0;
9396         spec->master_sw = val;
9397         alc262_hp_master_update(codec);
9398         return 1;
9399 }
9400
9401 #define ALC262_HP_MASTER_SWITCH                                 \
9402         {                                                       \
9403                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
9404                 .name = "Master Playback Switch",               \
9405                 .info = snd_ctl_boolean_mono_info,              \
9406                 .get = alc262_hp_master_sw_get,                 \
9407                 .put = alc262_hp_master_sw_put,                 \
9408         }
9409
9410 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9411         ALC262_HP_MASTER_SWITCH,
9412         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9413         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9414         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9415         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9416                               HDA_OUTPUT),
9417         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9418                             HDA_OUTPUT),
9419         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9420         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9421         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9422         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9423         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9424         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9425         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9426         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9427         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9428         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9429         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9430         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9431         { } /* end */
9432 };
9433
9434 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9435         ALC262_HP_MASTER_SWITCH,
9436         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9437         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9438         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9439         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9440         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9441                               HDA_OUTPUT),
9442         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9443                             HDA_OUTPUT),
9444         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9445         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9446         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9447         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9448         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9449         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9450         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9451         { } /* end */
9452 };
9453
9454 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9455         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9456         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9457         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9458         { } /* end */
9459 };
9460
9461 /* mute/unmute internal speaker according to the hp jack and mute state */
9462 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9463 {
9464         struct alc_spec *spec = codec->spec;
9465
9466         spec->autocfg.hp_pins[0] = 0x15;
9467         spec->autocfg.speaker_pins[0] = 0x0c; /* HACK: not actually a pin */
9468         alc_automute_amp(codec);
9469 }
9470
9471 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9472         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9473         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9474         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9475         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9476         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9477         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9478         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9479         { } /* end */
9480 };
9481
9482 static struct hda_verb alc262_hp_t5735_verbs[] = {
9483         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9484         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9485
9486         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9487         { }
9488 };
9489
9490 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9491         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9492         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9493         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9494         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9495         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9496         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9497         { } /* end */
9498 };
9499
9500 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9501         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9502         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9503         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9504         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9505         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9506         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9507         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9508         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9509         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9510         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9511         {}
9512 };
9513
9514 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9515         .num_items = 1,
9516         .items = {
9517                 { "Line", 0x1 },
9518         },
9519 };
9520
9521 /* bind hp and internal speaker mute (with plug check) as master switch */
9522 static void alc262_hippo_master_update(struct hda_codec *codec)
9523 {
9524         struct alc_spec *spec = codec->spec;
9525         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
9526         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
9527         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
9528         unsigned int mute;
9529
9530         /* HP */
9531         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
9532         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
9533                                  HDA_AMP_MUTE, mute);
9534         /* mute internal speaker per jack sense */
9535         if (spec->jack_present)
9536                 mute = HDA_AMP_MUTE;
9537         if (line_nid)
9538                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
9539                                          HDA_AMP_MUTE, mute);
9540         if (speaker_nid && speaker_nid != line_nid)
9541                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
9542                                          HDA_AMP_MUTE, mute);
9543 }
9544
9545 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
9546
9547 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
9548                                       struct snd_ctl_elem_value *ucontrol)
9549 {
9550         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9551         struct alc_spec *spec = codec->spec;
9552         int val = !!*ucontrol->value.integer.value;
9553
9554         if (val == spec->master_sw)
9555                 return 0;
9556         spec->master_sw = val;
9557         alc262_hippo_master_update(codec);
9558         return 1;
9559 }
9560
9561 #define ALC262_HIPPO_MASTER_SWITCH                              \
9562         {                                                       \
9563                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
9564                 .name = "Master Playback Switch",               \
9565                 .info = snd_ctl_boolean_mono_info,              \
9566                 .get = alc262_hippo_master_sw_get,              \
9567                 .put = alc262_hippo_master_sw_put,              \
9568         }
9569
9570 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
9571         ALC262_HIPPO_MASTER_SWITCH,
9572         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9573         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9574         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9575         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9576         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9577         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9578         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9579         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9580         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9581         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9582         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9583         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9584         { } /* end */
9585 };
9586
9587 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
9588         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9589         ALC262_HIPPO_MASTER_SWITCH,
9590         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9591         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9592         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9593         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9594         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9595         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9596         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9597         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9598         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9599         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9600         { } /* end */
9601 };
9602
9603 /* mute/unmute internal speaker according to the hp jack and mute state */
9604 static void alc262_hippo_automute(struct hda_codec *codec)
9605 {
9606         struct alc_spec *spec = codec->spec;
9607         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
9608         unsigned int present;
9609
9610         /* need to execute and sync at first */
9611         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
9612         present = snd_hda_codec_read(codec, hp_nid, 0,
9613                                      AC_VERB_GET_PIN_SENSE, 0);
9614         spec->jack_present = (present & 0x80000000) != 0;
9615         alc262_hippo_master_update(codec);
9616 }
9617
9618 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
9619 {
9620         if ((res >> 26) != ALC880_HP_EVENT)
9621                 return;
9622         alc262_hippo_automute(codec);
9623 }
9624
9625 static void alc262_hippo_init_hook(struct hda_codec *codec)
9626 {
9627         struct alc_spec *spec = codec->spec;
9628
9629         spec->autocfg.hp_pins[0] = 0x15;
9630         spec->autocfg.speaker_pins[0] = 0x14;
9631         alc262_hippo_automute(codec);
9632 }
9633
9634 static void alc262_hippo1_init_hook(struct hda_codec *codec)
9635 {
9636         struct alc_spec *spec = codec->spec;
9637
9638         spec->autocfg.hp_pins[0] = 0x1b;
9639         spec->autocfg.speaker_pins[0] = 0x14;
9640         alc262_hippo_automute(codec);
9641 }
9642
9643
9644 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9645         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9646         ALC262_HIPPO_MASTER_SWITCH,
9647         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9648         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9649         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9650         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9651         { } /* end */
9652 };
9653
9654 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9655         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9656         ALC262_HIPPO_MASTER_SWITCH,
9657         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
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_tyan_mixer[] = {
9666         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9667         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9668         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
9669         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
9670         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9671         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9672         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9673         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9674         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9675         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9676         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9677         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9678         { } /* end */
9679 };
9680
9681 static struct hda_verb alc262_tyan_verbs[] = {
9682         /* Headphone automute */
9683         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9684         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9685         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9686
9687         /* P11 AUX_IN, white 4-pin connector */
9688         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9689         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
9690         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
9691         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
9692
9693         {}
9694 };
9695
9696 /* unsolicited event for HP jack sensing */
9697 static void alc262_tyan_init_hook(struct hda_codec *codec)
9698 {
9699         struct alc_spec *spec = codec->spec;
9700
9701         spec->autocfg.hp_pins[0] = 0x1b;
9702         spec->autocfg.speaker_pins[0] = 0x15;
9703         alc_automute_amp(codec);
9704 }
9705
9706
9707 #define alc262_capture_mixer            alc882_capture_mixer
9708 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
9709
9710 /*
9711  * generic initialization of ADC, input mixers and output mixers
9712  */
9713 static struct hda_verb alc262_init_verbs[] = {
9714         /*
9715          * Unmute ADC0-2 and set the default input to mic-in
9716          */
9717         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9718         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9719         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9720         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9721         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9722         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9723
9724         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9725          * mixer widget
9726          * Note: PASD motherboards uses the Line In 2 as the input for
9727          * front panel mic (mic 2)
9728          */
9729         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9730         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9731         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9732         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9733         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9734         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9735
9736         /*
9737          * Set up output mixers (0x0c - 0x0e)
9738          */
9739         /* set vol=0 to output mixers */
9740         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9741         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9742         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9743         /* set up input amps for analog loopback */
9744         /* Amp Indices: DAC = 0, mixer = 1 */
9745         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9746         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9747         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9748         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9749         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9750         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9751
9752         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9753         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9754         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9755         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9756         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9757         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9758
9759         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9760         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9761         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9762         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9763         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9764
9765         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9766         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9767
9768         /* FIXME: use matrix-type input source selection */
9769         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9770         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9771         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9772         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9773         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9774         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9775         /* Input mixer2 */
9776         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9777         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9778         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9779         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9780         /* Input mixer3 */
9781         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9782         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9783         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9784         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9785
9786         { }
9787 };
9788
9789 static struct hda_verb alc262_eapd_verbs[] = {
9790         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9791         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9792         { }
9793 };
9794
9795 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9796         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9797         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9798         {}
9799 };
9800
9801 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9802         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9803         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9804         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9805
9806         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9807         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9808         {}
9809 };
9810
9811 static struct hda_verb alc262_sony_unsol_verbs[] = {
9812         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9813         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9814         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
9815
9816         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9817         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9818         {}
9819 };
9820
9821 static struct hda_input_mux alc262_dmic_capture_source = {
9822         .num_items = 2,
9823         .items = {
9824                 { "Int DMic", 0x9 },
9825                 { "Mic", 0x0 },
9826         },
9827 };
9828
9829 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
9830         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9831         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9832         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9833         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9834         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9835         { } /* end */
9836 };
9837
9838 static struct hda_verb alc262_toshiba_s06_verbs[] = {
9839         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9840         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9841         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9842         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9843         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
9844         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9845         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
9846         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9847         {}
9848 };
9849
9850 static void alc262_dmic_automute(struct hda_codec *codec)
9851 {
9852         unsigned int present;
9853
9854         present = snd_hda_codec_read(codec, 0x18, 0,
9855                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9856         snd_hda_codec_write(codec, 0x22, 0,
9857                                 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
9858 }
9859
9860
9861 /* unsolicited event for HP jack sensing */
9862 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
9863                                        unsigned int res)
9864 {
9865         if ((res >> 26) == ALC880_MIC_EVENT)
9866                 alc262_dmic_automute(codec);
9867         else
9868                 alc_sku_unsol_event(codec, res);
9869 }
9870
9871 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
9872 {
9873         struct alc_spec *spec = codec->spec;
9874
9875         spec->autocfg.hp_pins[0] = 0x15;
9876         spec->autocfg.speaker_pins[0] = 0x14;
9877         alc_automute_pin(codec);
9878         alc262_dmic_automute(codec);
9879 }
9880
9881 /*
9882  * nec model
9883  *  0x15 = headphone
9884  *  0x16 = internal speaker
9885  *  0x18 = external mic
9886  */
9887
9888 static struct snd_kcontrol_new alc262_nec_mixer[] = {
9889         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9890         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
9891
9892         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9893         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9894         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9895
9896         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9897         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9898         { } /* end */
9899 };
9900
9901 static struct hda_verb alc262_nec_verbs[] = {
9902         /* Unmute Speaker */
9903         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9904
9905         /* Headphone */
9906         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9907         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9908
9909         /* External mic to headphone */
9910         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9911         /* External mic to speaker */
9912         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9913         {}
9914 };
9915
9916 /*
9917  * fujitsu model
9918  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
9919  *  0x1b = port replicator headphone out
9920  */
9921
9922 #define ALC_HP_EVENT    0x37
9923
9924 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
9925         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9926         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9927         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9928         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9929         {}
9930 };
9931
9932 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
9933         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9934         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9935         {}
9936 };
9937
9938 static struct hda_input_mux alc262_fujitsu_capture_source = {
9939         .num_items = 3,
9940         .items = {
9941                 { "Mic", 0x0 },
9942                 { "Int Mic", 0x1 },
9943                 { "CD", 0x4 },
9944         },
9945 };
9946
9947 static struct hda_input_mux alc262_HP_capture_source = {
9948         .num_items = 5,
9949         .items = {
9950                 { "Mic", 0x0 },
9951                 { "Front Mic", 0x1 },
9952                 { "Line", 0x2 },
9953                 { "CD", 0x4 },
9954                 { "AUX IN", 0x6 },
9955         },
9956 };
9957
9958 static struct hda_input_mux alc262_HP_D7000_capture_source = {
9959         .num_items = 4,
9960         .items = {
9961                 { "Mic", 0x0 },
9962                 { "Front Mic", 0x2 },
9963                 { "Line", 0x1 },
9964                 { "CD", 0x4 },
9965         },
9966 };
9967
9968 /* mute/unmute internal speaker according to the hp jacks and mute state */
9969 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
9970 {
9971         struct alc_spec *spec = codec->spec;
9972         unsigned int mute;
9973
9974         if (force || !spec->sense_updated) {
9975                 unsigned int present;
9976                 /* need to execute and sync at first */
9977                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
9978                 /* check laptop HP jack */
9979                 present = snd_hda_codec_read(codec, 0x14, 0,
9980                                              AC_VERB_GET_PIN_SENSE, 0);
9981                 /* need to execute and sync at first */
9982                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9983                 /* check docking HP jack */
9984                 present |= snd_hda_codec_read(codec, 0x1b, 0,
9985                                               AC_VERB_GET_PIN_SENSE, 0);
9986                 if (present & AC_PINSENSE_PRESENCE)
9987                         spec->jack_present = 1;
9988                 else
9989                         spec->jack_present = 0;
9990                 spec->sense_updated = 1;
9991         }
9992         /* unmute internal speaker only if both HPs are unplugged and
9993          * master switch is on
9994          */
9995         if (spec->jack_present)
9996                 mute = HDA_AMP_MUTE;
9997         else
9998                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
9999         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10000                                  HDA_AMP_MUTE, mute);
10001 }
10002
10003 /* unsolicited event for HP jack sensing */
10004 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10005                                        unsigned int res)
10006 {
10007         if ((res >> 26) != ALC_HP_EVENT)
10008                 return;
10009         alc262_fujitsu_automute(codec, 1);
10010 }
10011
10012 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10013 {
10014         alc262_fujitsu_automute(codec, 1);
10015 }
10016
10017 /* bind volumes of both NID 0x0c and 0x0d */
10018 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10019         .ops = &snd_hda_bind_vol,
10020         .values = {
10021                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10022                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10023                 0
10024         },
10025 };
10026
10027 /* mute/unmute internal speaker according to the hp jack and mute state */
10028 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10029 {
10030         struct alc_spec *spec = codec->spec;
10031         unsigned int mute;
10032
10033         if (force || !spec->sense_updated) {
10034                 unsigned int present_int_hp;
10035                 /* need to execute and sync at first */
10036                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10037                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
10038                                         AC_VERB_GET_PIN_SENSE, 0);
10039                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
10040                 spec->sense_updated = 1;
10041         }
10042         if (spec->jack_present) {
10043                 /* mute internal speaker */
10044                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10045                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10046                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10047                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10048         } else {
10049                 /* unmute internal speaker if necessary */
10050                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10051                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10052                                          HDA_AMP_MUTE, mute);
10053                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10054                                          HDA_AMP_MUTE, mute);
10055         }
10056 }
10057
10058 /* unsolicited event for HP jack sensing */
10059 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10060                                        unsigned int res)
10061 {
10062         if ((res >> 26) != ALC_HP_EVENT)
10063                 return;
10064         alc262_lenovo_3000_automute(codec, 1);
10065 }
10066
10067 /* bind hp and internal speaker mute (with plug check) */
10068 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10069                                          struct snd_ctl_elem_value *ucontrol)
10070 {
10071         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10072         long *valp = ucontrol->value.integer.value;
10073         int change;
10074
10075         change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10076                                                  HDA_AMP_MUTE,
10077                                                  valp ? 0 : HDA_AMP_MUTE);
10078         change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10079                                                  HDA_AMP_MUTE,
10080                                                  valp ? 0 : HDA_AMP_MUTE);
10081
10082         if (change)
10083                 alc262_fujitsu_automute(codec, 0);
10084         return change;
10085 }
10086
10087 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10088         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10089         {
10090                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10091                 .name = "Master Playback Switch",
10092                 .info = snd_hda_mixer_amp_switch_info,
10093                 .get = snd_hda_mixer_amp_switch_get,
10094                 .put = alc262_fujitsu_master_sw_put,
10095                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10096         },
10097         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10098         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10099         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10100         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10101         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10102         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10103         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10104         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10105         { } /* end */
10106 };
10107
10108 /* bind hp and internal speaker mute (with plug check) */
10109 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10110                                          struct snd_ctl_elem_value *ucontrol)
10111 {
10112         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10113         long *valp = ucontrol->value.integer.value;
10114         int change;
10115
10116         change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10117                                                  HDA_AMP_MUTE,
10118                                                  valp ? 0 : HDA_AMP_MUTE);
10119
10120         if (change)
10121                 alc262_lenovo_3000_automute(codec, 0);
10122         return change;
10123 }
10124
10125 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10126         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10127         {
10128                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10129                 .name = "Master Playback Switch",
10130                 .info = snd_hda_mixer_amp_switch_info,
10131                 .get = snd_hda_mixer_amp_switch_get,
10132                 .put = alc262_lenovo_3000_master_sw_put,
10133                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10134         },
10135         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10136         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10137         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10138         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10139         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10140         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10141         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10142         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10143         { } /* end */
10144 };
10145
10146 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10147         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10148         ALC262_HIPPO_MASTER_SWITCH,
10149         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10150         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10151         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10152         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10153         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10154         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10155         { } /* end */
10156 };
10157
10158 /* additional init verbs for Benq laptops */
10159 static struct hda_verb alc262_EAPD_verbs[] = {
10160         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10161         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10162         {}
10163 };
10164
10165 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10166         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10167         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10168
10169         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10170         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10171         {}
10172 };
10173
10174 /* Samsung Q1 Ultra Vista model setup */
10175 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10176         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10177         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10178         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10179         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10180         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10181         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10182         { } /* end */
10183 };
10184
10185 static struct hda_verb alc262_ultra_verbs[] = {
10186         /* output mixer */
10187         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10188         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10189         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10190         /* speaker */
10191         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10192         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10193         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10194         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10195         /* HP */
10196         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10197         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10198         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10199         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10200         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10201         /* internal mic */
10202         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10203         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10204         /* ADC, choose mic */
10205         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10206         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10207         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10208         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10209         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10210         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10211         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10212         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10213         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10214         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
10215         {}
10216 };
10217
10218 /* mute/unmute internal speaker according to the hp jack and mute state */
10219 static void alc262_ultra_automute(struct hda_codec *codec)
10220 {
10221         struct alc_spec *spec = codec->spec;
10222         unsigned int mute;
10223
10224         mute = 0;
10225         /* auto-mute only when HP is used as HP */
10226         if (!spec->cur_mux[0]) {
10227                 unsigned int present;
10228                 /* need to execute and sync at first */
10229                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
10230                 present = snd_hda_codec_read(codec, 0x15, 0,
10231                                              AC_VERB_GET_PIN_SENSE, 0);
10232                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
10233                 if (spec->jack_present)
10234                         mute = HDA_AMP_MUTE;
10235         }
10236         /* mute/unmute internal speaker */
10237         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10238                                  HDA_AMP_MUTE, mute);
10239         /* mute/unmute HP */
10240         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10241                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
10242 }
10243
10244 /* unsolicited event for HP jack sensing */
10245 static void alc262_ultra_unsol_event(struct hda_codec *codec,
10246                                        unsigned int res)
10247 {
10248         if ((res >> 26) != ALC880_HP_EVENT)
10249                 return;
10250         alc262_ultra_automute(codec);
10251 }
10252
10253 static struct hda_input_mux alc262_ultra_capture_source = {
10254         .num_items = 2,
10255         .items = {
10256                 { "Mic", 0x1 },
10257                 { "Headphone", 0x7 },
10258         },
10259 };
10260
10261 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
10262                                      struct snd_ctl_elem_value *ucontrol)
10263 {
10264         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10265         struct alc_spec *spec = codec->spec;
10266         int ret;
10267
10268         ret = alc_mux_enum_put(kcontrol, ucontrol);
10269         if (!ret)
10270                 return 0;
10271         /* reprogram the HP pin as mic or HP according to the input source */
10272         snd_hda_codec_write_cache(codec, 0x15, 0,
10273                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10274                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
10275         alc262_ultra_automute(codec); /* mute/unmute HP */
10276         return ret;
10277 }
10278
10279 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
10280         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10281         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10282         {
10283                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10284                 .name = "Capture Source",
10285                 .info = alc_mux_enum_info,
10286                 .get = alc_mux_enum_get,
10287                 .put = alc262_ultra_mux_enum_put,
10288         },
10289         { } /* end */
10290 };
10291
10292 /* add playback controls from the parsed DAC table */
10293 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
10294                                              const struct auto_pin_cfg *cfg)
10295 {
10296         hda_nid_t nid;
10297         int err;
10298
10299         spec->multiout.num_dacs = 1;    /* only use one dac */
10300         spec->multiout.dac_nids = spec->private_dac_nids;
10301         spec->multiout.dac_nids[0] = 2;
10302
10303         nid = cfg->line_out_pins[0];
10304         if (nid) {
10305                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10306                                   "Front Playback Volume",
10307                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
10308                 if (err < 0)
10309                         return err;
10310                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10311                                   "Front Playback Switch",
10312                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10313                 if (err < 0)
10314                         return err;
10315         }
10316
10317         nid = cfg->speaker_pins[0];
10318         if (nid) {
10319                 if (nid == 0x16) {
10320                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10321                                           "Speaker Playback Volume",
10322                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10323                                                               HDA_OUTPUT));
10324                         if (err < 0)
10325                                 return err;
10326                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10327                                           "Speaker Playback Switch",
10328                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10329                                                               HDA_OUTPUT));
10330                         if (err < 0)
10331                                 return err;
10332                 } else {
10333                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10334                                           "Speaker Playback Switch",
10335                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10336                                                               HDA_OUTPUT));
10337                         if (err < 0)
10338                                 return err;
10339                 }
10340         }
10341         nid = cfg->hp_pins[0];
10342         if (nid) {
10343                 /* spec->multiout.hp_nid = 2; */
10344                 if (nid == 0x16) {
10345                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10346                                           "Headphone Playback Volume",
10347                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10348                                                               HDA_OUTPUT));
10349                         if (err < 0)
10350                                 return err;
10351                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10352                                           "Headphone Playback Switch",
10353                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10354                                                               HDA_OUTPUT));
10355                         if (err < 0)
10356                                 return err;
10357                 } else {
10358                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10359                                           "Headphone Playback Switch",
10360                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10361                                                               HDA_OUTPUT));
10362                         if (err < 0)
10363                                 return err;
10364                 }
10365         }
10366         return 0;
10367 }
10368
10369 /* identical with ALC880 */
10370 #define alc262_auto_create_analog_input_ctls \
10371         alc880_auto_create_analog_input_ctls
10372
10373 /*
10374  * generic initialization of ADC, input mixers and output mixers
10375  */
10376 static struct hda_verb alc262_volume_init_verbs[] = {
10377         /*
10378          * Unmute ADC0-2 and set the default input to mic-in
10379          */
10380         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10381         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10382         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10383         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10384         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10385         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10386
10387         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10388          * mixer widget
10389          * Note: PASD motherboards uses the Line In 2 as the input for
10390          * front panel mic (mic 2)
10391          */
10392         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10393         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10394         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10395         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10396         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10397         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10398
10399         /*
10400          * Set up output mixers (0x0c - 0x0f)
10401          */
10402         /* set vol=0 to output mixers */
10403         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10404         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10405         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10406
10407         /* set up input amps for analog loopback */
10408         /* Amp Indices: DAC = 0, mixer = 1 */
10409         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10410         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10411         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10412         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10413         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10414         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10415
10416         /* FIXME: use matrix-type input source selection */
10417         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10418         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10419         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10420         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10421         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10422         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10423         /* Input mixer2 */
10424         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10425         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10426         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10427         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10428         /* Input mixer3 */
10429         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10430         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10431         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10432         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10433
10434         { }
10435 };
10436
10437 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10438         /*
10439          * Unmute ADC0-2 and set the default input to mic-in
10440          */
10441         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10442         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10443         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10444         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10445         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10446         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10447
10448         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10449          * mixer widget
10450          * Note: PASD motherboards uses the Line In 2 as the input for
10451          * front panel mic (mic 2)
10452          */
10453         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10454         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10455         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10456         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10457         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10458         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10459         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10460         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10461
10462         /*
10463          * Set up output mixers (0x0c - 0x0e)
10464          */
10465         /* set vol=0 to output mixers */
10466         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10467         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10468         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10469
10470         /* set up input amps for analog loopback */
10471         /* Amp Indices: DAC = 0, mixer = 1 */
10472         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10473         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10474         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10475         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10476         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10477         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10478
10479         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10480         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10481         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10482
10483         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10484         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10485
10486         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10487         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10488
10489         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10490         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10491         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10492         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10493         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10494
10495         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10496         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10497         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10498         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10499         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10500         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10501
10502
10503         /* FIXME: use matrix-type input source selection */
10504         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10505         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10506         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10507         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10508         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10509         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10510         /* Input mixer2 */
10511         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10512         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10513         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10514         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10515         /* Input mixer3 */
10516         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10517         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10518         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10519         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10520
10521         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10522
10523         { }
10524 };
10525
10526 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10527         /*
10528          * Unmute ADC0-2 and set the default input to mic-in
10529          */
10530         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10531         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10532         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10533         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10534         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10535         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10536
10537         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10538          * mixer widget
10539          * Note: PASD motherboards uses the Line In 2 as the input for front
10540          * panel mic (mic 2)
10541          */
10542         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10543         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10544         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10545         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10546         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10547         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10548         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10549         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10550         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10551         /*
10552          * Set up output mixers (0x0c - 0x0e)
10553          */
10554         /* set vol=0 to output mixers */
10555         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10556         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10557         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10558
10559         /* set up input amps for analog loopback */
10560         /* Amp Indices: DAC = 0, mixer = 1 */
10561         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10562         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10563         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10564         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10565         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10566         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10567
10568
10569         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
10570         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
10571         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
10572         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
10573         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10574         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
10575         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
10576
10577         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10578         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10579
10580         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10581         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10582
10583         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10584         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10585         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10586         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10587         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10588         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10589
10590         /* FIXME: use matrix-type input source selection */
10591         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10592         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10593         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10594         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10595         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10596         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10597         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10598         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
10599         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10600         /* Input mixer2 */
10601         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10602         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10603         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10604         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10605         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10606         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10607         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10608         /* Input mixer3 */
10609         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10610         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10611         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10612         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10613         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10614         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10615         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10616
10617         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10618
10619         { }
10620 };
10621
10622 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10623
10624         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
10625         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10626         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10627
10628         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
10629         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10630         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10631         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10632
10633         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
10634         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10635         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10636         {}
10637 };
10638
10639
10640 #ifdef CONFIG_SND_HDA_POWER_SAVE
10641 #define alc262_loopbacks        alc880_loopbacks
10642 #endif
10643
10644 /* pcm configuration: identiacal with ALC880 */
10645 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
10646 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
10647 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
10648 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
10649
10650 /*
10651  * BIOS auto configuration
10652  */
10653 static int alc262_parse_auto_config(struct hda_codec *codec)
10654 {
10655         struct alc_spec *spec = codec->spec;
10656         int err;
10657         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10658
10659         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10660                                            alc262_ignore);
10661         if (err < 0)
10662                 return err;
10663         if (!spec->autocfg.line_outs) {
10664                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
10665                         spec->multiout.max_channels = 2;
10666                         spec->no_analog = 1;
10667                         goto dig_only;
10668                 }
10669                 return 0; /* can't find valid BIOS pin config */
10670         }
10671         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10672         if (err < 0)
10673                 return err;
10674         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10675         if (err < 0)
10676                 return err;
10677
10678         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10679
10680  dig_only:
10681         if (spec->autocfg.dig_outs) {
10682                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10683                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
10684         }
10685         if (spec->autocfg.dig_in_pin)
10686                 spec->dig_in_nid = ALC262_DIGIN_NID;
10687
10688         if (spec->kctls.list)
10689                 add_mixer(spec, spec->kctls.list);
10690
10691         add_verb(spec, alc262_volume_init_verbs);
10692         spec->num_mux_defs = 1;
10693         spec->input_mux = &spec->private_imux[0];
10694
10695         err = alc_auto_add_mic_boost(codec);
10696         if (err < 0)
10697                 return err;
10698
10699         alc_ssid_check(codec, 0x15, 0x14, 0x1b);
10700
10701         return 1;
10702 }
10703
10704 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
10705 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
10706 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
10707 #define alc262_auto_init_input_src      alc882_auto_init_input_src
10708
10709
10710 /* init callback for auto-configuration model -- overriding the default init */
10711 static void alc262_auto_init(struct hda_codec *codec)
10712 {
10713         struct alc_spec *spec = codec->spec;
10714         alc262_auto_init_multi_out(codec);
10715         alc262_auto_init_hp_out(codec);
10716         alc262_auto_init_analog_input(codec);
10717         alc262_auto_init_input_src(codec);
10718         if (spec->unsol_event)
10719                 alc_inithook(codec);
10720 }
10721
10722 /*
10723  * configuration and preset
10724  */
10725 static const char *alc262_models[ALC262_MODEL_LAST] = {
10726         [ALC262_BASIC]          = "basic",
10727         [ALC262_HIPPO]          = "hippo",
10728         [ALC262_HIPPO_1]        = "hippo_1",
10729         [ALC262_FUJITSU]        = "fujitsu",
10730         [ALC262_HP_BPC]         = "hp-bpc",
10731         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10732         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
10733         [ALC262_HP_RP5700]      = "hp-rp5700",
10734         [ALC262_BENQ_ED8]       = "benq",
10735         [ALC262_BENQ_T31]       = "benq-t31",
10736         [ALC262_SONY_ASSAMD]    = "sony-assamd",
10737         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
10738         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
10739         [ALC262_ULTRA]          = "ultra",
10740         [ALC262_LENOVO_3000]    = "lenovo-3000",
10741         [ALC262_NEC]            = "nec",
10742         [ALC262_TYAN]           = "tyan",
10743         [ALC262_AUTO]           = "auto",
10744 };
10745
10746 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10747         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10748         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10749         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
10750                            ALC262_HP_BPC),
10751         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
10752                            ALC262_HP_BPC),
10753         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
10754                            ALC262_HP_BPC),
10755         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10756         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10757         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10758         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10759         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10760         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10761         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10762         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10763         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10764         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10765         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10766         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10767                       ALC262_HP_TC_T5735),
10768         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10769         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10770         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10771         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10772         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
10773         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
10774                            ALC262_SONY_ASSAMD),
10775         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10776                       ALC262_TOSHIBA_RX1),
10777         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
10778         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10779         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10780         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
10781         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
10782                            ALC262_ULTRA),
10783         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
10784         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10785         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10786         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10787         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
10788         {}
10789 };
10790
10791 static struct alc_config_preset alc262_presets[] = {
10792         [ALC262_BASIC] = {
10793                 .mixers = { alc262_base_mixer },
10794                 .init_verbs = { alc262_init_verbs },
10795                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10796                 .dac_nids = alc262_dac_nids,
10797                 .hp_nid = 0x03,
10798                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10799                 .channel_mode = alc262_modes,
10800                 .input_mux = &alc262_capture_source,
10801         },
10802         [ALC262_HIPPO] = {
10803                 .mixers = { alc262_hippo_mixer },
10804                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
10805                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10806                 .dac_nids = alc262_dac_nids,
10807                 .hp_nid = 0x03,
10808                 .dig_out_nid = ALC262_DIGOUT_NID,
10809                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10810                 .channel_mode = alc262_modes,
10811                 .input_mux = &alc262_capture_source,
10812                 .unsol_event = alc262_hippo_unsol_event,
10813                 .init_hook = alc262_hippo_init_hook,
10814         },
10815         [ALC262_HIPPO_1] = {
10816                 .mixers = { alc262_hippo1_mixer },
10817                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
10818                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10819                 .dac_nids = alc262_dac_nids,
10820                 .hp_nid = 0x02,
10821                 .dig_out_nid = ALC262_DIGOUT_NID,
10822                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10823                 .channel_mode = alc262_modes,
10824                 .input_mux = &alc262_capture_source,
10825                 .unsol_event = alc262_hippo_unsol_event,
10826                 .init_hook = alc262_hippo1_init_hook,
10827         },
10828         [ALC262_FUJITSU] = {
10829                 .mixers = { alc262_fujitsu_mixer },
10830                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10831                                 alc262_fujitsu_unsol_verbs },
10832                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10833                 .dac_nids = alc262_dac_nids,
10834                 .hp_nid = 0x03,
10835                 .dig_out_nid = ALC262_DIGOUT_NID,
10836                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10837                 .channel_mode = alc262_modes,
10838                 .input_mux = &alc262_fujitsu_capture_source,
10839                 .unsol_event = alc262_fujitsu_unsol_event,
10840                 .init_hook = alc262_fujitsu_init_hook,
10841         },
10842         [ALC262_HP_BPC] = {
10843                 .mixers = { alc262_HP_BPC_mixer },
10844                 .init_verbs = { alc262_HP_BPC_init_verbs },
10845                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10846                 .dac_nids = alc262_dac_nids,
10847                 .hp_nid = 0x03,
10848                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10849                 .channel_mode = alc262_modes,
10850                 .input_mux = &alc262_HP_capture_source,
10851                 .unsol_event = alc262_hp_bpc_unsol_event,
10852                 .init_hook = alc262_hp_bpc_automute,
10853         },
10854         [ALC262_HP_BPC_D7000_WF] = {
10855                 .mixers = { alc262_HP_BPC_WildWest_mixer },
10856                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10857                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10858                 .dac_nids = alc262_dac_nids,
10859                 .hp_nid = 0x03,
10860                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10861                 .channel_mode = alc262_modes,
10862                 .input_mux = &alc262_HP_D7000_capture_source,
10863                 .unsol_event = alc262_hp_wildwest_unsol_event,
10864                 .init_hook = alc262_hp_wildwest_automute,
10865         },
10866         [ALC262_HP_BPC_D7000_WL] = {
10867                 .mixers = { alc262_HP_BPC_WildWest_mixer,
10868                             alc262_HP_BPC_WildWest_option_mixer },
10869                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10870                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10871                 .dac_nids = alc262_dac_nids,
10872                 .hp_nid = 0x03,
10873                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10874                 .channel_mode = alc262_modes,
10875                 .input_mux = &alc262_HP_D7000_capture_source,
10876                 .unsol_event = alc262_hp_wildwest_unsol_event,
10877                 .init_hook = alc262_hp_wildwest_automute,
10878         },
10879         [ALC262_HP_TC_T5735] = {
10880                 .mixers = { alc262_hp_t5735_mixer },
10881                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
10882                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10883                 .dac_nids = alc262_dac_nids,
10884                 .hp_nid = 0x03,
10885                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10886                 .channel_mode = alc262_modes,
10887                 .input_mux = &alc262_capture_source,
10888                 .unsol_event = alc_automute_amp_unsol_event,
10889                 .init_hook = alc262_hp_t5735_init_hook,
10890         },
10891         [ALC262_HP_RP5700] = {
10892                 .mixers = { alc262_hp_rp5700_mixer },
10893                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
10894                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10895                 .dac_nids = alc262_dac_nids,
10896                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10897                 .channel_mode = alc262_modes,
10898                 .input_mux = &alc262_hp_rp5700_capture_source,
10899         },
10900         [ALC262_BENQ_ED8] = {
10901                 .mixers = { alc262_base_mixer },
10902                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
10903                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10904                 .dac_nids = alc262_dac_nids,
10905                 .hp_nid = 0x03,
10906                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10907                 .channel_mode = alc262_modes,
10908                 .input_mux = &alc262_capture_source,
10909         },
10910         [ALC262_SONY_ASSAMD] = {
10911                 .mixers = { alc262_sony_mixer },
10912                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
10913                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10914                 .dac_nids = alc262_dac_nids,
10915                 .hp_nid = 0x02,
10916                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10917                 .channel_mode = alc262_modes,
10918                 .input_mux = &alc262_capture_source,
10919                 .unsol_event = alc262_hippo_unsol_event,
10920                 .init_hook = alc262_hippo_init_hook,
10921         },
10922         [ALC262_BENQ_T31] = {
10923                 .mixers = { alc262_benq_t31_mixer },
10924                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
10925                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10926                 .dac_nids = alc262_dac_nids,
10927                 .hp_nid = 0x03,
10928                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10929                 .channel_mode = alc262_modes,
10930                 .input_mux = &alc262_capture_source,
10931                 .unsol_event = alc262_hippo_unsol_event,
10932                 .init_hook = alc262_hippo_init_hook,
10933         },
10934         [ALC262_ULTRA] = {
10935                 .mixers = { alc262_ultra_mixer },
10936                 .cap_mixer = alc262_ultra_capture_mixer,
10937                 .init_verbs = { alc262_ultra_verbs },
10938                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10939                 .dac_nids = alc262_dac_nids,
10940                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10941                 .channel_mode = alc262_modes,
10942                 .input_mux = &alc262_ultra_capture_source,
10943                 .adc_nids = alc262_adc_nids, /* ADC0 */
10944                 .capsrc_nids = alc262_capsrc_nids,
10945                 .num_adc_nids = 1, /* single ADC */
10946                 .unsol_event = alc262_ultra_unsol_event,
10947                 .init_hook = alc262_ultra_automute,
10948         },
10949         [ALC262_LENOVO_3000] = {
10950                 .mixers = { alc262_lenovo_3000_mixer },
10951                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10952                                 alc262_lenovo_3000_unsol_verbs },
10953                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10954                 .dac_nids = alc262_dac_nids,
10955                 .hp_nid = 0x03,
10956                 .dig_out_nid = ALC262_DIGOUT_NID,
10957                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10958                 .channel_mode = alc262_modes,
10959                 .input_mux = &alc262_fujitsu_capture_source,
10960                 .unsol_event = alc262_lenovo_3000_unsol_event,
10961         },
10962         [ALC262_NEC] = {
10963                 .mixers = { alc262_nec_mixer },
10964                 .init_verbs = { alc262_nec_verbs },
10965                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10966                 .dac_nids = alc262_dac_nids,
10967                 .hp_nid = 0x03,
10968                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10969                 .channel_mode = alc262_modes,
10970                 .input_mux = &alc262_capture_source,
10971         },
10972         [ALC262_TOSHIBA_S06] = {
10973                 .mixers = { alc262_toshiba_s06_mixer },
10974                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
10975                                                         alc262_eapd_verbs },
10976                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10977                 .capsrc_nids = alc262_dmic_capsrc_nids,
10978                 .dac_nids = alc262_dac_nids,
10979                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
10980                 .dig_out_nid = ALC262_DIGOUT_NID,
10981                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10982                 .channel_mode = alc262_modes,
10983                 .input_mux = &alc262_dmic_capture_source,
10984                 .unsol_event = alc262_toshiba_s06_unsol_event,
10985                 .init_hook = alc262_toshiba_s06_init_hook,
10986         },
10987         [ALC262_TOSHIBA_RX1] = {
10988                 .mixers = { alc262_toshiba_rx1_mixer },
10989                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
10990                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10991                 .dac_nids = alc262_dac_nids,
10992                 .hp_nid = 0x03,
10993                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10994                 .channel_mode = alc262_modes,
10995                 .input_mux = &alc262_capture_source,
10996                 .unsol_event = alc262_hippo_unsol_event,
10997                 .init_hook = alc262_hippo_init_hook,
10998         },
10999         [ALC262_TYAN] = {
11000                 .mixers = { alc262_tyan_mixer },
11001                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11002                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11003                 .dac_nids = alc262_dac_nids,
11004                 .hp_nid = 0x02,
11005                 .dig_out_nid = ALC262_DIGOUT_NID,
11006                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11007                 .channel_mode = alc262_modes,
11008                 .input_mux = &alc262_capture_source,
11009                 .unsol_event = alc_automute_amp_unsol_event,
11010                 .init_hook = alc262_tyan_init_hook,
11011         },
11012 };
11013
11014 static int patch_alc262(struct hda_codec *codec)
11015 {
11016         struct alc_spec *spec;
11017         int board_config;
11018         int err;
11019
11020         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11021         if (spec == NULL)
11022                 return -ENOMEM;
11023
11024         codec->spec = spec;
11025 #if 0
11026         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11027          * under-run
11028          */
11029         {
11030         int tmp;
11031         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11032         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11033         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11034         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11035         }
11036 #endif
11037
11038         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11039
11040         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11041                                                   alc262_models,
11042                                                   alc262_cfg_tbl);
11043
11044         if (board_config < 0) {
11045                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
11046                        "trying auto-probe from BIOS...\n", codec->chip_name);
11047                 board_config = ALC262_AUTO;
11048         }
11049
11050         if (board_config == ALC262_AUTO) {
11051                 /* automatic parse from the BIOS config */
11052                 err = alc262_parse_auto_config(codec);
11053                 if (err < 0) {
11054                         alc_free(codec);
11055                         return err;
11056                 } else if (!err) {
11057                         printk(KERN_INFO
11058                                "hda_codec: Cannot set up configuration "
11059                                "from BIOS.  Using base mode...\n");
11060                         board_config = ALC262_BASIC;
11061                 }
11062         }
11063
11064         if (!spec->no_analog) {
11065                 err = snd_hda_attach_beep_device(codec, 0x1);
11066                 if (err < 0) {
11067                         alc_free(codec);
11068                         return err;
11069                 }
11070         }
11071
11072         if (board_config != ALC262_AUTO)
11073                 setup_preset(spec, &alc262_presets[board_config]);
11074
11075         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11076         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11077
11078         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11079         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11080
11081         spec->capture_style = CAPT_MIX;
11082         if (!spec->adc_nids && spec->input_mux) {
11083                 /* check whether NID 0x07 is valid */
11084                 unsigned int wcap = get_wcaps(codec, 0x07);
11085
11086                 /* get type */
11087                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11088                 if (wcap != AC_WID_AUD_IN) {
11089                         spec->adc_nids = alc262_adc_nids_alt;
11090                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
11091                         spec->capsrc_nids = alc262_capsrc_nids_alt;
11092                 } else {
11093                         spec->adc_nids = alc262_adc_nids;
11094                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
11095                         spec->capsrc_nids = alc262_capsrc_nids;
11096                 }
11097         }
11098         if (!spec->cap_mixer && !spec->no_analog)
11099                 set_capture_mixer(spec);
11100         if (!spec->no_analog)
11101                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11102
11103         spec->vmaster_nid = 0x0c;
11104
11105         codec->patch_ops = alc_patch_ops;
11106         if (board_config == ALC262_AUTO)
11107                 spec->init_hook = alc262_auto_init;
11108 #ifdef CONFIG_SND_HDA_POWER_SAVE
11109         if (!spec->loopback.amplist)
11110                 spec->loopback.amplist = alc262_loopbacks;
11111 #endif
11112         codec->proc_widget_hook = print_realtek_coef;
11113
11114         return 0;
11115 }
11116
11117 /*
11118  *  ALC268 channel source setting (2 channel)
11119  */
11120 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
11121 #define alc268_modes            alc260_modes
11122
11123 static hda_nid_t alc268_dac_nids[2] = {
11124         /* front, hp */
11125         0x02, 0x03
11126 };
11127
11128 static hda_nid_t alc268_adc_nids[2] = {
11129         /* ADC0-1 */
11130         0x08, 0x07
11131 };
11132
11133 static hda_nid_t alc268_adc_nids_alt[1] = {
11134         /* ADC0 */
11135         0x08
11136 };
11137
11138 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11139
11140 static struct snd_kcontrol_new alc268_base_mixer[] = {
11141         /* output mixer control */
11142         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11143         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11144         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11145         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11146         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11147         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11148         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11149         { }
11150 };
11151
11152 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
11153         /* output mixer control */
11154         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11155         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11156         ALC262_HIPPO_MASTER_SWITCH,
11157         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11158         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11159         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11160         { }
11161 };
11162
11163 /* bind Beep switches of both NID 0x0f and 0x10 */
11164 static struct hda_bind_ctls alc268_bind_beep_sw = {
11165         .ops = &snd_hda_bind_sw,
11166         .values = {
11167                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
11168                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
11169                 0
11170         },
11171 };
11172
11173 static struct snd_kcontrol_new alc268_beep_mixer[] = {
11174         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
11175         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
11176         { }
11177 };
11178
11179 static struct hda_verb alc268_eapd_verbs[] = {
11180         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11181         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11182         { }
11183 };
11184
11185 /* Toshiba specific */
11186 static struct hda_verb alc268_toshiba_verbs[] = {
11187         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11188         { } /* end */
11189 };
11190
11191 static struct hda_input_mux alc268_acer_lc_capture_source = {
11192         .num_items = 2,
11193         .items = {
11194                 { "i-Mic", 0x6 },
11195                 { "E-Mic", 0x0 },
11196         },
11197 };
11198
11199 /* Acer specific */
11200 /* bind volumes of both NID 0x02 and 0x03 */
11201 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
11202         .ops = &snd_hda_bind_vol,
11203         .values = {
11204                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11205                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11206                 0
11207         },
11208 };
11209
11210 /* mute/unmute internal speaker according to the hp jack and mute state */
11211 static void alc268_acer_automute(struct hda_codec *codec, int force)
11212 {
11213         struct alc_spec *spec = codec->spec;
11214         unsigned int mute;
11215
11216         if (force || !spec->sense_updated) {
11217                 unsigned int present;
11218                 present = snd_hda_codec_read(codec, 0x14, 0,
11219                                          AC_VERB_GET_PIN_SENSE, 0);
11220                 spec->jack_present = (present & 0x80000000) != 0;
11221                 spec->sense_updated = 1;
11222         }
11223         if (spec->jack_present)
11224                 mute = HDA_AMP_MUTE; /* mute internal speaker */
11225         else /* unmute internal speaker if necessary */
11226                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11227         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11228                                  HDA_AMP_MUTE, mute);
11229 }
11230
11231
11232 /* bind hp and internal speaker mute (with plug check) */
11233 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
11234                                      struct snd_ctl_elem_value *ucontrol)
11235 {
11236         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11237         long *valp = ucontrol->value.integer.value;
11238         int change;
11239
11240         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
11241                                           HDA_AMP_MUTE,
11242                                           valp[0] ? 0 : HDA_AMP_MUTE);
11243         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
11244                                            HDA_AMP_MUTE,
11245                                            valp[1] ? 0 : HDA_AMP_MUTE);
11246         if (change)
11247                 alc268_acer_automute(codec, 0);
11248         return change;
11249 }
11250
11251 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
11252         /* output mixer control */
11253         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11254         {
11255                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11256                 .name = "Master Playback Switch",
11257                 .info = snd_hda_mixer_amp_switch_info,
11258                 .get = snd_hda_mixer_amp_switch_get,
11259                 .put = alc268_acer_master_sw_put,
11260                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11261         },
11262         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
11263         { }
11264 };
11265
11266 static struct snd_kcontrol_new alc268_acer_mixer[] = {
11267         /* output mixer control */
11268         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11269         {
11270                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11271                 .name = "Master Playback Switch",
11272                 .info = snd_hda_mixer_amp_switch_info,
11273                 .get = snd_hda_mixer_amp_switch_get,
11274                 .put = alc268_acer_master_sw_put,
11275                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11276         },
11277         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11278         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11279         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11280         { }
11281 };
11282
11283 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
11284         /* output mixer control */
11285         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11286         {
11287                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11288                 .name = "Master Playback Switch",
11289                 .info = snd_hda_mixer_amp_switch_info,
11290                 .get = snd_hda_mixer_amp_switch_get,
11291                 .put = alc268_acer_master_sw_put,
11292                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11293         },
11294         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11295         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11296         { }
11297 };
11298
11299 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
11300         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11301         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11302         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11303         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11304         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
11305         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
11306         { }
11307 };
11308
11309 static struct hda_verb alc268_acer_verbs[] = {
11310         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
11311         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11312         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11313         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11314         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11315         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11316         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11317         { }
11318 };
11319
11320 /* unsolicited event for HP jack sensing */
11321 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
11322 #define alc268_toshiba_init_hook        alc262_hippo_init_hook
11323
11324 static void alc268_acer_unsol_event(struct hda_codec *codec,
11325                                        unsigned int res)
11326 {
11327         if ((res >> 26) != ALC880_HP_EVENT)
11328                 return;
11329         alc268_acer_automute(codec, 1);
11330 }
11331
11332 static void alc268_acer_init_hook(struct hda_codec *codec)
11333 {
11334         alc268_acer_automute(codec, 1);
11335 }
11336
11337 /* toggle speaker-output according to the hp-jack state */
11338 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
11339 {
11340         unsigned int present;
11341         unsigned char bits;
11342
11343         present = snd_hda_codec_read(codec, 0x15, 0,
11344                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11345         bits = present ? AMP_IN_MUTE(0) : 0;
11346         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
11347                                 AMP_IN_MUTE(0), bits);
11348         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
11349                                 AMP_IN_MUTE(0), bits);
11350 }
11351
11352
11353 static void alc268_acer_mic_automute(struct hda_codec *codec)
11354 {
11355         unsigned int present;
11356
11357         present = snd_hda_codec_read(codec, 0x18, 0,
11358                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11359         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11360                             present ? 0x0 : 0x6);
11361 }
11362
11363 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
11364                                     unsigned int res)
11365 {
11366         if ((res >> 26) == ALC880_HP_EVENT)
11367                 alc268_aspire_one_speaker_automute(codec);
11368         if ((res >> 26) == ALC880_MIC_EVENT)
11369                 alc268_acer_mic_automute(codec);
11370 }
11371
11372 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
11373 {
11374         alc268_aspire_one_speaker_automute(codec);
11375         alc268_acer_mic_automute(codec);
11376 }
11377
11378 static struct snd_kcontrol_new alc268_dell_mixer[] = {
11379         /* output mixer control */
11380         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11381         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11382         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11383         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11384         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11385         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11386         { }
11387 };
11388
11389 static struct hda_verb alc268_dell_verbs[] = {
11390         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11391         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11392         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11393         { }
11394 };
11395
11396 /* mute/unmute internal speaker according to the hp jack and mute state */
11397 static void alc268_dell_init_hook(struct hda_codec *codec)
11398 {
11399         struct alc_spec *spec = codec->spec;
11400
11401         spec->autocfg.hp_pins[0] = 0x15;
11402         spec->autocfg.speaker_pins[0] = 0x14;
11403         alc_automute_pin(codec);
11404 }
11405
11406 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
11407         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11408         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11409         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11410         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11411         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11412         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
11413         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
11414         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11415         { }
11416 };
11417
11418 static struct hda_verb alc267_quanta_il1_verbs[] = {
11419         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11420         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11421         { }
11422 };
11423
11424 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11425 {
11426         unsigned int present;
11427
11428         present = snd_hda_codec_read(codec, 0x18, 0,
11429                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11430         snd_hda_codec_write(codec, 0x23, 0,
11431                             AC_VERB_SET_CONNECT_SEL,
11432                             present ? 0x00 : 0x01);
11433 }
11434
11435 static void alc267_quanta_il1_init_hook(struct hda_codec *codec)
11436 {
11437         struct alc_spec *spec = codec->spec;
11438
11439         spec->autocfg.hp_pins[0] = 0x15;
11440         spec->autocfg.speaker_pins[0] = 0x14;
11441         alc_automute_pin(codec);
11442         alc267_quanta_il1_mic_automute(codec);
11443 }
11444
11445 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11446                                            unsigned int res)
11447 {
11448         switch (res >> 26) {
11449         case ALC880_MIC_EVENT:
11450                 alc267_quanta_il1_mic_automute(codec);
11451                 break;
11452         default:
11453                 alc_sku_unsol_event(codec, res);
11454                 break;
11455         }
11456 }
11457
11458 /*
11459  * generic initialization of ADC, input mixers and output mixers
11460  */
11461 static struct hda_verb alc268_base_init_verbs[] = {
11462         /* Unmute DAC0-1 and set vol = 0 */
11463         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11464         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11465
11466         /*
11467          * Set up output mixers (0x0c - 0x0e)
11468          */
11469         /* set vol=0 to output mixers */
11470         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11471         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11472
11473         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11474         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11475
11476         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11477         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11478         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11479         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11480         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11481         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11482         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11483         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11484
11485         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11486         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11487         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11488         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11489         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11490
11491         /* set PCBEEP vol = 0, mute connections */
11492         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11493         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11494         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11495
11496         /* Unmute Selector 23h,24h and set the default input to mic-in */
11497
11498         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11499         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11500         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11501         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11502
11503         { }
11504 };
11505
11506 /*
11507  * generic initialization of ADC, input mixers and output mixers
11508  */
11509 static struct hda_verb alc268_volume_init_verbs[] = {
11510         /* set output DAC */
11511         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11512         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11513
11514         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11515         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11516         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11517         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11518         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11519
11520         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11521         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11522         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11523
11524         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11525         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11526
11527         /* set PCBEEP vol = 0, mute connections */
11528         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11529         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11530         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11531
11532         { }
11533 };
11534
11535 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11536         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11537         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11538         {
11539                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11540                 /* The multiple "Capture Source" controls confuse alsamixer
11541                  * So call somewhat different..
11542                  */
11543                 /* .name = "Capture Source", */
11544                 .name = "Input Source",
11545                 .count = 1,
11546                 .info = alc_mux_enum_info,
11547                 .get = alc_mux_enum_get,
11548                 .put = alc_mux_enum_put,
11549         },
11550         { } /* end */
11551 };
11552
11553 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11554         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11555         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11556         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11557         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11558         {
11559                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11560                 /* The multiple "Capture Source" controls confuse alsamixer
11561                  * So call somewhat different..
11562                  */
11563                 /* .name = "Capture Source", */
11564                 .name = "Input Source",
11565                 .count = 2,
11566                 .info = alc_mux_enum_info,
11567                 .get = alc_mux_enum_get,
11568                 .put = alc_mux_enum_put,
11569         },
11570         { } /* end */
11571 };
11572
11573 static struct hda_input_mux alc268_capture_source = {
11574         .num_items = 4,
11575         .items = {
11576                 { "Mic", 0x0 },
11577                 { "Front Mic", 0x1 },
11578                 { "Line", 0x2 },
11579                 { "CD", 0x3 },
11580         },
11581 };
11582
11583 static struct hda_input_mux alc268_acer_capture_source = {
11584         .num_items = 3,
11585         .items = {
11586                 { "Mic", 0x0 },
11587                 { "Internal Mic", 0x1 },
11588                 { "Line", 0x2 },
11589         },
11590 };
11591
11592 static struct hda_input_mux alc268_acer_dmic_capture_source = {
11593         .num_items = 3,
11594         .items = {
11595                 { "Mic", 0x0 },
11596                 { "Internal Mic", 0x6 },
11597                 { "Line", 0x2 },
11598         },
11599 };
11600
11601 #ifdef CONFIG_SND_DEBUG
11602 static struct snd_kcontrol_new alc268_test_mixer[] = {
11603         /* Volume widgets */
11604         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11605         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11606         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11607         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11608         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11609         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11610         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11611         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11612         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11613         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11614         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11615         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11616         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11617         /* The below appears problematic on some hardwares */
11618         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11619         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11620         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11621         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11622         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11623
11624         /* Modes for retasking pin widgets */
11625         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11626         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11627         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11628         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11629
11630         /* Controls for GPIO pins, assuming they are configured as outputs */
11631         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11632         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11633         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11634         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11635
11636         /* Switches to allow the digital SPDIF output pin to be enabled.
11637          * The ALC268 does not have an SPDIF input.
11638          */
11639         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11640
11641         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
11642          * this output to turn on an external amplifier.
11643          */
11644         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11645         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11646
11647         { } /* end */
11648 };
11649 #endif
11650
11651 /* create input playback/capture controls for the given pin */
11652 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11653                                     const char *ctlname, int idx)
11654 {
11655         char name[32];
11656         int err;
11657
11658         sprintf(name, "%s Playback Volume", ctlname);
11659         if (nid == 0x14) {
11660                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11661                                   HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
11662                                                       HDA_OUTPUT));
11663                 if (err < 0)
11664                         return err;
11665         } else if (nid == 0x15) {
11666                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11667                                   HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
11668                                                       HDA_OUTPUT));
11669                 if (err < 0)
11670                         return err;
11671         } else
11672                 return -1;
11673         sprintf(name, "%s Playback Switch", ctlname);
11674         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11675                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11676         if (err < 0)
11677                 return err;
11678         return 0;
11679 }
11680
11681 /* add playback controls from the parsed DAC table */
11682 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11683                                              const struct auto_pin_cfg *cfg)
11684 {
11685         hda_nid_t nid;
11686         int err;
11687
11688         spec->multiout.num_dacs = 2;    /* only use one dac */
11689         spec->multiout.dac_nids = spec->private_dac_nids;
11690         spec->multiout.dac_nids[0] = 2;
11691         spec->multiout.dac_nids[1] = 3;
11692
11693         nid = cfg->line_out_pins[0];
11694         if (nid)
11695                 alc268_new_analog_output(spec, nid, "Front", 0);
11696
11697         nid = cfg->speaker_pins[0];
11698         if (nid == 0x1d) {
11699                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11700                                   "Speaker Playback Volume",
11701                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11702                 if (err < 0)
11703                         return err;
11704         }
11705         nid = cfg->hp_pins[0];
11706         if (nid)
11707                 alc268_new_analog_output(spec, nid, "Headphone", 0);
11708
11709         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11710         if (nid == 0x16) {
11711                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11712                                   "Mono Playback Switch",
11713                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
11714                 if (err < 0)
11715                         return err;
11716         }
11717         return 0;
11718 }
11719
11720 /* create playback/capture controls for input pins */
11721 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11722                                                 const struct auto_pin_cfg *cfg)
11723 {
11724         struct hda_input_mux *imux = &spec->private_imux[0];
11725         int i, idx1;
11726
11727         for (i = 0; i < AUTO_PIN_LAST; i++) {
11728                 switch(cfg->input_pins[i]) {
11729                 case 0x18:
11730                         idx1 = 0;       /* Mic 1 */
11731                         break;
11732                 case 0x19:
11733                         idx1 = 1;       /* Mic 2 */
11734                         break;
11735                 case 0x1a:
11736                         idx1 = 2;       /* Line In */
11737                         break;
11738                 case 0x1c:
11739                         idx1 = 3;       /* CD */
11740                         break;
11741                 case 0x12:
11742                 case 0x13:
11743                         idx1 = 6;       /* digital mics */
11744                         break;
11745                 default:
11746                         continue;
11747                 }
11748                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11749                 imux->items[imux->num_items].index = idx1;
11750                 imux->num_items++;
11751         }
11752         return 0;
11753 }
11754
11755 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11756 {
11757         struct alc_spec *spec = codec->spec;
11758         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11759         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11760         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11761         unsigned int    dac_vol1, dac_vol2;
11762
11763         if (speaker_nid) {
11764                 snd_hda_codec_write(codec, speaker_nid, 0,
11765                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11766                 snd_hda_codec_write(codec, 0x0f, 0,
11767                                     AC_VERB_SET_AMP_GAIN_MUTE,
11768                                     AMP_IN_UNMUTE(1));
11769                 snd_hda_codec_write(codec, 0x10, 0,
11770                                     AC_VERB_SET_AMP_GAIN_MUTE,
11771                                     AMP_IN_UNMUTE(1));
11772         } else {
11773                 snd_hda_codec_write(codec, 0x0f, 0,
11774                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11775                 snd_hda_codec_write(codec, 0x10, 0,
11776                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11777         }
11778
11779         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
11780         if (line_nid == 0x14)
11781                 dac_vol2 = AMP_OUT_ZERO;
11782         else if (line_nid == 0x15)
11783                 dac_vol1 = AMP_OUT_ZERO;
11784         if (hp_nid == 0x14)
11785                 dac_vol2 = AMP_OUT_ZERO;
11786         else if (hp_nid == 0x15)
11787                 dac_vol1 = AMP_OUT_ZERO;
11788         if (line_nid != 0x16 || hp_nid != 0x16 ||
11789             spec->autocfg.line_out_pins[1] != 0x16 ||
11790             spec->autocfg.line_out_pins[2] != 0x16)
11791                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
11792
11793         snd_hda_codec_write(codec, 0x02, 0,
11794                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
11795         snd_hda_codec_write(codec, 0x03, 0,
11796                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
11797 }
11798
11799 /* pcm configuration: identiacal with ALC880 */
11800 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
11801 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
11802 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
11803 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
11804
11805 /*
11806  * BIOS auto configuration
11807  */
11808 static int alc268_parse_auto_config(struct hda_codec *codec)
11809 {
11810         struct alc_spec *spec = codec->spec;
11811         int err;
11812         static hda_nid_t alc268_ignore[] = { 0 };
11813
11814         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11815                                            alc268_ignore);
11816         if (err < 0)
11817                 return err;
11818         if (!spec->autocfg.line_outs) {
11819                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11820                         spec->multiout.max_channels = 2;
11821                         spec->no_analog = 1;
11822                         goto dig_only;
11823                 }
11824                 return 0; /* can't find valid BIOS pin config */
11825         }
11826         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
11827         if (err < 0)
11828                 return err;
11829         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
11830         if (err < 0)
11831                 return err;
11832
11833         spec->multiout.max_channels = 2;
11834
11835  dig_only:
11836         /* digital only support output */
11837         if (spec->autocfg.dig_outs) {
11838                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
11839                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11840         }
11841         if (spec->kctls.list)
11842                 add_mixer(spec, spec->kctls.list);
11843
11844         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
11845                 add_mixer(spec, alc268_beep_mixer);
11846
11847         add_verb(spec, alc268_volume_init_verbs);
11848         spec->num_mux_defs = 1;
11849         spec->input_mux = &spec->private_imux[0];
11850
11851         err = alc_auto_add_mic_boost(codec);
11852         if (err < 0)
11853                 return err;
11854
11855         return 1;
11856 }
11857
11858 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
11859 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
11860 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
11861
11862 /* init callback for auto-configuration model -- overriding the default init */
11863 static void alc268_auto_init(struct hda_codec *codec)
11864 {
11865         struct alc_spec *spec = codec->spec;
11866         alc268_auto_init_multi_out(codec);
11867         alc268_auto_init_hp_out(codec);
11868         alc268_auto_init_mono_speaker_out(codec);
11869         alc268_auto_init_analog_input(codec);
11870         if (spec->unsol_event)
11871                 alc_inithook(codec);
11872 }
11873
11874 /*
11875  * configuration and preset
11876  */
11877 static const char *alc268_models[ALC268_MODEL_LAST] = {
11878         [ALC267_QUANTA_IL1]     = "quanta-il1",
11879         [ALC268_3ST]            = "3stack",
11880         [ALC268_TOSHIBA]        = "toshiba",
11881         [ALC268_ACER]           = "acer",
11882         [ALC268_ACER_DMIC]      = "acer-dmic",
11883         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
11884         [ALC268_DELL]           = "dell",
11885         [ALC268_ZEPTO]          = "zepto",
11886 #ifdef CONFIG_SND_DEBUG
11887         [ALC268_TEST]           = "test",
11888 #endif
11889         [ALC268_AUTO]           = "auto",
11890 };
11891
11892 static struct snd_pci_quirk alc268_cfg_tbl[] = {
11893         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
11894         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
11895         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
11896         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
11897         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
11898         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
11899                                                 ALC268_ACER_ASPIRE_ONE),
11900         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
11901         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
11902         SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
11903         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
11904         SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
11905         SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
11906         SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
11907         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
11908         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
11909         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
11910         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
11911         {}
11912 };
11913
11914 static struct alc_config_preset alc268_presets[] = {
11915         [ALC267_QUANTA_IL1] = {
11916                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
11917                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11918                                 alc267_quanta_il1_verbs },
11919                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11920                 .dac_nids = alc268_dac_nids,
11921                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11922                 .adc_nids = alc268_adc_nids_alt,
11923                 .hp_nid = 0x03,
11924                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11925                 .channel_mode = alc268_modes,
11926                 .input_mux = &alc268_capture_source,
11927                 .unsol_event = alc267_quanta_il1_unsol_event,
11928                 .init_hook = alc267_quanta_il1_init_hook,
11929         },
11930         [ALC268_3ST] = {
11931                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11932                             alc268_beep_mixer },
11933                 .init_verbs = { alc268_base_init_verbs },
11934                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11935                 .dac_nids = alc268_dac_nids,
11936                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11937                 .adc_nids = alc268_adc_nids_alt,
11938                 .capsrc_nids = alc268_capsrc_nids,
11939                 .hp_nid = 0x03,
11940                 .dig_out_nid = ALC268_DIGOUT_NID,
11941                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11942                 .channel_mode = alc268_modes,
11943                 .input_mux = &alc268_capture_source,
11944         },
11945         [ALC268_TOSHIBA] = {
11946                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
11947                             alc268_beep_mixer },
11948                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11949                                 alc268_toshiba_verbs },
11950                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11951                 .dac_nids = alc268_dac_nids,
11952                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11953                 .adc_nids = alc268_adc_nids_alt,
11954                 .capsrc_nids = alc268_capsrc_nids,
11955                 .hp_nid = 0x03,
11956                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11957                 .channel_mode = alc268_modes,
11958                 .input_mux = &alc268_capture_source,
11959                 .unsol_event = alc268_toshiba_unsol_event,
11960                 .init_hook = alc268_toshiba_init_hook,
11961         },
11962         [ALC268_ACER] = {
11963                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
11964                             alc268_beep_mixer },
11965                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11966                                 alc268_acer_verbs },
11967                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11968                 .dac_nids = alc268_dac_nids,
11969                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11970                 .adc_nids = alc268_adc_nids_alt,
11971                 .capsrc_nids = alc268_capsrc_nids,
11972                 .hp_nid = 0x02,
11973                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11974                 .channel_mode = alc268_modes,
11975                 .input_mux = &alc268_acer_capture_source,
11976                 .unsol_event = alc268_acer_unsol_event,
11977                 .init_hook = alc268_acer_init_hook,
11978         },
11979         [ALC268_ACER_DMIC] = {
11980                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
11981                             alc268_beep_mixer },
11982                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11983                                 alc268_acer_verbs },
11984                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11985                 .dac_nids = alc268_dac_nids,
11986                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11987                 .adc_nids = alc268_adc_nids_alt,
11988                 .capsrc_nids = alc268_capsrc_nids,
11989                 .hp_nid = 0x02,
11990                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11991                 .channel_mode = alc268_modes,
11992                 .input_mux = &alc268_acer_dmic_capture_source,
11993                 .unsol_event = alc268_acer_unsol_event,
11994                 .init_hook = alc268_acer_init_hook,
11995         },
11996         [ALC268_ACER_ASPIRE_ONE] = {
11997                 .mixers = { alc268_acer_aspire_one_mixer,
11998                             alc268_beep_mixer,
11999                             alc268_capture_alt_mixer },
12000                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12001                                 alc268_acer_aspire_one_verbs },
12002                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12003                 .dac_nids = alc268_dac_nids,
12004                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12005                 .adc_nids = alc268_adc_nids_alt,
12006                 .capsrc_nids = alc268_capsrc_nids,
12007                 .hp_nid = 0x03,
12008                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12009                 .channel_mode = alc268_modes,
12010                 .input_mux = &alc268_acer_lc_capture_source,
12011                 .unsol_event = alc268_acer_lc_unsol_event,
12012                 .init_hook = alc268_acer_lc_init_hook,
12013         },
12014         [ALC268_DELL] = {
12015                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
12016                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12017                                 alc268_dell_verbs },
12018                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12019                 .dac_nids = alc268_dac_nids,
12020                 .hp_nid = 0x02,
12021                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12022                 .channel_mode = alc268_modes,
12023                 .unsol_event = alc_sku_unsol_event,
12024                 .init_hook = alc268_dell_init_hook,
12025                 .input_mux = &alc268_capture_source,
12026         },
12027         [ALC268_ZEPTO] = {
12028                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12029                             alc268_beep_mixer },
12030                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12031                                 alc268_toshiba_verbs },
12032                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12033                 .dac_nids = alc268_dac_nids,
12034                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12035                 .adc_nids = alc268_adc_nids_alt,
12036                 .capsrc_nids = alc268_capsrc_nids,
12037                 .hp_nid = 0x03,
12038                 .dig_out_nid = ALC268_DIGOUT_NID,
12039                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12040                 .channel_mode = alc268_modes,
12041                 .input_mux = &alc268_capture_source,
12042                 .unsol_event = alc268_toshiba_unsol_event,
12043                 .init_hook = alc268_toshiba_init_hook
12044         },
12045 #ifdef CONFIG_SND_DEBUG
12046         [ALC268_TEST] = {
12047                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
12048                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12049                                 alc268_volume_init_verbs },
12050                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12051                 .dac_nids = alc268_dac_nids,
12052                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12053                 .adc_nids = alc268_adc_nids_alt,
12054                 .capsrc_nids = alc268_capsrc_nids,
12055                 .hp_nid = 0x03,
12056                 .dig_out_nid = ALC268_DIGOUT_NID,
12057                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12058                 .channel_mode = alc268_modes,
12059                 .input_mux = &alc268_capture_source,
12060         },
12061 #endif
12062 };
12063
12064 static int patch_alc268(struct hda_codec *codec)
12065 {
12066         struct alc_spec *spec;
12067         int board_config;
12068         int i, has_beep, err;
12069
12070         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12071         if (spec == NULL)
12072                 return -ENOMEM;
12073
12074         codec->spec = spec;
12075
12076         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12077                                                   alc268_models,
12078                                                   alc268_cfg_tbl);
12079
12080         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12081                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
12082                        "trying auto-probe from BIOS...\n", codec->chip_name);
12083                 board_config = ALC268_AUTO;
12084         }
12085
12086         if (board_config == ALC268_AUTO) {
12087                 /* automatic parse from the BIOS config */
12088                 err = alc268_parse_auto_config(codec);
12089                 if (err < 0) {
12090                         alc_free(codec);
12091                         return err;
12092                 } else if (!err) {
12093                         printk(KERN_INFO
12094                                "hda_codec: Cannot set up configuration "
12095                                "from BIOS.  Using base mode...\n");
12096                         board_config = ALC268_3ST;
12097                 }
12098         }
12099
12100         if (board_config != ALC268_AUTO)
12101                 setup_preset(spec, &alc268_presets[board_config]);
12102
12103         spec->stream_analog_playback = &alc268_pcm_analog_playback;
12104         spec->stream_analog_capture = &alc268_pcm_analog_capture;
12105         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12106
12107         spec->stream_digital_playback = &alc268_pcm_digital_playback;
12108
12109         has_beep = 0;
12110         for (i = 0; i < spec->num_mixers; i++) {
12111                 if (spec->mixers[i] == alc268_beep_mixer) {
12112                         has_beep = 1;
12113                         break;
12114                 }
12115         }
12116
12117         if (has_beep) {
12118                 err = snd_hda_attach_beep_device(codec, 0x1);
12119                 if (err < 0) {
12120                         alc_free(codec);
12121                         return err;
12122                 }
12123                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12124                         /* override the amp caps for beep generator */
12125                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12126                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12127                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12128                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12129                                           (0 << AC_AMPCAP_MUTE_SHIFT));
12130         }
12131
12132         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12133                 /* check whether NID 0x07 is valid */
12134                 unsigned int wcap = get_wcaps(codec, 0x07);
12135                 int i;
12136
12137                 /* get type */
12138                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
12139                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
12140                         spec->adc_nids = alc268_adc_nids_alt;
12141                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
12142                         add_mixer(spec, alc268_capture_alt_mixer);
12143                 } else {
12144                         spec->adc_nids = alc268_adc_nids;
12145                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
12146                         add_mixer(spec, alc268_capture_mixer);
12147                 }
12148                 spec->capsrc_nids = alc268_capsrc_nids;
12149                 /* set default input source */
12150                 for (i = 0; i < spec->num_adc_nids; i++)
12151                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
12152                                 0, AC_VERB_SET_CONNECT_SEL,
12153                                 spec->input_mux->items[0].index);
12154         }
12155
12156         spec->vmaster_nid = 0x02;
12157
12158         codec->patch_ops = alc_patch_ops;
12159         if (board_config == ALC268_AUTO)
12160                 spec->init_hook = alc268_auto_init;
12161
12162         codec->proc_widget_hook = print_realtek_coef;
12163
12164         return 0;
12165 }
12166
12167 /*
12168  *  ALC269 channel source setting (2 channel)
12169  */
12170 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
12171
12172 #define alc269_dac_nids         alc260_dac_nids
12173
12174 static hda_nid_t alc269_adc_nids[1] = {
12175         /* ADC1 */
12176         0x08,
12177 };
12178
12179 static hda_nid_t alc269_capsrc_nids[1] = {
12180         0x23,
12181 };
12182
12183 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
12184  *       not a mux!
12185  */
12186
12187 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
12188         .num_items = 2,
12189         .items = {
12190                 { "i-Mic", 0x5 },
12191                 { "e-Mic", 0x0 },
12192         },
12193 };
12194
12195 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
12196         .num_items = 2,
12197         .items = {
12198                 { "i-Mic", 0x1 },
12199                 { "e-Mic", 0x0 },
12200         },
12201 };
12202
12203 #define alc269_modes            alc260_modes
12204 #define alc269_capture_source   alc880_lg_lw_capture_source
12205
12206 static struct snd_kcontrol_new alc269_base_mixer[] = {
12207         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12208         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12209         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12210         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12211         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12212         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12213         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12214         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12215         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12216         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12217         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12218         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
12219         { } /* end */
12220 };
12221
12222 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
12223         /* output mixer control */
12224         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12225         {
12226                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12227                 .name = "Master Playback Switch",
12228                 .info = snd_hda_mixer_amp_switch_info,
12229                 .get = snd_hda_mixer_amp_switch_get,
12230                 .put = alc268_acer_master_sw_put,
12231                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12232         },
12233         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12234         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12235         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12236         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12237         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12238         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12239         { }
12240 };
12241
12242 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
12243         /* output mixer control */
12244         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12245         {
12246                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12247                 .name = "Master Playback Switch",
12248                 .info = snd_hda_mixer_amp_switch_info,
12249                 .get = snd_hda_mixer_amp_switch_get,
12250                 .put = alc268_acer_master_sw_put,
12251                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12252         },
12253         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12254         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12255         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12256         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12257         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12258         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12259         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
12260         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
12261         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
12262         { }
12263 };
12264
12265 /* bind volumes of both NID 0x0c and 0x0d */
12266 static struct hda_bind_ctls alc269_epc_bind_vol = {
12267         .ops = &snd_hda_bind_vol,
12268         .values = {
12269                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12270                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12271                 0
12272         },
12273 };
12274
12275 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
12276         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12277         HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
12278         HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12279         { } /* end */
12280 };
12281
12282 /* capture mixer elements */
12283 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
12284         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12285         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12286         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12287         { } /* end */
12288 };
12289
12290 /* FSC amilo */
12291 static struct snd_kcontrol_new alc269_fujitsu_mixer[] = {
12292         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12293         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12294         HDA_BIND_VOL("PCM Playback Volume", &alc269_epc_bind_vol),
12295         { } /* end */
12296 };
12297
12298 static struct hda_verb alc269_quanta_fl1_verbs[] = {
12299         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12300         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12301         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12302         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12303         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12304         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12305         { }
12306 };
12307
12308 static struct hda_verb alc269_lifebook_verbs[] = {
12309         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12310         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
12311         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12312         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12313         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12314         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12315         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12316         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12317         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12318         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12319         { }
12320 };
12321
12322 /* toggle speaker-output according to the hp-jack state */
12323 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
12324 {
12325         unsigned int present;
12326         unsigned char bits;
12327
12328         present = snd_hda_codec_read(codec, 0x15, 0,
12329                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12330         bits = present ? AMP_IN_MUTE(0) : 0;
12331         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12332                         AMP_IN_MUTE(0), bits);
12333         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12334                         AMP_IN_MUTE(0), bits);
12335
12336         snd_hda_codec_write(codec, 0x20, 0,
12337                         AC_VERB_SET_COEF_INDEX, 0x0c);
12338         snd_hda_codec_write(codec, 0x20, 0,
12339                         AC_VERB_SET_PROC_COEF, 0x680);
12340
12341         snd_hda_codec_write(codec, 0x20, 0,
12342                         AC_VERB_SET_COEF_INDEX, 0x0c);
12343         snd_hda_codec_write(codec, 0x20, 0,
12344                         AC_VERB_SET_PROC_COEF, 0x480);
12345 }
12346
12347 /* toggle speaker-output according to the hp-jacks state */
12348 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
12349 {
12350         unsigned int present;
12351         unsigned char bits;
12352
12353         /* Check laptop headphone socket */
12354         present = snd_hda_codec_read(codec, 0x15, 0,
12355                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12356
12357         /* Check port replicator headphone socket */
12358         present |= snd_hda_codec_read(codec, 0x1a, 0,
12359                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12360
12361         bits = present ? AMP_IN_MUTE(0) : 0;
12362         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12363                         AMP_IN_MUTE(0), bits);
12364         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12365                         AMP_IN_MUTE(0), bits);
12366
12367         snd_hda_codec_write(codec, 0x20, 0,
12368                         AC_VERB_SET_COEF_INDEX, 0x0c);
12369         snd_hda_codec_write(codec, 0x20, 0,
12370                         AC_VERB_SET_PROC_COEF, 0x680);
12371
12372         snd_hda_codec_write(codec, 0x20, 0,
12373                         AC_VERB_SET_COEF_INDEX, 0x0c);
12374         snd_hda_codec_write(codec, 0x20, 0,
12375                         AC_VERB_SET_PROC_COEF, 0x480);
12376 }
12377
12378 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
12379 {
12380         unsigned int present;
12381
12382         present = snd_hda_codec_read(codec, 0x18, 0,
12383                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12384         snd_hda_codec_write(codec, 0x23, 0,
12385                             AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
12386 }
12387
12388 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
12389 {
12390         unsigned int present_laptop;
12391         unsigned int present_dock;
12392
12393         present_laptop = snd_hda_codec_read(codec, 0x18, 0,
12394                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12395
12396         present_dock = snd_hda_codec_read(codec, 0x1b, 0,
12397                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12398
12399         /* Laptop mic port overrides dock mic port, design decision */
12400         if (present_dock)
12401                 snd_hda_codec_write(codec, 0x23, 0,
12402                                 AC_VERB_SET_CONNECT_SEL, 0x3);
12403         if (present_laptop)
12404                 snd_hda_codec_write(codec, 0x23, 0,
12405                                 AC_VERB_SET_CONNECT_SEL, 0x0);
12406         if (!present_dock && !present_laptop)
12407                 snd_hda_codec_write(codec, 0x23, 0,
12408                                 AC_VERB_SET_CONNECT_SEL, 0x1);
12409 }
12410
12411 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
12412                                     unsigned int res)
12413 {
12414         if ((res >> 26) == ALC880_HP_EVENT)
12415                 alc269_quanta_fl1_speaker_automute(codec);
12416         if ((res >> 26) == ALC880_MIC_EVENT)
12417                 alc269_quanta_fl1_mic_automute(codec);
12418 }
12419
12420 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
12421                                         unsigned int res)
12422 {
12423         if ((res >> 26) == ALC880_HP_EVENT)
12424                 alc269_lifebook_speaker_automute(codec);
12425         if ((res >> 26) == ALC880_MIC_EVENT)
12426                 alc269_lifebook_mic_autoswitch(codec);
12427 }
12428
12429 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
12430 {
12431         alc269_quanta_fl1_speaker_automute(codec);
12432         alc269_quanta_fl1_mic_automute(codec);
12433 }
12434
12435 static void alc269_lifebook_init_hook(struct hda_codec *codec)
12436 {
12437         alc269_lifebook_speaker_automute(codec);
12438         alc269_lifebook_mic_autoswitch(codec);
12439 }
12440
12441 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
12442         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12443         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
12444         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12445         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
12446         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12447         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12448         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12449         {}
12450 };
12451
12452 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
12453         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12454         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
12455         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12456         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
12457         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12458         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12459         {}
12460 };
12461
12462 /* toggle speaker-output according to the hp-jack state */
12463 static void alc269_speaker_automute(struct hda_codec *codec)
12464 {
12465         unsigned int present;
12466         unsigned char bits;
12467
12468         present = snd_hda_codec_read(codec, 0x15, 0,
12469                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12470         bits = present ? AMP_IN_MUTE(0) : 0;
12471         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12472                                 AMP_IN_MUTE(0), bits);
12473         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12474                                 AMP_IN_MUTE(0), bits);
12475 }
12476
12477 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
12478 {
12479         unsigned int present;
12480
12481         present = snd_hda_codec_read(codec, 0x18, 0,
12482                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12483         snd_hda_codec_write(codec, 0x23, 0,
12484                                 AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
12485 }
12486
12487 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
12488 {
12489         unsigned int present;
12490
12491         present = snd_hda_codec_read(codec, 0x18, 0,
12492                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12493         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12494                                 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
12495         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12496                                 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
12497 }
12498
12499 /* unsolicited event for HP jack sensing */
12500 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
12501                                      unsigned int res)
12502 {
12503         if ((res >> 26) == ALC880_HP_EVENT)
12504                 alc269_speaker_automute(codec);
12505
12506         if ((res >> 26) == ALC880_MIC_EVENT)
12507                 alc269_eeepc_dmic_automute(codec);
12508 }
12509
12510 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
12511 {
12512         alc269_speaker_automute(codec);
12513         alc269_eeepc_dmic_automute(codec);
12514 }
12515
12516 /* unsolicited event for HP jack sensing */
12517 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
12518                                      unsigned int res)
12519 {
12520         if ((res >> 26) == ALC880_HP_EVENT)
12521                 alc269_speaker_automute(codec);
12522
12523         if ((res >> 26) == ALC880_MIC_EVENT)
12524                 alc269_eeepc_amic_automute(codec);
12525 }
12526
12527 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12528 {
12529         alc269_speaker_automute(codec);
12530         alc269_eeepc_amic_automute(codec);
12531 }
12532
12533 /*
12534  * generic initialization of ADC, input mixers and output mixers
12535  */
12536 static struct hda_verb alc269_init_verbs[] = {
12537         /*
12538          * Unmute ADC0 and set the default input to mic-in
12539          */
12540         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12541
12542         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12543          * analog-loopback mixer widget
12544          * Note: PASD motherboards uses the Line In 2 as the input for
12545          * front panel mic (mic 2)
12546          */
12547         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12548         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12549         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12550         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12551         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12552         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12553
12554         /*
12555          * Set up output mixers (0x0c - 0x0e)
12556          */
12557         /* set vol=0 to output mixers */
12558         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12559         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12560
12561         /* set up input amps for analog loopback */
12562         /* Amp Indices: DAC = 0, mixer = 1 */
12563         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12564         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12565         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12566         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12567         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12568         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12569
12570         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12571         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12572         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12573         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12574         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12575         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12576         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12577
12578         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12579         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12580         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12581         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12582         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12583         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12584         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12585
12586         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12587         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12588
12589         /* FIXME: use matrix-type input source selection */
12590         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12591         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12592         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12593         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12594         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12595         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12596
12597         /* set EAPD */
12598         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12599         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12600         { }
12601 };
12602
12603 /* add playback controls from the parsed DAC table */
12604 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12605                                              const struct auto_pin_cfg *cfg)
12606 {
12607         hda_nid_t nid;
12608         int err;
12609
12610         spec->multiout.num_dacs = 1;    /* only use one dac */
12611         spec->multiout.dac_nids = spec->private_dac_nids;
12612         spec->multiout.dac_nids[0] = 2;
12613
12614         nid = cfg->line_out_pins[0];
12615         if (nid) {
12616                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12617                                   "Front Playback Volume",
12618                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12619                 if (err < 0)
12620                         return err;
12621                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12622                                   "Front Playback Switch",
12623                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12624                 if (err < 0)
12625                         return err;
12626         }
12627
12628         nid = cfg->speaker_pins[0];
12629         if (nid) {
12630                 if (!cfg->line_out_pins[0]) {
12631                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12632                                           "Speaker Playback Volume",
12633                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12634                                                               HDA_OUTPUT));
12635                         if (err < 0)
12636                                 return err;
12637                 }
12638                 if (nid == 0x16) {
12639                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12640                                           "Speaker Playback Switch",
12641                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12642                                                               HDA_OUTPUT));
12643                         if (err < 0)
12644                                 return err;
12645                 } else {
12646                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12647                                           "Speaker Playback Switch",
12648                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12649                                                               HDA_OUTPUT));
12650                         if (err < 0)
12651                                 return err;
12652                 }
12653         }
12654         nid = cfg->hp_pins[0];
12655         if (nid) {
12656                 /* spec->multiout.hp_nid = 2; */
12657                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12658                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12659                                           "Headphone Playback Volume",
12660                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12661                                                               HDA_OUTPUT));
12662                         if (err < 0)
12663                                 return err;
12664                 }
12665                 if (nid == 0x16) {
12666                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12667                                           "Headphone Playback Switch",
12668                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12669                                                               HDA_OUTPUT));
12670                         if (err < 0)
12671                                 return err;
12672                 } else {
12673                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12674                                           "Headphone Playback Switch",
12675                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12676                                                               HDA_OUTPUT));
12677                         if (err < 0)
12678                                 return err;
12679                 }
12680         }
12681         return 0;
12682 }
12683
12684 static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec,
12685                                                 const struct auto_pin_cfg *cfg)
12686 {
12687         int err;
12688
12689         err = alc880_auto_create_analog_input_ctls(spec, cfg);
12690         if (err < 0)
12691                 return err;
12692         /* digital-mic input pin is excluded in alc880_auto_create..()
12693          * because it's under 0x18
12694          */
12695         if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
12696             cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
12697                 struct hda_input_mux *imux = &spec->private_imux[0];
12698                 imux->items[imux->num_items].label = "Int Mic";
12699                 imux->items[imux->num_items].index = 0x05;
12700                 imux->num_items++;
12701         }
12702         return 0;
12703 }
12704
12705 #ifdef CONFIG_SND_HDA_POWER_SAVE
12706 #define alc269_loopbacks        alc880_loopbacks
12707 #endif
12708
12709 /* pcm configuration: identiacal with ALC880 */
12710 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
12711 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
12712 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
12713 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
12714
12715 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
12716         .substreams = 1,
12717         .channels_min = 2,
12718         .channels_max = 8,
12719         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
12720         /* NID is set in alc_build_pcms */
12721         .ops = {
12722                 .open = alc880_playback_pcm_open,
12723                 .prepare = alc880_playback_pcm_prepare,
12724                 .cleanup = alc880_playback_pcm_cleanup
12725         },
12726 };
12727
12728 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
12729         .substreams = 1,
12730         .channels_min = 2,
12731         .channels_max = 2,
12732         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
12733         /* NID is set in alc_build_pcms */
12734 };
12735
12736 /*
12737  * BIOS auto configuration
12738  */
12739 static int alc269_parse_auto_config(struct hda_codec *codec)
12740 {
12741         struct alc_spec *spec = codec->spec;
12742         int err;
12743         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12744
12745         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12746                                            alc269_ignore);
12747         if (err < 0)
12748                 return err;
12749
12750         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12751         if (err < 0)
12752                 return err;
12753         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12754         if (err < 0)
12755                 return err;
12756
12757         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12758
12759         if (spec->autocfg.dig_outs)
12760                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12761
12762         if (spec->kctls.list)
12763                 add_mixer(spec, spec->kctls.list);
12764
12765         add_verb(spec, alc269_init_verbs);
12766         spec->num_mux_defs = 1;
12767         spec->input_mux = &spec->private_imux[0];
12768         /* set default input source */
12769         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12770                                   0, AC_VERB_SET_CONNECT_SEL,
12771                                   spec->input_mux->items[0].index);
12772
12773         err = alc_auto_add_mic_boost(codec);
12774         if (err < 0)
12775                 return err;
12776
12777         if (!spec->cap_mixer && !spec->no_analog)
12778                 set_capture_mixer(spec);
12779
12780         return 1;
12781 }
12782
12783 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
12784 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
12785 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
12786
12787
12788 /* init callback for auto-configuration model -- overriding the default init */
12789 static void alc269_auto_init(struct hda_codec *codec)
12790 {
12791         struct alc_spec *spec = codec->spec;
12792         alc269_auto_init_multi_out(codec);
12793         alc269_auto_init_hp_out(codec);
12794         alc269_auto_init_analog_input(codec);
12795         if (spec->unsol_event)
12796                 alc_inithook(codec);
12797 }
12798
12799 /*
12800  * configuration and preset
12801  */
12802 static const char *alc269_models[ALC269_MODEL_LAST] = {
12803         [ALC269_BASIC]                  = "basic",
12804         [ALC269_QUANTA_FL1]             = "quanta",
12805         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
12806         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
12807         [ALC269_FUJITSU]                = "fujitsu",
12808         [ALC269_LIFEBOOK]               = "lifebook"
12809 };
12810
12811 static struct snd_pci_quirk alc269_cfg_tbl[] = {
12812         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
12813         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
12814                       ALC269_ASUS_EEEPC_P703),
12815         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_ASUS_EEEPC_P703),
12816         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_ASUS_EEEPC_P703),
12817         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_ASUS_EEEPC_P703),
12818         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_ASUS_EEEPC_P703),
12819         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_ASUS_EEEPC_P703),
12820         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_ASUS_EEEPC_P703),
12821         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
12822                       ALC269_ASUS_EEEPC_P901),
12823         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
12824                       ALC269_ASUS_EEEPC_P901),
12825         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_ASUS_EEEPC_P901),
12826         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
12827         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
12828         {}
12829 };
12830
12831 static struct alc_config_preset alc269_presets[] = {
12832         [ALC269_BASIC] = {
12833                 .mixers = { alc269_base_mixer },
12834                 .init_verbs = { alc269_init_verbs },
12835                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12836                 .dac_nids = alc269_dac_nids,
12837                 .hp_nid = 0x03,
12838                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12839                 .channel_mode = alc269_modes,
12840                 .input_mux = &alc269_capture_source,
12841         },
12842         [ALC269_QUANTA_FL1] = {
12843                 .mixers = { alc269_quanta_fl1_mixer },
12844                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
12845                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12846                 .dac_nids = alc269_dac_nids,
12847                 .hp_nid = 0x03,
12848                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12849                 .channel_mode = alc269_modes,
12850                 .input_mux = &alc269_capture_source,
12851                 .unsol_event = alc269_quanta_fl1_unsol_event,
12852                 .init_hook = alc269_quanta_fl1_init_hook,
12853         },
12854         [ALC269_ASUS_EEEPC_P703] = {
12855                 .mixers = { alc269_eeepc_mixer },
12856                 .cap_mixer = alc269_epc_capture_mixer,
12857                 .init_verbs = { alc269_init_verbs,
12858                                 alc269_eeepc_amic_init_verbs },
12859                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12860                 .dac_nids = alc269_dac_nids,
12861                 .hp_nid = 0x03,
12862                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12863                 .channel_mode = alc269_modes,
12864                 .input_mux = &alc269_eeepc_amic_capture_source,
12865                 .unsol_event = alc269_eeepc_amic_unsol_event,
12866                 .init_hook = alc269_eeepc_amic_inithook,
12867         },
12868         [ALC269_ASUS_EEEPC_P901] = {
12869                 .mixers = { alc269_eeepc_mixer },
12870                 .cap_mixer = alc269_epc_capture_mixer,
12871                 .init_verbs = { alc269_init_verbs,
12872                                 alc269_eeepc_dmic_init_verbs },
12873                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12874                 .dac_nids = alc269_dac_nids,
12875                 .hp_nid = 0x03,
12876                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12877                 .channel_mode = alc269_modes,
12878                 .input_mux = &alc269_eeepc_dmic_capture_source,
12879                 .unsol_event = alc269_eeepc_dmic_unsol_event,
12880                 .init_hook = alc269_eeepc_dmic_inithook,
12881         },
12882         [ALC269_FUJITSU] = {
12883                 .mixers = { alc269_fujitsu_mixer },
12884                 .cap_mixer = alc269_epc_capture_mixer,
12885                 .init_verbs = { alc269_init_verbs,
12886                                 alc269_eeepc_dmic_init_verbs },
12887                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12888                 .dac_nids = alc269_dac_nids,
12889                 .hp_nid = 0x03,
12890                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12891                 .channel_mode = alc269_modes,
12892                 .input_mux = &alc269_eeepc_dmic_capture_source,
12893                 .unsol_event = alc269_eeepc_dmic_unsol_event,
12894                 .init_hook = alc269_eeepc_dmic_inithook,
12895         },
12896         [ALC269_LIFEBOOK] = {
12897                 .mixers = { alc269_lifebook_mixer },
12898                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
12899                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12900                 .dac_nids = alc269_dac_nids,
12901                 .hp_nid = 0x03,
12902                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12903                 .channel_mode = alc269_modes,
12904                 .input_mux = &alc269_capture_source,
12905                 .unsol_event = alc269_lifebook_unsol_event,
12906                 .init_hook = alc269_lifebook_init_hook,
12907         },
12908 };
12909
12910 static int patch_alc269(struct hda_codec *codec)
12911 {
12912         struct alc_spec *spec;
12913         int board_config;
12914         int err;
12915
12916         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12917         if (spec == NULL)
12918                 return -ENOMEM;
12919
12920         codec->spec = spec;
12921
12922         alc_fix_pll_init(codec, 0x20, 0x04, 15);
12923
12924         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
12925                                                   alc269_models,
12926                                                   alc269_cfg_tbl);
12927
12928         if (board_config < 0) {
12929                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
12930                        "trying auto-probe from BIOS...\n", codec->chip_name);
12931                 board_config = ALC269_AUTO;
12932         }
12933
12934         if (board_config == ALC269_AUTO) {
12935                 /* automatic parse from the BIOS config */
12936                 err = alc269_parse_auto_config(codec);
12937                 if (err < 0) {
12938                         alc_free(codec);
12939                         return err;
12940                 } else if (!err) {
12941                         printk(KERN_INFO
12942                                "hda_codec: Cannot set up configuration "
12943                                "from BIOS.  Using base mode...\n");
12944                         board_config = ALC269_BASIC;
12945                 }
12946         }
12947
12948         err = snd_hda_attach_beep_device(codec, 0x1);
12949         if (err < 0) {
12950                 alc_free(codec);
12951                 return err;
12952         }
12953
12954         if (board_config != ALC269_AUTO)
12955                 setup_preset(spec, &alc269_presets[board_config]);
12956
12957         if (codec->subsystem_id == 0x17aa3bf8) {
12958                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
12959                  * fix the sample rate of analog I/O to 44.1kHz
12960                  */
12961                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
12962                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
12963         } else {
12964                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
12965                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
12966         }
12967         spec->stream_digital_playback = &alc269_pcm_digital_playback;
12968         spec->stream_digital_capture = &alc269_pcm_digital_capture;
12969
12970         spec->adc_nids = alc269_adc_nids;
12971         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
12972         spec->capsrc_nids = alc269_capsrc_nids;
12973         if (!spec->cap_mixer)
12974                 set_capture_mixer(spec);
12975         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
12976
12977         codec->patch_ops = alc_patch_ops;
12978         if (board_config == ALC269_AUTO)
12979                 spec->init_hook = alc269_auto_init;
12980 #ifdef CONFIG_SND_HDA_POWER_SAVE
12981         if (!spec->loopback.amplist)
12982                 spec->loopback.amplist = alc269_loopbacks;
12983 #endif
12984         codec->proc_widget_hook = print_realtek_coef;
12985
12986         return 0;
12987 }
12988
12989 /*
12990  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
12991  */
12992
12993 /*
12994  * set the path ways for 2 channel output
12995  * need to set the codec line out and mic 1 pin widgets to inputs
12996  */
12997 static struct hda_verb alc861_threestack_ch2_init[] = {
12998         /* set pin widget 1Ah (line in) for input */
12999         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13000         /* set pin widget 18h (mic1/2) for input, for mic also enable
13001          * the vref
13002          */
13003         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13004
13005         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13006 #if 0
13007         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13008         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13009 #endif
13010         { } /* end */
13011 };
13012 /*
13013  * 6ch mode
13014  * need to set the codec line out and mic 1 pin widgets to outputs
13015  */
13016 static struct hda_verb alc861_threestack_ch6_init[] = {
13017         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13018         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13019         /* set pin widget 18h (mic1) for output (CLFE)*/
13020         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13021
13022         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13023         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13024
13025         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13026 #if 0
13027         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13028         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13029 #endif
13030         { } /* end */
13031 };
13032
13033 static struct hda_channel_mode alc861_threestack_modes[2] = {
13034         { 2, alc861_threestack_ch2_init },
13035         { 6, alc861_threestack_ch6_init },
13036 };
13037 /* Set mic1 as input and unmute the mixer */
13038 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13039         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13040         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13041         { } /* end */
13042 };
13043 /* Set mic1 as output and mute mixer */
13044 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13045         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13046         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13047         { } /* end */
13048 };
13049
13050 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13051         { 2, alc861_uniwill_m31_ch2_init },
13052         { 4, alc861_uniwill_m31_ch4_init },
13053 };
13054
13055 /* Set mic1 and line-in as input and unmute the mixer */
13056 static struct hda_verb alc861_asus_ch2_init[] = {
13057         /* set pin widget 1Ah (line in) for input */
13058         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13059         /* set pin widget 18h (mic1/2) for input, for mic also enable
13060          * the vref
13061          */
13062         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13063
13064         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13065 #if 0
13066         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13067         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13068 #endif
13069         { } /* end */
13070 };
13071 /* Set mic1 nad line-in as output and mute mixer */
13072 static struct hda_verb alc861_asus_ch6_init[] = {
13073         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13074         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13075         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13076         /* set pin widget 18h (mic1) for output (CLFE)*/
13077         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13078         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13079         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13080         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13081
13082         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13083 #if 0
13084         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13085         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13086 #endif
13087         { } /* end */
13088 };
13089
13090 static struct hda_channel_mode alc861_asus_modes[2] = {
13091         { 2, alc861_asus_ch2_init },
13092         { 6, alc861_asus_ch6_init },
13093 };
13094
13095 /* patch-ALC861 */
13096
13097 static struct snd_kcontrol_new alc861_base_mixer[] = {
13098         /* output mixer control */
13099         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13100         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13101         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13102         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13103         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13104
13105         /*Input mixer control */
13106         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13107            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13108         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13109         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13110         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13111         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13112         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13113         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13114         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13115         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13116
13117         { } /* end */
13118 };
13119
13120 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13121         /* output mixer control */
13122         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13123         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13124         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13125         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13126         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13127
13128         /* Input mixer control */
13129         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13130            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13131         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13132         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13133         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13134         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13135         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13136         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13137         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13138         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13139
13140         {
13141                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13142                 .name = "Channel Mode",
13143                 .info = alc_ch_mode_info,
13144                 .get = alc_ch_mode_get,
13145                 .put = alc_ch_mode_put,
13146                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13147         },
13148         { } /* end */
13149 };
13150
13151 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13152         /* output mixer control */
13153         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13154         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13155         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13156
13157         { } /* end */
13158 };
13159
13160 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13161         /* output mixer control */
13162         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13163         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13164         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13165         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13166         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13167
13168         /* Input mixer control */
13169         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13170            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13171         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13172         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13173         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13174         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13175         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13176         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13177         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13178         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13179
13180         {
13181                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13182                 .name = "Channel Mode",
13183                 .info = alc_ch_mode_info,
13184                 .get = alc_ch_mode_get,
13185                 .put = alc_ch_mode_put,
13186                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13187         },
13188         { } /* end */
13189 };
13190
13191 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13192         /* output mixer control */
13193         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13194         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13195         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13196         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13197         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13198
13199         /* Input mixer control */
13200         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13201         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13202         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13203         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13204         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13205         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13206         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13207         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13208         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13209         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13210
13211         {
13212                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13213                 .name = "Channel Mode",
13214                 .info = alc_ch_mode_info,
13215                 .get = alc_ch_mode_get,
13216                 .put = alc_ch_mode_put,
13217                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13218         },
13219         { }
13220 };
13221
13222 /* additional mixer */
13223 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13224         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13225         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13226         { }
13227 };
13228
13229 /*
13230  * generic initialization of ADC, input mixers and output mixers
13231  */
13232 static struct hda_verb alc861_base_init_verbs[] = {
13233         /*
13234          * Unmute ADC0 and set the default input to mic-in
13235          */
13236         /* port-A for surround (rear panel) */
13237         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13238         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
13239         /* port-B for mic-in (rear panel) with vref */
13240         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13241         /* port-C for line-in (rear panel) */
13242         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13243         /* port-D for Front */
13244         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13245         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13246         /* port-E for HP out (front panel) */
13247         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13248         /* route front PCM to HP */
13249         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13250         /* port-F for mic-in (front panel) with vref */
13251         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13252         /* port-G for CLFE (rear panel) */
13253         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13254         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13255         /* port-H for side (rear panel) */
13256         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13257         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
13258         /* CD-in */
13259         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13260         /* route front mic to ADC1*/
13261         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13262         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13263
13264         /* Unmute DAC0~3 & spdif out*/
13265         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13266         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13267         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13268         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13269         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13270
13271         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13272         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13273         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13274         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13275         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13276
13277         /* Unmute Stereo Mixer 15 */
13278         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13279         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13280         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13281         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13282
13283         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13284         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13285         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13286         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13287         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13288         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13289         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13290         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13291         /* hp used DAC 3 (Front) */
13292         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13293         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13294
13295         { }
13296 };
13297
13298 static struct hda_verb alc861_threestack_init_verbs[] = {
13299         /*
13300          * Unmute ADC0 and set the default input to mic-in
13301          */
13302         /* port-A for surround (rear panel) */
13303         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13304         /* port-B for mic-in (rear panel) with vref */
13305         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13306         /* port-C for line-in (rear panel) */
13307         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13308         /* port-D for Front */
13309         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13310         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13311         /* port-E for HP out (front panel) */
13312         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13313         /* route front PCM to HP */
13314         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13315         /* port-F for mic-in (front panel) with vref */
13316         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13317         /* port-G for CLFE (rear panel) */
13318         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13319         /* port-H for side (rear panel) */
13320         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13321         /* CD-in */
13322         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13323         /* route front mic to ADC1*/
13324         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13325         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13326         /* Unmute DAC0~3 & spdif out*/
13327         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13328         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13329         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13330         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13331         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13332
13333         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13334         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13335         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13336         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13337         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13338
13339         /* Unmute Stereo Mixer 15 */
13340         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13341         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13342         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13343         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13344
13345         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13346         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13347         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13348         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13349         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13350         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13351         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13352         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13353         /* hp used DAC 3 (Front) */
13354         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13355         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13356         { }
13357 };
13358
13359 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
13360         /*
13361          * Unmute ADC0 and set the default input to mic-in
13362          */
13363         /* port-A for surround (rear panel) */
13364         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13365         /* port-B for mic-in (rear panel) with vref */
13366         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13367         /* port-C for line-in (rear panel) */
13368         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13369         /* port-D for Front */
13370         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13371         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13372         /* port-E for HP out (front panel) */
13373         /* this has to be set to VREF80 */
13374         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13375         /* route front PCM to HP */
13376         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13377         /* port-F for mic-in (front panel) with vref */
13378         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13379         /* port-G for CLFE (rear panel) */
13380         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13381         /* port-H for side (rear panel) */
13382         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13383         /* CD-in */
13384         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13385         /* route front mic to ADC1*/
13386         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13387         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13388         /* Unmute DAC0~3 & spdif out*/
13389         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13390         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13391         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13392         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13393         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13394
13395         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13396         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13397         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13398         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13399         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13400
13401         /* Unmute Stereo Mixer 15 */
13402         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13403         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13404         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13405         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13406
13407         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13408         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13409         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13410         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13411         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13412         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13413         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13414         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13415         /* hp used DAC 3 (Front) */
13416         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13417         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13418         { }
13419 };
13420
13421 static struct hda_verb alc861_asus_init_verbs[] = {
13422         /*
13423          * Unmute ADC0 and set the default input to mic-in
13424          */
13425         /* port-A for surround (rear panel)
13426          * according to codec#0 this is the HP jack
13427          */
13428         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
13429         /* route front PCM to HP */
13430         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
13431         /* port-B for mic-in (rear panel) with vref */
13432         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13433         /* port-C for line-in (rear panel) */
13434         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13435         /* port-D for Front */
13436         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13437         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13438         /* port-E for HP out (front panel) */
13439         /* this has to be set to VREF80 */
13440         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13441         /* route front PCM to HP */
13442         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13443         /* port-F for mic-in (front panel) with vref */
13444         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13445         /* port-G for CLFE (rear panel) */
13446         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13447         /* port-H for side (rear panel) */
13448         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13449         /* CD-in */
13450         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13451         /* route front mic to ADC1*/
13452         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13453         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13454         /* Unmute DAC0~3 & spdif out*/
13455         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13456         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13457         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13458         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13459         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13460         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13461         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13462         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13463         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13464         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13465
13466         /* Unmute Stereo Mixer 15 */
13467         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13468         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13469         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13470         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13471
13472         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13473         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13474         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13475         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13476         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13477         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13478         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13479         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13480         /* hp used DAC 3 (Front) */
13481         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13482         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13483         { }
13484 };
13485
13486 /* additional init verbs for ASUS laptops */
13487 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
13488         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
13489         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
13490         { }
13491 };
13492
13493 /*
13494  * generic initialization of ADC, input mixers and output mixers
13495  */
13496 static struct hda_verb alc861_auto_init_verbs[] = {
13497         /*
13498          * Unmute ADC0 and set the default input to mic-in
13499          */
13500         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
13501         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13502
13503         /* Unmute DAC0~3 & spdif out*/
13504         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13505         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13506         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13507         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13508         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13509
13510         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13511         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13512         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13513         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13514         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13515
13516         /* Unmute Stereo Mixer 15 */
13517         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13518         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13519         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13520         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
13521
13522         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13523         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13524         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13525         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13526         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13527         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13528         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13529         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13530
13531         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13532         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13533         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13534         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13535         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13536         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13537         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13538         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13539
13540         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
13541
13542         { }
13543 };
13544
13545 static struct hda_verb alc861_toshiba_init_verbs[] = {
13546         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13547
13548         { }
13549 };
13550
13551 /* toggle speaker-output according to the hp-jack state */
13552 static void alc861_toshiba_automute(struct hda_codec *codec)
13553 {
13554         unsigned int present;
13555
13556         present = snd_hda_codec_read(codec, 0x0f, 0,
13557                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13558         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13559                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13560         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13561                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13562 }
13563
13564 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13565                                        unsigned int res)
13566 {
13567         if ((res >> 26) == ALC880_HP_EVENT)
13568                 alc861_toshiba_automute(codec);
13569 }
13570
13571 /* pcm configuration: identiacal with ALC880 */
13572 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
13573 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
13574 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
13575 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
13576
13577
13578 #define ALC861_DIGOUT_NID       0x07
13579
13580 static struct hda_channel_mode alc861_8ch_modes[1] = {
13581         { 8, NULL }
13582 };
13583
13584 static hda_nid_t alc861_dac_nids[4] = {
13585         /* front, surround, clfe, side */
13586         0x03, 0x06, 0x05, 0x04
13587 };
13588
13589 static hda_nid_t alc660_dac_nids[3] = {
13590         /* front, clfe, surround */
13591         0x03, 0x05, 0x06
13592 };
13593
13594 static hda_nid_t alc861_adc_nids[1] = {
13595         /* ADC0-2 */
13596         0x08,
13597 };
13598
13599 static struct hda_input_mux alc861_capture_source = {
13600         .num_items = 5,
13601         .items = {
13602                 { "Mic", 0x0 },
13603                 { "Front Mic", 0x3 },
13604                 { "Line", 0x1 },
13605                 { "CD", 0x4 },
13606                 { "Mixer", 0x5 },
13607         },
13608 };
13609
13610 /* fill in the dac_nids table from the parsed pin configuration */
13611 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13612                                      const struct auto_pin_cfg *cfg)
13613 {
13614         int i;
13615         hda_nid_t nid;
13616
13617         spec->multiout.dac_nids = spec->private_dac_nids;
13618         for (i = 0; i < cfg->line_outs; i++) {
13619                 nid = cfg->line_out_pins[i];
13620                 if (nid) {
13621                         if (i >= ARRAY_SIZE(alc861_dac_nids))
13622                                 continue;
13623                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13624                 }
13625         }
13626         spec->multiout.num_dacs = cfg->line_outs;
13627         return 0;
13628 }
13629
13630 /* add playback controls from the parsed DAC table */
13631 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13632                                              const struct auto_pin_cfg *cfg)
13633 {
13634         char name[32];
13635         static const char *chname[4] = {
13636                 "Front", "Surround", NULL /*CLFE*/, "Side"
13637         };
13638         hda_nid_t nid;
13639         int i, idx, err;
13640
13641         for (i = 0; i < cfg->line_outs; i++) {
13642                 nid = spec->multiout.dac_nids[i];
13643                 if (!nid)
13644                         continue;
13645                 if (nid == 0x05) {
13646                         /* Center/LFE */
13647                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13648                                           "Center Playback Switch",
13649                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13650                                                               HDA_OUTPUT));
13651                         if (err < 0)
13652                                 return err;
13653                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13654                                           "LFE Playback Switch",
13655                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13656                                                               HDA_OUTPUT));
13657                         if (err < 0)
13658                                 return err;
13659                 } else {
13660                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13661                              idx++)
13662                                 if (nid == alc861_dac_nids[idx])
13663                                         break;
13664                         sprintf(name, "%s Playback Switch", chname[idx]);
13665                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13666                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13667                                                               HDA_OUTPUT));
13668                         if (err < 0)
13669                                 return err;
13670                 }
13671         }
13672         return 0;
13673 }
13674
13675 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13676 {
13677         int err;
13678         hda_nid_t nid;
13679
13680         if (!pin)
13681                 return 0;
13682
13683         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13684                 nid = 0x03;
13685                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13686                                   "Headphone Playback Switch",
13687                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13688                 if (err < 0)
13689                         return err;
13690                 spec->multiout.hp_nid = nid;
13691         }
13692         return 0;
13693 }
13694
13695 /* create playback/capture controls for input pins */
13696 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13697                                                 const struct auto_pin_cfg *cfg)
13698 {
13699         struct hda_input_mux *imux = &spec->private_imux[0];
13700         int i, err, idx, idx1;
13701
13702         for (i = 0; i < AUTO_PIN_LAST; i++) {
13703                 switch (cfg->input_pins[i]) {
13704                 case 0x0c:
13705                         idx1 = 1;
13706                         idx = 2;        /* Line In */
13707                         break;
13708                 case 0x0f:
13709                         idx1 = 2;
13710                         idx = 2;        /* Line In */
13711                         break;
13712                 case 0x0d:
13713                         idx1 = 0;
13714                         idx = 1;        /* Mic In */
13715                         break;
13716                 case 0x10:
13717                         idx1 = 3;
13718                         idx = 1;        /* Mic In */
13719                         break;
13720                 case 0x11:
13721                         idx1 = 4;
13722                         idx = 0;        /* CD */
13723                         break;
13724                 default:
13725                         continue;
13726                 }
13727
13728                 err = new_analog_input(spec, cfg->input_pins[i],
13729                                        auto_pin_cfg_labels[i], idx, 0x15);
13730                 if (err < 0)
13731                         return err;
13732
13733                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13734                 imux->items[imux->num_items].index = idx1;
13735                 imux->num_items++;
13736         }
13737         return 0;
13738 }
13739
13740 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13741                                               hda_nid_t nid,
13742                                               int pin_type, int dac_idx)
13743 {
13744         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13745                             pin_type);
13746         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13747                             AMP_OUT_UNMUTE);
13748 }
13749
13750 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13751 {
13752         struct alc_spec *spec = codec->spec;
13753         int i;
13754
13755         for (i = 0; i < spec->autocfg.line_outs; i++) {
13756                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13757                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13758                 if (nid)
13759                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13760                                                           spec->multiout.dac_nids[i]);
13761         }
13762 }
13763
13764 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13765 {
13766         struct alc_spec *spec = codec->spec;
13767         hda_nid_t pin;
13768
13769         pin = spec->autocfg.hp_pins[0];
13770         if (pin) /* connect to front */
13771                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13772                                                   spec->multiout.dac_nids[0]);
13773         pin = spec->autocfg.speaker_pins[0];
13774         if (pin)
13775                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13776 }
13777
13778 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13779 {
13780         struct alc_spec *spec = codec->spec;
13781         int i;
13782
13783         for (i = 0; i < AUTO_PIN_LAST; i++) {
13784                 hda_nid_t nid = spec->autocfg.input_pins[i];
13785                 if (nid >= 0x0c && nid <= 0x11)
13786                         alc_set_input_pin(codec, nid, i);
13787         }
13788 }
13789
13790 /* parse the BIOS configuration and set up the alc_spec */
13791 /* return 1 if successful, 0 if the proper config is not found,
13792  * or a negative error code
13793  */
13794 static int alc861_parse_auto_config(struct hda_codec *codec)
13795 {
13796         struct alc_spec *spec = codec->spec;
13797         int err;
13798         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
13799
13800         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13801                                            alc861_ignore);
13802         if (err < 0)
13803                 return err;
13804         if (!spec->autocfg.line_outs)
13805                 return 0; /* can't find valid BIOS pin config */
13806
13807         err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
13808         if (err < 0)
13809                 return err;
13810         err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
13811         if (err < 0)
13812                 return err;
13813         err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
13814         if (err < 0)
13815                 return err;
13816         err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
13817         if (err < 0)
13818                 return err;
13819
13820         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13821
13822         if (spec->autocfg.dig_outs)
13823                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
13824
13825         if (spec->kctls.list)
13826                 add_mixer(spec, spec->kctls.list);
13827
13828         add_verb(spec, alc861_auto_init_verbs);
13829
13830         spec->num_mux_defs = 1;
13831         spec->input_mux = &spec->private_imux[0];
13832
13833         spec->adc_nids = alc861_adc_nids;
13834         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
13835         set_capture_mixer(spec);
13836
13837         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b);
13838
13839         return 1;
13840 }
13841
13842 /* additional initialization for auto-configuration model */
13843 static void alc861_auto_init(struct hda_codec *codec)
13844 {
13845         struct alc_spec *spec = codec->spec;
13846         alc861_auto_init_multi_out(codec);
13847         alc861_auto_init_hp_out(codec);
13848         alc861_auto_init_analog_input(codec);
13849         if (spec->unsol_event)
13850                 alc_inithook(codec);
13851 }
13852
13853 #ifdef CONFIG_SND_HDA_POWER_SAVE
13854 static struct hda_amp_list alc861_loopbacks[] = {
13855         { 0x15, HDA_INPUT, 0 },
13856         { 0x15, HDA_INPUT, 1 },
13857         { 0x15, HDA_INPUT, 2 },
13858         { 0x15, HDA_INPUT, 3 },
13859         { } /* end */
13860 };
13861 #endif
13862
13863
13864 /*
13865  * configuration and preset
13866  */
13867 static const char *alc861_models[ALC861_MODEL_LAST] = {
13868         [ALC861_3ST]            = "3stack",
13869         [ALC660_3ST]            = "3stack-660",
13870         [ALC861_3ST_DIG]        = "3stack-dig",
13871         [ALC861_6ST_DIG]        = "6stack-dig",
13872         [ALC861_UNIWILL_M31]    = "uniwill-m31",
13873         [ALC861_TOSHIBA]        = "toshiba",
13874         [ALC861_ASUS]           = "asus",
13875         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
13876         [ALC861_AUTO]           = "auto",
13877 };
13878
13879 static struct snd_pci_quirk alc861_cfg_tbl[] = {
13880         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
13881         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13882         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13883         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
13884         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
13885         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
13886         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
13887         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
13888          *        Any other models that need this preset?
13889          */
13890         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
13891         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
13892         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
13893         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
13894         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
13895         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
13896         /* FIXME: the below seems conflict */
13897         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
13898         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
13899         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
13900         {}
13901 };
13902
13903 static struct alc_config_preset alc861_presets[] = {
13904         [ALC861_3ST] = {
13905                 .mixers = { alc861_3ST_mixer },
13906                 .init_verbs = { alc861_threestack_init_verbs },
13907                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13908                 .dac_nids = alc861_dac_nids,
13909                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13910                 .channel_mode = alc861_threestack_modes,
13911                 .need_dac_fix = 1,
13912                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13913                 .adc_nids = alc861_adc_nids,
13914                 .input_mux = &alc861_capture_source,
13915         },
13916         [ALC861_3ST_DIG] = {
13917                 .mixers = { alc861_base_mixer },
13918                 .init_verbs = { alc861_threestack_init_verbs },
13919                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13920                 .dac_nids = alc861_dac_nids,
13921                 .dig_out_nid = ALC861_DIGOUT_NID,
13922                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13923                 .channel_mode = alc861_threestack_modes,
13924                 .need_dac_fix = 1,
13925                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13926                 .adc_nids = alc861_adc_nids,
13927                 .input_mux = &alc861_capture_source,
13928         },
13929         [ALC861_6ST_DIG] = {
13930                 .mixers = { alc861_base_mixer },
13931                 .init_verbs = { alc861_base_init_verbs },
13932                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13933                 .dac_nids = alc861_dac_nids,
13934                 .dig_out_nid = ALC861_DIGOUT_NID,
13935                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
13936                 .channel_mode = alc861_8ch_modes,
13937                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13938                 .adc_nids = alc861_adc_nids,
13939                 .input_mux = &alc861_capture_source,
13940         },
13941         [ALC660_3ST] = {
13942                 .mixers = { alc861_3ST_mixer },
13943                 .init_verbs = { alc861_threestack_init_verbs },
13944                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
13945                 .dac_nids = alc660_dac_nids,
13946                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13947                 .channel_mode = alc861_threestack_modes,
13948                 .need_dac_fix = 1,
13949                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13950                 .adc_nids = alc861_adc_nids,
13951                 .input_mux = &alc861_capture_source,
13952         },
13953         [ALC861_UNIWILL_M31] = {
13954                 .mixers = { alc861_uniwill_m31_mixer },
13955                 .init_verbs = { alc861_uniwill_m31_init_verbs },
13956                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13957                 .dac_nids = alc861_dac_nids,
13958                 .dig_out_nid = ALC861_DIGOUT_NID,
13959                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
13960                 .channel_mode = alc861_uniwill_m31_modes,
13961                 .need_dac_fix = 1,
13962                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13963                 .adc_nids = alc861_adc_nids,
13964                 .input_mux = &alc861_capture_source,
13965         },
13966         [ALC861_TOSHIBA] = {
13967                 .mixers = { alc861_toshiba_mixer },
13968                 .init_verbs = { alc861_base_init_verbs,
13969                                 alc861_toshiba_init_verbs },
13970                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13971                 .dac_nids = alc861_dac_nids,
13972                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
13973                 .channel_mode = alc883_3ST_2ch_modes,
13974                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13975                 .adc_nids = alc861_adc_nids,
13976                 .input_mux = &alc861_capture_source,
13977                 .unsol_event = alc861_toshiba_unsol_event,
13978                 .init_hook = alc861_toshiba_automute,
13979         },
13980         [ALC861_ASUS] = {
13981                 .mixers = { alc861_asus_mixer },
13982                 .init_verbs = { alc861_asus_init_verbs },
13983                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13984                 .dac_nids = alc861_dac_nids,
13985                 .dig_out_nid = ALC861_DIGOUT_NID,
13986                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
13987                 .channel_mode = alc861_asus_modes,
13988                 .need_dac_fix = 1,
13989                 .hp_nid = 0x06,
13990                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13991                 .adc_nids = alc861_adc_nids,
13992                 .input_mux = &alc861_capture_source,
13993         },
13994         [ALC861_ASUS_LAPTOP] = {
13995                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
13996                 .init_verbs = { alc861_asus_init_verbs,
13997                                 alc861_asus_laptop_init_verbs },
13998                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13999                 .dac_nids = alc861_dac_nids,
14000                 .dig_out_nid = ALC861_DIGOUT_NID,
14001                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14002                 .channel_mode = alc883_3ST_2ch_modes,
14003                 .need_dac_fix = 1,
14004                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14005                 .adc_nids = alc861_adc_nids,
14006                 .input_mux = &alc861_capture_source,
14007         },
14008 };
14009
14010
14011 static int patch_alc861(struct hda_codec *codec)
14012 {
14013         struct alc_spec *spec;
14014         int board_config;
14015         int err;
14016
14017         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14018         if (spec == NULL)
14019                 return -ENOMEM;
14020
14021         codec->spec = spec;
14022
14023         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14024                                                   alc861_models,
14025                                                   alc861_cfg_tbl);
14026
14027         if (board_config < 0) {
14028                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
14029                        "trying auto-probe from BIOS...\n", codec->chip_name);
14030                 board_config = ALC861_AUTO;
14031         }
14032
14033         if (board_config == ALC861_AUTO) {
14034                 /* automatic parse from the BIOS config */
14035                 err = alc861_parse_auto_config(codec);
14036                 if (err < 0) {
14037                         alc_free(codec);
14038                         return err;
14039                 } else if (!err) {
14040                         printk(KERN_INFO
14041                                "hda_codec: Cannot set up configuration "
14042                                "from BIOS.  Using base mode...\n");
14043                    board_config = ALC861_3ST_DIG;
14044                 }
14045         }
14046
14047         err = snd_hda_attach_beep_device(codec, 0x23);
14048         if (err < 0) {
14049                 alc_free(codec);
14050                 return err;
14051         }
14052
14053         if (board_config != ALC861_AUTO)
14054                 setup_preset(spec, &alc861_presets[board_config]);
14055
14056         spec->stream_analog_playback = &alc861_pcm_analog_playback;
14057         spec->stream_analog_capture = &alc861_pcm_analog_capture;
14058
14059         spec->stream_digital_playback = &alc861_pcm_digital_playback;
14060         spec->stream_digital_capture = &alc861_pcm_digital_capture;
14061
14062         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14063
14064         spec->vmaster_nid = 0x03;
14065
14066         codec->patch_ops = alc_patch_ops;
14067         if (board_config == ALC861_AUTO)
14068                 spec->init_hook = alc861_auto_init;
14069 #ifdef CONFIG_SND_HDA_POWER_SAVE
14070         if (!spec->loopback.amplist)
14071                 spec->loopback.amplist = alc861_loopbacks;
14072 #endif
14073         codec->proc_widget_hook = print_realtek_coef;
14074
14075         return 0;
14076 }
14077
14078 /*
14079  * ALC861-VD support
14080  *
14081  * Based on ALC882
14082  *
14083  * In addition, an independent DAC
14084  */
14085 #define ALC861VD_DIGOUT_NID     0x06
14086
14087 static hda_nid_t alc861vd_dac_nids[4] = {
14088         /* front, surr, clfe, side surr */
14089         0x02, 0x03, 0x04, 0x05
14090 };
14091
14092 /* dac_nids for ALC660vd are in a different order - according to
14093  * Realtek's driver.
14094  * This should probably tesult in a different mixer for 6stack models
14095  * of ALC660vd codecs, but for now there is only 3stack mixer
14096  * - and it is the same as in 861vd.
14097  * adc_nids in ALC660vd are (is) the same as in 861vd
14098  */
14099 static hda_nid_t alc660vd_dac_nids[3] = {
14100         /* front, rear, clfe, rear_surr */
14101         0x02, 0x04, 0x03
14102 };
14103
14104 static hda_nid_t alc861vd_adc_nids[1] = {
14105         /* ADC0 */
14106         0x09,
14107 };
14108
14109 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14110
14111 /* input MUX */
14112 /* FIXME: should be a matrix-type input source selection */
14113 static struct hda_input_mux alc861vd_capture_source = {
14114         .num_items = 4,
14115         .items = {
14116                 { "Mic", 0x0 },
14117                 { "Front Mic", 0x1 },
14118                 { "Line", 0x2 },
14119                 { "CD", 0x4 },
14120         },
14121 };
14122
14123 static struct hda_input_mux alc861vd_dallas_capture_source = {
14124         .num_items = 2,
14125         .items = {
14126                 { "Ext Mic", 0x0 },
14127                 { "Int Mic", 0x1 },
14128         },
14129 };
14130
14131 static struct hda_input_mux alc861vd_hp_capture_source = {
14132         .num_items = 2,
14133         .items = {
14134                 { "Front Mic", 0x0 },
14135                 { "ATAPI Mic", 0x1 },
14136         },
14137 };
14138
14139 /*
14140  * 2ch mode
14141  */
14142 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14143         { 2, NULL }
14144 };
14145
14146 /*
14147  * 6ch mode
14148  */
14149 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14150         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14151         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14152         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14153         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14154         { } /* end */
14155 };
14156
14157 /*
14158  * 8ch mode
14159  */
14160 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14161         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14162         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14163         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14164         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14165         { } /* end */
14166 };
14167
14168 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14169         { 6, alc861vd_6stack_ch6_init },
14170         { 8, alc861vd_6stack_ch8_init },
14171 };
14172
14173 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14174         {
14175                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14176                 .name = "Channel Mode",
14177                 .info = alc_ch_mode_info,
14178                 .get = alc_ch_mode_get,
14179                 .put = alc_ch_mode_put,
14180         },
14181         { } /* end */
14182 };
14183
14184 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14185  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14186  */
14187 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14188         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14189         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14190
14191         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14192         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14193
14194         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14195                                 HDA_OUTPUT),
14196         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14197                                 HDA_OUTPUT),
14198         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14199         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14200
14201         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14202         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14203
14204         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14205
14206         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14207         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14208         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14209
14210         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14211         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14212         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14213
14214         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14215         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14216
14217         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14218         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14219
14220         { } /* end */
14221 };
14222
14223 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
14224         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14225         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14226
14227         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14228
14229         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14230         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14231         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14232
14233         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14234         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14235         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14236
14237         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14238         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14239
14240         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14241         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14242
14243         { } /* end */
14244 };
14245
14246 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
14247         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14248         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
14249         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14250
14251         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14252
14253         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14254         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14255         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14256
14257         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14258         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14259         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14260
14261         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14262         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14263
14264         { } /* end */
14265 };
14266
14267 /* Pin assignment: Speaker=0x14, HP = 0x15,
14268  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
14269  */
14270 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
14271         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14272         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
14273         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14274         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14275         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
14276         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14277         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14278         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
14279         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14280         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14281         { } /* end */
14282 };
14283
14284 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
14285  *                 Front Mic=0x18, ATAPI Mic = 0x19,
14286  */
14287 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
14288         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14289         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14290         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14291         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14292         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14293         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14294         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14295         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14296
14297         { } /* end */
14298 };
14299
14300 /*
14301  * generic initialization of ADC, input mixers and output mixers
14302  */
14303 static struct hda_verb alc861vd_volume_init_verbs[] = {
14304         /*
14305          * Unmute ADC0 and set the default input to mic-in
14306          */
14307         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14308         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14309
14310         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
14311          * the analog-loopback mixer widget
14312          */
14313         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14314         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14315         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14316         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14317         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14318         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14319
14320         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
14321         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14322         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14323         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14324         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14325
14326         /*
14327          * Set up output mixers (0x02 - 0x05)
14328          */
14329         /* set vol=0 to output mixers */
14330         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14331         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14332         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14333         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14334
14335         /* set up input amps for analog loopback */
14336         /* Amp Indices: DAC = 0, mixer = 1 */
14337         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14338         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14339         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14340         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14341         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14342         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14343         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14344         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14345
14346         { }
14347 };
14348
14349 /*
14350  * 3-stack pin configuration:
14351  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
14352  */
14353 static struct hda_verb alc861vd_3stack_init_verbs[] = {
14354         /*
14355          * Set pin mode and muting
14356          */
14357         /* set front pin widgets 0x14 for output */
14358         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14359         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14360         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14361
14362         /* Mic (rear) pin: input vref at 80% */
14363         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14364         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14365         /* Front Mic pin: input vref at 80% */
14366         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14367         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14368         /* Line In pin: input */
14369         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14370         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14371         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14372         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14373         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14374         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14375         /* CD pin widget for input */
14376         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14377
14378         { }
14379 };
14380
14381 /*
14382  * 6-stack pin configuration:
14383  */
14384 static struct hda_verb alc861vd_6stack_init_verbs[] = {
14385         /*
14386          * Set pin mode and muting
14387          */
14388         /* set front pin widgets 0x14 for output */
14389         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14390         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14391         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14392
14393         /* Rear Pin: output 1 (0x0d) */
14394         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14395         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14396         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14397         /* CLFE Pin: output 2 (0x0e) */
14398         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14399         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14400         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
14401         /* Side Pin: output 3 (0x0f) */
14402         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14403         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14404         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
14405
14406         /* Mic (rear) pin: input vref at 80% */
14407         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14408         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14409         /* Front Mic pin: input vref at 80% */
14410         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14411         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14412         /* Line In pin: input */
14413         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14414         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14415         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14416         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14417         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14418         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14419         /* CD pin widget for input */
14420         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14421
14422         { }
14423 };
14424
14425 static struct hda_verb alc861vd_eapd_verbs[] = {
14426         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14427         { }
14428 };
14429
14430 static struct hda_verb alc660vd_eapd_verbs[] = {
14431         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14432         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14433         { }
14434 };
14435
14436 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
14437         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14438         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14439         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
14440         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14441         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14442         {}
14443 };
14444
14445 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
14446 {
14447         unsigned int present;
14448         unsigned char bits;
14449
14450         present = snd_hda_codec_read(codec, 0x18, 0,
14451                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14452         bits = present ? HDA_AMP_MUTE : 0;
14453         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
14454                                  HDA_AMP_MUTE, bits);
14455 }
14456
14457 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
14458 {
14459         struct alc_spec *spec = codec->spec;
14460
14461         spec->autocfg.hp_pins[0] = 0x1b;
14462         spec->autocfg.speaker_pins[0] = 0x14;
14463         alc_automute_amp(codec);
14464         alc861vd_lenovo_mic_automute(codec);
14465 }
14466
14467 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
14468                                         unsigned int res)
14469 {
14470         switch (res >> 26) {
14471         case ALC880_MIC_EVENT:
14472                 alc861vd_lenovo_mic_automute(codec);
14473                 break;
14474         default:
14475                 alc_automute_amp_unsol_event(codec, res);
14476                 break;
14477         }
14478 }
14479
14480 static struct hda_verb alc861vd_dallas_verbs[] = {
14481         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14482         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14483         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14484         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14485
14486         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14487         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14488         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14489         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14490         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14491         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14492         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14493         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14494
14495         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14496         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14497         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14498         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14499         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14500         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14501         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14502         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14503
14504         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14505         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14506         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14507         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14508         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14509         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14510         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14511         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14512
14513         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14514         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14515         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14516         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14517
14518         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14519         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14520         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14521
14522         { } /* end */
14523 };
14524
14525 /* toggle speaker-output according to the hp-jack state */
14526 static void alc861vd_dallas_init_hook(struct hda_codec *codec)
14527 {
14528         struct alc_spec *spec = codec->spec;
14529
14530         spec->autocfg.hp_pins[0] = 0x15;
14531         spec->autocfg.speaker_pins[0] = 0x14;
14532         alc_automute_amp(codec);
14533 }
14534
14535 #ifdef CONFIG_SND_HDA_POWER_SAVE
14536 #define alc861vd_loopbacks      alc880_loopbacks
14537 #endif
14538
14539 /* pcm configuration: identiacal with ALC880 */
14540 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
14541 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
14542 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
14543 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
14544
14545 /*
14546  * configuration and preset
14547  */
14548 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14549         [ALC660VD_3ST]          = "3stack-660",
14550         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
14551         [ALC660VD_ASUS_V1S]     = "asus-v1s",
14552         [ALC861VD_3ST]          = "3stack",
14553         [ALC861VD_3ST_DIG]      = "3stack-digout",
14554         [ALC861VD_6ST_DIG]      = "6stack-digout",
14555         [ALC861VD_LENOVO]       = "lenovo",
14556         [ALC861VD_DALLAS]       = "dallas",
14557         [ALC861VD_HP]           = "hp",
14558         [ALC861VD_AUTO]         = "auto",
14559 };
14560
14561 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14562         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14563         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14564         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14565         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14566         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
14567         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14568         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14569         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14570         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14571         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14572         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14573         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14574         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14575         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
14576         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14577         {}
14578 };
14579
14580 static struct alc_config_preset alc861vd_presets[] = {
14581         [ALC660VD_3ST] = {
14582                 .mixers = { alc861vd_3st_mixer },
14583                 .init_verbs = { alc861vd_volume_init_verbs,
14584                                  alc861vd_3stack_init_verbs },
14585                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14586                 .dac_nids = alc660vd_dac_nids,
14587                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14588                 .channel_mode = alc861vd_3stack_2ch_modes,
14589                 .input_mux = &alc861vd_capture_source,
14590         },
14591         [ALC660VD_3ST_DIG] = {
14592                 .mixers = { alc861vd_3st_mixer },
14593                 .init_verbs = { alc861vd_volume_init_verbs,
14594                                  alc861vd_3stack_init_verbs },
14595                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14596                 .dac_nids = alc660vd_dac_nids,
14597                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14598                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14599                 .channel_mode = alc861vd_3stack_2ch_modes,
14600                 .input_mux = &alc861vd_capture_source,
14601         },
14602         [ALC861VD_3ST] = {
14603                 .mixers = { alc861vd_3st_mixer },
14604                 .init_verbs = { alc861vd_volume_init_verbs,
14605                                  alc861vd_3stack_init_verbs },
14606                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14607                 .dac_nids = alc861vd_dac_nids,
14608                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14609                 .channel_mode = alc861vd_3stack_2ch_modes,
14610                 .input_mux = &alc861vd_capture_source,
14611         },
14612         [ALC861VD_3ST_DIG] = {
14613                 .mixers = { alc861vd_3st_mixer },
14614                 .init_verbs = { alc861vd_volume_init_verbs,
14615                                  alc861vd_3stack_init_verbs },
14616                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14617                 .dac_nids = alc861vd_dac_nids,
14618                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14619                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14620                 .channel_mode = alc861vd_3stack_2ch_modes,
14621                 .input_mux = &alc861vd_capture_source,
14622         },
14623         [ALC861VD_6ST_DIG] = {
14624                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14625                 .init_verbs = { alc861vd_volume_init_verbs,
14626                                 alc861vd_6stack_init_verbs },
14627                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14628                 .dac_nids = alc861vd_dac_nids,
14629                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14630                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14631                 .channel_mode = alc861vd_6stack_modes,
14632                 .input_mux = &alc861vd_capture_source,
14633         },
14634         [ALC861VD_LENOVO] = {
14635                 .mixers = { alc861vd_lenovo_mixer },
14636                 .init_verbs = { alc861vd_volume_init_verbs,
14637                                 alc861vd_3stack_init_verbs,
14638                                 alc861vd_eapd_verbs,
14639                                 alc861vd_lenovo_unsol_verbs },
14640                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14641                 .dac_nids = alc660vd_dac_nids,
14642                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14643                 .channel_mode = alc861vd_3stack_2ch_modes,
14644                 .input_mux = &alc861vd_capture_source,
14645                 .unsol_event = alc861vd_lenovo_unsol_event,
14646                 .init_hook = alc861vd_lenovo_init_hook,
14647         },
14648         [ALC861VD_DALLAS] = {
14649                 .mixers = { alc861vd_dallas_mixer },
14650                 .init_verbs = { alc861vd_dallas_verbs },
14651                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14652                 .dac_nids = alc861vd_dac_nids,
14653                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14654                 .channel_mode = alc861vd_3stack_2ch_modes,
14655                 .input_mux = &alc861vd_dallas_capture_source,
14656                 .unsol_event = alc_automute_amp_unsol_event,
14657                 .init_hook = alc861vd_dallas_init_hook,
14658         },
14659         [ALC861VD_HP] = {
14660                 .mixers = { alc861vd_hp_mixer },
14661                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14662                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14663                 .dac_nids = alc861vd_dac_nids,
14664                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14665                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14666                 .channel_mode = alc861vd_3stack_2ch_modes,
14667                 .input_mux = &alc861vd_hp_capture_source,
14668                 .unsol_event = alc_automute_amp_unsol_event,
14669                 .init_hook = alc861vd_dallas_init_hook,
14670         },
14671         [ALC660VD_ASUS_V1S] = {
14672                 .mixers = { alc861vd_lenovo_mixer },
14673                 .init_verbs = { alc861vd_volume_init_verbs,
14674                                 alc861vd_3stack_init_verbs,
14675                                 alc861vd_eapd_verbs,
14676                                 alc861vd_lenovo_unsol_verbs },
14677                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14678                 .dac_nids = alc660vd_dac_nids,
14679                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14680                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14681                 .channel_mode = alc861vd_3stack_2ch_modes,
14682                 .input_mux = &alc861vd_capture_source,
14683                 .unsol_event = alc861vd_lenovo_unsol_event,
14684                 .init_hook = alc861vd_lenovo_init_hook,
14685         },
14686 };
14687
14688 /*
14689  * BIOS auto configuration
14690  */
14691 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14692                                 hda_nid_t nid, int pin_type, int dac_idx)
14693 {
14694         alc_set_pin_output(codec, nid, pin_type);
14695 }
14696
14697 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14698 {
14699         struct alc_spec *spec = codec->spec;
14700         int i;
14701
14702         for (i = 0; i <= HDA_SIDE; i++) {
14703                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14704                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14705                 if (nid)
14706                         alc861vd_auto_set_output_and_unmute(codec, nid,
14707                                                             pin_type, i);
14708         }
14709 }
14710
14711
14712 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14713 {
14714         struct alc_spec *spec = codec->spec;
14715         hda_nid_t pin;
14716
14717         pin = spec->autocfg.hp_pins[0];
14718         if (pin) /* connect to front and  use dac 0 */
14719                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14720         pin = spec->autocfg.speaker_pins[0];
14721         if (pin)
14722                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14723 }
14724
14725 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
14726 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
14727
14728 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14729 {
14730         struct alc_spec *spec = codec->spec;
14731         int i;
14732
14733         for (i = 0; i < AUTO_PIN_LAST; i++) {
14734                 hda_nid_t nid = spec->autocfg.input_pins[i];
14735                 if (alc861vd_is_input_pin(nid)) {
14736                         alc_set_input_pin(codec, nid, i);
14737                         if (nid != ALC861VD_PIN_CD_NID &&
14738                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
14739                                 snd_hda_codec_write(codec, nid, 0,
14740                                                 AC_VERB_SET_AMP_GAIN_MUTE,
14741                                                 AMP_OUT_MUTE);
14742                 }
14743         }
14744 }
14745
14746 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
14747
14748 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
14749 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
14750
14751 /* add playback controls from the parsed DAC table */
14752 /* Based on ALC880 version. But ALC861VD has separate,
14753  * different NIDs for mute/unmute switch and volume control */
14754 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14755                                              const struct auto_pin_cfg *cfg)
14756 {
14757         char name[32];
14758         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14759         hda_nid_t nid_v, nid_s;
14760         int i, err;
14761
14762         for (i = 0; i < cfg->line_outs; i++) {
14763                 if (!spec->multiout.dac_nids[i])
14764                         continue;
14765                 nid_v = alc861vd_idx_to_mixer_vol(
14766                                 alc880_dac_to_idx(
14767                                         spec->multiout.dac_nids[i]));
14768                 nid_s = alc861vd_idx_to_mixer_switch(
14769                                 alc880_dac_to_idx(
14770                                         spec->multiout.dac_nids[i]));
14771
14772                 if (i == 2) {
14773                         /* Center/LFE */
14774                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14775                                           "Center Playback Volume",
14776                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14777                                                               HDA_OUTPUT));
14778                         if (err < 0)
14779                                 return err;
14780                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14781                                           "LFE Playback Volume",
14782                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14783                                                               HDA_OUTPUT));
14784                         if (err < 0)
14785                                 return err;
14786                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14787                                           "Center Playback Switch",
14788                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
14789                                                               HDA_INPUT));
14790                         if (err < 0)
14791                                 return err;
14792                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14793                                           "LFE Playback Switch",
14794                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
14795                                                               HDA_INPUT));
14796                         if (err < 0)
14797                                 return err;
14798                 } else {
14799                         sprintf(name, "%s Playback Volume", chname[i]);
14800                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14801                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
14802                                                               HDA_OUTPUT));
14803                         if (err < 0)
14804                                 return err;
14805                         sprintf(name, "%s Playback Switch", chname[i]);
14806                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14807                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
14808                                                               HDA_INPUT));
14809                         if (err < 0)
14810                                 return err;
14811                 }
14812         }
14813         return 0;
14814 }
14815
14816 /* add playback controls for speaker and HP outputs */
14817 /* Based on ALC880 version. But ALC861VD has separate,
14818  * different NIDs for mute/unmute switch and volume control */
14819 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
14820                                         hda_nid_t pin, const char *pfx)
14821 {
14822         hda_nid_t nid_v, nid_s;
14823         int err;
14824         char name[32];
14825
14826         if (!pin)
14827                 return 0;
14828
14829         if (alc880_is_fixed_pin(pin)) {
14830                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14831                 /* specify the DAC as the extra output */
14832                 if (!spec->multiout.hp_nid)
14833                         spec->multiout.hp_nid = nid_v;
14834                 else
14835                         spec->multiout.extra_out_nid[0] = nid_v;
14836                 /* control HP volume/switch on the output mixer amp */
14837                 nid_v = alc861vd_idx_to_mixer_vol(
14838                                 alc880_fixed_pin_idx(pin));
14839                 nid_s = alc861vd_idx_to_mixer_switch(
14840                                 alc880_fixed_pin_idx(pin));
14841
14842                 sprintf(name, "%s Playback Volume", pfx);
14843                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14844                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
14845                 if (err < 0)
14846                         return err;
14847                 sprintf(name, "%s Playback Switch", pfx);
14848                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14849                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
14850                 if (err < 0)
14851                         return err;
14852         } else if (alc880_is_multi_pin(pin)) {
14853                 /* set manual connection */
14854                 /* we have only a switch on HP-out PIN */
14855                 sprintf(name, "%s Playback Switch", pfx);
14856                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
14857                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
14858                 if (err < 0)
14859                         return err;
14860         }
14861         return 0;
14862 }
14863
14864 /* parse the BIOS configuration and set up the alc_spec
14865  * return 1 if successful, 0 if the proper config is not found,
14866  * or a negative error code
14867  * Based on ALC880 version - had to change it to override
14868  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
14869 static int alc861vd_parse_auto_config(struct hda_codec *codec)
14870 {
14871         struct alc_spec *spec = codec->spec;
14872         int err;
14873         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
14874
14875         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14876                                            alc861vd_ignore);
14877         if (err < 0)
14878                 return err;
14879         if (!spec->autocfg.line_outs)
14880                 return 0; /* can't find valid BIOS pin config */
14881
14882         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
14883         if (err < 0)
14884                 return err;
14885         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
14886         if (err < 0)
14887                 return err;
14888         err = alc861vd_auto_create_extra_out(spec,
14889                                              spec->autocfg.speaker_pins[0],
14890                                              "Speaker");
14891         if (err < 0)
14892                 return err;
14893         err = alc861vd_auto_create_extra_out(spec,
14894                                              spec->autocfg.hp_pins[0],
14895                                              "Headphone");
14896         if (err < 0)
14897                 return err;
14898         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
14899         if (err < 0)
14900                 return err;
14901
14902         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14903
14904         if (spec->autocfg.dig_outs)
14905                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
14906
14907         if (spec->kctls.list)
14908                 add_mixer(spec, spec->kctls.list);
14909
14910         add_verb(spec, alc861vd_volume_init_verbs);
14911
14912         spec->num_mux_defs = 1;
14913         spec->input_mux = &spec->private_imux[0];
14914
14915         err = alc_auto_add_mic_boost(codec);
14916         if (err < 0)
14917                 return err;
14918
14919         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
14920
14921         return 1;
14922 }
14923
14924 /* additional initialization for auto-configuration model */
14925 static void alc861vd_auto_init(struct hda_codec *codec)
14926 {
14927         struct alc_spec *spec = codec->spec;
14928         alc861vd_auto_init_multi_out(codec);
14929         alc861vd_auto_init_hp_out(codec);
14930         alc861vd_auto_init_analog_input(codec);
14931         alc861vd_auto_init_input_src(codec);
14932         if (spec->unsol_event)
14933                 alc_inithook(codec);
14934 }
14935
14936 static int patch_alc861vd(struct hda_codec *codec)
14937 {
14938         struct alc_spec *spec;
14939         int err, board_config;
14940
14941         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14942         if (spec == NULL)
14943                 return -ENOMEM;
14944
14945         codec->spec = spec;
14946
14947         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
14948                                                   alc861vd_models,
14949                                                   alc861vd_cfg_tbl);
14950
14951         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
14952                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
14953                        "trying auto-probe from BIOS...\n", codec->chip_name);
14954                 board_config = ALC861VD_AUTO;
14955         }
14956
14957         if (board_config == ALC861VD_AUTO) {
14958                 /* automatic parse from the BIOS config */
14959                 err = alc861vd_parse_auto_config(codec);
14960                 if (err < 0) {
14961                         alc_free(codec);
14962                         return err;
14963                 } else if (!err) {
14964                         printk(KERN_INFO
14965                                "hda_codec: Cannot set up configuration "
14966                                "from BIOS.  Using base mode...\n");
14967                         board_config = ALC861VD_3ST;
14968                 }
14969         }
14970
14971         err = snd_hda_attach_beep_device(codec, 0x23);
14972         if (err < 0) {
14973                 alc_free(codec);
14974                 return err;
14975         }
14976
14977         if (board_config != ALC861VD_AUTO)
14978                 setup_preset(spec, &alc861vd_presets[board_config]);
14979
14980         if (codec->vendor_id == 0x10ec0660) {
14981                 /* always turn on EAPD */
14982                 add_verb(spec, alc660vd_eapd_verbs);
14983         }
14984
14985         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
14986         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
14987
14988         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
14989         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
14990
14991         spec->adc_nids = alc861vd_adc_nids;
14992         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
14993         spec->capsrc_nids = alc861vd_capsrc_nids;
14994         spec->capture_style = CAPT_MIX;
14995
14996         set_capture_mixer(spec);
14997         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
14998
14999         spec->vmaster_nid = 0x02;
15000
15001         codec->patch_ops = alc_patch_ops;
15002
15003         if (board_config == ALC861VD_AUTO)
15004                 spec->init_hook = alc861vd_auto_init;
15005 #ifdef CONFIG_SND_HDA_POWER_SAVE
15006         if (!spec->loopback.amplist)
15007                 spec->loopback.amplist = alc861vd_loopbacks;
15008 #endif
15009         codec->proc_widget_hook = print_realtek_coef;
15010
15011         return 0;
15012 }
15013
15014 /*
15015  * ALC662 support
15016  *
15017  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15018  * configuration.  Each pin widget can choose any input DACs and a mixer.
15019  * Each ADC is connected from a mixer of all inputs.  This makes possible
15020  * 6-channel independent captures.
15021  *
15022  * In addition, an independent DAC for the multi-playback (not used in this
15023  * driver yet).
15024  */
15025 #define ALC662_DIGOUT_NID       0x06
15026 #define ALC662_DIGIN_NID        0x0a
15027
15028 static hda_nid_t alc662_dac_nids[4] = {
15029         /* front, rear, clfe, rear_surr */
15030         0x02, 0x03, 0x04
15031 };
15032
15033 static hda_nid_t alc272_dac_nids[2] = {
15034         0x02, 0x03
15035 };
15036
15037 static hda_nid_t alc662_adc_nids[1] = {
15038         /* ADC1-2 */
15039         0x09,
15040 };
15041
15042 static hda_nid_t alc272_adc_nids[1] = {
15043         /* ADC1-2 */
15044         0x08,
15045 };
15046
15047 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
15048 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
15049
15050
15051 /* input MUX */
15052 /* FIXME: should be a matrix-type input source selection */
15053 static struct hda_input_mux alc662_capture_source = {
15054         .num_items = 4,
15055         .items = {
15056                 { "Mic", 0x0 },
15057                 { "Front Mic", 0x1 },
15058                 { "Line", 0x2 },
15059                 { "CD", 0x4 },
15060         },
15061 };
15062
15063 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15064         .num_items = 2,
15065         .items = {
15066                 { "Mic", 0x1 },
15067                 { "Line", 0x2 },
15068         },
15069 };
15070
15071 static struct hda_input_mux alc662_eeepc_capture_source = {
15072         .num_items = 2,
15073         .items = {
15074                 { "i-Mic", 0x1 },
15075                 { "e-Mic", 0x0 },
15076         },
15077 };
15078
15079 static struct hda_input_mux alc663_capture_source = {
15080         .num_items = 3,
15081         .items = {
15082                 { "Mic", 0x0 },
15083                 { "Front Mic", 0x1 },
15084                 { "Line", 0x2 },
15085         },
15086 };
15087
15088 static struct hda_input_mux alc663_m51va_capture_source = {
15089         .num_items = 2,
15090         .items = {
15091                 { "Ext-Mic", 0x0 },
15092                 { "D-Mic", 0x9 },
15093         },
15094 };
15095
15096 #if 1 /* set to 0 for testing other input sources below */
15097 static struct hda_input_mux alc272_nc10_capture_source = {
15098         .num_items = 2,
15099         .items = {
15100                 { "Autoselect Mic", 0x0 },
15101                 { "Internal Mic", 0x1 },
15102         },
15103 };
15104 #else
15105 static struct hda_input_mux alc272_nc10_capture_source = {
15106         .num_items = 16,
15107         .items = {
15108                 { "Autoselect Mic", 0x0 },
15109                 { "Internal Mic", 0x1 },
15110                 { "In-0x02", 0x2 },
15111                 { "In-0x03", 0x3 },
15112                 { "In-0x04", 0x4 },
15113                 { "In-0x05", 0x5 },
15114                 { "In-0x06", 0x6 },
15115                 { "In-0x07", 0x7 },
15116                 { "In-0x08", 0x8 },
15117                 { "In-0x09", 0x9 },
15118                 { "In-0x0a", 0x0a },
15119                 { "In-0x0b", 0x0b },
15120                 { "In-0x0c", 0x0c },
15121                 { "In-0x0d", 0x0d },
15122                 { "In-0x0e", 0x0e },
15123                 { "In-0x0f", 0x0f },
15124         },
15125 };
15126 #endif
15127
15128 /*
15129  * 2ch mode
15130  */
15131 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15132         { 2, NULL }
15133 };
15134
15135 /*
15136  * 2ch mode
15137  */
15138 static struct hda_verb alc662_3ST_ch2_init[] = {
15139         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15140         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15141         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15142         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15143         { } /* end */
15144 };
15145
15146 /*
15147  * 6ch mode
15148  */
15149 static struct hda_verb alc662_3ST_ch6_init[] = {
15150         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15151         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15152         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15153         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15154         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15155         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15156         { } /* end */
15157 };
15158
15159 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15160         { 2, alc662_3ST_ch2_init },
15161         { 6, alc662_3ST_ch6_init },
15162 };
15163
15164 /*
15165  * 2ch mode
15166  */
15167 static struct hda_verb alc662_sixstack_ch6_init[] = {
15168         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15169         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15170         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15171         { } /* end */
15172 };
15173
15174 /*
15175  * 6ch mode
15176  */
15177 static struct hda_verb alc662_sixstack_ch8_init[] = {
15178         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15179         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15180         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15181         { } /* end */
15182 };
15183
15184 static struct hda_channel_mode alc662_5stack_modes[2] = {
15185         { 2, alc662_sixstack_ch6_init },
15186         { 6, alc662_sixstack_ch8_init },
15187 };
15188
15189 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15190  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15191  */
15192
15193 static struct snd_kcontrol_new alc662_base_mixer[] = {
15194         /* output mixer control */
15195         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
15196         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15197         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
15198         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15199         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15200         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15201         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15202         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15203         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15204
15205         /*Input mixer control */
15206         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
15207         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
15208         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
15209         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
15210         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
15211         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
15212         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
15213         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
15214         { } /* end */
15215 };
15216
15217 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
15218         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15219         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15220         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15221         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15222         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15223         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15224         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15225         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15226         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15227         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15228         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15229         { } /* end */
15230 };
15231
15232 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
15233         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15234         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15235         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15236         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15237         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15238         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15239         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15240         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15241         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15242         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15243         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15244         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15245         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15246         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15247         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15248         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15249         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15250         { } /* end */
15251 };
15252
15253 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
15254         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15255         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
15256         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15257         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
15258         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15259         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15260         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15261         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15262         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15263         { } /* end */
15264 };
15265
15266 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
15267         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15268         ALC262_HIPPO_MASTER_SWITCH,
15269
15270         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
15271         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15272         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15273
15274         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15275         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15276         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15277         { } /* end */
15278 };
15279
15280 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
15281         ALC262_HIPPO_MASTER_SWITCH,
15282         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15283         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15284         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15285         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15286         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
15287         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15288         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15289         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15290         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15291         { } /* end */
15292 };
15293
15294 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
15295         .ops = &snd_hda_bind_vol,
15296         .values = {
15297                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15298                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
15299                 0
15300         },
15301 };
15302
15303 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
15304         .ops = &snd_hda_bind_sw,
15305         .values = {
15306                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15307                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15308                 0
15309         },
15310 };
15311
15312 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
15313         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15314         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
15315         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15316         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15317         { } /* end */
15318 };
15319
15320 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
15321         .ops = &snd_hda_bind_sw,
15322         .values = {
15323                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15324                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15325                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15326                 0
15327         },
15328 };
15329
15330 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
15331         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15332         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
15333         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15334         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15335         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15336         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15337
15338         { } /* end */
15339 };
15340
15341 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
15342         .ops = &snd_hda_bind_sw,
15343         .values = {
15344                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15345                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15346                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15347                 0
15348         },
15349 };
15350
15351 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
15352         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15353         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
15354         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15355         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15356         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15357         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15358         { } /* end */
15359 };
15360
15361 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
15362         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15363         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15364         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15365         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15366         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15367         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15368         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15369         { } /* end */
15370 };
15371
15372 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
15373         .ops = &snd_hda_bind_vol,
15374         .values = {
15375                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15376                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
15377                 0
15378         },
15379 };
15380
15381 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
15382         .ops = &snd_hda_bind_sw,
15383         .values = {
15384                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15385                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
15386                 0
15387         },
15388 };
15389
15390 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
15391         HDA_BIND_VOL("Master Playback Volume",
15392                                 &alc663_asus_two_bind_master_vol),
15393         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15394         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15395         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15396         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15397         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15398         { } /* end */
15399 };
15400
15401 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
15402         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15403         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15404         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15405         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15406         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15407         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15408         { } /* end */
15409 };
15410
15411 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
15412         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15413         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15414         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15415         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15416         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15417
15418         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15419         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15420         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15421         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15422         { } /* end */
15423 };
15424
15425 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
15426         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15427         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15428         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15429
15430         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15431         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15432         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15433         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15434         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15435         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15436         { } /* end */
15437 };
15438
15439 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
15440         {
15441                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15442                 .name = "Channel Mode",
15443                 .info = alc_ch_mode_info,
15444                 .get = alc_ch_mode_get,
15445                 .put = alc_ch_mode_put,
15446         },
15447         { } /* end */
15448 };
15449
15450 static struct hda_verb alc662_init_verbs[] = {
15451         /* ADC: mute amp left and right */
15452         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15453         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15454         /* Front mixer: unmute input/output amp left and right (volume = 0) */
15455
15456         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15457         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15458         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15459         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15460         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15461
15462         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15463         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15464         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15465         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15466         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15467         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15468
15469         /* Front Pin: output 0 (0x0c) */
15470         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15471         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15472
15473         /* Rear Pin: output 1 (0x0d) */
15474         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15475         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15476
15477         /* CLFE Pin: output 2 (0x0e) */
15478         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15479         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15480
15481         /* Mic (rear) pin: input vref at 80% */
15482         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15483         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15484         /* Front Mic pin: input vref at 80% */
15485         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15486         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15487         /* Line In pin: input */
15488         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15489         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15490         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15491         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15492         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15493         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15494         /* CD pin widget for input */
15495         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15496
15497         /* FIXME: use matrix-type input source selection */
15498         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15499         /* Input mixer */
15500         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15501         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15502
15503         /* always trun on EAPD */
15504         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15505         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15506
15507         { }
15508 };
15509
15510 static struct hda_verb alc662_sue_init_verbs[] = {
15511         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15512         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15513         {}
15514 };
15515
15516 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
15517         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15518         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15519         {}
15520 };
15521
15522 /* Set Unsolicited Event*/
15523 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15524         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15525         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15526         {}
15527 };
15528
15529 /*
15530  * generic initialization of ADC, input mixers and output mixers
15531  */
15532 static struct hda_verb alc662_auto_init_verbs[] = {
15533         /*
15534          * Unmute ADC and set the default input to mic-in
15535          */
15536         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15537         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15538
15539         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15540          * mixer widget
15541          * Note: PASD motherboards uses the Line In 2 as the input for front
15542          * panel mic (mic 2)
15543          */
15544         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15545         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15546         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15547         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15548         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15549         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15550
15551         /*
15552          * Set up output mixers (0x0c - 0x0f)
15553          */
15554         /* set vol=0 to output mixers */
15555         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15556         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15557         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15558
15559         /* set up input amps for analog loopback */
15560         /* Amp Indices: DAC = 0, mixer = 1 */
15561         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15562         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15563         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15564         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15565         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15566         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15567
15568
15569         /* FIXME: use matrix-type input source selection */
15570         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15571         /* Input mixer */
15572         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15573         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15574         { }
15575 };
15576
15577 /* additional verbs for ALC663 */
15578 static struct hda_verb alc663_auto_init_verbs[] = {
15579         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15580         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15581         { }
15582 };
15583
15584 static struct hda_verb alc663_m51va_init_verbs[] = {
15585         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15586         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15587         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15588         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15589         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15590         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15591         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15592         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15593         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15594         {}
15595 };
15596
15597 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15598         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15599         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15600         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15601         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15602         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15603         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15604         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15605         {}
15606 };
15607
15608 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15609         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15610         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15611         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15612         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15613         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15614         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15615         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15616         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15617         {}
15618 };
15619
15620 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15621         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15622         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15623         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15624         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15625         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15626         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15627         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15628         {}
15629 };
15630
15631 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15632         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15633         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15634         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15635         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15636         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15637         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15638         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15639         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15640         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15641         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15642         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15643         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15644         {}
15645 };
15646
15647 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15648         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15649         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15650         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15651         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15652         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15653         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15654         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15655         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15656         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15657         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15658         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15659         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15660         {}
15661 };
15662
15663 static struct hda_verb alc663_g71v_init_verbs[] = {
15664         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15665         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15666         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15667
15668         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15669         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15670         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15671
15672         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15673         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15674         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15675         {}
15676 };
15677
15678 static struct hda_verb alc663_g50v_init_verbs[] = {
15679         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15680         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15681         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15682
15683         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15684         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15685         {}
15686 };
15687
15688 static struct hda_verb alc662_ecs_init_verbs[] = {
15689         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15690         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15691         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15692         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15693         {}
15694 };
15695
15696 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
15697         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15698         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15699         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15700         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15701         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15702         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15703         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15704         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15705         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15706         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15707         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15708         {}
15709 };
15710
15711 static struct hda_verb alc272_dell_init_verbs[] = {
15712         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15713         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15714         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15715         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15716         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15717         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15718         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15719         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15720         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15721         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15722         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15723         {}
15724 };
15725
15726 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15727         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15728         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15729         { } /* end */
15730 };
15731
15732 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
15733         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
15734         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
15735         { } /* end */
15736 };
15737
15738 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15739 {
15740         unsigned int present;
15741         unsigned char bits;
15742
15743         present = snd_hda_codec_read(codec, 0x14, 0,
15744                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15745         bits = present ? HDA_AMP_MUTE : 0;
15746         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15747                                  HDA_AMP_MUTE, bits);
15748 }
15749
15750 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15751 {
15752         unsigned int present;
15753         unsigned char bits;
15754
15755         present = snd_hda_codec_read(codec, 0x1b, 0,
15756                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15757         bits = present ? HDA_AMP_MUTE : 0;
15758         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15759                                  HDA_AMP_MUTE, bits);
15760         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15761                                  HDA_AMP_MUTE, bits);
15762 }
15763
15764 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15765                                            unsigned int res)
15766 {
15767         if ((res >> 26) == ALC880_HP_EVENT)
15768                 alc662_lenovo_101e_all_automute(codec);
15769         if ((res >> 26) == ALC880_FRONT_EVENT)
15770                 alc662_lenovo_101e_ispeaker_automute(codec);
15771 }
15772
15773 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15774 {
15775         unsigned int present;
15776
15777         present = snd_hda_codec_read(codec, 0x18, 0,
15778                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15779         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15780                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15781         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15782                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15783         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15784                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15785         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15786                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15787 }
15788
15789 /* unsolicited event for HP jack sensing */
15790 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
15791                                      unsigned int res)
15792 {
15793         if ((res >> 26) == ALC880_MIC_EVENT)
15794                 alc662_eeepc_mic_automute(codec);
15795         else
15796                 alc262_hippo_unsol_event(codec, res);
15797 }
15798
15799 static void alc662_eeepc_inithook(struct hda_codec *codec)
15800 {
15801         alc262_hippo1_init_hook(codec);
15802         alc662_eeepc_mic_automute(codec);
15803 }
15804
15805 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
15806 {
15807         struct alc_spec *spec = codec->spec;
15808
15809         spec->autocfg.hp_pins[0] = 0x14;
15810         spec->autocfg.speaker_pins[0] = 0x1b;
15811         alc262_hippo_master_update(codec);
15812 }
15813
15814 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
15815 {
15816         unsigned int present;
15817         unsigned char bits;
15818
15819         present = snd_hda_codec_read(codec, 0x21, 0,
15820                         AC_VERB_GET_PIN_SENSE, 0)
15821                         & AC_PINSENSE_PRESENCE;
15822         bits = present ? HDA_AMP_MUTE : 0;
15823         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15824                                 AMP_IN_MUTE(0), bits);
15825         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15826                                 AMP_IN_MUTE(0), bits);
15827 }
15828
15829 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
15830 {
15831         unsigned int present;
15832         unsigned char bits;
15833
15834         present = snd_hda_codec_read(codec, 0x21, 0,
15835                         AC_VERB_GET_PIN_SENSE, 0)
15836                         & AC_PINSENSE_PRESENCE;
15837         bits = present ? HDA_AMP_MUTE : 0;
15838         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15839                                 AMP_IN_MUTE(0), bits);
15840         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15841                                 AMP_IN_MUTE(0), bits);
15842         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15843                                 AMP_IN_MUTE(0), bits);
15844         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15845                                 AMP_IN_MUTE(0), bits);
15846 }
15847
15848 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
15849 {
15850         unsigned int present;
15851         unsigned char bits;
15852
15853         present = snd_hda_codec_read(codec, 0x15, 0,
15854                         AC_VERB_GET_PIN_SENSE, 0)
15855                         & AC_PINSENSE_PRESENCE;
15856         bits = present ? HDA_AMP_MUTE : 0;
15857         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15858                                 AMP_IN_MUTE(0), bits);
15859         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15860                                 AMP_IN_MUTE(0), bits);
15861         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15862                                 AMP_IN_MUTE(0), bits);
15863         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15864                                 AMP_IN_MUTE(0), bits);
15865 }
15866
15867 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
15868 {
15869         unsigned int present;
15870         unsigned char bits;
15871
15872         present = snd_hda_codec_read(codec, 0x1b, 0,
15873                         AC_VERB_GET_PIN_SENSE, 0)
15874                         & AC_PINSENSE_PRESENCE;
15875         bits = present ? 0 : PIN_OUT;
15876         snd_hda_codec_write(codec, 0x14, 0,
15877                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
15878 }
15879
15880 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
15881 {
15882         unsigned int present1, present2;
15883
15884         present1 = snd_hda_codec_read(codec, 0x21, 0,
15885                         AC_VERB_GET_PIN_SENSE, 0)
15886                         & AC_PINSENSE_PRESENCE;
15887         present2 = snd_hda_codec_read(codec, 0x15, 0,
15888                         AC_VERB_GET_PIN_SENSE, 0)
15889                         & AC_PINSENSE_PRESENCE;
15890
15891         if (present1 || present2) {
15892                 snd_hda_codec_write_cache(codec, 0x14, 0,
15893                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
15894         } else {
15895                 snd_hda_codec_write_cache(codec, 0x14, 0,
15896                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
15897         }
15898 }
15899
15900 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
15901 {
15902         unsigned int present1, present2;
15903
15904         present1 = snd_hda_codec_read(codec, 0x1b, 0,
15905                                 AC_VERB_GET_PIN_SENSE, 0)
15906                                 & AC_PINSENSE_PRESENCE;
15907         present2 = snd_hda_codec_read(codec, 0x15, 0,
15908                                 AC_VERB_GET_PIN_SENSE, 0)
15909                                 & AC_PINSENSE_PRESENCE;
15910
15911         if (present1 || present2) {
15912                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15913                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15914                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15915                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15916         } else {
15917                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15918                                 AMP_IN_MUTE(0), 0);
15919                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15920                                 AMP_IN_MUTE(0), 0);
15921         }
15922 }
15923
15924 static void alc663_m51va_mic_automute(struct hda_codec *codec)
15925 {
15926         unsigned int present;
15927
15928         present = snd_hda_codec_read(codec, 0x18, 0,
15929                         AC_VERB_GET_PIN_SENSE, 0)
15930                         & AC_PINSENSE_PRESENCE;
15931         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15932                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15933         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15934                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15935         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15936                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15937         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15938                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15939 }
15940
15941 static void alc663_m51va_unsol_event(struct hda_codec *codec,
15942                                            unsigned int res)
15943 {
15944         switch (res >> 26) {
15945         case ALC880_HP_EVENT:
15946                 alc663_m51va_speaker_automute(codec);
15947                 break;
15948         case ALC880_MIC_EVENT:
15949                 alc663_m51va_mic_automute(codec);
15950                 break;
15951         }
15952 }
15953
15954 static void alc663_m51va_inithook(struct hda_codec *codec)
15955 {
15956         alc663_m51va_speaker_automute(codec);
15957         alc663_m51va_mic_automute(codec);
15958 }
15959
15960 /* ***************** Mode1 ******************************/
15961 static void alc663_mode1_unsol_event(struct hda_codec *codec,
15962                                            unsigned int res)
15963 {
15964         switch (res >> 26) {
15965         case ALC880_HP_EVENT:
15966                 alc663_m51va_speaker_automute(codec);
15967                 break;
15968         case ALC880_MIC_EVENT:
15969                 alc662_eeepc_mic_automute(codec);
15970                 break;
15971         }
15972 }
15973
15974 static void alc663_mode1_inithook(struct hda_codec *codec)
15975 {
15976         alc663_m51va_speaker_automute(codec);
15977         alc662_eeepc_mic_automute(codec);
15978 }
15979 /* ***************** Mode2 ******************************/
15980 static void alc662_mode2_unsol_event(struct hda_codec *codec,
15981                                            unsigned int res)
15982 {
15983         switch (res >> 26) {
15984         case ALC880_HP_EVENT:
15985                 alc662_f5z_speaker_automute(codec);
15986                 break;
15987         case ALC880_MIC_EVENT:
15988                 alc662_eeepc_mic_automute(codec);
15989                 break;
15990         }
15991 }
15992
15993 static void alc662_mode2_inithook(struct hda_codec *codec)
15994 {
15995         alc662_f5z_speaker_automute(codec);
15996         alc662_eeepc_mic_automute(codec);
15997 }
15998 /* ***************** Mode3 ******************************/
15999 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16000                                            unsigned int res)
16001 {
16002         switch (res >> 26) {
16003         case ALC880_HP_EVENT:
16004                 alc663_two_hp_m1_speaker_automute(codec);
16005                 break;
16006         case ALC880_MIC_EVENT:
16007                 alc662_eeepc_mic_automute(codec);
16008                 break;
16009         }
16010 }
16011
16012 static void alc663_mode3_inithook(struct hda_codec *codec)
16013 {
16014         alc663_two_hp_m1_speaker_automute(codec);
16015         alc662_eeepc_mic_automute(codec);
16016 }
16017 /* ***************** Mode4 ******************************/
16018 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16019                                            unsigned int res)
16020 {
16021         switch (res >> 26) {
16022         case ALC880_HP_EVENT:
16023                 alc663_21jd_two_speaker_automute(codec);
16024                 break;
16025         case ALC880_MIC_EVENT:
16026                 alc662_eeepc_mic_automute(codec);
16027                 break;
16028         }
16029 }
16030
16031 static void alc663_mode4_inithook(struct hda_codec *codec)
16032 {
16033         alc663_21jd_two_speaker_automute(codec);
16034         alc662_eeepc_mic_automute(codec);
16035 }
16036 /* ***************** Mode5 ******************************/
16037 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16038                                            unsigned int res)
16039 {
16040         switch (res >> 26) {
16041         case ALC880_HP_EVENT:
16042                 alc663_15jd_two_speaker_automute(codec);
16043                 break;
16044         case ALC880_MIC_EVENT:
16045                 alc662_eeepc_mic_automute(codec);
16046                 break;
16047         }
16048 }
16049
16050 static void alc663_mode5_inithook(struct hda_codec *codec)
16051 {
16052         alc663_15jd_two_speaker_automute(codec);
16053         alc662_eeepc_mic_automute(codec);
16054 }
16055 /* ***************** Mode6 ******************************/
16056 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16057                                            unsigned int res)
16058 {
16059         switch (res >> 26) {
16060         case ALC880_HP_EVENT:
16061                 alc663_two_hp_m2_speaker_automute(codec);
16062                 break;
16063         case ALC880_MIC_EVENT:
16064                 alc662_eeepc_mic_automute(codec);
16065                 break;
16066         }
16067 }
16068
16069 static void alc663_mode6_inithook(struct hda_codec *codec)
16070 {
16071         alc663_two_hp_m2_speaker_automute(codec);
16072         alc662_eeepc_mic_automute(codec);
16073 }
16074
16075 static void alc663_g71v_hp_automute(struct hda_codec *codec)
16076 {
16077         unsigned int present;
16078         unsigned char bits;
16079
16080         present = snd_hda_codec_read(codec, 0x21, 0,
16081                                      AC_VERB_GET_PIN_SENSE, 0)
16082                 & AC_PINSENSE_PRESENCE;
16083         bits = present ? HDA_AMP_MUTE : 0;
16084         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16085                                  HDA_AMP_MUTE, bits);
16086         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16087                                  HDA_AMP_MUTE, bits);
16088 }
16089
16090 static void alc663_g71v_front_automute(struct hda_codec *codec)
16091 {
16092         unsigned int present;
16093         unsigned char bits;
16094
16095         present = snd_hda_codec_read(codec, 0x15, 0,
16096                                      AC_VERB_GET_PIN_SENSE, 0)
16097                 & AC_PINSENSE_PRESENCE;
16098         bits = present ? HDA_AMP_MUTE : 0;
16099         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16100                                  HDA_AMP_MUTE, bits);
16101 }
16102
16103 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16104                                            unsigned int res)
16105 {
16106         switch (res >> 26) {
16107         case ALC880_HP_EVENT:
16108                 alc663_g71v_hp_automute(codec);
16109                 break;
16110         case ALC880_FRONT_EVENT:
16111                 alc663_g71v_front_automute(codec);
16112                 break;
16113         case ALC880_MIC_EVENT:
16114                 alc662_eeepc_mic_automute(codec);
16115                 break;
16116         }
16117 }
16118
16119 static void alc663_g71v_inithook(struct hda_codec *codec)
16120 {
16121         alc663_g71v_front_automute(codec);
16122         alc663_g71v_hp_automute(codec);
16123         alc662_eeepc_mic_automute(codec);
16124 }
16125
16126 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16127                                            unsigned int res)
16128 {
16129         switch (res >> 26) {
16130         case ALC880_HP_EVENT:
16131                 alc663_m51va_speaker_automute(codec);
16132                 break;
16133         case ALC880_MIC_EVENT:
16134                 alc662_eeepc_mic_automute(codec);
16135                 break;
16136         }
16137 }
16138
16139 static void alc663_g50v_inithook(struct hda_codec *codec)
16140 {
16141         alc663_m51va_speaker_automute(codec);
16142         alc662_eeepc_mic_automute(codec);
16143 }
16144
16145 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16146         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16147         ALC262_HIPPO_MASTER_SWITCH,
16148
16149         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16150         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16151         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16152
16153         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16154         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16155         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16156         { } /* end */
16157 };
16158
16159 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
16160         /* Master Playback automatically created from Speaker and Headphone */
16161         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16162         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16163         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16164         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16165
16166         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16167         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16168         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
16169
16170         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16171         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16172         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
16173         { } /* end */
16174 };
16175
16176 #ifdef CONFIG_SND_HDA_POWER_SAVE
16177 #define alc662_loopbacks        alc880_loopbacks
16178 #endif
16179
16180
16181 /* pcm configuration: identiacal with ALC880 */
16182 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
16183 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
16184 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
16185 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
16186
16187 /*
16188  * configuration and preset
16189  */
16190 static const char *alc662_models[ALC662_MODEL_LAST] = {
16191         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
16192         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
16193         [ALC662_3ST_6ch]        = "3stack-6ch",
16194         [ALC662_5ST_DIG]        = "6stack-dig",
16195         [ALC662_LENOVO_101E]    = "lenovo-101e",
16196         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
16197         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
16198         [ALC662_ECS] = "ecs",
16199         [ALC663_ASUS_M51VA] = "m51va",
16200         [ALC663_ASUS_G71V] = "g71v",
16201         [ALC663_ASUS_H13] = "h13",
16202         [ALC663_ASUS_G50V] = "g50v",
16203         [ALC663_ASUS_MODE1] = "asus-mode1",
16204         [ALC662_ASUS_MODE2] = "asus-mode2",
16205         [ALC663_ASUS_MODE3] = "asus-mode3",
16206         [ALC663_ASUS_MODE4] = "asus-mode4",
16207         [ALC663_ASUS_MODE5] = "asus-mode5",
16208         [ALC663_ASUS_MODE6] = "asus-mode6",
16209         [ALC272_DELL]           = "dell",
16210         [ALC272_DELL_ZM1]       = "dell-zm1",
16211         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
16212         [ALC662_AUTO]           = "auto",
16213 };
16214
16215 static struct snd_pci_quirk alc662_cfg_tbl[] = {
16216         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
16217         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
16218         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
16219         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
16220         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
16221         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
16222         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
16223         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
16224         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
16225         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
16226         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
16227         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
16228         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
16229         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
16230         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
16231         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
16232         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
16233         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
16234         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
16235         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
16236         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
16237         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
16238         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
16239         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
16240         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
16241         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
16242         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
16243         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
16244         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
16245         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
16246         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
16247         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
16248         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
16249         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
16250         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
16251         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
16252         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
16253         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
16254         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
16255         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
16256         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
16257         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
16258         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
16259         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
16260         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
16261         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
16262         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
16263         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
16264         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
16265         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
16266         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
16267         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
16268                       ALC662_3ST_6ch_DIG),
16269         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
16270         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
16271                       ALC662_3ST_6ch_DIG),
16272         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
16273         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
16274         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
16275         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
16276                                         ALC662_3ST_6ch_DIG),
16277         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
16278                            ALC663_ASUS_H13),
16279         {}
16280 };
16281
16282 static struct alc_config_preset alc662_presets[] = {
16283         [ALC662_3ST_2ch_DIG] = {
16284                 .mixers = { alc662_3ST_2ch_mixer },
16285                 .init_verbs = { alc662_init_verbs },
16286                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16287                 .dac_nids = alc662_dac_nids,
16288                 .dig_out_nid = ALC662_DIGOUT_NID,
16289                 .dig_in_nid = ALC662_DIGIN_NID,
16290                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16291                 .channel_mode = alc662_3ST_2ch_modes,
16292                 .input_mux = &alc662_capture_source,
16293         },
16294         [ALC662_3ST_6ch_DIG] = {
16295                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16296                 .init_verbs = { alc662_init_verbs },
16297                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16298                 .dac_nids = alc662_dac_nids,
16299                 .dig_out_nid = ALC662_DIGOUT_NID,
16300                 .dig_in_nid = ALC662_DIGIN_NID,
16301                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16302                 .channel_mode = alc662_3ST_6ch_modes,
16303                 .need_dac_fix = 1,
16304                 .input_mux = &alc662_capture_source,
16305         },
16306         [ALC662_3ST_6ch] = {
16307                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16308                 .init_verbs = { alc662_init_verbs },
16309                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16310                 .dac_nids = alc662_dac_nids,
16311                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16312                 .channel_mode = alc662_3ST_6ch_modes,
16313                 .need_dac_fix = 1,
16314                 .input_mux = &alc662_capture_source,
16315         },
16316         [ALC662_5ST_DIG] = {
16317                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
16318                 .init_verbs = { alc662_init_verbs },
16319                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16320                 .dac_nids = alc662_dac_nids,
16321                 .dig_out_nid = ALC662_DIGOUT_NID,
16322                 .dig_in_nid = ALC662_DIGIN_NID,
16323                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
16324                 .channel_mode = alc662_5stack_modes,
16325                 .input_mux = &alc662_capture_source,
16326         },
16327         [ALC662_LENOVO_101E] = {
16328                 .mixers = { alc662_lenovo_101e_mixer },
16329                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
16330                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16331                 .dac_nids = alc662_dac_nids,
16332                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16333                 .channel_mode = alc662_3ST_2ch_modes,
16334                 .input_mux = &alc662_lenovo_101e_capture_source,
16335                 .unsol_event = alc662_lenovo_101e_unsol_event,
16336                 .init_hook = alc662_lenovo_101e_all_automute,
16337         },
16338         [ALC662_ASUS_EEEPC_P701] = {
16339                 .mixers = { alc662_eeepc_p701_mixer },
16340                 .init_verbs = { alc662_init_verbs,
16341                                 alc662_eeepc_sue_init_verbs },
16342                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16343                 .dac_nids = alc662_dac_nids,
16344                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16345                 .channel_mode = alc662_3ST_2ch_modes,
16346                 .input_mux = &alc662_eeepc_capture_source,
16347                 .unsol_event = alc662_eeepc_unsol_event,
16348                 .init_hook = alc662_eeepc_inithook,
16349         },
16350         [ALC662_ASUS_EEEPC_EP20] = {
16351                 .mixers = { alc662_eeepc_ep20_mixer,
16352                             alc662_chmode_mixer },
16353                 .init_verbs = { alc662_init_verbs,
16354                                 alc662_eeepc_ep20_sue_init_verbs },
16355                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16356                 .dac_nids = alc662_dac_nids,
16357                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16358                 .channel_mode = alc662_3ST_6ch_modes,
16359                 .input_mux = &alc662_lenovo_101e_capture_source,
16360                 .unsol_event = alc662_eeepc_unsol_event,
16361                 .init_hook = alc662_eeepc_ep20_inithook,
16362         },
16363         [ALC662_ECS] = {
16364                 .mixers = { alc662_ecs_mixer },
16365                 .init_verbs = { alc662_init_verbs,
16366                                 alc662_ecs_init_verbs },
16367                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16368                 .dac_nids = alc662_dac_nids,
16369                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16370                 .channel_mode = alc662_3ST_2ch_modes,
16371                 .input_mux = &alc662_eeepc_capture_source,
16372                 .unsol_event = alc662_eeepc_unsol_event,
16373                 .init_hook = alc662_eeepc_inithook,
16374         },
16375         [ALC663_ASUS_M51VA] = {
16376                 .mixers = { alc663_m51va_mixer },
16377                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16378                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16379                 .dac_nids = alc662_dac_nids,
16380                 .dig_out_nid = ALC662_DIGOUT_NID,
16381                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16382                 .channel_mode = alc662_3ST_2ch_modes,
16383                 .input_mux = &alc663_m51va_capture_source,
16384                 .unsol_event = alc663_m51va_unsol_event,
16385                 .init_hook = alc663_m51va_inithook,
16386         },
16387         [ALC663_ASUS_G71V] = {
16388                 .mixers = { alc663_g71v_mixer },
16389                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
16390                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16391                 .dac_nids = alc662_dac_nids,
16392                 .dig_out_nid = ALC662_DIGOUT_NID,
16393                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16394                 .channel_mode = alc662_3ST_2ch_modes,
16395                 .input_mux = &alc662_eeepc_capture_source,
16396                 .unsol_event = alc663_g71v_unsol_event,
16397                 .init_hook = alc663_g71v_inithook,
16398         },
16399         [ALC663_ASUS_H13] = {
16400                 .mixers = { alc663_m51va_mixer },
16401                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16402                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16403                 .dac_nids = alc662_dac_nids,
16404                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16405                 .channel_mode = alc662_3ST_2ch_modes,
16406                 .input_mux = &alc663_m51va_capture_source,
16407                 .unsol_event = alc663_m51va_unsol_event,
16408                 .init_hook = alc663_m51va_inithook,
16409         },
16410         [ALC663_ASUS_G50V] = {
16411                 .mixers = { alc663_g50v_mixer },
16412                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
16413                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16414                 .dac_nids = alc662_dac_nids,
16415                 .dig_out_nid = ALC662_DIGOUT_NID,
16416                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16417                 .channel_mode = alc662_3ST_6ch_modes,
16418                 .input_mux = &alc663_capture_source,
16419                 .unsol_event = alc663_g50v_unsol_event,
16420                 .init_hook = alc663_g50v_inithook,
16421         },
16422         [ALC663_ASUS_MODE1] = {
16423                 .mixers = { alc663_m51va_mixer },
16424                 .cap_mixer = alc662_auto_capture_mixer,
16425                 .init_verbs = { alc662_init_verbs,
16426                                 alc663_21jd_amic_init_verbs },
16427                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16428                 .hp_nid = 0x03,
16429                 .dac_nids = alc662_dac_nids,
16430                 .dig_out_nid = ALC662_DIGOUT_NID,
16431                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16432                 .channel_mode = alc662_3ST_2ch_modes,
16433                 .input_mux = &alc662_eeepc_capture_source,
16434                 .unsol_event = alc663_mode1_unsol_event,
16435                 .init_hook = alc663_mode1_inithook,
16436         },
16437         [ALC662_ASUS_MODE2] = {
16438                 .mixers = { alc662_1bjd_mixer },
16439                 .cap_mixer = alc662_auto_capture_mixer,
16440                 .init_verbs = { alc662_init_verbs,
16441                                 alc662_1bjd_amic_init_verbs },
16442                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16443                 .dac_nids = alc662_dac_nids,
16444                 .dig_out_nid = ALC662_DIGOUT_NID,
16445                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16446                 .channel_mode = alc662_3ST_2ch_modes,
16447                 .input_mux = &alc662_eeepc_capture_source,
16448                 .unsol_event = alc662_mode2_unsol_event,
16449                 .init_hook = alc662_mode2_inithook,
16450         },
16451         [ALC663_ASUS_MODE3] = {
16452                 .mixers = { alc663_two_hp_m1_mixer },
16453                 .cap_mixer = alc662_auto_capture_mixer,
16454                 .init_verbs = { alc662_init_verbs,
16455                                 alc663_two_hp_amic_m1_init_verbs },
16456                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16457                 .hp_nid = 0x03,
16458                 .dac_nids = alc662_dac_nids,
16459                 .dig_out_nid = ALC662_DIGOUT_NID,
16460                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16461                 .channel_mode = alc662_3ST_2ch_modes,
16462                 .input_mux = &alc662_eeepc_capture_source,
16463                 .unsol_event = alc663_mode3_unsol_event,
16464                 .init_hook = alc663_mode3_inithook,
16465         },
16466         [ALC663_ASUS_MODE4] = {
16467                 .mixers = { alc663_asus_21jd_clfe_mixer },
16468                 .cap_mixer = alc662_auto_capture_mixer,
16469                 .init_verbs = { alc662_init_verbs,
16470                                 alc663_21jd_amic_init_verbs},
16471                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16472                 .hp_nid = 0x03,
16473                 .dac_nids = alc662_dac_nids,
16474                 .dig_out_nid = ALC662_DIGOUT_NID,
16475                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16476                 .channel_mode = alc662_3ST_2ch_modes,
16477                 .input_mux = &alc662_eeepc_capture_source,
16478                 .unsol_event = alc663_mode4_unsol_event,
16479                 .init_hook = alc663_mode4_inithook,
16480         },
16481         [ALC663_ASUS_MODE5] = {
16482                 .mixers = { alc663_asus_15jd_clfe_mixer },
16483                 .cap_mixer = alc662_auto_capture_mixer,
16484                 .init_verbs = { alc662_init_verbs,
16485                                 alc663_15jd_amic_init_verbs },
16486                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16487                 .hp_nid = 0x03,
16488                 .dac_nids = alc662_dac_nids,
16489                 .dig_out_nid = ALC662_DIGOUT_NID,
16490                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16491                 .channel_mode = alc662_3ST_2ch_modes,
16492                 .input_mux = &alc662_eeepc_capture_source,
16493                 .unsol_event = alc663_mode5_unsol_event,
16494                 .init_hook = alc663_mode5_inithook,
16495         },
16496         [ALC663_ASUS_MODE6] = {
16497                 .mixers = { alc663_two_hp_m2_mixer },
16498                 .cap_mixer = alc662_auto_capture_mixer,
16499                 .init_verbs = { alc662_init_verbs,
16500                                 alc663_two_hp_amic_m2_init_verbs },
16501                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16502                 .hp_nid = 0x03,
16503                 .dac_nids = alc662_dac_nids,
16504                 .dig_out_nid = ALC662_DIGOUT_NID,
16505                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16506                 .channel_mode = alc662_3ST_2ch_modes,
16507                 .input_mux = &alc662_eeepc_capture_source,
16508                 .unsol_event = alc663_mode6_unsol_event,
16509                 .init_hook = alc663_mode6_inithook,
16510         },
16511         [ALC272_DELL] = {
16512                 .mixers = { alc663_m51va_mixer },
16513                 .cap_mixer = alc272_auto_capture_mixer,
16514                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
16515                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
16516                 .dac_nids = alc662_dac_nids,
16517                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16518                 .adc_nids = alc272_adc_nids,
16519                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
16520                 .capsrc_nids = alc272_capsrc_nids,
16521                 .channel_mode = alc662_3ST_2ch_modes,
16522                 .input_mux = &alc663_m51va_capture_source,
16523                 .unsol_event = alc663_m51va_unsol_event,
16524                 .init_hook = alc663_m51va_inithook,
16525         },
16526         [ALC272_DELL_ZM1] = {
16527                 .mixers = { alc663_m51va_mixer },
16528                 .cap_mixer = alc662_auto_capture_mixer,
16529                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
16530                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
16531                 .dac_nids = alc662_dac_nids,
16532                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16533                 .adc_nids = alc662_adc_nids,
16534                 .num_adc_nids = ARRAY_SIZE(alc662_adc_nids),
16535                 .capsrc_nids = alc662_capsrc_nids,
16536                 .channel_mode = alc662_3ST_2ch_modes,
16537                 .input_mux = &alc663_m51va_capture_source,
16538                 .unsol_event = alc663_m51va_unsol_event,
16539                 .init_hook = alc663_m51va_inithook,
16540         },
16541         [ALC272_SAMSUNG_NC10] = {
16542                 .mixers = { alc272_nc10_mixer },
16543                 .init_verbs = { alc662_init_verbs,
16544                                 alc663_21jd_amic_init_verbs },
16545                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
16546                 .dac_nids = alc272_dac_nids,
16547                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16548                 .channel_mode = alc662_3ST_2ch_modes,
16549                 .input_mux = &alc272_nc10_capture_source,
16550                 .unsol_event = alc663_mode4_unsol_event,
16551                 .init_hook = alc663_mode4_inithook,
16552         },
16553 };
16554
16555
16556 /*
16557  * BIOS auto configuration
16558  */
16559
16560 /* add playback controls from the parsed DAC table */
16561 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
16562                                              const struct auto_pin_cfg *cfg)
16563 {
16564         char name[32];
16565         static const char *chname[4] = {
16566                 "Front", "Surround", NULL /*CLFE*/, "Side"
16567         };
16568         hda_nid_t nid;
16569         int i, err;
16570
16571         for (i = 0; i < cfg->line_outs; i++) {
16572                 if (!spec->multiout.dac_nids[i])
16573                         continue;
16574                 nid = alc880_idx_to_dac(i);
16575                 if (i == 2) {
16576                         /* Center/LFE */
16577                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16578                                           "Center Playback Volume",
16579                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16580                                                               HDA_OUTPUT));
16581                         if (err < 0)
16582                                 return err;
16583                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16584                                           "LFE Playback Volume",
16585                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16586                                                               HDA_OUTPUT));
16587                         if (err < 0)
16588                                 return err;
16589                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16590                                           "Center Playback Switch",
16591                                           HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16592                                                               HDA_INPUT));
16593                         if (err < 0)
16594                                 return err;
16595                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16596                                           "LFE Playback Switch",
16597                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16598                                                               HDA_INPUT));
16599                         if (err < 0)
16600                                 return err;
16601                 } else {
16602                         sprintf(name, "%s Playback Volume", chname[i]);
16603                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16604                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16605                                                               HDA_OUTPUT));
16606                         if (err < 0)
16607                                 return err;
16608                         sprintf(name, "%s Playback Switch", chname[i]);
16609                         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16610                                 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16611                                                     3, 0, HDA_INPUT));
16612                         if (err < 0)
16613                                 return err;
16614                 }
16615         }
16616         return 0;
16617 }
16618
16619 /* add playback controls for speaker and HP outputs */
16620 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16621                                         const char *pfx)
16622 {
16623         hda_nid_t nid;
16624         int err;
16625         char name[32];
16626
16627         if (!pin)
16628                 return 0;
16629
16630         if (pin == 0x17) {
16631                 /* ALC663 has a mono output pin on 0x17 */
16632                 sprintf(name, "%s Playback Switch", pfx);
16633                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16634                                   HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16635                 return err;
16636         }
16637
16638         if (alc880_is_fixed_pin(pin)) {
16639                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16640                 /* printk(KERN_DEBUG "DAC nid=%x\n",nid); */
16641                 /* specify the DAC as the extra output */
16642                 if (!spec->multiout.hp_nid)
16643                         spec->multiout.hp_nid = nid;
16644                 else
16645                         spec->multiout.extra_out_nid[0] = nid;
16646                 /* control HP volume/switch on the output mixer amp */
16647                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16648                 sprintf(name, "%s Playback Volume", pfx);
16649                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16650                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16651                 if (err < 0)
16652                         return err;
16653                 sprintf(name, "%s Playback Switch", pfx);
16654                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16655                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16656                 if (err < 0)
16657                         return err;
16658         } else if (alc880_is_multi_pin(pin)) {
16659                 /* set manual connection */
16660                 /* we have only a switch on HP-out PIN */
16661                 sprintf(name, "%s Playback Switch", pfx);
16662                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16663                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16664                 if (err < 0)
16665                         return err;
16666         }
16667         return 0;
16668 }
16669
16670 /* return the index of the src widget from the connection list of the nid.
16671  * return -1 if not found
16672  */
16673 static int alc662_input_pin_idx(struct hda_codec *codec, hda_nid_t nid,
16674                                 hda_nid_t src)
16675 {
16676         hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
16677         int i, conns;
16678
16679         conns = snd_hda_get_connections(codec, nid, conn_list,
16680                                         ARRAY_SIZE(conn_list));
16681         if (conns < 0)
16682                 return -1;
16683         for (i = 0; i < conns; i++)
16684                 if (conn_list[i] == src)
16685                         return i;
16686         return -1;
16687 }
16688
16689 static int alc662_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
16690 {
16691         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
16692         return (pincap & AC_PINCAP_IN) != 0;
16693 }
16694
16695 /* create playback/capture controls for input pins */
16696 static int alc662_auto_create_analog_input_ctls(struct hda_codec *codec,
16697                                                 const struct auto_pin_cfg *cfg)
16698 {
16699         struct alc_spec *spec = codec->spec;
16700         struct hda_input_mux *imux = &spec->private_imux[0];
16701         int i, err, idx;
16702
16703         for (i = 0; i < AUTO_PIN_LAST; i++) {
16704                 if (alc662_is_input_pin(codec, cfg->input_pins[i])) {
16705                         idx = alc662_input_pin_idx(codec, 0x0b,
16706                                                    cfg->input_pins[i]);
16707                         if (idx >= 0) {
16708                                 err = new_analog_input(spec, cfg->input_pins[i],
16709                                                        auto_pin_cfg_labels[i],
16710                                                        idx, 0x0b);
16711                                 if (err < 0)
16712                                         return err;
16713                         }
16714                         idx = alc662_input_pin_idx(codec, 0x22,
16715                                                    cfg->input_pins[i]);
16716                         if (idx >= 0) {
16717                                 imux->items[imux->num_items].label =
16718                                         auto_pin_cfg_labels[i];
16719                                 imux->items[imux->num_items].index = idx;
16720                                 imux->num_items++;
16721                         }
16722                 }
16723         }
16724         return 0;
16725 }
16726
16727 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16728                                               hda_nid_t nid, int pin_type,
16729                                               int dac_idx)
16730 {
16731         alc_set_pin_output(codec, nid, pin_type);
16732         /* need the manual connection? */
16733         if (alc880_is_multi_pin(nid)) {
16734                 struct alc_spec *spec = codec->spec;
16735                 int idx = alc880_multi_pin_idx(nid);
16736                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16737                                     AC_VERB_SET_CONNECT_SEL,
16738                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16739         }
16740 }
16741
16742 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16743 {
16744         struct alc_spec *spec = codec->spec;
16745         int i;
16746
16747         for (i = 0; i <= HDA_SIDE; i++) {
16748                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16749                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16750                 if (nid)
16751                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16752                                                           i);
16753         }
16754 }
16755
16756 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16757 {
16758         struct alc_spec *spec = codec->spec;
16759         hda_nid_t pin;
16760
16761         pin = spec->autocfg.hp_pins[0];
16762         if (pin) /* connect to front */
16763                 /* use dac 0 */
16764                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16765         pin = spec->autocfg.speaker_pins[0];
16766         if (pin)
16767                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16768 }
16769
16770 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
16771
16772 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16773 {
16774         struct alc_spec *spec = codec->spec;
16775         int i;
16776
16777         for (i = 0; i < AUTO_PIN_LAST; i++) {
16778                 hda_nid_t nid = spec->autocfg.input_pins[i];
16779                 if (alc662_is_input_pin(codec, nid)) {
16780                         alc_set_input_pin(codec, nid, i);
16781                         if (nid != ALC662_PIN_CD_NID &&
16782                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16783                                 snd_hda_codec_write(codec, nid, 0,
16784                                                     AC_VERB_SET_AMP_GAIN_MUTE,
16785                                                     AMP_OUT_MUTE);
16786                 }
16787         }
16788 }
16789
16790 #define alc662_auto_init_input_src      alc882_auto_init_input_src
16791
16792 static int alc662_parse_auto_config(struct hda_codec *codec)
16793 {
16794         struct alc_spec *spec = codec->spec;
16795         int err;
16796         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
16797
16798         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16799                                            alc662_ignore);
16800         if (err < 0)
16801                 return err;
16802         if (!spec->autocfg.line_outs)
16803                 return 0; /* can't find valid BIOS pin config */
16804
16805         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16806         if (err < 0)
16807                 return err;
16808         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
16809         if (err < 0)
16810                 return err;
16811         err = alc662_auto_create_extra_out(spec,
16812                                            spec->autocfg.speaker_pins[0],
16813                                            "Speaker");
16814         if (err < 0)
16815                 return err;
16816         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
16817                                            "Headphone");
16818         if (err < 0)
16819                 return err;
16820         err = alc662_auto_create_analog_input_ctls(codec, &spec->autocfg);
16821         if (err < 0)
16822                 return err;
16823
16824         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16825
16826         if (spec->autocfg.dig_outs)
16827                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
16828
16829         if (spec->kctls.list)
16830                 add_mixer(spec, spec->kctls.list);
16831
16832         spec->num_mux_defs = 1;
16833         spec->input_mux = &spec->private_imux[0];
16834
16835         add_verb(spec, alc662_auto_init_verbs);
16836         if (codec->vendor_id == 0x10ec0663)
16837                 add_verb(spec, alc663_auto_init_verbs);
16838
16839         err = alc_auto_add_mic_boost(codec);
16840         if (err < 0)
16841                 return err;
16842
16843         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
16844
16845         return 1;
16846 }
16847
16848 /* additional initialization for auto-configuration model */
16849 static void alc662_auto_init(struct hda_codec *codec)
16850 {
16851         struct alc_spec *spec = codec->spec;
16852         alc662_auto_init_multi_out(codec);
16853         alc662_auto_init_hp_out(codec);
16854         alc662_auto_init_analog_input(codec);
16855         alc662_auto_init_input_src(codec);
16856         if (spec->unsol_event)
16857                 alc_inithook(codec);
16858 }
16859
16860 static int patch_alc662(struct hda_codec *codec)
16861 {
16862         struct alc_spec *spec;
16863         int err, board_config;
16864
16865         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16866         if (!spec)
16867                 return -ENOMEM;
16868
16869         codec->spec = spec;
16870
16871         alc_fix_pll_init(codec, 0x20, 0x04, 15);
16872
16873         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
16874                                                   alc662_models,
16875                                                   alc662_cfg_tbl);
16876         if (board_config < 0) {
16877                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
16878                        "trying auto-probe from BIOS...\n", codec->chip_name);
16879                 board_config = ALC662_AUTO;
16880         }
16881
16882         if (board_config == ALC662_AUTO) {
16883                 /* automatic parse from the BIOS config */
16884                 err = alc662_parse_auto_config(codec);
16885                 if (err < 0) {
16886                         alc_free(codec);
16887                         return err;
16888                 } else if (!err) {
16889                         printk(KERN_INFO
16890                                "hda_codec: Cannot set up configuration "
16891                                "from BIOS.  Using base mode...\n");
16892                         board_config = ALC662_3ST_2ch_DIG;
16893                 }
16894         }
16895
16896         err = snd_hda_attach_beep_device(codec, 0x1);
16897         if (err < 0) {
16898                 alc_free(codec);
16899                 return err;
16900         }
16901
16902         if (board_config != ALC662_AUTO)
16903                 setup_preset(spec, &alc662_presets[board_config]);
16904
16905         spec->stream_analog_playback = &alc662_pcm_analog_playback;
16906         spec->stream_analog_capture = &alc662_pcm_analog_capture;
16907
16908         spec->stream_digital_playback = &alc662_pcm_digital_playback;
16909         spec->stream_digital_capture = &alc662_pcm_digital_capture;
16910
16911         spec->adc_nids = alc662_adc_nids;
16912         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
16913         spec->capsrc_nids = alc662_capsrc_nids;
16914         spec->capture_style = CAPT_MIX;
16915
16916         if (!spec->cap_mixer)
16917                 set_capture_mixer(spec);
16918         if (codec->vendor_id == 0x10ec0662)
16919                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
16920         else
16921                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
16922
16923         spec->vmaster_nid = 0x02;
16924
16925         codec->patch_ops = alc_patch_ops;
16926         if (board_config == ALC662_AUTO)
16927                 spec->init_hook = alc662_auto_init;
16928 #ifdef CONFIG_SND_HDA_POWER_SAVE
16929         if (!spec->loopback.amplist)
16930                 spec->loopback.amplist = alc662_loopbacks;
16931 #endif
16932         codec->proc_widget_hook = print_realtek_coef;
16933
16934         return 0;
16935 }
16936
16937 /*
16938  * patch entries
16939  */
16940 static struct hda_codec_preset snd_hda_preset_realtek[] = {
16941         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
16942         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
16943         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
16944         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
16945         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
16946         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
16947         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
16948           .patch = patch_alc861 },
16949         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
16950         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
16951         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
16952         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
16953           .patch = patch_alc883 },
16954         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
16955           .patch = patch_alc662 },
16956         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
16957         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
16958         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
16959         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
16960         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
16961           .patch = patch_alc882 }, /* should be patch_alc883() in future */
16962         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
16963           .patch = patch_alc882 }, /* should be patch_alc883() in future */
16964         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
16965         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
16966         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
16967           .patch = patch_alc883 },
16968         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
16969         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
16970         {} /* terminator */
16971 };
16972
16973 MODULE_ALIAS("snd-hda-codec-id:10ec*");
16974
16975 MODULE_LICENSE("GPL");
16976 MODULE_DESCRIPTION("Realtek HD-audio codec");
16977
16978 static struct hda_codec_preset_list realtek_list = {
16979         .preset = snd_hda_preset_realtek,
16980         .owner = THIS_MODULE,
16981 };
16982
16983 static int __init patch_realtek_init(void)
16984 {
16985         return snd_hda_add_codec_preset(&realtek_list);
16986 }
16987
16988 static void __exit patch_realtek_exit(void)
16989 {
16990         snd_hda_delete_codec_preset(&realtek_list);
16991 }
16992
16993 module_init(patch_realtek_init)
16994 module_exit(patch_realtek_exit)