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

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for ALC 260/880/882 codecs
   5  *
   6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   7  *                    PeiSen Hou <pshou@realtek.com.tw>
   8  *                    Takashi Iwai <tiwai@suse.de>
   9  *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
  10  *
  11  *  This driver is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This driver is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/slab.h>
  29 #include <linux/pci.h>
  30 #include <sound/core.h>
  31 #include "hda_codec.h"
  32 #include "hda_local.h"
  33 #include "hda_beep.h"
  34
  35 #define ALC880_FRONT_EVENT              0x01
  36 #define ALC880_DCVOL_EVENT              0x02
  37 #define ALC880_HP_EVENT                 0x04
  38 #define ALC880_MIC_EVENT                0x08
  39
  40 /* ALC880 board config type */
  41 enum {
  42         ALC880_3ST,
  43         ALC880_3ST_DIG,
  44         ALC880_5ST,
  45         ALC880_5ST_DIG,
  46         ALC880_W810,
  47         ALC880_Z71V,
  48         ALC880_6ST,
  49         ALC880_6ST_DIG,
  50         ALC880_F1734,
  51         ALC880_ASUS,
  52         ALC880_ASUS_DIG,
  53         ALC880_ASUS_W1V,
  54         ALC880_ASUS_DIG2,
  55         ALC880_FUJITSU,
  56         ALC880_UNIWILL_DIG,
  57         ALC880_UNIWILL,
  58         ALC880_UNIWILL_P53,
  59         ALC880_CLEVO,
  60         ALC880_TCL_S700,
  61         ALC880_LG,
  62         ALC880_LG_LW,
  63         ALC880_MEDION_RIM,
  64 #ifdef CONFIG_SND_DEBUG
  65         ALC880_TEST,
  66 #endif
  67         ALC880_AUTO,
  68         ALC880_MODEL_LAST /* last tag */
  69 };
  70
  71 /* ALC260 models */
  72 enum {
  73         ALC260_BASIC,
  74         ALC260_HP,
  75         ALC260_HP_DC7600,
  76         ALC260_HP_3013,
  77         ALC260_FUJITSU_S702X,
  78         ALC260_ACER,
  79         ALC260_WILL,
  80         ALC260_REPLACER_672V,
  81         ALC260_FAVORIT100,
  82 #ifdef CONFIG_SND_DEBUG
  83         ALC260_TEST,
  84 #endif
  85         ALC260_AUTO,
  86         ALC260_MODEL_LAST /* last tag */
  87 };
  88
  89 /* ALC262 models */
  90 enum {
  91         ALC262_BASIC,
  92         ALC262_HIPPO,
  93         ALC262_HIPPO_1,
  94         ALC262_FUJITSU,
  95         ALC262_HP_BPC,
  96         ALC262_HP_BPC_D7000_WL,
  97         ALC262_HP_BPC_D7000_WF,
  98         ALC262_HP_TC_T5735,
  99         ALC262_HP_RP5700,
 100         ALC262_BENQ_ED8,
 101         ALC262_SONY_ASSAMD,
 102         ALC262_BENQ_T31,
 103         ALC262_ULTRA,
 104         ALC262_LENOVO_3000,
 105         ALC262_NEC,
 106         ALC262_TOSHIBA_S06,
 107         ALC262_TOSHIBA_RX1,
 108         ALC262_TYAN,
 109         ALC262_AUTO,
 110         ALC262_MODEL_LAST /* last tag */
 111 };
 112
 113 /* ALC268 models */
 114 enum {
 115         ALC267_QUANTA_IL1,
 116         ALC268_3ST,
 117         ALC268_TOSHIBA,
 118         ALC268_ACER,
 119         ALC268_ACER_DMIC,
 120         ALC268_ACER_ASPIRE_ONE,
 121         ALC268_DELL,
 122         ALC268_ZEPTO,
 123 #ifdef CONFIG_SND_DEBUG
 124         ALC268_TEST,
 125 #endif
 126         ALC268_AUTO,
 127         ALC268_MODEL_LAST /* last tag */
 128 };
 129
 130 /* ALC269 models */
 131 enum {
 132         ALC269_BASIC,
 133         ALC269_QUANTA_FL1,
 134         ALC269_ASUS_AMIC,
 135         ALC269_ASUS_DMIC,
 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         ALC663_ASUS_MODE7,
 192         ALC663_ASUS_MODE8,
 193         ALC272_DELL,
 194         ALC272_DELL_ZM1,
 195         ALC272_SAMSUNG_NC10,
 196         ALC662_AUTO,
 197         ALC662_MODEL_LAST,
 198 };
 199
 200 /* ALC882 models */
 201 enum {
 202         ALC882_3ST_DIG,
 203         ALC882_6ST_DIG,
 204         ALC882_ARIMA,
 205         ALC882_W2JC,
 206         ALC882_TARGA,
 207         ALC882_ASUS_A7J,
 208         ALC882_ASUS_A7M,
 209         ALC885_MACPRO,
 210         ALC885_MBP3,
 211         ALC885_MB5,
 212         ALC885_IMAC24,
 213         ALC885_IMAC91,
 214         ALC883_3ST_2ch_DIG,
 215         ALC883_3ST_6ch_DIG,
 216         ALC883_3ST_6ch,
 217         ALC883_6ST_DIG,
 218         ALC883_TARGA_DIG,
 219         ALC883_TARGA_2ch_DIG,
 220         ALC883_TARGA_8ch_DIG,
 221         ALC883_ACER,
 222         ALC883_ACER_ASPIRE,
 223         ALC888_ACER_ASPIRE_4930G,
 224         ALC888_ACER_ASPIRE_6530G,
 225         ALC888_ACER_ASPIRE_8930G,
 226         ALC888_ACER_ASPIRE_7730G,
 227         ALC883_MEDION,
 228         ALC883_MEDION_MD2,
 229         ALC883_LAPTOP_EAPD,
 230         ALC883_LENOVO_101E_2ch,
 231         ALC883_LENOVO_NB0763,
 232         ALC888_LENOVO_MS7195_DIG,
 233         ALC888_LENOVO_SKY,
 234         ALC883_HAIER_W66,
 235         ALC888_3ST_HP,
 236         ALC888_6ST_DELL,
 237         ALC883_MITAC,
 238         ALC883_CLEVO_M540R,
 239         ALC883_CLEVO_M720,
 240         ALC883_FUJITSU_PI2515,
 241         ALC888_FUJITSU_XA3530,
 242         ALC883_3ST_6ch_INTEL,
 243         ALC889A_INTEL,
 244         ALC889_INTEL,
 245         ALC888_ASUS_M90V,
 246         ALC888_ASUS_EEE1601,
 247         ALC889A_MB31,
 248         ALC1200_ASUS_P5Q,
 249         ALC883_SONY_VAIO_TT,
 250         ALC882_AUTO,
 251         ALC882_MODEL_LAST,
 252 };
 253
 254 /* for GPIO Poll */
 255 #define GPIO_MASK       0x03
 256
 257 /* extra amp-initialization sequence types */
 258 enum {
 259         ALC_INIT_NONE,
 260         ALC_INIT_DEFAULT,
 261         ALC_INIT_GPIO1,
 262         ALC_INIT_GPIO2,
 263         ALC_INIT_GPIO3,
 264 };
 265
 266 struct alc_mic_route {
 267         hda_nid_t pin;
 268         unsigned char mux_idx;
 269         unsigned char amix_idx;
 270 };
 271
 272 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 273
 274 struct alc_spec {
 275         /* codec parameterization */
 276         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 277         unsigned int num_mixers;
 278         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 279         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 280
 281         const struct hda_verb *init_verbs[10];  /* initialization verbs
 282                                                  * don't forget NULL
 283                                                  * termination!
 284                                                  */
 285         unsigned int num_init_verbs;
 286
 287         char stream_name_analog[32];    /* analog PCM stream */
 288         struct hda_pcm_stream *stream_analog_playback;
 289         struct hda_pcm_stream *stream_analog_capture;
 290         struct hda_pcm_stream *stream_analog_alt_playback;
 291         struct hda_pcm_stream *stream_analog_alt_capture;
 292
 293         char stream_name_digital[32];   /* digital PCM stream */
 294         struct hda_pcm_stream *stream_digital_playback;
 295         struct hda_pcm_stream *stream_digital_capture;
 296
 297         /* playback */
 298         struct hda_multi_out multiout;  /* playback set-up
 299                                          * max_channels, dacs must be set
 300                                          * dig_out_nid and hp_nid are optional
 301                                          */
 302         hda_nid_t alt_dac_nid;
 303         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 304         int dig_out_type;
 305
 306         /* capture */
 307         unsigned int num_adc_nids;
 308         hda_nid_t *adc_nids;
 309         hda_nid_t *capsrc_nids;
 310         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 311
 312         /* capture source */
 313         unsigned int num_mux_defs;
 314         const struct hda_input_mux *input_mux;
 315         unsigned int cur_mux[3];
 316         struct alc_mic_route ext_mic;
 317         struct alc_mic_route int_mic;
 318
 319         /* channel model */
 320         const struct hda_channel_mode *channel_mode;
 321         int num_channel_mode;
 322         int need_dac_fix;
 323         int const_channel_count;
 324         int ext_channel_count;
 325
 326         /* PCM information */
 327         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 328
 329         /* dynamic controls, init_verbs and input_mux */
 330         struct auto_pin_cfg autocfg;
 331         struct snd_array kctls;
 332         struct hda_input_mux private_imux[3];
 333         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 334         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 335         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 336
 337         /* hooks */
 338         void (*init_hook)(struct hda_codec *codec);
 339         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 340 #ifdef CONFIG_SND_HDA_POWER_SAVE
 341         void (*power_hook)(struct hda_codec *codec, int power);
 342 #endif
 343
 344         /* for pin sensing */
 345         unsigned int sense_updated: 1;
 346         unsigned int jack_present: 1;
 347         unsigned int master_sw: 1;
 348         unsigned int auto_mic:1;
 349
 350         /* other flags */
 351         unsigned int no_analog :1; /* digital I/O only */
 352         int init_amp;
 353
 354         /* for virtual master */
 355         hda_nid_t vmaster_nid;
 356 #ifdef CONFIG_SND_HDA_POWER_SAVE
 357         struct hda_loopback_check loopback;
 358 #endif
 359
 360         /* for PLL fix */
 361         hda_nid_t pll_nid;
 362         unsigned int pll_coef_idx, pll_coef_bit;
 363 };
 364
 365 /*
 366  * configuration template - to be copied to the spec instance
 367  */
 368 struct alc_config_preset {
 369         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 370                                              * with spec
 371                                              */
 372         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 373         const struct hda_verb *init_verbs[5];
 374         unsigned int num_dacs;
 375         hda_nid_t *dac_nids;
 376         hda_nid_t dig_out_nid;          /* optional */
 377         hda_nid_t hp_nid;               /* optional */
 378         hda_nid_t *slave_dig_outs;
 379         unsigned int num_adc_nids;
 380         hda_nid_t *adc_nids;
 381         hda_nid_t *capsrc_nids;
 382         hda_nid_t dig_in_nid;
 383         unsigned int num_channel_mode;
 384         const struct hda_channel_mode *channel_mode;
 385         int need_dac_fix;
 386         int const_channel_count;
 387         unsigned int num_mux_defs;
 388         const struct hda_input_mux *input_mux;
 389         void (*unsol_event)(struct hda_codec *, unsigned int);
 390         void (*setup)(struct hda_codec *);
 391         void (*init_hook)(struct hda_codec *);
 392 #ifdef CONFIG_SND_HDA_POWER_SAVE
 393         struct hda_amp_list *loopbacks;
 394         void (*power_hook)(struct hda_codec *codec, int power);
 395 #endif
 396 };
 397
 398
 399 /*
 400  * input MUX handling
 401  */
 402 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 403                              struct snd_ctl_elem_info *uinfo)
 404 {
 405         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 406         struct alc_spec *spec = codec->spec;
 407         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 408         if (mux_idx >= spec->num_mux_defs)
 409                 mux_idx = 0;
 410         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 411 }
 412
 413 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 414                             struct snd_ctl_elem_value *ucontrol)
 415 {
 416         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 417         struct alc_spec *spec = codec->spec;
 418         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 419
 420         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 421         return 0;
 422 }
 423
 424 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 425                             struct snd_ctl_elem_value *ucontrol)
 426 {
 427         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 428         struct alc_spec *spec = codec->spec;
 429         const struct hda_input_mux *imux;
 430         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 431         unsigned int mux_idx;
 432         hda_nid_t nid = spec->capsrc_nids ?
 433                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 434         unsigned int type;
 435
 436         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 437         imux = &spec->input_mux[mux_idx];
 438
 439         type = get_wcaps_type(get_wcaps(codec, nid));
 440         if (type == AC_WID_AUD_MIX) {
 441                 /* Matrix-mixer style (e.g. ALC882) */
 442                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 443                 unsigned int i, idx;
 444
 445                 idx = ucontrol->value.enumerated.item[0];
 446                 if (idx >= imux->num_items)
 447                         idx = imux->num_items - 1;
 448                 if (*cur_val == idx)
 449                         return 0;
 450                 for (i = 0; i < imux->num_items; i++) {
 451                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 452                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 453                                                  imux->items[i].index,
 454                                                  HDA_AMP_MUTE, v);
 455                 }
 456                 *cur_val = idx;
 457                 return 1;
 458         } else {
 459                 /* MUX style (e.g. ALC880) */
 460                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 461                                              &spec->cur_mux[adc_idx]);
 462         }
 463 }
 464
 465 /*
 466  * channel mode setting
 467  */
 468 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 469                             struct snd_ctl_elem_info *uinfo)
 470 {
 471         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 472         struct alc_spec *spec = codec->spec;
 473         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 474                                     spec->num_channel_mode);
 475 }
 476
 477 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 478                            struct snd_ctl_elem_value *ucontrol)
 479 {
 480         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 481         struct alc_spec *spec = codec->spec;
 482         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 483                                    spec->num_channel_mode,
 484                                    spec->ext_channel_count);
 485 }
 486
 487 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 488                            struct snd_ctl_elem_value *ucontrol)
 489 {
 490         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 491         struct alc_spec *spec = codec->spec;
 492         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 493                                       spec->num_channel_mode,
 494                                       &spec->ext_channel_count);
 495         if (err >= 0 && !spec->const_channel_count) {
 496                 spec->multiout.max_channels = spec->ext_channel_count;
 497                 if (spec->need_dac_fix)
 498                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 499         }
 500         return err;
 501 }
 502
 503 /*
 504  * Control the mode of pin widget settings via the mixer.  "pc" is used
 505  * instead of "%" to avoid consequences of accidently treating the % as
 506  * being part of a format specifier.  Maximum allowed length of a value is
 507  * 63 characters plus NULL terminator.
 508  *
 509  * Note: some retasking pin complexes seem to ignore requests for input
 510  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 511  * are requested.  Therefore order this list so that this behaviour will not
 512  * cause problems when mixer clients move through the enum sequentially.
 513  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 514  * March 2006.
 515  */
 516 static char *alc_pin_mode_names[] = {
 517         "Mic 50pc bias", "Mic 80pc bias",
 518         "Line in", "Line out", "Headphone out",
 519 };
 520 static unsigned char alc_pin_mode_values[] = {
 521         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 522 };
 523 /* The control can present all 5 options, or it can limit the options based
 524  * in the pin being assumed to be exclusively an input or an output pin.  In
 525  * addition, "input" pins may or may not process the mic bias option
 526  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 527  * accept requests for bias as of chip versions up to March 2006) and/or
 528  * wiring in the computer.
 529  */
 530 #define ALC_PIN_DIR_IN              0x00
 531 #define ALC_PIN_DIR_OUT             0x01
 532 #define ALC_PIN_DIR_INOUT           0x02
 533 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 534 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 535
 536 /* Info about the pin modes supported by the different pin direction modes.
 537  * For each direction the minimum and maximum values are given.
 538  */
 539 static signed char alc_pin_mode_dir_info[5][2] = {
 540         { 0, 2 },    /* ALC_PIN_DIR_IN */
 541         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 542         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 543         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 544         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 545 };
 546 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 547 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 548 #define alc_pin_mode_n_items(_dir) \
 549         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 550
 551 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 552                              struct snd_ctl_elem_info *uinfo)
 553 {
 554         unsigned int item_num = uinfo->value.enumerated.item;
 555         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 556
 557         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 558         uinfo->count = 1;
 559         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 560
 561         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 562                 item_num = alc_pin_mode_min(dir);
 563         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 564         return 0;
 565 }
 566
 567 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 568                             struct snd_ctl_elem_value *ucontrol)
 569 {
 570         unsigned int i;
 571         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 572         hda_nid_t nid = kcontrol->private_value & 0xffff;
 573         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 574         long *valp = ucontrol->value.integer.value;
 575         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 576                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 577                                                  0x00);
 578
 579         /* Find enumerated value for current pinctl setting */
 580         i = alc_pin_mode_min(dir);
 581         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 582                 i++;
 583         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 584         return 0;
 585 }
 586
 587 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 588                             struct snd_ctl_elem_value *ucontrol)
 589 {
 590         signed int change;
 591         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 592         hda_nid_t nid = kcontrol->private_value & 0xffff;
 593         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 594         long val = *ucontrol->value.integer.value;
 595         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 596                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 597                                                  0x00);
 598
 599         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 600                 val = alc_pin_mode_min(dir);
 601
 602         change = pinctl != alc_pin_mode_values[val];
 603         if (change) {
 604                 /* Set pin mode to that requested */
 605                 snd_hda_codec_write_cache(codec, nid, 0,
 606                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 607                                           alc_pin_mode_values[val]);
 608
 609                 /* Also enable the retasking pin's input/output as required
 610                  * for the requested pin mode.  Enum values of 2 or less are
 611                  * input modes.
 612                  *
 613                  * Dynamically switching the input/output buffers probably
 614                  * reduces noise slightly (particularly on input) so we'll
 615                  * do it.  However, having both input and output buffers
 616                  * enabled simultaneously doesn't seem to be problematic if
 617                  * this turns out to be necessary in the future.
 618                  */
 619                 if (val <= 2) {
 620                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 621                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 622                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 623                                                  HDA_AMP_MUTE, 0);
 624                 } else {
 625                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 626                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 627                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 628                                                  HDA_AMP_MUTE, 0);
 629                 }
 630         }
 631         return change;
 632 }
 633
 634 #define ALC_PIN_MODE(xname, nid, dir) \
 635         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 636           .info = alc_pin_mode_info, \
 637           .get = alc_pin_mode_get, \
 638           .put = alc_pin_mode_put, \
 639           .private_value = nid | (dir<<16) }
 640
 641 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 642  * together using a mask with more than one bit set.  This control is
 643  * currently used only by the ALC260 test model.  At this stage they are not
 644  * needed for any "production" models.
 645  */
 646 #ifdef CONFIG_SND_DEBUG
 647 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 648
 649 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 650                              struct snd_ctl_elem_value *ucontrol)
 651 {
 652         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 653         hda_nid_t nid = kcontrol->private_value & 0xffff;
 654         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 655         long *valp = ucontrol->value.integer.value;
 656         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 657                                               AC_VERB_GET_GPIO_DATA, 0x00);
 658
 659         *valp = (val & mask) != 0;
 660         return 0;
 661 }
 662 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 663                              struct snd_ctl_elem_value *ucontrol)
 664 {
 665         signed int change;
 666         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 667         hda_nid_t nid = kcontrol->private_value & 0xffff;
 668         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 669         long val = *ucontrol->value.integer.value;
 670         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 671                                                     AC_VERB_GET_GPIO_DATA,
 672                                                     0x00);
 673
 674         /* Set/unset the masked GPIO bit(s) as needed */
 675         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 676         if (val == 0)
 677                 gpio_data &= ~mask;
 678         else
 679                 gpio_data |= mask;
 680         snd_hda_codec_write_cache(codec, nid, 0,
 681                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 682
 683         return change;
 684 }
 685 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 686         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 687           .info = alc_gpio_data_info, \
 688           .get = alc_gpio_data_get, \
 689           .put = alc_gpio_data_put, \
 690           .private_value = nid | (mask<<16) }
 691 #endif   /* CONFIG_SND_DEBUG */
 692
 693 /* A switch control to allow the enabling of the digital IO pins on the
 694  * ALC260.  This is incredibly simplistic; the intention of this control is
 695  * to provide something in the test model allowing digital outputs to be
 696  * identified if present.  If models are found which can utilise these
 697  * outputs a more complete mixer control can be devised for those models if
 698  * necessary.
 699  */
 700 #ifdef CONFIG_SND_DEBUG
 701 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 702
 703 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 704                               struct snd_ctl_elem_value *ucontrol)
 705 {
 706         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 707         hda_nid_t nid = kcontrol->private_value & 0xffff;
 708         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 709         long *valp = ucontrol->value.integer.value;
 710         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 711                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 712
 713         *valp = (val & mask) != 0;
 714         return 0;
 715 }
 716 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 717                               struct snd_ctl_elem_value *ucontrol)
 718 {
 719         signed int change;
 720         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 721         hda_nid_t nid = kcontrol->private_value & 0xffff;
 722         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 723         long val = *ucontrol->value.integer.value;
 724         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 725                                                     AC_VERB_GET_DIGI_CONVERT_1,
 726                                                     0x00);
 727
 728         /* Set/unset the masked control bit(s) as needed */
 729         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 730         if (val==0)
 731                 ctrl_data &= ~mask;
 732         else
 733                 ctrl_data |= mask;
 734         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 735                                   ctrl_data);
 736
 737         return change;
 738 }
 739 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 740         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 741           .info = alc_spdif_ctrl_info, \
 742           .get = alc_spdif_ctrl_get, \
 743           .put = alc_spdif_ctrl_put, \
 744           .private_value = nid | (mask<<16) }
 745 #endif   /* CONFIG_SND_DEBUG */
 746
 747 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 748  * Again, this is only used in the ALC26x test models to help identify when
 749  * the EAPD line must be asserted for features to work.
 750  */
 751 #ifdef CONFIG_SND_DEBUG
 752 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 753
 754 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 755                               struct snd_ctl_elem_value *ucontrol)
 756 {
 757         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 758         hda_nid_t nid = kcontrol->private_value & 0xffff;
 759         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 760         long *valp = ucontrol->value.integer.value;
 761         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 762                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 763
 764         *valp = (val & mask) != 0;
 765         return 0;
 766 }
 767
 768 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 769                               struct snd_ctl_elem_value *ucontrol)
 770 {
 771         int change;
 772         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 773         hda_nid_t nid = kcontrol->private_value & 0xffff;
 774         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 775         long val = *ucontrol->value.integer.value;
 776         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 777                                                     AC_VERB_GET_EAPD_BTLENABLE,
 778                                                     0x00);
 779
 780         /* Set/unset the masked control bit(s) as needed */
 781         change = (!val ? 0 : mask) != (ctrl_data & mask);
 782         if (!val)
 783                 ctrl_data &= ~mask;
 784         else
 785                 ctrl_data |= mask;
 786         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 787                                   ctrl_data);
 788
 789         return change;
 790 }
 791
 792 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 793         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 794           .info = alc_eapd_ctrl_info, \
 795           .get = alc_eapd_ctrl_get, \
 796           .put = alc_eapd_ctrl_put, \
 797           .private_value = nid | (mask<<16) }
 798 #endif   /* CONFIG_SND_DEBUG */
 799
 800 /*
 801  * set up the input pin config (depending on the given auto-pin type)
 802  */
 803 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 804                               int auto_pin_type)
 805 {
 806         unsigned int val = PIN_IN;
 807
 808         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 809                 unsigned int pincap;
 810                 pincap = snd_hda_query_pin_caps(codec, nid);
 811                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 812                 if (pincap & AC_PINCAP_VREF_80)
 813                         val = PIN_VREF80;
 814                 else if (pincap & AC_PINCAP_VREF_50)
 815                         val = PIN_VREF50;
 816                 else if (pincap & AC_PINCAP_VREF_100)
 817                         val = PIN_VREF100;
 818                 else if (pincap & AC_PINCAP_VREF_GRD)
 819                         val = PIN_VREFGRD;
 820         }
 821         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 822 }
 823
 824 /*
 825  */
 826 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 827 {
 828         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 829                 return;
 830         spec->mixers[spec->num_mixers++] = mix;
 831 }
 832
 833 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 834 {
 835         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 836                 return;
 837         spec->init_verbs[spec->num_init_verbs++] = verb;
 838 }
 839
 840 #ifdef CONFIG_PROC_FS
 841 /*
 842  * hook for proc
 843  */
 844 static void print_realtek_coef(struct snd_info_buffer *buffer,
 845                                struct hda_codec *codec, hda_nid_t nid)
 846 {
 847         int coeff;
 848
 849         if (nid != 0x20)
 850                 return;
 851         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 852         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 853         coeff = snd_hda_codec_read(codec, nid, 0,
 854                                    AC_VERB_GET_COEF_INDEX, 0);
 855         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 856 }
 857 #else
 858 #define print_realtek_coef      NULL
 859 #endif
 860
 861 /*
 862  * set up from the preset table
 863  */
 864 static void setup_preset(struct hda_codec *codec,
 865                          const struct alc_config_preset *preset)
 866 {
 867         struct alc_spec *spec = codec->spec;
 868         int i;
 869
 870         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 871                 add_mixer(spec, preset->mixers[i]);
 872         spec->cap_mixer = preset->cap_mixer;
 873         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 874              i++)
 875                 add_verb(spec, preset->init_verbs[i]);
 876
 877         spec->channel_mode = preset->channel_mode;
 878         spec->num_channel_mode = preset->num_channel_mode;
 879         spec->need_dac_fix = preset->need_dac_fix;
 880         spec->const_channel_count = preset->const_channel_count;
 881
 882         if (preset->const_channel_count)
 883                 spec->multiout.max_channels = preset->const_channel_count;
 884         else
 885                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 886         spec->ext_channel_count = spec->channel_mode[0].channels;
 887
 888         spec->multiout.num_dacs = preset->num_dacs;
 889         spec->multiout.dac_nids = preset->dac_nids;
 890         spec->multiout.dig_out_nid = preset->dig_out_nid;
 891         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 892         spec->multiout.hp_nid = preset->hp_nid;
 893
 894         spec->num_mux_defs = preset->num_mux_defs;
 895         if (!spec->num_mux_defs)
 896                 spec->num_mux_defs = 1;
 897         spec->input_mux = preset->input_mux;
 898
 899         spec->num_adc_nids = preset->num_adc_nids;
 900         spec->adc_nids = preset->adc_nids;
 901         spec->capsrc_nids = preset->capsrc_nids;
 902         spec->dig_in_nid = preset->dig_in_nid;
 903
 904         spec->unsol_event = preset->unsol_event;
 905         spec->init_hook = preset->init_hook;
 906 #ifdef CONFIG_SND_HDA_POWER_SAVE
 907         spec->power_hook = preset->power_hook;
 908         spec->loopback.amplist = preset->loopbacks;
 909 #endif
 910
 911         if (preset->setup)
 912                 preset->setup(codec);
 913 }
 914
 915 /* Enable GPIO mask and set output */
 916 static struct hda_verb alc_gpio1_init_verbs[] = {
 917         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 918         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 919         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 920         { }
 921 };
 922
 923 static struct hda_verb alc_gpio2_init_verbs[] = {
 924         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 925         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 926         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 927         { }
 928 };
 929
 930 static struct hda_verb alc_gpio3_init_verbs[] = {
 931         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 932         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 933         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 934         { }
 935 };
 936
 937 /*
 938  * Fix hardware PLL issue
 939  * On some codecs, the analog PLL gating control must be off while
 940  * the default value is 1.
 941  */
 942 static void alc_fix_pll(struct hda_codec *codec)
 943 {
 944         struct alc_spec *spec = codec->spec;
 945         unsigned int val;
 946
 947         if (!spec->pll_nid)
 948                 return;
 949         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 950                             spec->pll_coef_idx);
 951         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 952                                  AC_VERB_GET_PROC_COEF, 0);
 953         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 954                             spec->pll_coef_idx);
 955         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 956                             val & ~(1 << spec->pll_coef_bit));
 957 }
 958
 959 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 960                              unsigned int coef_idx, unsigned int coef_bit)
 961 {
 962         struct alc_spec *spec = codec->spec;
 963         spec->pll_nid = nid;
 964         spec->pll_coef_idx = coef_idx;
 965         spec->pll_coef_bit = coef_bit;
 966         alc_fix_pll(codec);
 967 }
 968
 969 static void alc_automute_pin(struct hda_codec *codec)
 970 {
 971         struct alc_spec *spec = codec->spec;
 972         unsigned int nid = spec->autocfg.hp_pins[0];
 973         int i;
 974
 975         if (!nid)
 976                 return;
 977         spec->jack_present = snd_hda_jack_detect(codec, nid);
 978         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
 979                 nid = spec->autocfg.speaker_pins[i];
 980                 if (!nid)
 981                         break;
 982                 snd_hda_codec_write(codec, nid, 0,
 983                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 984                                     spec->jack_present ? 0 : PIN_OUT);
 985         }
 986 }
 987
 988 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
 989                                 hda_nid_t nid)
 990 {
 991         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
 992         int i, nums;
 993
 994         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
 995         for (i = 0; i < nums; i++)
 996                 if (conn[i] == nid)
 997                         return i;
 998         return -1;
 999 }
1000
1001 static void alc_mic_automute(struct hda_codec *codec)
1002 {
1003         struct alc_spec *spec = codec->spec;
1004         struct alc_mic_route *dead, *alive;
1005         unsigned int present, type;
1006         hda_nid_t cap_nid;
1007
1008         if (!spec->auto_mic)
1009                 return;
1010         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1011                 return;
1012         if (snd_BUG_ON(!spec->adc_nids))
1013                 return;
1014
1015         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1016
1017         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1018         if (present) {
1019                 alive = &spec->ext_mic;
1020                 dead = &spec->int_mic;
1021         } else {
1022                 alive = &spec->int_mic;
1023                 dead = &spec->ext_mic;
1024         }
1025
1026         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1027         if (type == AC_WID_AUD_MIX) {
1028                 /* Matrix-mixer style (e.g. ALC882) */
1029                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1030                                          alive->mux_idx,
1031                                          HDA_AMP_MUTE, 0);
1032                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1033                                          dead->mux_idx,
1034                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1035         } else {
1036                 /* MUX style (e.g. ALC880) */
1037                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1038                                           AC_VERB_SET_CONNECT_SEL,
1039                                           alive->mux_idx);
1040         }
1041
1042         /* FIXME: analog mixer */
1043 }
1044
1045 /* unsolicited event for HP jack sensing */
1046 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1047 {
1048         if (codec->vendor_id == 0x10ec0880)
1049                 res >>= 28;
1050         else
1051                 res >>= 26;
1052         switch (res) {
1053         case ALC880_HP_EVENT:
1054                 alc_automute_pin(codec);
1055                 break;
1056         case ALC880_MIC_EVENT:
1057                 alc_mic_automute(codec);
1058                 break;
1059         }
1060 }
1061
1062 static void alc_inithook(struct hda_codec *codec)
1063 {
1064         alc_automute_pin(codec);
1065         alc_mic_automute(codec);
1066 }
1067
1068 /* additional initialization for ALC888 variants */
1069 static void alc888_coef_init(struct hda_codec *codec)
1070 {
1071         unsigned int tmp;
1072
1073         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1074         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1075         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1076         if ((tmp & 0xf0) == 0x20)
1077                 /* alc888S-VC */
1078                 snd_hda_codec_read(codec, 0x20, 0,
1079                                    AC_VERB_SET_PROC_COEF, 0x830);
1080          else
1081                  /* alc888-VB */
1082                  snd_hda_codec_read(codec, 0x20, 0,
1083                                     AC_VERB_SET_PROC_COEF, 0x3030);
1084 }
1085
1086 static void alc889_coef_init(struct hda_codec *codec)
1087 {
1088         unsigned int tmp;
1089
1090         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1091         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1092         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1093         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1094 }
1095
1096 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1097 {
1098         unsigned int tmp;
1099
1100         switch (type) {
1101         case ALC_INIT_GPIO1:
1102                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1103                 break;
1104         case ALC_INIT_GPIO2:
1105                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1106                 break;
1107         case ALC_INIT_GPIO3:
1108                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1109                 break;
1110         case ALC_INIT_DEFAULT:
1111                 switch (codec->vendor_id) {
1112                 case 0x10ec0260:
1113                         snd_hda_codec_write(codec, 0x0f, 0,
1114                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1115                         snd_hda_codec_write(codec, 0x10, 0,
1116                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1117                         break;
1118                 case 0x10ec0262:
1119                 case 0x10ec0267:
1120                 case 0x10ec0268:
1121                 case 0x10ec0269:
1122                 case 0x10ec0272:
1123                 case 0x10ec0660:
1124                 case 0x10ec0662:
1125                 case 0x10ec0663:
1126                 case 0x10ec0862:
1127                 case 0x10ec0889:
1128                         snd_hda_codec_write(codec, 0x14, 0,
1129                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1130                         snd_hda_codec_write(codec, 0x15, 0,
1131                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1132                         break;
1133                 }
1134                 switch (codec->vendor_id) {
1135                 case 0x10ec0260:
1136                         snd_hda_codec_write(codec, 0x1a, 0,
1137                                             AC_VERB_SET_COEF_INDEX, 7);
1138                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1139                                                  AC_VERB_GET_PROC_COEF, 0);
1140                         snd_hda_codec_write(codec, 0x1a, 0,
1141                                             AC_VERB_SET_COEF_INDEX, 7);
1142                         snd_hda_codec_write(codec, 0x1a, 0,
1143                                             AC_VERB_SET_PROC_COEF,
1144                                             tmp | 0x2010);
1145                         break;
1146                 case 0x10ec0262:
1147                 case 0x10ec0880:
1148                 case 0x10ec0882:
1149                 case 0x10ec0883:
1150                 case 0x10ec0885:
1151                 case 0x10ec0887:
1152                 case 0x10ec0889:
1153                         alc889_coef_init(codec);
1154                         break;
1155                 case 0x10ec0888:
1156                         alc888_coef_init(codec);
1157                         break;
1158                 case 0x10ec0267:
1159                 case 0x10ec0268:
1160                         snd_hda_codec_write(codec, 0x20, 0,
1161                                             AC_VERB_SET_COEF_INDEX, 7);
1162                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1163                                                  AC_VERB_GET_PROC_COEF, 0);
1164                         snd_hda_codec_write(codec, 0x20, 0,
1165                                             AC_VERB_SET_COEF_INDEX, 7);
1166                         snd_hda_codec_write(codec, 0x20, 0,
1167                                             AC_VERB_SET_PROC_COEF,
1168                                             tmp | 0x3000);
1169                         break;
1170                 }
1171                 break;
1172         }
1173 }
1174
1175 static void alc_init_auto_hp(struct hda_codec *codec)
1176 {
1177         struct alc_spec *spec = codec->spec;
1178
1179         if (!spec->autocfg.hp_pins[0])
1180                 return;
1181
1182         if (!spec->autocfg.speaker_pins[0]) {
1183                 if (spec->autocfg.line_out_pins[0] &&
1184                     spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1185                         spec->autocfg.speaker_pins[0] =
1186                                 spec->autocfg.line_out_pins[0];
1187                 else
1188                         return;
1189         }
1190
1191         snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1192                     spec->autocfg.hp_pins[0]);
1193         snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1194                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1195                                   AC_USRSP_EN | ALC880_HP_EVENT);
1196         spec->unsol_event = alc_sku_unsol_event;
1197 }
1198
1199 static void alc_init_auto_mic(struct hda_codec *codec)
1200 {
1201         struct alc_spec *spec = codec->spec;
1202         struct auto_pin_cfg *cfg = &spec->autocfg;
1203         hda_nid_t fixed, ext;
1204         int i;
1205
1206         /* there must be only two mic inputs exclusively */
1207         for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++)
1208                 if (cfg->input_pins[i])
1209                         return;
1210
1211         fixed = ext = 0;
1212         for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) {
1213                 hda_nid_t nid = cfg->input_pins[i];
1214                 unsigned int defcfg;
1215                 if (!nid)
1216                         return;
1217                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1218                 switch (get_defcfg_connect(defcfg)) {
1219                 case AC_JACK_PORT_FIXED:
1220                         if (fixed)
1221                                 return; /* already occupied */
1222                         fixed = nid;
1223                         break;
1224                 case AC_JACK_PORT_COMPLEX:
1225                         if (ext)
1226                                 return; /* already occupied */
1227                         ext = nid;
1228                         break;
1229                 default:
1230                         return; /* invalid entry */
1231                 }
1232         }
1233         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1234                 return; /* no unsol support */
1235         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1236                     ext, fixed);
1237         spec->ext_mic.pin = ext;
1238         spec->int_mic.pin = fixed;
1239         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1240         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1241         spec->auto_mic = 1;
1242         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1243                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1244                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1245         spec->unsol_event = alc_sku_unsol_event;
1246 }
1247
1248 /* check subsystem ID and set up device-specific initialization;
1249  * return 1 if initialized, 0 if invalid SSID
1250  */
1251 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1252  *      31 ~ 16 :       Manufacture ID
1253  *      15 ~ 8  :       SKU ID
1254  *      7  ~ 0  :       Assembly ID
1255  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1256  */
1257 static int alc_subsystem_id(struct hda_codec *codec,
1258                             hda_nid_t porta, hda_nid_t porte,
1259                             hda_nid_t portd)
1260 {
1261         unsigned int ass, tmp, i;
1262         unsigned nid;
1263         struct alc_spec *spec = codec->spec;
1264
1265         ass = codec->subsystem_id & 0xffff;
1266         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1267                 goto do_sku;
1268
1269         /* invalid SSID, check the special NID pin defcfg instead */
1270         /*
1271          * 31~30        : port connectivity
1272          * 29~21        : reserve
1273          * 20           : PCBEEP input
1274          * 19~16        : Check sum (15:1)
1275          * 15~1         : Custom
1276          * 0            : override
1277         */
1278         nid = 0x1d;
1279         if (codec->vendor_id == 0x10ec0260)
1280                 nid = 0x17;
1281         ass = snd_hda_codec_get_pincfg(codec, nid);
1282         snd_printd("realtek: No valid SSID, "
1283                    "checking pincfg 0x%08x for NID 0x%x\n",
1284                    ass, nid);
1285         if (!(ass & 1) && !(ass & 0x100000))
1286                 return 0;
1287         if ((ass >> 30) != 1)   /* no physical connection */
1288                 return 0;
1289
1290         /* check sum */
1291         tmp = 0;
1292         for (i = 1; i < 16; i++) {
1293                 if ((ass >> i) & 1)
1294                         tmp++;
1295         }
1296         if (((ass >> 16) & 0xf) != tmp)
1297                 return 0;
1298 do_sku:
1299         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1300                    ass & 0xffff, codec->vendor_id);
1301         /*
1302          * 0 : override
1303          * 1 :  Swap Jack
1304          * 2 : 0 --> Desktop, 1 --> Laptop
1305          * 3~5 : External Amplifier control
1306          * 7~6 : Reserved
1307         */
1308         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1309         switch (tmp) {
1310         case 1:
1311                 spec->init_amp = ALC_INIT_GPIO1;
1312                 break;
1313         case 3:
1314                 spec->init_amp = ALC_INIT_GPIO2;
1315                 break;
1316         case 7:
1317                 spec->init_amp = ALC_INIT_GPIO3;
1318                 break;
1319         case 5:
1320                 spec->init_amp = ALC_INIT_DEFAULT;
1321                 break;
1322         }
1323
1324         /* is laptop or Desktop and enable the function "Mute internal speaker
1325          * when the external headphone out jack is plugged"
1326          */
1327         if (!(ass & 0x8000))
1328                 return 1;
1329         /*
1330          * 10~8 : Jack location
1331          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1332          * 14~13: Resvered
1333          * 15   : 1 --> enable the function "Mute internal speaker
1334          *              when the external headphone out jack is plugged"
1335          */
1336         if (!spec->autocfg.hp_pins[0]) {
1337                 hda_nid_t nid;
1338                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1339                 if (tmp == 0)
1340                         nid = porta;
1341                 else if (tmp == 1)
1342                         nid = porte;
1343                 else if (tmp == 2)
1344                         nid = portd;
1345                 else
1346                         return 1;
1347                 for (i = 0; i < spec->autocfg.line_outs; i++)
1348                         if (spec->autocfg.line_out_pins[i] == nid)
1349                                 return 1;
1350                 spec->autocfg.hp_pins[0] = nid;
1351         }
1352
1353         alc_init_auto_hp(codec);
1354         alc_init_auto_mic(codec);
1355         return 1;
1356 }
1357
1358 static void alc_ssid_check(struct hda_codec *codec,
1359                            hda_nid_t porta, hda_nid_t porte, hda_nid_t portd)
1360 {
1361         if (!alc_subsystem_id(codec, porta, porte, portd)) {
1362                 struct alc_spec *spec = codec->spec;
1363                 snd_printd("realtek: "
1364                            "Enable default setup for auto mode as fallback\n");
1365                 spec->init_amp = ALC_INIT_DEFAULT;
1366                 alc_init_auto_hp(codec);
1367                 alc_init_auto_mic(codec);
1368         }
1369 }
1370
1371 /*
1372  * Fix-up pin default configurations and add default verbs
1373  */
1374
1375 struct alc_pincfg {
1376         hda_nid_t nid;
1377         u32 val;
1378 };
1379
1380 struct alc_fixup {
1381         const struct alc_pincfg *pins;
1382         const struct hda_verb *verbs;
1383 };
1384
1385 static void alc_pick_fixup(struct hda_codec *codec,
1386                            const struct snd_pci_quirk *quirk,
1387                            const struct alc_fixup *fix)
1388 {
1389         const struct alc_pincfg *cfg;
1390
1391         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1392         if (!quirk)
1393                 return;
1394
1395         fix += quirk->value;
1396         cfg = fix->pins;
1397         if (cfg) {
1398                 for (; cfg->nid; cfg++)
1399                         snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1400         }
1401         if (fix->verbs)
1402                 add_verb(codec->spec, fix->verbs);
1403 }
1404
1405 static int alc_read_coef_idx(struct hda_codec *codec,
1406                         unsigned int coef_idx)
1407 {
1408         unsigned int val;
1409         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1410                                 coef_idx);
1411         val = snd_hda_codec_read(codec, 0x20, 0,
1412                                 AC_VERB_GET_PROC_COEF, 0);
1413         return val;
1414 }
1415
1416 /*
1417  * ALC888
1418  */
1419
1420 /*
1421  * 2ch mode
1422  */
1423 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1424 /* Mic-in jack as mic in */
1425         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1426         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1427 /* Line-in jack as Line in */
1428         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1429         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1430 /* Line-Out as Front */
1431         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1432         { } /* end */
1433 };
1434
1435 /*
1436  * 4ch mode
1437  */
1438 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1439 /* Mic-in jack as mic in */
1440         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1441         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1442 /* Line-in jack as Surround */
1443         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1444         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1445 /* Line-Out as Front */
1446         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1447         { } /* end */
1448 };
1449
1450 /*
1451  * 6ch mode
1452  */
1453 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1454 /* Mic-in jack as CLFE */
1455         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1456         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1457 /* Line-in jack as Surround */
1458         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1459         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1460 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1461         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1462         { } /* end */
1463 };
1464
1465 /*
1466  * 8ch mode
1467  */
1468 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1469 /* Mic-in jack as CLFE */
1470         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1471         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1472 /* Line-in jack as Surround */
1473         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1474         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1475 /* Line-Out as Side */
1476         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1477         { } /* end */
1478 };
1479
1480 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1481         { 2, alc888_4ST_ch2_intel_init },
1482         { 4, alc888_4ST_ch4_intel_init },
1483         { 6, alc888_4ST_ch6_intel_init },
1484         { 8, alc888_4ST_ch8_intel_init },
1485 };
1486
1487 /*
1488  * ALC888 Fujitsu Siemens Amillo xa3530
1489  */
1490
1491 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1492 /* Front Mic: set to PIN_IN (empty by default) */
1493         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1494 /* Connect Internal HP to Front */
1495         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1496         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1497         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1498 /* Connect Bass HP to Front */
1499         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1500         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1501         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1502 /* Connect Line-Out side jack (SPDIF) to Side */
1503         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1504         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1505         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1506 /* Connect Mic jack to CLFE */
1507         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1508         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1509         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1510 /* Connect Line-in jack to Surround */
1511         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1512         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1513         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1514 /* Connect HP out jack to Front */
1515         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1516         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1517         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1518 /* Enable unsolicited event for HP jack and Line-out jack */
1519         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1520         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1521         {}
1522 };
1523
1524 static void alc_automute_amp(struct hda_codec *codec)
1525 {
1526         struct alc_spec *spec = codec->spec;
1527         unsigned int mute;
1528         hda_nid_t nid;
1529         int i;
1530
1531         spec->jack_present = 0;
1532         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1533                 nid = spec->autocfg.hp_pins[i];
1534                 if (!nid)
1535                         break;
1536                 if (snd_hda_jack_detect(codec, nid)) {
1537                         spec->jack_present = 1;
1538                         break;
1539                 }
1540         }
1541
1542         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1543         /* Toggle internal speakers muting */
1544         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1545                 nid = spec->autocfg.speaker_pins[i];
1546                 if (!nid)
1547                         break;
1548                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1549                                          HDA_AMP_MUTE, mute);
1550         }
1551 }
1552
1553 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1554                                          unsigned int res)
1555 {
1556         if (codec->vendor_id == 0x10ec0880)
1557                 res >>= 28;
1558         else
1559                 res >>= 26;
1560         if (res == ALC880_HP_EVENT)
1561                 alc_automute_amp(codec);
1562 }
1563
1564 static void alc889_automute_setup(struct hda_codec *codec)
1565 {
1566         struct alc_spec *spec = codec->spec;
1567
1568         spec->autocfg.hp_pins[0] = 0x15;
1569         spec->autocfg.speaker_pins[0] = 0x14;
1570         spec->autocfg.speaker_pins[1] = 0x16;
1571         spec->autocfg.speaker_pins[2] = 0x17;
1572         spec->autocfg.speaker_pins[3] = 0x19;
1573         spec->autocfg.speaker_pins[4] = 0x1a;
1574 }
1575
1576 static void alc889_intel_init_hook(struct hda_codec *codec)
1577 {
1578         alc889_coef_init(codec);
1579         alc_automute_amp(codec);
1580 }
1581
1582 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1583 {
1584         struct alc_spec *spec = codec->spec;
1585
1586         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1587         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1588         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1589         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1590 }
1591
1592 /*
1593  * ALC888 Acer Aspire 4930G model
1594  */
1595
1596 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1597 /* Front Mic: set to PIN_IN (empty by default) */
1598         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1599 /* Unselect Front Mic by default in input mixer 3 */
1600         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1601 /* Enable unsolicited event for HP jack */
1602         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1603 /* Connect Internal HP to front */
1604         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1605         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1606         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1607 /* Connect HP out to front */
1608         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1609         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1610         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1611         { }
1612 };
1613
1614 /*
1615  * ALC888 Acer Aspire 6530G model
1616  */
1617
1618 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1619 /* Bias voltage on for external mic port */
1620         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1621 /* Front Mic: set to PIN_IN (empty by default) */
1622         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1623 /* Unselect Front Mic by default in input mixer 3 */
1624         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1625 /* Enable unsolicited event for HP jack */
1626         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1627 /* Enable speaker output */
1628         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1629         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1630 /* Enable headphone output */
1631         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1632         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1633         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1634         { }
1635 };
1636
1637 /*
1638  * ALC889 Acer Aspire 8930G model
1639  */
1640
1641 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1642 /* Front Mic: set to PIN_IN (empty by default) */
1643         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1644 /* Unselect Front Mic by default in input mixer 3 */
1645         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1646 /* Enable unsolicited event for HP jack */
1647         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1648 /* Connect Internal Front to Front */
1649         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1650         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1651         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1652 /* Connect Internal Rear to Rear */
1653         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1654         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1655         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1656 /* Connect Internal CLFE to CLFE */
1657         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1658         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1659         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1660 /* Connect HP out to Front */
1661         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1662         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1663         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1664 /* Enable all DACs */
1665 /*  DAC DISABLE/MUTE 1? */
1666 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
1667         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
1668         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1669 /*  DAC DISABLE/MUTE 2? */
1670 /*  some bit here disables the other DACs. Init=0x4900 */
1671         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
1672         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1673 /* DMIC fix
1674  * This laptop has a stereo digital microphone. The mics are only 1cm apart
1675  * which makes the stereo useless. However, either the mic or the ALC889
1676  * makes the signal become a difference/sum signal instead of standard
1677  * stereo, which is annoying. So instead we flip this bit which makes the
1678  * codec replicate the sum signal to both channels, turning it into a
1679  * normal mono mic.
1680  */
1681 /*  DMIC_CONTROL? Init value = 0x0001 */
1682         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
1683         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
1684         { }
1685 };
1686
1687 static struct hda_input_mux alc888_2_capture_sources[2] = {
1688         /* Front mic only available on one ADC */
1689         {
1690                 .num_items = 4,
1691                 .items = {
1692                         { "Mic", 0x0 },
1693                         { "Line", 0x2 },
1694                         { "CD", 0x4 },
1695                         { "Front Mic", 0xb },
1696                 },
1697         },
1698         {
1699                 .num_items = 3,
1700                 .items = {
1701                         { "Mic", 0x0 },
1702                         { "Line", 0x2 },
1703                         { "CD", 0x4 },
1704                 },
1705         }
1706 };
1707
1708 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
1709         /* Interal mic only available on one ADC */
1710         {
1711                 .num_items = 5,
1712                 .items = {
1713                         { "Ext Mic", 0x0 },
1714                         { "Line In", 0x2 },
1715                         { "CD", 0x4 },
1716                         { "Input Mix", 0xa },
1717                         { "Int Mic", 0xb },
1718                 },
1719         },
1720         {
1721                 .num_items = 4,
1722                 .items = {
1723                         { "Ext Mic", 0x0 },
1724                         { "Line In", 0x2 },
1725                         { "CD", 0x4 },
1726                         { "Input Mix", 0xa },
1727                 },
1728         }
1729 };
1730
1731 static struct hda_input_mux alc889_capture_sources[3] = {
1732         /* Digital mic only available on first "ADC" */
1733         {
1734                 .num_items = 5,
1735                 .items = {
1736                         { "Mic", 0x0 },
1737                         { "Line", 0x2 },
1738                         { "CD", 0x4 },
1739                         { "Front Mic", 0xb },
1740                         { "Input Mix", 0xa },
1741                 },
1742         },
1743         {
1744                 .num_items = 4,
1745                 .items = {
1746                         { "Mic", 0x0 },
1747                         { "Line", 0x2 },
1748                         { "CD", 0x4 },
1749                         { "Input Mix", 0xa },
1750                 },
1751         },
1752         {
1753                 .num_items = 4,
1754                 .items = {
1755                         { "Mic", 0x0 },
1756                         { "Line", 0x2 },
1757                         { "CD", 0x4 },
1758                         { "Input Mix", 0xa },
1759                 },
1760         }
1761 };
1762
1763 static struct snd_kcontrol_new alc888_base_mixer[] = {
1764         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1765         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1766         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1767         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1768         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1769                 HDA_OUTPUT),
1770         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1771         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1772         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1773         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1774         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1775         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1776         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1777         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1778         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1779         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1780         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1781         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1782         { } /* end */
1783 };
1784
1785 static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
1786         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1787         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1788         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1789         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1790         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1791                 HDA_OUTPUT),
1792         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1793         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1794         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1795         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1796         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1797         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1798         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1799         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1800         { } /* end */
1801 };
1802
1803
1804 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
1805 {
1806         struct alc_spec *spec = codec->spec;
1807
1808         spec->autocfg.hp_pins[0] = 0x15;
1809         spec->autocfg.speaker_pins[0] = 0x14;
1810         spec->autocfg.speaker_pins[1] = 0x16;
1811         spec->autocfg.speaker_pins[2] = 0x17;
1812 }
1813
1814 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
1815 {
1816         struct alc_spec *spec = codec->spec;
1817
1818         spec->autocfg.hp_pins[0] = 0x15;
1819         spec->autocfg.speaker_pins[0] = 0x14;
1820         spec->autocfg.speaker_pins[1] = 0x16;
1821         spec->autocfg.speaker_pins[2] = 0x17;
1822 }
1823
1824 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
1825 {
1826         struct alc_spec *spec = codec->spec;
1827
1828         spec->autocfg.hp_pins[0] = 0x15;
1829         spec->autocfg.speaker_pins[0] = 0x14;
1830         spec->autocfg.speaker_pins[1] = 0x16;
1831         spec->autocfg.speaker_pins[2] = 0x1b;
1832 }
1833
1834 #ifdef CONFIG_SND_HDA_POWER_SAVE
1835 static void alc889_power_eapd(struct hda_codec *codec, int power)
1836 {
1837         snd_hda_codec_write(codec, 0x14, 0,
1838                             AC_VERB_SET_EAPD_BTLENABLE, power ? 2 : 0);
1839         snd_hda_codec_write(codec, 0x15, 0,
1840                             AC_VERB_SET_EAPD_BTLENABLE, power ? 2 : 0);
1841 }
1842 #endif
1843
1844 /*
1845  * ALC880 3-stack model
1846  *
1847  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1848  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1849  *                 F-Mic = 0x1b, HP = 0x19
1850  */
1851
1852 static hda_nid_t alc880_dac_nids[4] = {
1853         /* front, rear, clfe, rear_surr */
1854         0x02, 0x05, 0x04, 0x03
1855 };
1856
1857 static hda_nid_t alc880_adc_nids[3] = {
1858         /* ADC0-2 */
1859         0x07, 0x08, 0x09,
1860 };
1861
1862 /* The datasheet says the node 0x07 is connected from inputs,
1863  * but it shows zero connection in the real implementation on some devices.
1864  * Note: this is a 915GAV bug, fixed on 915GLV
1865  */
1866 static hda_nid_t alc880_adc_nids_alt[2] = {
1867         /* ADC1-2 */
1868         0x08, 0x09,
1869 };
1870
1871 #define ALC880_DIGOUT_NID       0x06
1872 #define ALC880_DIGIN_NID        0x0a
1873
1874 static struct hda_input_mux alc880_capture_source = {
1875         .num_items = 4,
1876         .items = {
1877                 { "Mic", 0x0 },
1878                 { "Front Mic", 0x3 },
1879                 { "Line", 0x2 },
1880                 { "CD", 0x4 },
1881         },
1882 };
1883
1884 /* channel source setting (2/6 channel selection for 3-stack) */
1885 /* 2ch mode */
1886 static struct hda_verb alc880_threestack_ch2_init[] = {
1887         /* set line-in to input, mute it */
1888         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1889         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1890         /* set mic-in to input vref 80%, mute it */
1891         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1892         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1893         { } /* end */
1894 };
1895
1896 /* 6ch mode */
1897 static struct hda_verb alc880_threestack_ch6_init[] = {
1898         /* set line-in to output, unmute it */
1899         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1900         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1901         /* set mic-in to output, unmute it */
1902         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1903         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1904         { } /* end */
1905 };
1906
1907 static struct hda_channel_mode alc880_threestack_modes[2] = {
1908         { 2, alc880_threestack_ch2_init },
1909         { 6, alc880_threestack_ch6_init },
1910 };
1911
1912 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1913         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1914         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1915         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1916         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1917         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1918         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1919         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1920         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1921         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1922         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1923         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1924         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1925         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1926         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1927         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1928         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1929         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1930         {
1931                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1932                 .name = "Channel Mode",
1933                 .info = alc_ch_mode_info,
1934                 .get = alc_ch_mode_get,
1935                 .put = alc_ch_mode_put,
1936         },
1937         { } /* end */
1938 };
1939
1940 /* capture mixer elements */
1941 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1942                             struct snd_ctl_elem_info *uinfo)
1943 {
1944         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1945         struct alc_spec *spec = codec->spec;
1946         int err;
1947
1948         mutex_lock(&codec->control_mutex);
1949         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1950                                                       HDA_INPUT);
1951         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1952         mutex_unlock(&codec->control_mutex);
1953         return err;
1954 }
1955
1956 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1957                            unsigned int size, unsigned int __user *tlv)
1958 {
1959         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1960         struct alc_spec *spec = codec->spec;
1961         int err;
1962
1963         mutex_lock(&codec->control_mutex);
1964         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1965                                                       HDA_INPUT);
1966         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1967         mutex_unlock(&codec->control_mutex);
1968         return err;
1969 }
1970
1971 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1972                              struct snd_ctl_elem_value *ucontrol);
1973
1974 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1975                                  struct snd_ctl_elem_value *ucontrol,
1976                                  getput_call_t func)
1977 {
1978         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1979         struct alc_spec *spec = codec->spec;
1980         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1981         int err;
1982
1983         mutex_lock(&codec->control_mutex);
1984         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1985                                                       3, 0, HDA_INPUT);
1986         err = func(kcontrol, ucontrol);
1987         mutex_unlock(&codec->control_mutex);
1988         return err;
1989 }
1990
1991 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1992                            struct snd_ctl_elem_value *ucontrol)
1993 {
1994         return alc_cap_getput_caller(kcontrol, ucontrol,
1995                                      snd_hda_mixer_amp_volume_get);
1996 }
1997
1998 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1999                            struct snd_ctl_elem_value *ucontrol)
2000 {
2001         return alc_cap_getput_caller(kcontrol, ucontrol,
2002                                      snd_hda_mixer_amp_volume_put);
2003 }
2004
2005 /* capture mixer elements */
2006 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2007
2008 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2009                           struct snd_ctl_elem_value *ucontrol)
2010 {
2011         return alc_cap_getput_caller(kcontrol, ucontrol,
2012                                      snd_hda_mixer_amp_switch_get);
2013 }
2014
2015 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2016                           struct snd_ctl_elem_value *ucontrol)
2017 {
2018         return alc_cap_getput_caller(kcontrol, ucontrol,
2019                                      snd_hda_mixer_amp_switch_put);
2020 }
2021
2022 #define _DEFINE_CAPMIX(num) \
2023         { \
2024                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2025                 .name = "Capture Switch", \
2026                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2027                 .count = num, \
2028                 .info = alc_cap_sw_info, \
2029                 .get = alc_cap_sw_get, \
2030                 .put = alc_cap_sw_put, \
2031         }, \
2032         { \
2033                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2034                 .name = "Capture Volume", \
2035                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2036                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2037                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2038                 .count = num, \
2039                 .info = alc_cap_vol_info, \
2040                 .get = alc_cap_vol_get, \
2041                 .put = alc_cap_vol_put, \
2042                 .tlv = { .c = alc_cap_vol_tlv }, \
2043         }
2044
2045 #define _DEFINE_CAPSRC(num) \
2046         { \
2047                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2048                 /* .name = "Capture Source", */ \
2049                 .name = "Input Source", \
2050                 .count = num, \
2051                 .info = alc_mux_enum_info, \
2052                 .get = alc_mux_enum_get, \
2053                 .put = alc_mux_enum_put, \
2054         }
2055
2056 #define DEFINE_CAPMIX(num) \
2057 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2058         _DEFINE_CAPMIX(num),                                  \
2059         _DEFINE_CAPSRC(num),                                  \
2060         { } /* end */                                         \
2061 }
2062
2063 #define DEFINE_CAPMIX_NOSRC(num) \
2064 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2065         _DEFINE_CAPMIX(num),                                        \
2066         { } /* end */                                               \
2067 }
2068
2069 /* up to three ADCs */
2070 DEFINE_CAPMIX(1);
2071 DEFINE_CAPMIX(2);
2072 DEFINE_CAPMIX(3);
2073 DEFINE_CAPMIX_NOSRC(1);
2074 DEFINE_CAPMIX_NOSRC(2);
2075 DEFINE_CAPMIX_NOSRC(3);
2076
2077 /*
2078  * ALC880 5-stack model
2079  *
2080  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2081  *      Side = 0x02 (0xd)
2082  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2083  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2084  */
2085
2086 /* additional mixers to alc880_three_stack_mixer */
2087 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2088         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2089         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2090         { } /* end */
2091 };
2092
2093 /* channel source setting (6/8 channel selection for 5-stack) */
2094 /* 6ch mode */
2095 static struct hda_verb alc880_fivestack_ch6_init[] = {
2096         /* set line-in to input, mute it */
2097         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2098         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2099         { } /* end */
2100 };
2101
2102 /* 8ch mode */
2103 static struct hda_verb alc880_fivestack_ch8_init[] = {
2104         /* set line-in to output, unmute it */
2105         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2106         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2107         { } /* end */
2108 };
2109
2110 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2111         { 6, alc880_fivestack_ch6_init },
2112         { 8, alc880_fivestack_ch8_init },
2113 };
2114
2115
2116 /*
2117  * ALC880 6-stack model
2118  *
2119  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2120  *      Side = 0x05 (0x0f)
2121  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2122  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2123  */
2124
2125 static hda_nid_t alc880_6st_dac_nids[4] = {
2126         /* front, rear, clfe, rear_surr */
2127         0x02, 0x03, 0x04, 0x05
2128 };
2129
2130 static struct hda_input_mux alc880_6stack_capture_source = {
2131         .num_items = 4,
2132         .items = {
2133                 { "Mic", 0x0 },
2134                 { "Front Mic", 0x1 },
2135                 { "Line", 0x2 },
2136                 { "CD", 0x4 },
2137         },
2138 };
2139
2140 /* fixed 8-channels */
2141 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2142         { 8, NULL },
2143 };
2144
2145 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2146         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2147         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2148         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2149         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2150         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2151         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2152         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2153         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2154         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2155         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2156         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2157         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2158         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2159         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2160         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2161         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2162         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2163         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2164         {
2165                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2166                 .name = "Channel Mode",
2167                 .info = alc_ch_mode_info,
2168                 .get = alc_ch_mode_get,
2169                 .put = alc_ch_mode_put,
2170         },
2171         { } /* end */
2172 };
2173
2174
2175 /*
2176  * ALC880 W810 model
2177  *
2178  * W810 has rear IO for:
2179  * Front (DAC 02)
2180  * Surround (DAC 03)
2181  * Center/LFE (DAC 04)
2182  * Digital out (06)
2183  *
2184  * The system also has a pair of internal speakers, and a headphone jack.
2185  * These are both connected to Line2 on the codec, hence to DAC 02.
2186  *
2187  * There is a variable resistor to control the speaker or headphone
2188  * volume. This is a hardware-only device without a software API.
2189  *
2190  * Plugging headphones in will disable the internal speakers. This is
2191  * implemented in hardware, not via the driver using jack sense. In
2192  * a similar fashion, plugging into the rear socket marked "front" will
2193  * disable both the speakers and headphones.
2194  *
2195  * For input, there's a microphone jack, and an "audio in" jack.
2196  * These may not do anything useful with this driver yet, because I
2197  * haven't setup any initialization verbs for these yet...
2198  */
2199
2200 static hda_nid_t alc880_w810_dac_nids[3] = {
2201         /* front, rear/surround, clfe */
2202         0x02, 0x03, 0x04
2203 };
2204
2205 /* fixed 6 channels */
2206 static struct hda_channel_mode alc880_w810_modes[1] = {
2207         { 6, NULL }
2208 };
2209
2210 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2211 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2212         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2213         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2214         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2215         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2216         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2217         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2218         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2219         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2220         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2221         { } /* end */
2222 };
2223
2224
2225 /*
2226  * Z710V model
2227  *
2228  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2229  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2230  *                 Line = 0x1a
2231  */
2232
2233 static hda_nid_t alc880_z71v_dac_nids[1] = {
2234         0x02
2235 };
2236 #define ALC880_Z71V_HP_DAC      0x03
2237
2238 /* fixed 2 channels */
2239 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2240         { 2, NULL }
2241 };
2242
2243 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2244         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2245         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2246         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2247         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2248         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2249         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2250         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2251         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2252         { } /* end */
2253 };
2254
2255
2256 /*
2257  * ALC880 F1734 model
2258  *
2259  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2260  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2261  */
2262
2263 static hda_nid_t alc880_f1734_dac_nids[1] = {
2264         0x03
2265 };
2266 #define ALC880_F1734_HP_DAC     0x02
2267
2268 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2269         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2270         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2271         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2272         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2273         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2274         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2275         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2276         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2277         { } /* end */
2278 };
2279
2280 static struct hda_input_mux alc880_f1734_capture_source = {
2281         .num_items = 2,
2282         .items = {
2283                 { "Mic", 0x1 },
2284                 { "CD", 0x4 },
2285         },
2286 };
2287
2288
2289 /*
2290  * ALC880 ASUS model
2291  *
2292  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2293  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2294  *  Mic = 0x18, Line = 0x1a
2295  */
2296
2297 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2298 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2299
2300 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2301         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2302         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2303         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2304         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2305         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2306         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2307         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2308         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2309         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2310         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2311         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2312         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2313         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2314         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2315         {
2316                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2317                 .name = "Channel Mode",
2318                 .info = alc_ch_mode_info,
2319                 .get = alc_ch_mode_get,
2320                 .put = alc_ch_mode_put,
2321         },
2322         { } /* end */
2323 };
2324
2325 /*
2326  * ALC880 ASUS W1V model
2327  *
2328  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2329  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2330  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2331  */
2332
2333 /* additional mixers to alc880_asus_mixer */
2334 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2335         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2336         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2337         { } /* end */
2338 };
2339
2340 /* TCL S700 */
2341 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2342         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2343         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2344         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2345         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2346         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2347         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2348         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2349         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2350         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2351         { } /* end */
2352 };
2353
2354 /* Uniwill */
2355 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2356         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2357         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2358         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2359         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2360         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2361         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2362         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2363         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2364         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2365         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2366         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2367         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2368         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2369         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2370         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2371         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2372         {
2373                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2374                 .name = "Channel Mode",
2375                 .info = alc_ch_mode_info,
2376                 .get = alc_ch_mode_get,
2377                 .put = alc_ch_mode_put,
2378         },
2379         { } /* end */
2380 };
2381
2382 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2383         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2384         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2385         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2386         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2387         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2388         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2389         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2390         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2391         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2392         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2393         { } /* end */
2394 };
2395
2396 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2397         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2398         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2399         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2400         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2401         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2402         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2403         { } /* end */
2404 };
2405
2406 /*
2407  * virtual master controls
2408  */
2409
2410 /*
2411  * slave controls for virtual master
2412  */
2413 static const char *alc_slave_vols[] = {
2414         "Front Playback Volume",
2415         "Surround Playback Volume",
2416         "Center Playback Volume",
2417         "LFE Playback Volume",
2418         "Side Playback Volume",
2419         "Headphone Playback Volume",
2420         "Speaker Playback Volume",
2421         "Mono Playback Volume",
2422         "Line-Out Playback Volume",
2423         "PCM Playback Volume",
2424         NULL,
2425 };
2426
2427 static const char *alc_slave_sws[] = {
2428         "Front Playback Switch",
2429         "Surround Playback Switch",
2430         "Center Playback Switch",
2431         "LFE Playback Switch",
2432         "Side Playback Switch",
2433         "Headphone Playback Switch",
2434         "Speaker Playback Switch",
2435         "Mono Playback Switch",
2436         "IEC958 Playback Switch",
2437         "Line-Out Playback Switch",
2438         "PCM Playback Switch",
2439         NULL,
2440 };
2441
2442 /*
2443  * build control elements
2444  */
2445
2446 static void alc_free_kctls(struct hda_codec *codec);
2447
2448 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2449 /* additional beep mixers; the actual parameters are overwritten at build */
2450 static struct snd_kcontrol_new alc_beep_mixer[] = {
2451         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2452         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2453         { } /* end */
2454 };
2455 #endif
2456
2457 static int alc_build_controls(struct hda_codec *codec)
2458 {
2459         struct alc_spec *spec = codec->spec;
2460         int err;
2461         int i;
2462
2463         for (i = 0; i < spec->num_mixers; i++) {
2464                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2465                 if (err < 0)
2466                         return err;
2467         }
2468         if (spec->cap_mixer) {
2469                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2470                 if (err < 0)
2471                         return err;
2472         }
2473         if (spec->multiout.dig_out_nid) {
2474                 err = snd_hda_create_spdif_out_ctls(codec,
2475                                                     spec->multiout.dig_out_nid);
2476                 if (err < 0)
2477                         return err;
2478                 if (!spec->no_analog) {
2479                         err = snd_hda_create_spdif_share_sw(codec,
2480                                                             &spec->multiout);
2481                         if (err < 0)
2482                                 return err;
2483                         spec->multiout.share_spdif = 1;
2484                 }
2485         }
2486         if (spec->dig_in_nid) {
2487                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2488                 if (err < 0)
2489                         return err;
2490         }
2491
2492 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2493         /* create beep controls if needed */
2494         if (spec->beep_amp) {
2495                 struct snd_kcontrol_new *knew;
2496                 for (knew = alc_beep_mixer; knew->name; knew++) {
2497                         struct snd_kcontrol *kctl;
2498                         kctl = snd_ctl_new1(knew, codec);
2499                         if (!kctl)
2500                                 return -ENOMEM;
2501                         kctl->private_value = spec->beep_amp;
2502                         err = snd_hda_ctl_add(codec,
2503                                         get_amp_nid_(spec->beep_amp), kctl);
2504                         if (err < 0)
2505                                 return err;
2506                 }
2507         }
2508 #endif
2509
2510         /* if we have no master control, let's create it */
2511         if (!spec->no_analog &&
2512             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2513                 unsigned int vmaster_tlv[4];
2514                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2515                                         HDA_OUTPUT, vmaster_tlv);
2516                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2517                                           vmaster_tlv, alc_slave_vols);
2518                 if (err < 0)
2519                         return err;
2520         }
2521         if (!spec->no_analog &&
2522             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2523                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2524                                           NULL, alc_slave_sws);
2525                 if (err < 0)
2526                         return err;
2527         }
2528
2529         alc_free_kctls(codec); /* no longer needed */
2530         return 0;
2531 }
2532
2533
2534 /*
2535  * initialize the codec volumes, etc
2536  */
2537
2538 /*
2539  * generic initialization of ADC, input mixers and output mixers
2540  */
2541 static struct hda_verb alc880_volume_init_verbs[] = {
2542         /*
2543          * Unmute ADC0-2 and set the default input to mic-in
2544          */
2545         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2546         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2547         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2548         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2549         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2550         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2551
2552         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2553          * mixer widget
2554          * Note: PASD motherboards uses the Line In 2 as the input for front
2555          * panel mic (mic 2)
2556          */
2557         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2558         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2559         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2560         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2561         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2562         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2563         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2564         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2565
2566         /*
2567          * Set up output mixers (0x0c - 0x0f)
2568          */
2569         /* set vol=0 to output mixers */
2570         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2571         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2572         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2573         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2574         /* set up input amps for analog loopback */
2575         /* Amp Indices: DAC = 0, mixer = 1 */
2576         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2577         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2578         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2579         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2580         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2581         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2582         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2583         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2584
2585         { }
2586 };
2587
2588 /*
2589  * 3-stack pin configuration:
2590  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2591  */
2592 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2593         /*
2594          * preset connection lists of input pins
2595          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2596          */
2597         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2598         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2599         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2600
2601         /*
2602          * Set pin mode and muting
2603          */
2604         /* set front pin widgets 0x14 for output */
2605         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2606         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2607         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2608         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2609         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2610         /* Mic2 (as headphone out) for HP output */
2611         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2612         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2613         /* Line In pin widget for input */
2614         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2615         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2616         /* Line2 (as front mic) pin widget for input and vref at 80% */
2617         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2618         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2619         /* CD pin widget for input */
2620         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2621
2622         { }
2623 };
2624
2625 /*
2626  * 5-stack pin configuration:
2627  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2628  * line-in/side = 0x1a, f-mic = 0x1b
2629  */
2630 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2631         /*
2632          * preset connection lists of input pins
2633          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2634          */
2635         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2636         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2637
2638         /*
2639          * Set pin mode and muting
2640          */
2641         /* set pin widgets 0x14-0x17 for output */
2642         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2643         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2644         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2645         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2646         /* unmute pins for output (no gain on this amp) */
2647         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2648         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2649         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2650         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2651
2652         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2653         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2654         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2655         /* Mic2 (as headphone out) for HP output */
2656         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2657         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2658         /* Line In pin widget for input */
2659         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2660         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2661         /* Line2 (as front mic) pin widget for input and vref at 80% */
2662         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2663         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2664         /* CD pin widget for input */
2665         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2666
2667         { }
2668 };
2669
2670 /*
2671  * W810 pin configuration:
2672  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2673  */
2674 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2675         /* hphone/speaker input selector: front DAC */
2676         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2677
2678         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2679         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2680         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2681         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2682         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2683         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2684
2685         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2686         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2687
2688         { }
2689 };
2690
2691 /*
2692  * Z71V pin configuration:
2693  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2694  */
2695 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2696         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2697         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2698         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2699         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2700
2701         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2702         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2703         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2704         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2705
2706         { }
2707 };
2708
2709 /*
2710  * 6-stack pin configuration:
2711  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2712  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2713  */
2714 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2715         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2716
2717         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2718         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2719         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2720         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2721         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2722         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2723         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2724         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2725
2726         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2727         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2728         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2729         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2730         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2731         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2732         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2733         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2734         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2735
2736         { }
2737 };
2738
2739 /*
2740  * Uniwill pin configuration:
2741  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2742  * line = 0x1a
2743  */
2744 static struct hda_verb alc880_uniwill_init_verbs[] = {
2745         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2746
2747         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2748         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2749         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2750         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2751         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2752         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2753         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2754         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2755         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2756         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2757         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2758         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2759         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2760         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2761
2762         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2763         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2764         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2765         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2766         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2767         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2768         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2769         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2770         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2771
2772         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2773         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2774
2775         { }
2776 };
2777
2778 /*
2779 * Uniwill P53
2780 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2781  */
2782 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2783         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2784
2785         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2786         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2787         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2788         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2789         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2790         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2791         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2792         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2793         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2794         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2795         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2796         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2797
2798         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2799         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2800         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2801         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2802         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2803         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2804
2805         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2806         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2807
2808         { }
2809 };
2810
2811 static struct hda_verb alc880_beep_init_verbs[] = {
2812         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2813         { }
2814 };
2815
2816 /* auto-toggle front mic */
2817 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2818 {
2819         unsigned int present;
2820         unsigned char bits;
2821
2822         present = snd_hda_jack_detect(codec, 0x18);
2823         bits = present ? HDA_AMP_MUTE : 0;
2824         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2825 }
2826
2827 static void alc880_uniwill_setup(struct hda_codec *codec)
2828 {
2829         struct alc_spec *spec = codec->spec;
2830
2831         spec->autocfg.hp_pins[0] = 0x14;
2832         spec->autocfg.speaker_pins[0] = 0x15;
2833         spec->autocfg.speaker_pins[0] = 0x16;
2834 }
2835
2836 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2837 {
2838         alc_automute_amp(codec);
2839         alc880_uniwill_mic_automute(codec);
2840 }
2841
2842 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2843                                        unsigned int res)
2844 {
2845         /* Looks like the unsol event is incompatible with the standard
2846          * definition.  4bit tag is placed at 28 bit!
2847          */
2848         switch (res >> 28) {
2849         case ALC880_MIC_EVENT:
2850                 alc880_uniwill_mic_automute(codec);
2851                 break;
2852         default:
2853                 alc_automute_amp_unsol_event(codec, res);
2854                 break;
2855         }
2856 }
2857
2858 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
2859 {
2860         struct alc_spec *spec = codec->spec;
2861
2862         spec->autocfg.hp_pins[0] = 0x14;
2863         spec->autocfg.speaker_pins[0] = 0x15;
2864 }
2865
2866 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2867 {
2868         unsigned int present;
2869
2870         present = snd_hda_codec_read(codec, 0x21, 0,
2871                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2872         present &= HDA_AMP_VOLMASK;
2873         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2874                                  HDA_AMP_VOLMASK, present);
2875         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2876                                  HDA_AMP_VOLMASK, present);
2877 }
2878
2879 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2880                                            unsigned int res)
2881 {
2882         /* Looks like the unsol event is incompatible with the standard
2883          * definition.  4bit tag is placed at 28 bit!
2884          */
2885         if ((res >> 28) == ALC880_DCVOL_EVENT)
2886                 alc880_uniwill_p53_dcvol_automute(codec);
2887         else
2888                 alc_automute_amp_unsol_event(codec, res);
2889 }
2890
2891 /*
2892  * F1734 pin configuration:
2893  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2894  */
2895 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2896         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2897         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2898         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2899         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2900         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2901
2902         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2903         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2904         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2905         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2906
2907         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2908         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2909         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2910         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2911         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2912         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2913         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2914         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2915         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2916
2917         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2918         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2919
2920         { }
2921 };
2922
2923 /*
2924  * ASUS pin configuration:
2925  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2926  */
2927 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2928         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2929         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2930         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2931         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2932
2933         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2934         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2935         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2936         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2937         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2938         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2939         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2940         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2941
2942         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2943         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2944         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2945         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2946         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2947         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2948         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2949         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2950         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2951
2952         { }
2953 };
2954
2955 /* Enable GPIO mask and set output */
2956 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2957 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2958 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
2959
2960 /* Clevo m520g init */
2961 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2962         /* headphone output */
2963         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2964         /* line-out */
2965         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2966         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2967         /* Line-in */
2968         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2969         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2970         /* CD */
2971         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2972         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2973         /* Mic1 (rear panel) */
2974         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2975         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2976         /* Mic2 (front panel) */
2977         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2978         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2979         /* headphone */
2980         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2981         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2982         /* change to EAPD mode */
2983         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2984         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2985
2986         { }
2987 };
2988
2989 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2990         /* change to EAPD mode */
2991         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2992         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2993
2994         /* Headphone output */
2995         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2996         /* Front output*/
2997         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2998         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2999
3000         /* Line In pin widget for input */
3001         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3002         /* CD pin widget for input */
3003         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3004         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3005         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3006
3007         /* change to EAPD mode */
3008         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3009         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3010
3011         { }
3012 };
3013
3014 /*
3015  * LG m1 express dual
3016  *
3017  * Pin assignment:
3018  *   Rear Line-In/Out (blue): 0x14
3019  *   Build-in Mic-In: 0x15
3020  *   Speaker-out: 0x17
3021  *   HP-Out (green): 0x1b
3022  *   Mic-In/Out (red): 0x19
3023  *   SPDIF-Out: 0x1e
3024  */
3025
3026 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3027 static hda_nid_t alc880_lg_dac_nids[3] = {
3028         0x05, 0x02, 0x03
3029 };
3030
3031 /* seems analog CD is not working */
3032 static struct hda_input_mux alc880_lg_capture_source = {
3033         .num_items = 3,
3034         .items = {
3035                 { "Mic", 0x1 },
3036                 { "Line", 0x5 },
3037                 { "Internal Mic", 0x6 },
3038         },
3039 };
3040
3041 /* 2,4,6 channel modes */
3042 static struct hda_verb alc880_lg_ch2_init[] = {
3043         /* set line-in and mic-in to input */
3044         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3045         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3046         { }
3047 };
3048
3049 static struct hda_verb alc880_lg_ch4_init[] = {
3050         /* set line-in to out and mic-in to input */
3051         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3052         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3053         { }
3054 };
3055
3056 static struct hda_verb alc880_lg_ch6_init[] = {
3057         /* set line-in and mic-in to output */
3058         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3059         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3060         { }
3061 };
3062
3063 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3064         { 2, alc880_lg_ch2_init },
3065         { 4, alc880_lg_ch4_init },
3066         { 6, alc880_lg_ch6_init },
3067 };
3068
3069 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3070         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3071         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3072         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3073         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3074         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3075         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3076         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3077         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3078         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3079         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3080         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3081         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3082         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3083         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3084         {
3085                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3086                 .name = "Channel Mode",
3087                 .info = alc_ch_mode_info,
3088                 .get = alc_ch_mode_get,
3089                 .put = alc_ch_mode_put,
3090         },
3091         { } /* end */
3092 };
3093
3094 static struct hda_verb alc880_lg_init_verbs[] = {
3095         /* set capture source to mic-in */
3096         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3097         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3098         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3099         /* mute all amp mixer inputs */
3100         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3101         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3102         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3103         /* line-in to input */
3104         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3105         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3106         /* built-in mic */
3107         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3108         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3109         /* speaker-out */
3110         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3111         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3112         /* mic-in to input */
3113         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3114         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3115         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3116         /* HP-out */
3117         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3118         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3119         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3120         /* jack sense */
3121         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3122         { }
3123 };
3124
3125 /* toggle speaker-output according to the hp-jack state */
3126 static void alc880_lg_setup(struct hda_codec *codec)
3127 {
3128         struct alc_spec *spec = codec->spec;
3129
3130         spec->autocfg.hp_pins[0] = 0x1b;
3131         spec->autocfg.speaker_pins[0] = 0x17;
3132 }
3133
3134 /*
3135  * LG LW20
3136  *
3137  * Pin assignment:
3138  *   Speaker-out: 0x14
3139  *   Mic-In: 0x18
3140  *   Built-in Mic-In: 0x19
3141  *   Line-In: 0x1b
3142  *   HP-Out: 0x1a
3143  *   SPDIF-Out: 0x1e
3144  */
3145
3146 static struct hda_input_mux alc880_lg_lw_capture_source = {
3147         .num_items = 3,
3148         .items = {
3149                 { "Mic", 0x0 },
3150                 { "Internal Mic", 0x1 },
3151                 { "Line In", 0x2 },
3152         },
3153 };
3154
3155 #define alc880_lg_lw_modes alc880_threestack_modes
3156
3157 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3158         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3159         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3160         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3161         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3162         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3163         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3164         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3165         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3166         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3167         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3168         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3169         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3170         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3171         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3172         {
3173                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3174                 .name = "Channel Mode",
3175                 .info = alc_ch_mode_info,
3176                 .get = alc_ch_mode_get,
3177                 .put = alc_ch_mode_put,
3178         },
3179         { } /* end */
3180 };
3181
3182 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3183         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3184         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3185         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3186
3187         /* set capture source to mic-in */
3188         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3189         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3190         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3191         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3192         /* speaker-out */
3193         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3194         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3195         /* HP-out */
3196         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3197         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3198         /* mic-in to input */
3199         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3200         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3201         /* built-in mic */
3202         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3203         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3204         /* jack sense */
3205         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3206         { }
3207 };
3208
3209 /* toggle speaker-output according to the hp-jack state */
3210 static void alc880_lg_lw_setup(struct hda_codec *codec)
3211 {
3212         struct alc_spec *spec = codec->spec;
3213
3214         spec->autocfg.hp_pins[0] = 0x1b;
3215         spec->autocfg.speaker_pins[0] = 0x14;
3216 }
3217
3218 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3219         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3220         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3221         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3222         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3223         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3224         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3225         { } /* end */
3226 };
3227
3228 static struct hda_input_mux alc880_medion_rim_capture_source = {
3229         .num_items = 2,
3230         .items = {
3231                 { "Mic", 0x0 },
3232                 { "Internal Mic", 0x1 },
3233         },
3234 };
3235
3236 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3237         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3238
3239         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3240         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3241
3242         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3243         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3244         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3245         /* Mic2 (as headphone out) for HP output */
3246         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3247         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3248         /* Internal Speaker */
3249         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3250         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3251
3252         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3253         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3254
3255         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3256         { }
3257 };
3258
3259 /* toggle speaker-output according to the hp-jack state */
3260 static void alc880_medion_rim_automute(struct hda_codec *codec)
3261 {
3262         struct alc_spec *spec = codec->spec;
3263         alc_automute_amp(codec);
3264         /* toggle EAPD */
3265         if (spec->jack_present)
3266                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3267         else
3268                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3269 }
3270
3271 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3272                                           unsigned int res)
3273 {
3274         /* Looks like the unsol event is incompatible with the standard
3275          * definition.  4bit tag is placed at 28 bit!
3276          */
3277         if ((res >> 28) == ALC880_HP_EVENT)
3278                 alc880_medion_rim_automute(codec);
3279 }
3280
3281 static void alc880_medion_rim_setup(struct hda_codec *codec)
3282 {
3283         struct alc_spec *spec = codec->spec;
3284
3285         spec->autocfg.hp_pins[0] = 0x14;
3286         spec->autocfg.speaker_pins[0] = 0x1b;
3287 }
3288
3289 #ifdef CONFIG_SND_HDA_POWER_SAVE
3290 static struct hda_amp_list alc880_loopbacks[] = {
3291         { 0x0b, HDA_INPUT, 0 },
3292         { 0x0b, HDA_INPUT, 1 },
3293         { 0x0b, HDA_INPUT, 2 },
3294         { 0x0b, HDA_INPUT, 3 },
3295         { 0x0b, HDA_INPUT, 4 },
3296         { } /* end */
3297 };
3298
3299 static struct hda_amp_list alc880_lg_loopbacks[] = {
3300         { 0x0b, HDA_INPUT, 1 },
3301         { 0x0b, HDA_INPUT, 6 },
3302         { 0x0b, HDA_INPUT, 7 },
3303         { } /* end */
3304 };
3305 #endif
3306
3307 /*
3308  * Common callbacks
3309  */
3310
3311 static int alc_init(struct hda_codec *codec)
3312 {
3313         struct alc_spec *spec = codec->spec;
3314         unsigned int i;
3315
3316         alc_fix_pll(codec);
3317         alc_auto_init_amp(codec, spec->init_amp);
3318
3319         for (i = 0; i < spec->num_init_verbs; i++)
3320                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3321
3322         if (spec->init_hook)
3323                 spec->init_hook(codec);
3324
3325         return 0;
3326 }
3327
3328 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3329 {
3330         struct alc_spec *spec = codec->spec;
3331
3332         if (spec->unsol_event)
3333                 spec->unsol_event(codec, res);
3334 }
3335
3336 #ifdef CONFIG_SND_HDA_POWER_SAVE
3337 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3338 {
3339         struct alc_spec *spec = codec->spec;
3340         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3341 }
3342 #endif
3343
3344 /*
3345  * Analog playback callbacks
3346  */
3347 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3348                                     struct hda_codec *codec,
3349                                     struct snd_pcm_substream *substream)
3350 {
3351         struct alc_spec *spec = codec->spec;
3352         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3353                                              hinfo);
3354 }
3355
3356 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3357                                        struct hda_codec *codec,
3358                                        unsigned int stream_tag,
3359                                        unsigned int format,
3360                                        struct snd_pcm_substream *substream)
3361 {
3362         struct alc_spec *spec = codec->spec;
3363         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3364                                                 stream_tag, format, substream);
3365 }
3366
3367 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3368                                        struct hda_codec *codec,
3369                                        struct snd_pcm_substream *substream)
3370 {
3371         struct alc_spec *spec = codec->spec;
3372         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3373 }
3374
3375 /*
3376  * Digital out
3377  */
3378 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3379                                         struct hda_codec *codec,
3380                                         struct snd_pcm_substream *substream)
3381 {
3382         struct alc_spec *spec = codec->spec;
3383         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3384 }
3385
3386 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3387                                            struct hda_codec *codec,
3388                                            unsigned int stream_tag,
3389                                            unsigned int format,
3390                                            struct snd_pcm_substream *substream)
3391 {
3392         struct alc_spec *spec = codec->spec;
3393         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3394                                              stream_tag, format, substream);
3395 }
3396
3397 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3398                                            struct hda_codec *codec,
3399                                            struct snd_pcm_substream *substream)
3400 {
3401         struct alc_spec *spec = codec->spec;
3402         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3403 }
3404
3405 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3406                                          struct hda_codec *codec,
3407                                          struct snd_pcm_substream *substream)
3408 {
3409         struct alc_spec *spec = codec->spec;
3410         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3411 }
3412
3413 /*
3414  * Analog capture
3415  */
3416 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3417                                       struct hda_codec *codec,
3418                                       unsigned int stream_tag,
3419                                       unsigned int format,
3420                                       struct snd_pcm_substream *substream)
3421 {
3422         struct alc_spec *spec = codec->spec;
3423
3424         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3425                                    stream_tag, 0, format);
3426         return 0;
3427 }
3428
3429 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3430                                       struct hda_codec *codec,
3431                                       struct snd_pcm_substream *substream)
3432 {
3433         struct alc_spec *spec = codec->spec;
3434
3435         snd_hda_codec_cleanup_stream(codec,
3436                                      spec->adc_nids[substream->number + 1]);
3437         return 0;
3438 }
3439
3440
3441 /*
3442  */
3443 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3444         .substreams = 1,
3445         .channels_min = 2,
3446         .channels_max = 8,
3447         /* NID is set in alc_build_pcms */
3448         .ops = {
3449                 .open = alc880_playback_pcm_open,
3450                 .prepare = alc880_playback_pcm_prepare,
3451                 .cleanup = alc880_playback_pcm_cleanup
3452         },
3453 };
3454
3455 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3456         .substreams = 1,
3457         .channels_min = 2,
3458         .channels_max = 2,
3459         /* NID is set in alc_build_pcms */
3460 };
3461
3462 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3463         .substreams = 1,
3464         .channels_min = 2,
3465         .channels_max = 2,
3466         /* NID is set in alc_build_pcms */
3467 };
3468
3469 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3470         .substreams = 2, /* can be overridden */
3471         .channels_min = 2,
3472         .channels_max = 2,
3473         /* NID is set in alc_build_pcms */
3474         .ops = {
3475                 .prepare = alc880_alt_capture_pcm_prepare,
3476                 .cleanup = alc880_alt_capture_pcm_cleanup
3477         },
3478 };
3479
3480 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3481         .substreams = 1,
3482         .channels_min = 2,
3483         .channels_max = 2,
3484         /* NID is set in alc_build_pcms */
3485         .ops = {
3486                 .open = alc880_dig_playback_pcm_open,
3487                 .close = alc880_dig_playback_pcm_close,
3488                 .prepare = alc880_dig_playback_pcm_prepare,
3489                 .cleanup = alc880_dig_playback_pcm_cleanup
3490         },
3491 };
3492
3493 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3494         .substreams = 1,
3495         .channels_min = 2,
3496         .channels_max = 2,
3497         /* NID is set in alc_build_pcms */
3498 };
3499
3500 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3501 static struct hda_pcm_stream alc_pcm_null_stream = {
3502         .substreams = 0,
3503         .channels_min = 0,
3504         .channels_max = 0,
3505 };
3506
3507 static int alc_build_pcms(struct hda_codec *codec)
3508 {
3509         struct alc_spec *spec = codec->spec;
3510         struct hda_pcm *info = spec->pcm_rec;
3511         int i;
3512
3513         codec->num_pcms = 1;
3514         codec->pcm_info = info;
3515
3516         if (spec->no_analog)
3517                 goto skip_analog;
3518
3519         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3520                  "%s Analog", codec->chip_name);
3521         info->name = spec->stream_name_analog;
3522
3523         if (spec->stream_analog_playback) {
3524                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3525                         return -EINVAL;
3526                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3527                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3528         }
3529         if (spec->stream_analog_capture) {
3530                 if (snd_BUG_ON(!spec->adc_nids))
3531                         return -EINVAL;
3532                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3533                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3534         }
3535
3536         if (spec->channel_mode) {
3537                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3538                 for (i = 0; i < spec->num_channel_mode; i++) {
3539                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3540                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3541                         }
3542                 }
3543         }
3544
3545  skip_analog:
3546         /* SPDIF for stream index #1 */
3547         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3548                 snprintf(spec->stream_name_digital,
3549                          sizeof(spec->stream_name_digital),
3550                          "%s Digital", codec->chip_name);
3551                 codec->num_pcms = 2;
3552                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3553                 info = spec->pcm_rec + 1;
3554                 info->name = spec->stream_name_digital;
3555                 if (spec->dig_out_type)
3556                         info->pcm_type = spec->dig_out_type;
3557                 else
3558                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3559                 if (spec->multiout.dig_out_nid &&
3560                     spec->stream_digital_playback) {
3561                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3562                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3563                 }
3564                 if (spec->dig_in_nid &&
3565                     spec->stream_digital_capture) {
3566                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3567                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3568                 }
3569                 /* FIXME: do we need this for all Realtek codec models? */
3570                 codec->spdif_status_reset = 1;
3571         }
3572
3573         if (spec->no_analog)
3574                 return 0;
3575
3576         /* If the use of more than one ADC is requested for the current
3577          * model, configure a second analog capture-only PCM.
3578          */
3579         /* Additional Analaog capture for index #2 */
3580         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3581             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3582                 codec->num_pcms = 3;
3583                 info = spec->pcm_rec + 2;
3584                 info->name = spec->stream_name_analog;
3585                 if (spec->alt_dac_nid) {
3586                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3587                                 *spec->stream_analog_alt_playback;
3588                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3589                                 spec->alt_dac_nid;
3590                 } else {
3591                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3592                                 alc_pcm_null_stream;
3593                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3594                 }
3595                 if (spec->num_adc_nids > 1) {
3596                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3597                                 *spec->stream_analog_alt_capture;
3598                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3599                                 spec->adc_nids[1];
3600                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3601                                 spec->num_adc_nids - 1;
3602                 } else {
3603                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3604                                 alc_pcm_null_stream;
3605                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3606                 }
3607         }
3608
3609         return 0;
3610 }
3611
3612 static void alc_free_kctls(struct hda_codec *codec)
3613 {
3614         struct alc_spec *spec = codec->spec;
3615
3616         if (spec->kctls.list) {
3617                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3618                 int i;
3619                 for (i = 0; i < spec->kctls.used; i++)
3620                         kfree(kctl[i].name);
3621         }
3622         snd_array_free(&spec->kctls);
3623 }
3624
3625 static void alc_free(struct hda_codec *codec)
3626 {
3627         struct alc_spec *spec = codec->spec;
3628
3629         if (!spec)
3630                 return;
3631
3632         alc_free_kctls(codec);
3633         kfree(spec);
3634         snd_hda_detach_beep_device(codec);
3635 }
3636
3637 #ifdef CONFIG_SND_HDA_POWER_SAVE
3638 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
3639 {
3640         struct alc_spec *spec = codec->spec;
3641         if (spec && spec->power_hook)
3642                 spec->power_hook(codec, 0);
3643         return 0;
3644 }
3645 #endif
3646
3647 #ifdef SND_HDA_NEEDS_RESUME
3648 static int alc_resume(struct hda_codec *codec)
3649 {
3650 #ifdef CONFIG_SND_HDA_POWER_SAVE
3651         struct alc_spec *spec = codec->spec;
3652 #endif
3653         codec->patch_ops.init(codec);
3654         snd_hda_codec_resume_amp(codec);
3655         snd_hda_codec_resume_cache(codec);
3656 #ifdef CONFIG_SND_HDA_POWER_SAVE
3657         if (spec && spec->power_hook)
3658                 spec->power_hook(codec, 1);
3659 #endif
3660         return 0;
3661 }
3662 #endif
3663
3664 /*
3665  */
3666 static struct hda_codec_ops alc_patch_ops = {
3667         .build_controls = alc_build_controls,
3668         .build_pcms = alc_build_pcms,
3669         .init = alc_init,
3670         .free = alc_free,
3671         .unsol_event = alc_unsol_event,
3672 #ifdef SND_HDA_NEEDS_RESUME
3673         .resume = alc_resume,
3674 #endif
3675 #ifdef CONFIG_SND_HDA_POWER_SAVE
3676         .suspend = alc_suspend,
3677         .check_power_status = alc_check_power_status,
3678 #endif
3679 };
3680
3681
3682 /*
3683  * Test configuration for debugging
3684  *
3685  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3686  * enum controls.
3687  */
3688 #ifdef CONFIG_SND_DEBUG
3689 static hda_nid_t alc880_test_dac_nids[4] = {
3690         0x02, 0x03, 0x04, 0x05
3691 };
3692
3693 static struct hda_input_mux alc880_test_capture_source = {
3694         .num_items = 7,
3695         .items = {
3696                 { "In-1", 0x0 },
3697                 { "In-2", 0x1 },
3698                 { "In-3", 0x2 },
3699                 { "In-4", 0x3 },
3700                 { "CD", 0x4 },
3701                 { "Front", 0x5 },
3702                 { "Surround", 0x6 },
3703         },
3704 };
3705
3706 static struct hda_channel_mode alc880_test_modes[4] = {
3707         { 2, NULL },
3708         { 4, NULL },
3709         { 6, NULL },
3710         { 8, NULL },
3711 };
3712
3713 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3714                                  struct snd_ctl_elem_info *uinfo)
3715 {
3716         static char *texts[] = {
3717                 "N/A", "Line Out", "HP Out",
3718                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3719         };
3720         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3721         uinfo->count = 1;
3722         uinfo->value.enumerated.items = 8;
3723         if (uinfo->value.enumerated.item >= 8)
3724                 uinfo->value.enumerated.item = 7;
3725         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3726         return 0;
3727 }
3728
3729 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3730                                 struct snd_ctl_elem_value *ucontrol)
3731 {
3732         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3733         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3734         unsigned int pin_ctl, item = 0;
3735
3736         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3737                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3738         if (pin_ctl & AC_PINCTL_OUT_EN) {
3739                 if (pin_ctl & AC_PINCTL_HP_EN)
3740                         item = 2;
3741                 else
3742                         item = 1;
3743         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3744                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3745                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3746                 case AC_PINCTL_VREF_50:  item = 4; break;
3747                 case AC_PINCTL_VREF_GRD: item = 5; break;
3748                 case AC_PINCTL_VREF_80:  item = 6; break;
3749                 case AC_PINCTL_VREF_100: item = 7; break;
3750                 }
3751         }
3752         ucontrol->value.enumerated.item[0] = item;
3753         return 0;
3754 }
3755
3756 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3757                                 struct snd_ctl_elem_value *ucontrol)
3758 {
3759         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3760         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3761         static unsigned int ctls[] = {
3762                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3763                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3764                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3765                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3766                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3767                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3768         };
3769         unsigned int old_ctl, new_ctl;
3770
3771         old_ctl = snd_hda_codec_read(codec, nid, 0,
3772                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3773         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3774         if (old_ctl != new_ctl) {
3775                 int val;
3776                 snd_hda_codec_write_cache(codec, nid, 0,
3777                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3778                                           new_ctl);
3779                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3780                         HDA_AMP_MUTE : 0;
3781                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3782                                          HDA_AMP_MUTE, val);
3783                 return 1;
3784         }
3785         return 0;
3786 }
3787
3788 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3789                                  struct snd_ctl_elem_info *uinfo)
3790 {
3791         static char *texts[] = {
3792                 "Front", "Surround", "CLFE", "Side"
3793         };
3794         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3795         uinfo->count = 1;
3796         uinfo->value.enumerated.items = 4;
3797         if (uinfo->value.enumerated.item >= 4)
3798                 uinfo->value.enumerated.item = 3;
3799         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3800         return 0;
3801 }
3802
3803 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3804                                 struct snd_ctl_elem_value *ucontrol)
3805 {
3806         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3807         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3808         unsigned int sel;
3809
3810         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3811         ucontrol->value.enumerated.item[0] = sel & 3;
3812         return 0;
3813 }
3814
3815 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3816                                 struct snd_ctl_elem_value *ucontrol)
3817 {
3818         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3819         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3820         unsigned int sel;
3821
3822         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3823         if (ucontrol->value.enumerated.item[0] != sel) {
3824                 sel = ucontrol->value.enumerated.item[0] & 3;
3825                 snd_hda_codec_write_cache(codec, nid, 0,
3826                                           AC_VERB_SET_CONNECT_SEL, sel);
3827                 return 1;
3828         }
3829         return 0;
3830 }
3831
3832 #define PIN_CTL_TEST(xname,nid) {                       \
3833                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3834                         .name = xname,                 \
3835                         .info = alc_test_pin_ctl_info, \
3836                         .get = alc_test_pin_ctl_get,   \
3837                         .put = alc_test_pin_ctl_put,   \
3838                         .private_value = nid           \
3839                         }
3840
3841 #define PIN_SRC_TEST(xname,nid) {                       \
3842                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3843                         .name = xname,                 \
3844                         .info = alc_test_pin_src_info, \
3845                         .get = alc_test_pin_src_get,   \
3846                         .put = alc_test_pin_src_put,   \
3847                         .private_value = nid           \
3848                         }
3849
3850 static struct snd_kcontrol_new alc880_test_mixer[] = {
3851         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3852         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3853         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3854         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3855         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3856         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3857         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3858         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3859         PIN_CTL_TEST("Front Pin Mode", 0x14),
3860         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3861         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3862         PIN_CTL_TEST("Side Pin Mode", 0x17),
3863         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3864         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3865         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3866         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3867         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3868         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3869         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3870         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3871         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3872         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3873         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3874         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3875         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3876         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3877         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3878         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3879         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3880         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3881         {
3882                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3883                 .name = "Channel Mode",
3884                 .info = alc_ch_mode_info,
3885                 .get = alc_ch_mode_get,
3886                 .put = alc_ch_mode_put,
3887         },
3888         { } /* end */
3889 };
3890
3891 static struct hda_verb alc880_test_init_verbs[] = {
3892         /* Unmute inputs of 0x0c - 0x0f */
3893         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3894         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3895         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3896         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3897         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3898         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3899         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3900         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3901         /* Vol output for 0x0c-0x0f */
3902         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3903         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3904         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3905         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3906         /* Set output pins 0x14-0x17 */
3907         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3908         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3909         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3910         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3911         /* Unmute output pins 0x14-0x17 */
3912         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3913         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3914         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3915         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3916         /* Set input pins 0x18-0x1c */
3917         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3918         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3919         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3920         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3921         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3922         /* Mute input pins 0x18-0x1b */
3923         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3924         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3925         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3926         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3927         /* ADC set up */
3928         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3929         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3930         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3931         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3932         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3933         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3934         /* Analog input/passthru */
3935         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3936         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3937         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3938         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3939         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3940         { }
3941 };
3942 #endif
3943
3944 /*
3945  */
3946
3947 static const char *alc880_models[ALC880_MODEL_LAST] = {
3948         [ALC880_3ST]            = "3stack",
3949         [ALC880_TCL_S700]       = "tcl",
3950         [ALC880_3ST_DIG]        = "3stack-digout",
3951         [ALC880_CLEVO]          = "clevo",
3952         [ALC880_5ST]            = "5stack",
3953         [ALC880_5ST_DIG]        = "5stack-digout",
3954         [ALC880_W810]           = "w810",
3955         [ALC880_Z71V]           = "z71v",
3956         [ALC880_6ST]            = "6stack",
3957         [ALC880_6ST_DIG]        = "6stack-digout",
3958         [ALC880_ASUS]           = "asus",
3959         [ALC880_ASUS_W1V]       = "asus-w1v",
3960         [ALC880_ASUS_DIG]       = "asus-dig",
3961         [ALC880_ASUS_DIG2]      = "asus-dig2",
3962         [ALC880_UNIWILL_DIG]    = "uniwill",
3963         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3964         [ALC880_FUJITSU]        = "fujitsu",
3965         [ALC880_F1734]          = "F1734",
3966         [ALC880_LG]             = "lg",
3967         [ALC880_LG_LW]          = "lg-lw",
3968         [ALC880_MEDION_RIM]     = "medion",
3969 #ifdef CONFIG_SND_DEBUG
3970         [ALC880_TEST]           = "test",
3971 #endif
3972         [ALC880_AUTO]           = "auto",
3973 };
3974
3975 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3976         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3977         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3978         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3979         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3980         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3981         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3982         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3983         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3984         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3985         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3986         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3987         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3988         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3989         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3990         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3991         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3992         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3993         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3994         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3995         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3996         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3997         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3998         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3999         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4000         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4001         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4002         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4003         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4004         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4005         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4006         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4007         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4008         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4009         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4010         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4011         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4012         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4013         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4014         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4015         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4016         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4017         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4018         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4019         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4020         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4021         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4022         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4023         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4024         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4025         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
4026         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4027         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4028         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4029         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4030         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4031         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4032         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4033         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4034         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4035         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4036         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4037         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4038         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4039         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4040         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4041         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4042         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4043         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4044         /* default Intel */
4045         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4046         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4047         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4048         {}
4049 };
4050
4051 /*
4052  * ALC880 codec presets
4053  */
4054 static struct alc_config_preset alc880_presets[] = {
4055         [ALC880_3ST] = {
4056                 .mixers = { alc880_three_stack_mixer },
4057                 .init_verbs = { alc880_volume_init_verbs,
4058                                 alc880_pin_3stack_init_verbs },
4059                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4060                 .dac_nids = alc880_dac_nids,
4061                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4062                 .channel_mode = alc880_threestack_modes,
4063                 .need_dac_fix = 1,
4064                 .input_mux = &alc880_capture_source,
4065         },
4066         [ALC880_3ST_DIG] = {
4067                 .mixers = { alc880_three_stack_mixer },
4068                 .init_verbs = { alc880_volume_init_verbs,
4069                                 alc880_pin_3stack_init_verbs },
4070                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4071                 .dac_nids = alc880_dac_nids,
4072                 .dig_out_nid = ALC880_DIGOUT_NID,
4073                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4074                 .channel_mode = alc880_threestack_modes,
4075                 .need_dac_fix = 1,
4076                 .input_mux = &alc880_capture_source,
4077         },
4078         [ALC880_TCL_S700] = {
4079                 .mixers = { alc880_tcl_s700_mixer },
4080                 .init_verbs = { alc880_volume_init_verbs,
4081                                 alc880_pin_tcl_S700_init_verbs,
4082                                 alc880_gpio2_init_verbs },
4083                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4084                 .dac_nids = alc880_dac_nids,
4085                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4086                 .num_adc_nids = 1, /* single ADC */
4087                 .hp_nid = 0x03,
4088                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4089                 .channel_mode = alc880_2_jack_modes,
4090                 .input_mux = &alc880_capture_source,
4091         },
4092         [ALC880_5ST] = {
4093                 .mixers = { alc880_three_stack_mixer,
4094                             alc880_five_stack_mixer},
4095                 .init_verbs = { alc880_volume_init_verbs,
4096                                 alc880_pin_5stack_init_verbs },
4097                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4098                 .dac_nids = alc880_dac_nids,
4099                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4100                 .channel_mode = alc880_fivestack_modes,
4101                 .input_mux = &alc880_capture_source,
4102         },
4103         [ALC880_5ST_DIG] = {
4104                 .mixers = { alc880_three_stack_mixer,
4105                             alc880_five_stack_mixer },
4106                 .init_verbs = { alc880_volume_init_verbs,
4107                                 alc880_pin_5stack_init_verbs },
4108                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4109                 .dac_nids = alc880_dac_nids,
4110                 .dig_out_nid = ALC880_DIGOUT_NID,
4111                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4112                 .channel_mode = alc880_fivestack_modes,
4113                 .input_mux = &alc880_capture_source,
4114         },
4115         [ALC880_6ST] = {
4116                 .mixers = { alc880_six_stack_mixer },
4117                 .init_verbs = { alc880_volume_init_verbs,
4118                                 alc880_pin_6stack_init_verbs },
4119                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4120                 .dac_nids = alc880_6st_dac_nids,
4121                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4122                 .channel_mode = alc880_sixstack_modes,
4123                 .input_mux = &alc880_6stack_capture_source,
4124         },
4125         [ALC880_6ST_DIG] = {
4126                 .mixers = { alc880_six_stack_mixer },
4127                 .init_verbs = { alc880_volume_init_verbs,
4128                                 alc880_pin_6stack_init_verbs },
4129                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4130                 .dac_nids = alc880_6st_dac_nids,
4131                 .dig_out_nid = ALC880_DIGOUT_NID,
4132                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4133                 .channel_mode = alc880_sixstack_modes,
4134                 .input_mux = &alc880_6stack_capture_source,
4135         },
4136         [ALC880_W810] = {
4137                 .mixers = { alc880_w810_base_mixer },
4138                 .init_verbs = { alc880_volume_init_verbs,
4139                                 alc880_pin_w810_init_verbs,
4140                                 alc880_gpio2_init_verbs },
4141                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4142                 .dac_nids = alc880_w810_dac_nids,
4143                 .dig_out_nid = ALC880_DIGOUT_NID,
4144                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4145                 .channel_mode = alc880_w810_modes,
4146                 .input_mux = &alc880_capture_source,
4147         },
4148         [ALC880_Z71V] = {
4149                 .mixers = { alc880_z71v_mixer },
4150                 .init_verbs = { alc880_volume_init_verbs,
4151                                 alc880_pin_z71v_init_verbs },
4152                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4153                 .dac_nids = alc880_z71v_dac_nids,
4154                 .dig_out_nid = ALC880_DIGOUT_NID,
4155                 .hp_nid = 0x03,
4156                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4157                 .channel_mode = alc880_2_jack_modes,
4158                 .input_mux = &alc880_capture_source,
4159         },
4160         [ALC880_F1734] = {
4161                 .mixers = { alc880_f1734_mixer },
4162                 .init_verbs = { alc880_volume_init_verbs,
4163                                 alc880_pin_f1734_init_verbs },
4164                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4165                 .dac_nids = alc880_f1734_dac_nids,
4166                 .hp_nid = 0x02,
4167                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4168                 .channel_mode = alc880_2_jack_modes,
4169                 .input_mux = &alc880_f1734_capture_source,
4170                 .unsol_event = alc880_uniwill_p53_unsol_event,
4171                 .setup = alc880_uniwill_p53_setup,
4172                 .init_hook = alc_automute_amp,
4173         },
4174         [ALC880_ASUS] = {
4175                 .mixers = { alc880_asus_mixer },
4176                 .init_verbs = { alc880_volume_init_verbs,
4177                                 alc880_pin_asus_init_verbs,
4178                                 alc880_gpio1_init_verbs },
4179                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4180                 .dac_nids = alc880_asus_dac_nids,
4181                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4182                 .channel_mode = alc880_asus_modes,
4183                 .need_dac_fix = 1,
4184                 .input_mux = &alc880_capture_source,
4185         },
4186         [ALC880_ASUS_DIG] = {
4187                 .mixers = { alc880_asus_mixer },
4188                 .init_verbs = { alc880_volume_init_verbs,
4189                                 alc880_pin_asus_init_verbs,
4190                                 alc880_gpio1_init_verbs },
4191                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4192                 .dac_nids = alc880_asus_dac_nids,
4193                 .dig_out_nid = ALC880_DIGOUT_NID,
4194                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4195                 .channel_mode = alc880_asus_modes,
4196                 .need_dac_fix = 1,
4197                 .input_mux = &alc880_capture_source,
4198         },
4199         [ALC880_ASUS_DIG2] = {
4200                 .mixers = { alc880_asus_mixer },
4201                 .init_verbs = { alc880_volume_init_verbs,
4202                                 alc880_pin_asus_init_verbs,
4203                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4204                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4205                 .dac_nids = alc880_asus_dac_nids,
4206                 .dig_out_nid = ALC880_DIGOUT_NID,
4207                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4208                 .channel_mode = alc880_asus_modes,
4209                 .need_dac_fix = 1,
4210                 .input_mux = &alc880_capture_source,
4211         },
4212         [ALC880_ASUS_W1V] = {
4213                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4214                 .init_verbs = { alc880_volume_init_verbs,
4215                                 alc880_pin_asus_init_verbs,
4216                                 alc880_gpio1_init_verbs },
4217                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4218                 .dac_nids = alc880_asus_dac_nids,
4219                 .dig_out_nid = ALC880_DIGOUT_NID,
4220                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4221                 .channel_mode = alc880_asus_modes,
4222                 .need_dac_fix = 1,
4223                 .input_mux = &alc880_capture_source,
4224         },
4225         [ALC880_UNIWILL_DIG] = {
4226                 .mixers = { alc880_asus_mixer },
4227                 .init_verbs = { alc880_volume_init_verbs,
4228                                 alc880_pin_asus_init_verbs },
4229                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4230                 .dac_nids = alc880_asus_dac_nids,
4231                 .dig_out_nid = ALC880_DIGOUT_NID,
4232                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4233                 .channel_mode = alc880_asus_modes,
4234                 .need_dac_fix = 1,
4235                 .input_mux = &alc880_capture_source,
4236         },
4237         [ALC880_UNIWILL] = {
4238                 .mixers = { alc880_uniwill_mixer },
4239                 .init_verbs = { alc880_volume_init_verbs,
4240                                 alc880_uniwill_init_verbs },
4241                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4242                 .dac_nids = alc880_asus_dac_nids,
4243                 .dig_out_nid = ALC880_DIGOUT_NID,
4244                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4245                 .channel_mode = alc880_threestack_modes,
4246                 .need_dac_fix = 1,
4247                 .input_mux = &alc880_capture_source,
4248                 .unsol_event = alc880_uniwill_unsol_event,
4249                 .setup = alc880_uniwill_setup,
4250                 .init_hook = alc880_uniwill_init_hook,
4251         },
4252         [ALC880_UNIWILL_P53] = {
4253                 .mixers = { alc880_uniwill_p53_mixer },
4254                 .init_verbs = { alc880_volume_init_verbs,
4255                                 alc880_uniwill_p53_init_verbs },
4256                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4257                 .dac_nids = alc880_asus_dac_nids,
4258                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4259                 .channel_mode = alc880_threestack_modes,
4260                 .input_mux = &alc880_capture_source,
4261                 .unsol_event = alc880_uniwill_p53_unsol_event,
4262                 .setup = alc880_uniwill_p53_setup,
4263                 .init_hook = alc_automute_amp,
4264         },
4265         [ALC880_FUJITSU] = {
4266                 .mixers = { alc880_fujitsu_mixer },
4267                 .init_verbs = { alc880_volume_init_verbs,
4268                                 alc880_uniwill_p53_init_verbs,
4269                                 alc880_beep_init_verbs },
4270                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4271                 .dac_nids = alc880_dac_nids,
4272                 .dig_out_nid = ALC880_DIGOUT_NID,
4273                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4274                 .channel_mode = alc880_2_jack_modes,
4275                 .input_mux = &alc880_capture_source,
4276                 .unsol_event = alc880_uniwill_p53_unsol_event,
4277                 .setup = alc880_uniwill_p53_setup,
4278                 .init_hook = alc_automute_amp,
4279         },
4280         [ALC880_CLEVO] = {
4281                 .mixers = { alc880_three_stack_mixer },
4282                 .init_verbs = { alc880_volume_init_verbs,
4283                                 alc880_pin_clevo_init_verbs },
4284                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4285                 .dac_nids = alc880_dac_nids,
4286                 .hp_nid = 0x03,
4287                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4288                 .channel_mode = alc880_threestack_modes,
4289                 .need_dac_fix = 1,
4290                 .input_mux = &alc880_capture_source,
4291         },
4292         [ALC880_LG] = {
4293                 .mixers = { alc880_lg_mixer },
4294                 .init_verbs = { alc880_volume_init_verbs,
4295                                 alc880_lg_init_verbs },
4296                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4297                 .dac_nids = alc880_lg_dac_nids,
4298                 .dig_out_nid = ALC880_DIGOUT_NID,
4299                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4300                 .channel_mode = alc880_lg_ch_modes,
4301                 .need_dac_fix = 1,
4302                 .input_mux = &alc880_lg_capture_source,
4303                 .unsol_event = alc_automute_amp_unsol_event,
4304                 .setup = alc880_lg_setup,
4305                 .init_hook = alc_automute_amp,
4306 #ifdef CONFIG_SND_HDA_POWER_SAVE
4307                 .loopbacks = alc880_lg_loopbacks,
4308 #endif
4309         },
4310         [ALC880_LG_LW] = {
4311                 .mixers = { alc880_lg_lw_mixer },
4312                 .init_verbs = { alc880_volume_init_verbs,
4313                                 alc880_lg_lw_init_verbs },
4314                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4315                 .dac_nids = alc880_dac_nids,
4316                 .dig_out_nid = ALC880_DIGOUT_NID,
4317                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4318                 .channel_mode = alc880_lg_lw_modes,
4319                 .input_mux = &alc880_lg_lw_capture_source,
4320                 .unsol_event = alc_automute_amp_unsol_event,
4321                 .setup = alc880_lg_lw_setup,
4322                 .init_hook = alc_automute_amp,
4323         },
4324         [ALC880_MEDION_RIM] = {
4325                 .mixers = { alc880_medion_rim_mixer },
4326                 .init_verbs = { alc880_volume_init_verbs,
4327                                 alc880_medion_rim_init_verbs,
4328                                 alc_gpio2_init_verbs },
4329                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4330                 .dac_nids = alc880_dac_nids,
4331                 .dig_out_nid = ALC880_DIGOUT_NID,
4332                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4333                 .channel_mode = alc880_2_jack_modes,
4334                 .input_mux = &alc880_medion_rim_capture_source,
4335                 .unsol_event = alc880_medion_rim_unsol_event,
4336                 .setup = alc880_medion_rim_setup,
4337                 .init_hook = alc880_medion_rim_automute,
4338         },
4339 #ifdef CONFIG_SND_DEBUG
4340         [ALC880_TEST] = {
4341                 .mixers = { alc880_test_mixer },
4342                 .init_verbs = { alc880_test_init_verbs },
4343                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4344                 .dac_nids = alc880_test_dac_nids,
4345                 .dig_out_nid = ALC880_DIGOUT_NID,
4346                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4347                 .channel_mode = alc880_test_modes,
4348                 .input_mux = &alc880_test_capture_source,
4349         },
4350 #endif
4351 };
4352
4353 /*
4354  * Automatic parse of I/O pins from the BIOS configuration
4355  */
4356
4357 enum {
4358         ALC_CTL_WIDGET_VOL,
4359         ALC_CTL_WIDGET_MUTE,
4360         ALC_CTL_BIND_MUTE,
4361 };
4362 static struct snd_kcontrol_new alc880_control_templates[] = {
4363         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4364         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4365         HDA_BIND_MUTE(NULL, 0, 0, 0),
4366 };
4367
4368 /* add dynamic controls */
4369 static int add_control(struct alc_spec *spec, int type, const char *name,
4370                        unsigned long val)
4371 {
4372         struct snd_kcontrol_new *knew;
4373
4374         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4375         knew = snd_array_new(&spec->kctls);
4376         if (!knew)
4377                 return -ENOMEM;
4378         *knew = alc880_control_templates[type];
4379         knew->name = kstrdup(name, GFP_KERNEL);
4380         if (!knew->name)
4381                 return -ENOMEM;
4382         if (get_amp_nid_(val))
4383                 knew->subdevice = HDA_SUBDEV_NID_FLAG | get_amp_nid_(val);
4384         knew->private_value = val;
4385         return 0;
4386 }
4387
4388 static int add_control_with_pfx(struct alc_spec *spec, int type,
4389                                 const char *pfx, const char *dir,
4390                                 const char *sfx, unsigned long val)
4391 {
4392         char name[32];
4393         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
4394         return add_control(spec, type, name, val);
4395 }
4396
4397 #define add_pb_vol_ctrl(spec, type, pfx, val) \
4398         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", val)
4399 #define add_pb_sw_ctrl(spec, type, pfx, val) \
4400         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", val)
4401
4402 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4403 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4404 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4405 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4406 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4407 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4408 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4409 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4410 #define ALC880_PIN_CD_NID               0x1c
4411
4412 /* fill in the dac_nids table from the parsed pin configuration */
4413 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4414                                      const struct auto_pin_cfg *cfg)
4415 {
4416         hda_nid_t nid;
4417         int assigned[4];
4418         int i, j;
4419
4420         memset(assigned, 0, sizeof(assigned));
4421         spec->multiout.dac_nids = spec->private_dac_nids;
4422
4423         /* check the pins hardwired to audio widget */
4424         for (i = 0; i < cfg->line_outs; i++) {
4425                 nid = cfg->line_out_pins[i];
4426                 if (alc880_is_fixed_pin(nid)) {
4427                         int idx = alc880_fixed_pin_idx(nid);
4428                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4429                         assigned[idx] = 1;
4430                 }
4431         }
4432         /* left pins can be connect to any audio widget */
4433         for (i = 0; i < cfg->line_outs; i++) {
4434                 nid = cfg->line_out_pins[i];
4435                 if (alc880_is_fixed_pin(nid))
4436                         continue;
4437                 /* search for an empty channel */
4438                 for (j = 0; j < cfg->line_outs; j++) {
4439                         if (!assigned[j]) {
4440                                 spec->multiout.dac_nids[i] =
4441                                         alc880_idx_to_dac(j);
4442                                 assigned[j] = 1;
4443                                 break;
4444                         }
4445                 }
4446         }
4447         spec->multiout.num_dacs = cfg->line_outs;
4448         return 0;
4449 }
4450
4451 /* add playback controls from the parsed DAC table */
4452 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4453                                              const struct auto_pin_cfg *cfg)
4454 {
4455         static const char *chname[4] = {
4456                 "Front", "Surround", NULL /*CLFE*/, "Side"
4457         };
4458         hda_nid_t nid;
4459         int i, err;
4460
4461         for (i = 0; i < cfg->line_outs; i++) {
4462                 if (!spec->multiout.dac_nids[i])
4463                         continue;
4464                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4465                 if (i == 2) {
4466                         /* Center/LFE */
4467                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4468                                               "Center",
4469                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4470                                                               HDA_OUTPUT));
4471                         if (err < 0)
4472                                 return err;
4473                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4474                                               "LFE",
4475                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4476                                                               HDA_OUTPUT));
4477                         if (err < 0)
4478                                 return err;
4479                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4480                                              "Center",
4481                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4482                                                               HDA_INPUT));
4483                         if (err < 0)
4484                                 return err;
4485                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4486                                              "LFE",
4487                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4488                                                               HDA_INPUT));
4489                         if (err < 0)
4490                                 return err;
4491                 } else {
4492                         const char *pfx;
4493                         if (cfg->line_outs == 1 &&
4494                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
4495                                 pfx = "Speaker";
4496                         else
4497                                 pfx = chname[i];
4498                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4499                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4500                                                               HDA_OUTPUT));
4501                         if (err < 0)
4502                                 return err;
4503                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4504                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4505                                                               HDA_INPUT));
4506                         if (err < 0)
4507                                 return err;
4508                 }
4509         }
4510         return 0;
4511 }
4512
4513 /* add playback controls for speaker and HP outputs */
4514 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4515                                         const char *pfx)
4516 {
4517         hda_nid_t nid;
4518         int err;
4519
4520         if (!pin)
4521                 return 0;
4522
4523         if (alc880_is_fixed_pin(pin)) {
4524                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4525                 /* specify the DAC as the extra output */
4526                 if (!spec->multiout.hp_nid)
4527                         spec->multiout.hp_nid = nid;
4528                 else
4529                         spec->multiout.extra_out_nid[0] = nid;
4530                 /* control HP volume/switch on the output mixer amp */
4531                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4532                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4533                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4534                 if (err < 0)
4535                         return err;
4536                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4537                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4538                 if (err < 0)
4539                         return err;
4540         } else if (alc880_is_multi_pin(pin)) {
4541                 /* set manual connection */
4542                 /* we have only a switch on HP-out PIN */
4543                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
4544                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4545                 if (err < 0)
4546                         return err;
4547         }
4548         return 0;
4549 }
4550
4551 /* create input playback/capture controls for the given pin */
4552 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4553                             const char *ctlname,
4554                             int idx, hda_nid_t mix_nid)
4555 {
4556         int err;
4557
4558         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
4559                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4560         if (err < 0)
4561                 return err;
4562         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
4563                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4564         if (err < 0)
4565                 return err;
4566         return 0;
4567 }
4568
4569 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
4570 {
4571         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
4572         return (pincap & AC_PINCAP_IN) != 0;
4573 }
4574
4575 /* create playback/capture controls for input pins */
4576 static int alc_auto_create_input_ctls(struct hda_codec *codec,
4577                                       const struct auto_pin_cfg *cfg,
4578                                       hda_nid_t mixer,
4579                                       hda_nid_t cap1, hda_nid_t cap2)
4580 {
4581         struct alc_spec *spec = codec->spec;
4582         struct hda_input_mux *imux = &spec->private_imux[0];
4583         int i, err, idx;
4584
4585         for (i = 0; i < AUTO_PIN_LAST; i++) {
4586                 hda_nid_t pin;
4587
4588                 pin = cfg->input_pins[i];
4589                 if (!alc_is_input_pin(codec, pin))
4590                         continue;
4591
4592                 if (mixer) {
4593                         idx = get_connection_index(codec, mixer, pin);
4594                         if (idx >= 0) {
4595                                 err = new_analog_input(spec, pin,
4596                                                        auto_pin_cfg_labels[i],
4597                                                        idx, mixer);
4598                                 if (err < 0)
4599                                         return err;
4600                         }
4601                 }
4602
4603                 if (!cap1)
4604                         continue;
4605                 idx = get_connection_index(codec, cap1, pin);
4606                 if (idx < 0 && cap2)
4607                         idx = get_connection_index(codec, cap2, pin);
4608                 if (idx >= 0) {
4609                         imux->items[imux->num_items].label =
4610                                 auto_pin_cfg_labels[i];
4611                         imux->items[imux->num_items].index = idx;
4612                         imux->num_items++;
4613                 }
4614         }
4615         return 0;
4616 }
4617
4618 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
4619                                                 const struct auto_pin_cfg *cfg)
4620 {
4621         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
4622 }
4623
4624 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4625                                unsigned int pin_type)
4626 {
4627         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4628                             pin_type);
4629         /* unmute pin */
4630         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4631                             AMP_OUT_UNMUTE);
4632 }
4633
4634 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4635                                               hda_nid_t nid, int pin_type,
4636                                               int dac_idx)
4637 {
4638         alc_set_pin_output(codec, nid, pin_type);
4639         /* need the manual connection? */
4640         if (alc880_is_multi_pin(nid)) {
4641                 struct alc_spec *spec = codec->spec;
4642                 int idx = alc880_multi_pin_idx(nid);
4643                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4644                                     AC_VERB_SET_CONNECT_SEL,
4645                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4646         }
4647 }
4648
4649 static int get_pin_type(int line_out_type)
4650 {
4651         if (line_out_type == AUTO_PIN_HP_OUT)
4652                 return PIN_HP;
4653         else
4654                 return PIN_OUT;
4655 }
4656
4657 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4658 {
4659         struct alc_spec *spec = codec->spec;
4660         int i;
4661
4662         for (i = 0; i < spec->autocfg.line_outs; i++) {
4663                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4664                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4665                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4666         }
4667 }
4668
4669 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4670 {
4671         struct alc_spec *spec = codec->spec;
4672         hda_nid_t pin;
4673
4674         pin = spec->autocfg.speaker_pins[0];
4675         if (pin) /* connect to front */
4676                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4677         pin = spec->autocfg.hp_pins[0];
4678         if (pin) /* connect to front */
4679                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4680 }
4681
4682 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4683 {
4684         struct alc_spec *spec = codec->spec;
4685         int i;
4686
4687         for (i = 0; i < AUTO_PIN_LAST; i++) {
4688                 hda_nid_t nid = spec->autocfg.input_pins[i];
4689                 if (alc_is_input_pin(codec, nid)) {
4690                         alc_set_input_pin(codec, nid, i);
4691                         if (nid != ALC880_PIN_CD_NID &&
4692                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4693                                 snd_hda_codec_write(codec, nid, 0,
4694                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4695                                                     AMP_OUT_MUTE);
4696                 }
4697         }
4698 }
4699
4700 /* parse the BIOS configuration and set up the alc_spec */
4701 /* return 1 if successful, 0 if the proper config is not found,
4702  * or a negative error code
4703  */
4704 static int alc880_parse_auto_config(struct hda_codec *codec)
4705 {
4706         struct alc_spec *spec = codec->spec;
4707         int i, err;
4708         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4709
4710         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4711                                            alc880_ignore);
4712         if (err < 0)
4713                 return err;
4714         if (!spec->autocfg.line_outs)
4715                 return 0; /* can't find valid BIOS pin config */
4716
4717         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4718         if (err < 0)
4719                 return err;
4720         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4721         if (err < 0)
4722                 return err;
4723         err = alc880_auto_create_extra_out(spec,
4724                                            spec->autocfg.speaker_pins[0],
4725                                            "Speaker");
4726         if (err < 0)
4727                 return err;
4728         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4729                                            "Headphone");
4730         if (err < 0)
4731                 return err;
4732         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
4733         if (err < 0)
4734                 return err;
4735
4736         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4737
4738         /* check multiple SPDIF-out (for recent codecs) */
4739         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4740                 hda_nid_t dig_nid;
4741                 err = snd_hda_get_connections(codec,
4742                                               spec->autocfg.dig_out_pins[i],
4743                                               &dig_nid, 1);
4744                 if (err < 0)
4745                         continue;
4746                 if (!i)
4747                         spec->multiout.dig_out_nid = dig_nid;
4748                 else {
4749                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4750                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
4751                                 break;
4752                         spec->slave_dig_outs[i - 1] = dig_nid;
4753                 }
4754         }
4755         if (spec->autocfg.dig_in_pin)
4756                 spec->dig_in_nid = ALC880_DIGIN_NID;
4757
4758         if (spec->kctls.list)
4759                 add_mixer(spec, spec->kctls.list);
4760
4761         add_verb(spec, alc880_volume_init_verbs);
4762
4763         spec->num_mux_defs = 1;
4764         spec->input_mux = &spec->private_imux[0];
4765
4766         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
4767
4768         return 1;
4769 }
4770
4771 /* additional initialization for auto-configuration model */
4772 static void alc880_auto_init(struct hda_codec *codec)
4773 {
4774         struct alc_spec *spec = codec->spec;
4775         alc880_auto_init_multi_out(codec);
4776         alc880_auto_init_extra_out(codec);
4777         alc880_auto_init_analog_input(codec);
4778         if (spec->unsol_event)
4779                 alc_inithook(codec);
4780 }
4781
4782 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
4783  * one of two digital mic pins, e.g. on ALC272
4784  */
4785 static void fixup_automic_adc(struct hda_codec *codec)
4786 {
4787         struct alc_spec *spec = codec->spec;
4788         int i;
4789
4790         for (i = 0; i < spec->num_adc_nids; i++) {
4791                 hda_nid_t cap = spec->capsrc_nids ?
4792                         spec->capsrc_nids[i] : spec->adc_nids[i];
4793                 int iidx, eidx;
4794
4795                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
4796                 if (iidx < 0)
4797                         continue;
4798                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
4799                 if (eidx < 0)
4800                         continue;
4801                 spec->int_mic.mux_idx = iidx;
4802                 spec->ext_mic.mux_idx = eidx;
4803                 if (spec->capsrc_nids)
4804                         spec->capsrc_nids += i;
4805                 spec->adc_nids += i;
4806                 spec->num_adc_nids = 1;
4807                 return;
4808         }
4809         snd_printd(KERN_INFO "hda_codec: %s: "
4810                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
4811                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
4812         spec->auto_mic = 0; /* disable auto-mic to be sure */
4813 }
4814
4815 static void set_capture_mixer(struct hda_codec *codec)
4816 {
4817         struct alc_spec *spec = codec->spec;
4818         static struct snd_kcontrol_new *caps[2][3] = {
4819                 { alc_capture_mixer_nosrc1,
4820                   alc_capture_mixer_nosrc2,
4821                   alc_capture_mixer_nosrc3 },
4822                 { alc_capture_mixer1,
4823                   alc_capture_mixer2,
4824                   alc_capture_mixer3 },
4825         };
4826         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4827                 int mux;
4828                 if (spec->auto_mic) {
4829                         mux = 0;
4830                         fixup_automic_adc(codec);
4831                 } else if (spec->input_mux && spec->input_mux->num_items > 1)
4832                         mux = 1;
4833                 else
4834                         mux = 0;
4835                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4836         }
4837 }
4838
4839 #ifdef CONFIG_SND_HDA_INPUT_BEEP
4840 #define set_beep_amp(spec, nid, idx, dir) \
4841         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4842 #else
4843 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
4844 #endif
4845
4846 /*
4847  * OK, here we have finally the patch for ALC880
4848  */
4849
4850 static int patch_alc880(struct hda_codec *codec)
4851 {
4852         struct alc_spec *spec;
4853         int board_config;
4854         int err;
4855
4856         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4857         if (spec == NULL)
4858                 return -ENOMEM;
4859
4860         codec->spec = spec;
4861
4862         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4863                                                   alc880_models,
4864                                                   alc880_cfg_tbl);
4865         if (board_config < 0) {
4866                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4867                        codec->chip_name);
4868                 board_config = ALC880_AUTO;
4869         }
4870
4871         if (board_config == ALC880_AUTO) {
4872                 /* automatic parse from the BIOS config */
4873                 err = alc880_parse_auto_config(codec);
4874                 if (err < 0) {
4875                         alc_free(codec);
4876                         return err;
4877                 } else if (!err) {
4878                         printk(KERN_INFO
4879                                "hda_codec: Cannot set up configuration "
4880                                "from BIOS.  Using 3-stack mode...\n");
4881                         board_config = ALC880_3ST;
4882                 }
4883         }
4884
4885         err = snd_hda_attach_beep_device(codec, 0x1);
4886         if (err < 0) {
4887                 alc_free(codec);
4888                 return err;
4889         }
4890
4891         if (board_config != ALC880_AUTO)
4892                 setup_preset(codec, &alc880_presets[board_config]);
4893
4894         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4895         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4896         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4897
4898         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4899         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4900
4901         if (!spec->adc_nids && spec->input_mux) {
4902                 /* check whether NID 0x07 is valid */
4903                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4904                 /* get type */
4905                 wcap = get_wcaps_type(wcap);
4906                 if (wcap != AC_WID_AUD_IN) {
4907                         spec->adc_nids = alc880_adc_nids_alt;
4908                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4909                 } else {
4910                         spec->adc_nids = alc880_adc_nids;
4911                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4912                 }
4913         }
4914         set_capture_mixer(codec);
4915         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4916
4917         spec->vmaster_nid = 0x0c;
4918
4919         codec->patch_ops = alc_patch_ops;
4920         if (board_config == ALC880_AUTO)
4921                 spec->init_hook = alc880_auto_init;
4922 #ifdef CONFIG_SND_HDA_POWER_SAVE
4923         if (!spec->loopback.amplist)
4924                 spec->loopback.amplist = alc880_loopbacks;
4925 #endif
4926         codec->proc_widget_hook = print_realtek_coef;
4927
4928         return 0;
4929 }
4930
4931
4932 /*
4933  * ALC260 support
4934  */
4935
4936 static hda_nid_t alc260_dac_nids[1] = {
4937         /* front */
4938         0x02,
4939 };
4940
4941 static hda_nid_t alc260_adc_nids[1] = {
4942         /* ADC0 */
4943         0x04,
4944 };
4945
4946 static hda_nid_t alc260_adc_nids_alt[1] = {
4947         /* ADC1 */
4948         0x05,
4949 };
4950
4951 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4952  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4953  */
4954 static hda_nid_t alc260_dual_adc_nids[2] = {
4955         /* ADC0, ADC1 */
4956         0x04, 0x05
4957 };
4958
4959 #define ALC260_DIGOUT_NID       0x03
4960 #define ALC260_DIGIN_NID        0x06
4961
4962 static struct hda_input_mux alc260_capture_source = {
4963         .num_items = 4,
4964         .items = {
4965                 { "Mic", 0x0 },
4966                 { "Front Mic", 0x1 },
4967                 { "Line", 0x2 },
4968                 { "CD", 0x4 },
4969         },
4970 };
4971
4972 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4973  * headphone jack and the internal CD lines since these are the only pins at
4974  * which audio can appear.  For flexibility, also allow the option of
4975  * recording the mixer output on the second ADC (ADC0 doesn't have a
4976  * connection to the mixer output).
4977  */
4978 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4979         {
4980                 .num_items = 3,
4981                 .items = {
4982                         { "Mic/Line", 0x0 },
4983                         { "CD", 0x4 },
4984                         { "Headphone", 0x2 },
4985                 },
4986         },
4987         {
4988                 .num_items = 4,
4989                 .items = {
4990                         { "Mic/Line", 0x0 },
4991                         { "CD", 0x4 },
4992                         { "Headphone", 0x2 },
4993                         { "Mixer", 0x5 },
4994                 },
4995         },
4996
4997 };
4998
4999 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5000  * the Fujitsu S702x, but jacks are marked differently.
5001  */
5002 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5003         {
5004                 .num_items = 4,
5005                 .items = {
5006                         { "Mic", 0x0 },
5007                         { "Line", 0x2 },
5008                         { "CD", 0x4 },
5009                         { "Headphone", 0x5 },
5010                 },
5011         },
5012         {
5013                 .num_items = 5,
5014                 .items = {
5015                         { "Mic", 0x0 },
5016                         { "Line", 0x2 },
5017                         { "CD", 0x4 },
5018                         { "Headphone", 0x6 },
5019                         { "Mixer", 0x5 },
5020                 },
5021         },
5022 };
5023
5024 /* Maxdata Favorit 100XS */
5025 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5026         {
5027                 .num_items = 2,
5028                 .items = {
5029                         { "Line/Mic", 0x0 },
5030                         { "CD", 0x4 },
5031                 },
5032         },
5033         {
5034                 .num_items = 3,
5035                 .items = {
5036                         { "Line/Mic", 0x0 },
5037                         { "CD", 0x4 },
5038                         { "Mixer", 0x5 },
5039                 },
5040         },
5041 };
5042
5043 /*
5044  * This is just place-holder, so there's something for alc_build_pcms to look
5045  * at when it calculates the maximum number of channels. ALC260 has no mixer
5046  * element which allows changing the channel mode, so the verb list is
5047  * never used.
5048  */
5049 static struct hda_channel_mode alc260_modes[1] = {
5050         { 2, NULL },
5051 };
5052
5053
5054 /* Mixer combinations
5055  *
5056  * basic: base_output + input + pc_beep + capture
5057  * HP: base_output + input + capture_alt
5058  * HP_3013: hp_3013 + input + capture
5059  * fujitsu: fujitsu + capture
5060  * acer: acer + capture
5061  */
5062
5063 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5064         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5065         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5066         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5067         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5068         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5069         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5070         { } /* end */
5071 };
5072
5073 static struct snd_kcontrol_new alc260_input_mixer[] = {
5074         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5075         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5076         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5077         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5078         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5079         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5080         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5081         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5082         { } /* end */
5083 };
5084
5085 /* update HP, line and mono out pins according to the master switch */
5086 static void alc260_hp_master_update(struct hda_codec *codec,
5087                                     hda_nid_t hp, hda_nid_t line,
5088                                     hda_nid_t mono)
5089 {
5090         struct alc_spec *spec = codec->spec;
5091         unsigned int val = spec->master_sw ? PIN_HP : 0;
5092         /* change HP and line-out pins */
5093         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5094                             val);
5095         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5096                             val);
5097         /* mono (speaker) depending on the HP jack sense */
5098         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5099         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5100                             val);
5101 }
5102
5103 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5104                                    struct snd_ctl_elem_value *ucontrol)
5105 {
5106         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5107         struct alc_spec *spec = codec->spec;
5108         *ucontrol->value.integer.value = spec->master_sw;
5109         return 0;
5110 }
5111
5112 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5113                                    struct snd_ctl_elem_value *ucontrol)
5114 {
5115         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5116         struct alc_spec *spec = codec->spec;
5117         int val = !!*ucontrol->value.integer.value;
5118         hda_nid_t hp, line, mono;
5119
5120         if (val == spec->master_sw)
5121                 return 0;
5122         spec->master_sw = val;
5123         hp = (kcontrol->private_value >> 16) & 0xff;
5124         line = (kcontrol->private_value >> 8) & 0xff;
5125         mono = kcontrol->private_value & 0xff;
5126         alc260_hp_master_update(codec, hp, line, mono);
5127         return 1;
5128 }
5129
5130 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5131         {
5132                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5133                 .name = "Master Playback Switch",
5134                 .info = snd_ctl_boolean_mono_info,
5135                 .get = alc260_hp_master_sw_get,
5136                 .put = alc260_hp_master_sw_put,
5137                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5138         },
5139         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5140         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5141         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5142         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5143         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5144                               HDA_OUTPUT),
5145         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5146         { } /* end */
5147 };
5148
5149 static struct hda_verb alc260_hp_unsol_verbs[] = {
5150         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5151         {},
5152 };
5153
5154 static void alc260_hp_automute(struct hda_codec *codec)
5155 {
5156         struct alc_spec *spec = codec->spec;
5157
5158         spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5159         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5160 }
5161
5162 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5163 {
5164         if ((res >> 26) == ALC880_HP_EVENT)
5165                 alc260_hp_automute(codec);
5166 }
5167
5168 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5169         {
5170                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5171                 .name = "Master Playback Switch",
5172                 .info = snd_ctl_boolean_mono_info,
5173                 .get = alc260_hp_master_sw_get,
5174                 .put = alc260_hp_master_sw_put,
5175                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5176         },
5177         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5178         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5179         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5180         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5181         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5182         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5183         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5184         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5185         { } /* end */
5186 };
5187
5188 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5189         .ops = &snd_hda_bind_vol,
5190         .values = {
5191                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5192                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5193                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5194                 0
5195         },
5196 };
5197
5198 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5199         .ops = &snd_hda_bind_sw,
5200         .values = {
5201                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5202                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5203                 0
5204         },
5205 };
5206
5207 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5208         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5209         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5210         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5211         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5212         { } /* end */
5213 };
5214
5215 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5216         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5217         {},
5218 };
5219
5220 static void alc260_hp_3013_automute(struct hda_codec *codec)
5221 {
5222         struct alc_spec *spec = codec->spec;
5223
5224         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
5225         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5226 }
5227
5228 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5229                                        unsigned int res)
5230 {
5231         if ((res >> 26) == ALC880_HP_EVENT)
5232                 alc260_hp_3013_automute(codec);
5233 }
5234
5235 static void alc260_hp_3012_automute(struct hda_codec *codec)
5236 {
5237         unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
5238
5239         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5240                             bits);
5241         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5242                             bits);
5243         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5244                             bits);
5245 }
5246
5247 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5248                                        unsigned int res)
5249 {
5250         if ((res >> 26) == ALC880_HP_EVENT)
5251                 alc260_hp_3012_automute(codec);
5252 }
5253
5254 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5255  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5256  */
5257 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5258         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5259         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5260         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5261         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5262         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5263         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5264         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5265         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5266         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5267         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5268         { } /* end */
5269 };
5270
5271 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5272  * versions of the ALC260 don't act on requests to enable mic bias from NID
5273  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5274  * datasheet doesn't mention this restriction.  At this stage it's not clear
5275  * whether this behaviour is intentional or is a hardware bug in chip
5276  * revisions available in early 2006.  Therefore for now allow the
5277  * "Headphone Jack Mode" control to span all choices, but if it turns out
5278  * that the lack of mic bias for this NID is intentional we could change the
5279  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5280  *
5281  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5282  * don't appear to make the mic bias available from the "line" jack, even
5283  * though the NID used for this jack (0x14) can supply it.  The theory is
5284  * that perhaps Acer have included blocking capacitors between the ALC260
5285  * and the output jack.  If this turns out to be the case for all such
5286  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5287  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5288  *
5289  * The C20x Tablet series have a mono internal speaker which is controlled
5290  * via the chip's Mono sum widget and pin complex, so include the necessary
5291  * controls for such models.  On models without a "mono speaker" the control
5292  * won't do anything.
5293  */
5294 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5295         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5296         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5297         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5298         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5299                               HDA_OUTPUT),
5300         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5301                            HDA_INPUT),
5302         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5303         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5304         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5305         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5306         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5307         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5308         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5309         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5310         { } /* end */
5311 };
5312
5313 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5314  */
5315 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5316         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5317         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5318         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5319         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5320         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5321         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5322         { } /* end */
5323 };
5324
5325 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5326  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5327  */
5328 static struct snd_kcontrol_new alc260_will_mixer[] = {
5329         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5330         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5331         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5332         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5333         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5334         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5335         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5336         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5337         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5338         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5339         { } /* end */
5340 };
5341
5342 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5343  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5344  */
5345 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5346         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5347         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5348         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5349         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5350         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5351         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
5352         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
5353         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5354         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5355         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5356         { } /* end */
5357 };
5358
5359 /*
5360  * initialization verbs
5361  */
5362 static struct hda_verb alc260_init_verbs[] = {
5363         /* Line In pin widget for input */
5364         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5365         /* CD pin widget for input */
5366         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5367         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5368         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5369         /* Mic2 (front panel) pin widget for input and vref at 80% */
5370         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5371         /* LINE-2 is used for line-out in rear */
5372         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5373         /* select line-out */
5374         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
5375         /* LINE-OUT pin */
5376         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5377         /* enable HP */
5378         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5379         /* enable Mono */
5380         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5381         /* mute capture amp left and right */
5382         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5383         /* set connection select to line in (default select for this ADC) */
5384         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5385         /* mute capture amp left and right */
5386         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5387         /* set connection select to line in (default select for this ADC) */
5388         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
5389         /* set vol=0 Line-Out mixer amp left and right */
5390         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5391         /* unmute pin widget amp left and right (no gain on this amp) */
5392         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5393         /* set vol=0 HP mixer amp left and right */
5394         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5395         /* unmute pin widget amp left and right (no gain on this amp) */
5396         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5397         /* set vol=0 Mono mixer amp left and right */
5398         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5399         /* unmute pin widget amp left and right (no gain on this amp) */
5400         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5401         /* unmute LINE-2 out pin */
5402         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5403         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5404          * Line In 2 = 0x03
5405          */
5406         /* mute analog inputs */
5407         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5408         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5409         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5410         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5411         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5412         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5413         /* mute Front out path */
5414         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5415         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5416         /* mute Headphone out path */
5417         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5418         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5419         /* mute Mono out path */
5420         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5421         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5422         { }
5423 };
5424
5425 #if 0 /* should be identical with alc260_init_verbs? */
5426 static struct hda_verb alc260_hp_init_verbs[] = {
5427         /* Headphone and output */
5428         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5429         /* mono output */
5430         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5431         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5432         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5433         /* Mic2 (front panel) pin widget for input and vref at 80% */
5434         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5435         /* Line In pin widget for input */
5436         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5437         /* Line-2 pin widget for output */
5438         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5439         /* CD pin widget for input */
5440         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5441         /* unmute amp left and right */
5442         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5443         /* set connection select to line in (default select for this ADC) */
5444         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5445         /* unmute Line-Out mixer amp left and right (volume = 0) */
5446         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5447         /* mute pin widget amp left and right (no gain on this amp) */
5448         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5449         /* unmute HP mixer amp left and right (volume = 0) */
5450         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5451         /* mute pin widget amp left and right (no gain on this amp) */
5452         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5453         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5454          * Line In 2 = 0x03
5455          */
5456         /* mute analog inputs */
5457         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5458         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5459         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5460         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5461         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5462         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5463         /* Unmute Front out path */
5464         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5465         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5466         /* Unmute Headphone out path */
5467         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5468         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5469         /* Unmute Mono out path */
5470         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5471         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5472         { }
5473 };
5474 #endif
5475
5476 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5477         /* Line out and output */
5478         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5479         /* mono output */
5480         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5481         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5482         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5483         /* Mic2 (front panel) pin widget for input and vref at 80% */
5484         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5485         /* Line In pin widget for input */
5486         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5487         /* Headphone pin widget for output */
5488         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5489         /* CD pin widget for input */
5490         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5491         /* unmute amp left and right */
5492         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5493         /* set connection select to line in (default select for this ADC) */
5494         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5495         /* unmute Line-Out mixer amp left and right (volume = 0) */
5496         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5497         /* mute pin widget amp left and right (no gain on this amp) */
5498         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5499         /* unmute HP mixer amp left and right (volume = 0) */
5500         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5501         /* mute pin widget amp left and right (no gain on this amp) */
5502         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5503         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5504          * Line In 2 = 0x03
5505          */
5506         /* mute analog inputs */
5507         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5508         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5509         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5510         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5511         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5512         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5513         /* Unmute Front out path */
5514         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5515         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5516         /* Unmute Headphone out path */
5517         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5518         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5519         /* Unmute Mono out path */
5520         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5521         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5522         { }
5523 };
5524
5525 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5526  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5527  * audio = 0x16, internal speaker = 0x10.
5528  */
5529 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5530         /* Disable all GPIOs */
5531         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5532         /* Internal speaker is connected to headphone pin */
5533         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5534         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5535         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5536         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5537         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5538         /* Ensure all other unused pins are disabled and muted. */
5539         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5540         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5541         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5542         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5543         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5544         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5545         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5546         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5547
5548         /* Disable digital (SPDIF) pins */
5549         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5550         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5551
5552         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5553          * when acting as an output.
5554          */
5555         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5556
5557         /* Start with output sum widgets muted and their output gains at min */
5558         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5559         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5560         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5561         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5562         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5563         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5564         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5565         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5566         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5567
5568         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5569         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5570         /* Unmute Line1 pin widget output buffer since it starts as an output.
5571          * If the pin mode is changed by the user the pin mode control will
5572          * take care of enabling the pin's input/output buffers as needed.
5573          * Therefore there's no need to enable the input buffer at this
5574          * stage.
5575          */
5576         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5577         /* Unmute input buffer of pin widget used for Line-in (no equiv
5578          * mixer ctrl)
5579          */
5580         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5581
5582         /* Mute capture amp left and right */
5583         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5584         /* Set ADC connection select to match default mixer setting - line
5585          * in (on mic1 pin)
5586          */
5587         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5588
5589         /* Do the same for the second ADC: mute capture input amp and
5590          * set ADC connection to line in (on mic1 pin)
5591          */
5592         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5593         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5594
5595         /* Mute all inputs to mixer widget (even unconnected ones) */
5596         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5597         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5598         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5599         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5600         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5601         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5602         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5603         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5604
5605         { }
5606 };
5607
5608 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5609  * similar laptops (adapted from Fujitsu init verbs).
5610  */
5611 static struct hda_verb alc260_acer_init_verbs[] = {
5612         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5613          * the headphone jack.  Turn this on and rely on the standard mute
5614          * methods whenever the user wants to turn these outputs off.
5615          */
5616         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5617         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5618         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5619         /* Internal speaker/Headphone jack is connected to Line-out pin */
5620         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5621         /* Internal microphone/Mic jack is connected to Mic1 pin */
5622         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5623         /* Line In jack is connected to Line1 pin */
5624         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5625         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5626         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5627         /* Ensure all other unused pins are disabled and muted. */
5628         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5629         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5630         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5631         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5632         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5633         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5634         /* Disable digital (SPDIF) pins */
5635         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5636         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5637
5638         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5639          * bus when acting as outputs.
5640          */
5641         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5642         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5643
5644         /* Start with output sum widgets muted and their output gains at min */
5645         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5646         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5647         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5648         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5649         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5650         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5651         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5652         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5653         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5654
5655         /* Unmute Line-out pin widget amp left and right
5656          * (no equiv mixer ctrl)
5657          */
5658         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5659         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5660         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5661         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5662          * inputs. If the pin mode is changed by the user the pin mode control
5663          * will take care of enabling the pin's input/output buffers as needed.
5664          * Therefore there's no need to enable the input buffer at this
5665          * stage.
5666          */
5667         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5668         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5669
5670         /* Mute capture amp left and right */
5671         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5672         /* Set ADC connection select to match default mixer setting - mic
5673          * (on mic1 pin)
5674          */
5675         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5676
5677         /* Do similar with the second ADC: mute capture input amp and
5678          * set ADC connection to mic to match ALSA's default state.
5679          */
5680         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5681         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5682
5683         /* Mute all inputs to mixer widget (even unconnected ones) */
5684         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5685         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5686         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5687         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5688         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5689         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5690         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5691         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5692
5693         { }
5694 };
5695
5696 /* Initialisation sequence for Maxdata Favorit 100XS
5697  * (adapted from Acer init verbs).
5698  */
5699 static struct hda_verb alc260_favorit100_init_verbs[] = {
5700         /* GPIO 0 enables the output jack.
5701          * Turn this on and rely on the standard mute
5702          * methods whenever the user wants to turn these outputs off.
5703          */
5704         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5705         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5706         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5707         /* Line/Mic input jack is connected to Mic1 pin */
5708         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5709         /* Ensure all other unused pins are disabled and muted. */
5710         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5711         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5712         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5713         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5714         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5715         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5716         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5717         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5718         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5719         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5720         /* Disable digital (SPDIF) pins */
5721         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5722         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5723
5724         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5725          * bus when acting as outputs.
5726          */
5727         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5728         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5729
5730         /* Start with output sum widgets muted and their output gains at min */
5731         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5732         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5733         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5734         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5735         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5736         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5737         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5738         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5739         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5740
5741         /* Unmute Line-out pin widget amp left and right
5742          * (no equiv mixer ctrl)
5743          */
5744         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5745         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5746          * inputs. If the pin mode is changed by the user the pin mode control
5747          * will take care of enabling the pin's input/output buffers as needed.
5748          * Therefore there's no need to enable the input buffer at this
5749          * stage.
5750          */
5751         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5752
5753         /* Mute capture amp left and right */
5754         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5755         /* Set ADC connection select to match default mixer setting - mic
5756          * (on mic1 pin)
5757          */
5758         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5759
5760         /* Do similar with the second ADC: mute capture input amp and
5761          * set ADC connection to mic to match ALSA's default state.
5762          */
5763         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5764         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5765
5766         /* Mute all inputs to mixer widget (even unconnected ones) */
5767         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5768         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5769         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5770         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5771         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5772         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5773         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5774         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5775
5776         { }
5777 };
5778
5779 static struct hda_verb alc260_will_verbs[] = {
5780         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5781         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5782         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5783         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5784         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5785         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5786         {}
5787 };
5788
5789 static struct hda_verb alc260_replacer_672v_verbs[] = {
5790         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5791         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5792         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5793
5794         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5795         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5796         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5797
5798         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5799         {}
5800 };
5801
5802 /* toggle speaker-output according to the hp-jack state */
5803 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5804 {
5805         unsigned int present;
5806
5807         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5808         present = snd_hda_jack_detect(codec, 0x0f);
5809         if (present) {
5810                 snd_hda_codec_write_cache(codec, 0x01, 0,
5811                                           AC_VERB_SET_GPIO_DATA, 1);
5812                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5813                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5814                                           PIN_HP);
5815         } else {
5816                 snd_hda_codec_write_cache(codec, 0x01, 0,
5817                                           AC_VERB_SET_GPIO_DATA, 0);
5818                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5819                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5820                                           PIN_OUT);
5821         }
5822 }
5823
5824 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5825                                        unsigned int res)
5826 {
5827         if ((res >> 26) == ALC880_HP_EVENT)
5828                 alc260_replacer_672v_automute(codec);
5829 }
5830
5831 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5832         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5833         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5834         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5835         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5836         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5837         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5838         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5839         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5840         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5841         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5842         {}
5843 };
5844
5845 /* Test configuration for debugging, modelled after the ALC880 test
5846  * configuration.
5847  */
5848 #ifdef CONFIG_SND_DEBUG
5849 static hda_nid_t alc260_test_dac_nids[1] = {
5850         0x02,
5851 };
5852 static hda_nid_t alc260_test_adc_nids[2] = {
5853         0x04, 0x05,
5854 };
5855 /* For testing the ALC260, each input MUX needs its own definition since
5856  * the signal assignments are different.  This assumes that the first ADC
5857  * is NID 0x04.
5858  */
5859 static struct hda_input_mux alc260_test_capture_sources[2] = {
5860         {
5861                 .num_items = 7,
5862                 .items = {
5863                         { "MIC1 pin", 0x0 },
5864                         { "MIC2 pin", 0x1 },
5865                         { "LINE1 pin", 0x2 },
5866                         { "LINE2 pin", 0x3 },
5867                         { "CD pin", 0x4 },
5868                         { "LINE-OUT pin", 0x5 },
5869                         { "HP-OUT pin", 0x6 },
5870                 },
5871         },
5872         {
5873                 .num_items = 8,
5874                 .items = {
5875                         { "MIC1 pin", 0x0 },
5876                         { "MIC2 pin", 0x1 },
5877                         { "LINE1 pin", 0x2 },
5878                         { "LINE2 pin", 0x3 },
5879                         { "CD pin", 0x4 },
5880                         { "Mixer", 0x5 },
5881                         { "LINE-OUT pin", 0x6 },
5882                         { "HP-OUT pin", 0x7 },
5883                 },
5884         },
5885 };
5886 static struct snd_kcontrol_new alc260_test_mixer[] = {
5887         /* Output driver widgets */
5888         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5889         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5890         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5891         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5892         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5893         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5894
5895         /* Modes for retasking pin widgets
5896          * Note: the ALC260 doesn't seem to act on requests to enable mic
5897          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5898          * mention this restriction.  At this stage it's not clear whether
5899          * this behaviour is intentional or is a hardware bug in chip
5900          * revisions available at least up until early 2006.  Therefore for
5901          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5902          * choices, but if it turns out that the lack of mic bias for these
5903          * NIDs is intentional we could change their modes from
5904          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5905          */
5906         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5907         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5908         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5909         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5910         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5911         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5912
5913         /* Loopback mixer controls */
5914         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5915         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5916         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5917         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5918         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5919         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5920         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5921         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5922         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5923         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5924         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5925         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5926         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5927         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5928
5929         /* Controls for GPIO pins, assuming they are configured as outputs */
5930         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5931         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5932         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5933         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5934
5935         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5936          * is ambigious as to which NID is which; testing on laptops which
5937          * make this output available should provide clarification.
5938          */
5939         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5940         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5941
5942         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5943          * this output to turn on an external amplifier.
5944          */
5945         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5946         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5947
5948         { } /* end */
5949 };
5950 static struct hda_verb alc260_test_init_verbs[] = {
5951         /* Enable all GPIOs as outputs with an initial value of 0 */
5952         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5953         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5954         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5955
5956         /* Enable retasking pins as output, initially without power amp */
5957         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5958         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5959         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5960         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5961         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5962         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5963
5964         /* Disable digital (SPDIF) pins initially, but users can enable
5965          * them via a mixer switch.  In the case of SPDIF-out, this initverb
5966          * payload also sets the generation to 0, output to be in "consumer"
5967          * PCM format, copyright asserted, no pre-emphasis and no validity
5968          * control.
5969          */
5970         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5971         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5972
5973         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5974          * OUT1 sum bus when acting as an output.
5975          */
5976         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5977         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5978         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5979         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5980
5981         /* Start with output sum widgets muted and their output gains at min */
5982         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5983         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5984         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5985         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5986         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5987         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5988         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5989         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5990         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5991
5992         /* Unmute retasking pin widget output buffers since the default
5993          * state appears to be output.  As the pin mode is changed by the
5994          * user the pin mode control will take care of enabling the pin's
5995          * input/output buffers as needed.
5996          */
5997         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5998         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5999         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6000         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6001         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6002         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6003         /* Also unmute the mono-out pin widget */
6004         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6005
6006         /* Mute capture amp left and right */
6007         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6008         /* Set ADC connection select to match default mixer setting (mic1
6009          * pin)
6010          */
6011         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6012
6013         /* Do the same for the second ADC: mute capture input amp and
6014          * set ADC connection to mic1 pin
6015          */
6016         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6017         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6018
6019         /* Mute all inputs to mixer widget (even unconnected ones) */
6020         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6021         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6022         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6023         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6024         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6025         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6026         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6027         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6028
6029         { }
6030 };
6031 #endif
6032
6033 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
6034 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
6035
6036 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
6037 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
6038
6039 /*
6040  * for BIOS auto-configuration
6041  */
6042
6043 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6044                                         const char *pfx, int *vol_bits)
6045 {
6046         hda_nid_t nid_vol;
6047         unsigned long vol_val, sw_val;
6048         int err;
6049
6050         if (nid >= 0x0f && nid < 0x11) {
6051                 nid_vol = nid - 0x7;
6052                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6053                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6054         } else if (nid == 0x11) {
6055                 nid_vol = nid - 0x7;
6056                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6057                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6058         } else if (nid >= 0x12 && nid <= 0x15) {
6059                 nid_vol = 0x08;
6060                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6061                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6062         } else
6063                 return 0; /* N/A */
6064
6065         if (!(*vol_bits & (1 << nid_vol))) {
6066                 /* first control for the volume widget */
6067                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6068                 if (err < 0)
6069                         return err;
6070                 *vol_bits |= (1 << nid_vol);
6071         }
6072         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6073         if (err < 0)
6074                 return err;
6075         return 1;
6076 }
6077
6078 /* add playback controls from the parsed DAC table */
6079 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6080                                              const struct auto_pin_cfg *cfg)
6081 {
6082         hda_nid_t nid;
6083         int err;
6084         int vols = 0;
6085
6086         spec->multiout.num_dacs = 1;
6087         spec->multiout.dac_nids = spec->private_dac_nids;
6088         spec->multiout.dac_nids[0] = 0x02;
6089
6090         nid = cfg->line_out_pins[0];
6091         if (nid) {
6092                 const char *pfx;
6093                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6094                         pfx = "Master";
6095                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6096                         pfx = "Speaker";
6097                 else
6098                         pfx = "Front";
6099                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6100                 if (err < 0)
6101                         return err;
6102         }
6103
6104         nid = cfg->speaker_pins[0];
6105         if (nid) {
6106                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6107                 if (err < 0)
6108                         return err;
6109         }
6110
6111         nid = cfg->hp_pins[0];
6112         if (nid) {
6113                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6114                                                    &vols);
6115                 if (err < 0)
6116                         return err;
6117         }
6118         return 0;
6119 }
6120
6121 /* create playback/capture controls for input pins */
6122 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6123                                                 const struct auto_pin_cfg *cfg)
6124 {
6125         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6126 }
6127
6128 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6129                                               hda_nid_t nid, int pin_type,
6130                                               int sel_idx)
6131 {
6132         alc_set_pin_output(codec, nid, pin_type);
6133         /* need the manual connection? */
6134         if (nid >= 0x12) {
6135                 int idx = nid - 0x12;
6136                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6137                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6138         }
6139 }
6140
6141 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6142 {
6143         struct alc_spec *spec = codec->spec;
6144         hda_nid_t nid;
6145
6146         nid = spec->autocfg.line_out_pins[0];
6147         if (nid) {
6148                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6149                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6150         }
6151
6152         nid = spec->autocfg.speaker_pins[0];
6153         if (nid)
6154                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6155
6156         nid = spec->autocfg.hp_pins[0];
6157         if (nid)
6158                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6159 }
6160
6161 #define ALC260_PIN_CD_NID               0x16
6162 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6163 {
6164         struct alc_spec *spec = codec->spec;
6165         int i;
6166
6167         for (i = 0; i < AUTO_PIN_LAST; i++) {
6168                 hda_nid_t nid = spec->autocfg.input_pins[i];
6169                 if (nid >= 0x12) {
6170                         alc_set_input_pin(codec, nid, i);
6171                         if (nid != ALC260_PIN_CD_NID &&
6172                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6173                                 snd_hda_codec_write(codec, nid, 0,
6174                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6175                                                     AMP_OUT_MUTE);
6176                 }
6177         }
6178 }
6179
6180 /*
6181  * generic initialization of ADC, input mixers and output mixers
6182  */
6183 static struct hda_verb alc260_volume_init_verbs[] = {
6184         /*
6185          * Unmute ADC0-1 and set the default input to mic-in
6186          */
6187         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6188         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6189         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6190         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6191
6192         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6193          * mixer widget
6194          * Note: PASD motherboards uses the Line In 2 as the input for
6195          * front panel mic (mic 2)
6196          */
6197         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6198         /* mute analog inputs */
6199         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6200         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6201         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6202         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6203         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6204
6205         /*
6206          * Set up output mixers (0x08 - 0x0a)
6207          */
6208         /* set vol=0 to output mixers */
6209         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6210         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6211         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6212         /* set up input amps for analog loopback */
6213         /* Amp Indices: DAC = 0, mixer = 1 */
6214         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6215         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6216         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6217         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6218         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6219         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6220
6221         { }
6222 };
6223
6224 static int alc260_parse_auto_config(struct hda_codec *codec)
6225 {
6226         struct alc_spec *spec = codec->spec;
6227         int err;
6228         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6229
6230         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6231                                            alc260_ignore);
6232         if (err < 0)
6233                 return err;
6234         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6235         if (err < 0)
6236                 return err;
6237         if (!spec->kctls.list)
6238                 return 0; /* can't find valid BIOS pin config */
6239         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
6240         if (err < 0)
6241                 return err;
6242
6243         spec->multiout.max_channels = 2;
6244
6245         if (spec->autocfg.dig_outs)
6246                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6247         if (spec->kctls.list)
6248                 add_mixer(spec, spec->kctls.list);
6249
6250         add_verb(spec, alc260_volume_init_verbs);
6251
6252         spec->num_mux_defs = 1;
6253         spec->input_mux = &spec->private_imux[0];
6254
6255         alc_ssid_check(codec, 0x10, 0x15, 0x0f);
6256
6257         return 1;
6258 }
6259
6260 /* additional initialization for auto-configuration model */
6261 static void alc260_auto_init(struct hda_codec *codec)
6262 {
6263         struct alc_spec *spec = codec->spec;
6264         alc260_auto_init_multi_out(codec);
6265         alc260_auto_init_analog_input(codec);
6266         if (spec->unsol_event)
6267                 alc_inithook(codec);
6268 }
6269
6270 #ifdef CONFIG_SND_HDA_POWER_SAVE
6271 static struct hda_amp_list alc260_loopbacks[] = {
6272         { 0x07, HDA_INPUT, 0 },
6273         { 0x07, HDA_INPUT, 1 },
6274         { 0x07, HDA_INPUT, 2 },
6275         { 0x07, HDA_INPUT, 3 },
6276         { 0x07, HDA_INPUT, 4 },
6277         { } /* end */
6278 };
6279 #endif
6280
6281 /*
6282  * ALC260 configurations
6283  */
6284 static const char *alc260_models[ALC260_MODEL_LAST] = {
6285         [ALC260_BASIC]          = "basic",
6286         [ALC260_HP]             = "hp",
6287         [ALC260_HP_3013]        = "hp-3013",
6288         [ALC260_HP_DC7600]      = "hp-dc7600",
6289         [ALC260_FUJITSU_S702X]  = "fujitsu",
6290         [ALC260_ACER]           = "acer",
6291         [ALC260_WILL]           = "will",
6292         [ALC260_REPLACER_672V]  = "replacer",
6293         [ALC260_FAVORIT100]     = "favorit100",
6294 #ifdef CONFIG_SND_DEBUG
6295         [ALC260_TEST]           = "test",
6296 #endif
6297         [ALC260_AUTO]           = "auto",
6298 };
6299
6300 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6301         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6302         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
6303         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6304         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6305         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6306         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
6307         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6308         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6309         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6310         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6311         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6312         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6313         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6314         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6315         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6316         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6317         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6318         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6319         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6320         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6321         {}
6322 };
6323
6324 static struct alc_config_preset alc260_presets[] = {
6325         [ALC260_BASIC] = {
6326                 .mixers = { alc260_base_output_mixer,
6327                             alc260_input_mixer },
6328                 .init_verbs = { alc260_init_verbs },
6329                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6330                 .dac_nids = alc260_dac_nids,
6331                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6332                 .adc_nids = alc260_adc_nids,
6333                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6334                 .channel_mode = alc260_modes,
6335                 .input_mux = &alc260_capture_source,
6336         },
6337         [ALC260_HP] = {
6338                 .mixers = { alc260_hp_output_mixer,
6339                             alc260_input_mixer },
6340                 .init_verbs = { alc260_init_verbs,
6341                                 alc260_hp_unsol_verbs },
6342                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6343                 .dac_nids = alc260_dac_nids,
6344                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6345                 .adc_nids = alc260_adc_nids_alt,
6346                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6347                 .channel_mode = alc260_modes,
6348                 .input_mux = &alc260_capture_source,
6349                 .unsol_event = alc260_hp_unsol_event,
6350                 .init_hook = alc260_hp_automute,
6351         },
6352         [ALC260_HP_DC7600] = {
6353                 .mixers = { alc260_hp_dc7600_mixer,
6354                             alc260_input_mixer },
6355                 .init_verbs = { alc260_init_verbs,
6356                                 alc260_hp_dc7600_verbs },
6357                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6358                 .dac_nids = alc260_dac_nids,
6359                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6360                 .adc_nids = alc260_adc_nids_alt,
6361                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6362                 .channel_mode = alc260_modes,
6363                 .input_mux = &alc260_capture_source,
6364                 .unsol_event = alc260_hp_3012_unsol_event,
6365                 .init_hook = alc260_hp_3012_automute,
6366         },
6367         [ALC260_HP_3013] = {
6368                 .mixers = { alc260_hp_3013_mixer,
6369                             alc260_input_mixer },
6370                 .init_verbs = { alc260_hp_3013_init_verbs,
6371                                 alc260_hp_3013_unsol_verbs },
6372                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6373                 .dac_nids = alc260_dac_nids,
6374                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6375                 .adc_nids = alc260_adc_nids_alt,
6376                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6377                 .channel_mode = alc260_modes,
6378                 .input_mux = &alc260_capture_source,
6379                 .unsol_event = alc260_hp_3013_unsol_event,
6380                 .init_hook = alc260_hp_3013_automute,
6381         },
6382         [ALC260_FUJITSU_S702X] = {
6383                 .mixers = { alc260_fujitsu_mixer },
6384                 .init_verbs = { alc260_fujitsu_init_verbs },
6385                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6386                 .dac_nids = alc260_dac_nids,
6387                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6388                 .adc_nids = alc260_dual_adc_nids,
6389                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6390                 .channel_mode = alc260_modes,
6391                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
6392                 .input_mux = alc260_fujitsu_capture_sources,
6393         },
6394         [ALC260_ACER] = {
6395                 .mixers = { alc260_acer_mixer },
6396                 .init_verbs = { alc260_acer_init_verbs },
6397                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6398                 .dac_nids = alc260_dac_nids,
6399                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6400                 .adc_nids = alc260_dual_adc_nids,
6401                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6402                 .channel_mode = alc260_modes,
6403                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
6404                 .input_mux = alc260_acer_capture_sources,
6405         },
6406         [ALC260_FAVORIT100] = {
6407                 .mixers = { alc260_favorit100_mixer },
6408                 .init_verbs = { alc260_favorit100_init_verbs },
6409                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6410                 .dac_nids = alc260_dac_nids,
6411                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6412                 .adc_nids = alc260_dual_adc_nids,
6413                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6414                 .channel_mode = alc260_modes,
6415                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6416                 .input_mux = alc260_favorit100_capture_sources,
6417         },
6418         [ALC260_WILL] = {
6419                 .mixers = { alc260_will_mixer },
6420                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
6421                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6422                 .dac_nids = alc260_dac_nids,
6423                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6424                 .adc_nids = alc260_adc_nids,
6425                 .dig_out_nid = ALC260_DIGOUT_NID,
6426                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6427                 .channel_mode = alc260_modes,
6428                 .input_mux = &alc260_capture_source,
6429         },
6430         [ALC260_REPLACER_672V] = {
6431                 .mixers = { alc260_replacer_672v_mixer },
6432                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6433                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6434                 .dac_nids = alc260_dac_nids,
6435                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6436                 .adc_nids = alc260_adc_nids,
6437                 .dig_out_nid = ALC260_DIGOUT_NID,
6438                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6439                 .channel_mode = alc260_modes,
6440                 .input_mux = &alc260_capture_source,
6441                 .unsol_event = alc260_replacer_672v_unsol_event,
6442                 .init_hook = alc260_replacer_672v_automute,
6443         },
6444 #ifdef CONFIG_SND_DEBUG
6445         [ALC260_TEST] = {
6446                 .mixers = { alc260_test_mixer },
6447                 .init_verbs = { alc260_test_init_verbs },
6448                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6449                 .dac_nids = alc260_test_dac_nids,
6450                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6451                 .adc_nids = alc260_test_adc_nids,
6452                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6453                 .channel_mode = alc260_modes,
6454                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6455                 .input_mux = alc260_test_capture_sources,
6456         },
6457 #endif
6458 };
6459
6460 static int patch_alc260(struct hda_codec *codec)
6461 {
6462         struct alc_spec *spec;
6463         int err, board_config;
6464
6465         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6466         if (spec == NULL)
6467                 return -ENOMEM;
6468
6469         codec->spec = spec;
6470
6471         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6472                                                   alc260_models,
6473                                                   alc260_cfg_tbl);
6474         if (board_config < 0) {
6475                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6476                            codec->chip_name);
6477                 board_config = ALC260_AUTO;
6478         }
6479
6480         if (board_config == ALC260_AUTO) {
6481                 /* automatic parse from the BIOS config */
6482                 err = alc260_parse_auto_config(codec);
6483                 if (err < 0) {
6484                         alc_free(codec);
6485                         return err;
6486                 } else if (!err) {
6487                         printk(KERN_INFO
6488                                "hda_codec: Cannot set up configuration "
6489                                "from BIOS.  Using base mode...\n");
6490                         board_config = ALC260_BASIC;
6491                 }
6492         }
6493
6494         err = snd_hda_attach_beep_device(codec, 0x1);
6495         if (err < 0) {
6496                 alc_free(codec);
6497                 return err;
6498         }
6499
6500         if (board_config != ALC260_AUTO)
6501                 setup_preset(codec, &alc260_presets[board_config]);
6502
6503         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6504         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6505
6506         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6507         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6508
6509         if (!spec->adc_nids && spec->input_mux) {
6510                 /* check whether NID 0x04 is valid */
6511                 unsigned int wcap = get_wcaps(codec, 0x04);
6512                 wcap = get_wcaps_type(wcap);
6513                 /* get type */
6514                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6515                         spec->adc_nids = alc260_adc_nids_alt;
6516                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6517                 } else {
6518                         spec->adc_nids = alc260_adc_nids;
6519                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6520                 }
6521         }
6522         set_capture_mixer(codec);
6523         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6524
6525         spec->vmaster_nid = 0x08;
6526
6527         codec->patch_ops = alc_patch_ops;
6528         if (board_config == ALC260_AUTO)
6529                 spec->init_hook = alc260_auto_init;
6530 #ifdef CONFIG_SND_HDA_POWER_SAVE
6531         if (!spec->loopback.amplist)
6532                 spec->loopback.amplist = alc260_loopbacks;
6533 #endif
6534         codec->proc_widget_hook = print_realtek_coef;
6535
6536         return 0;
6537 }
6538
6539
6540 /*
6541  * ALC882/883/885/888/889 support
6542  *
6543  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6544  * configuration.  Each pin widget can choose any input DACs and a mixer.
6545  * Each ADC is connected from a mixer of all inputs.  This makes possible
6546  * 6-channel independent captures.
6547  *
6548  * In addition, an independent DAC for the multi-playback (not used in this
6549  * driver yet).
6550  */
6551 #define ALC882_DIGOUT_NID       0x06
6552 #define ALC882_DIGIN_NID        0x0a
6553 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
6554 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
6555 #define ALC1200_DIGOUT_NID      0x10
6556
6557
6558 static struct hda_channel_mode alc882_ch_modes[1] = {
6559         { 8, NULL }
6560 };
6561
6562 /* DACs */
6563 static hda_nid_t alc882_dac_nids[4] = {
6564         /* front, rear, clfe, rear_surr */
6565         0x02, 0x03, 0x04, 0x05
6566 };
6567 #define alc883_dac_nids         alc882_dac_nids
6568
6569 /* ADCs */
6570 #define alc882_adc_nids         alc880_adc_nids
6571 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6572 #define alc883_adc_nids         alc882_adc_nids_alt
6573 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
6574 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
6575 #define alc889_adc_nids         alc880_adc_nids
6576
6577 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6578 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6579 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
6580 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
6581 #define alc889_capsrc_nids      alc882_capsrc_nids
6582
6583 /* input MUX */
6584 /* FIXME: should be a matrix-type input source selection */
6585
6586 static struct hda_input_mux alc882_capture_source = {
6587         .num_items = 4,
6588         .items = {
6589                 { "Mic", 0x0 },
6590                 { "Front Mic", 0x1 },
6591                 { "Line", 0x2 },
6592                 { "CD", 0x4 },
6593         },
6594 };
6595
6596 #define alc883_capture_source   alc882_capture_source
6597
6598 static struct hda_input_mux alc889_capture_source = {
6599         .num_items = 3,
6600         .items = {
6601                 { "Front Mic", 0x0 },
6602                 { "Mic", 0x3 },
6603                 { "Line", 0x2 },
6604         },
6605 };
6606
6607 static struct hda_input_mux mb5_capture_source = {
6608         .num_items = 3,
6609         .items = {
6610                 { "Mic", 0x1 },
6611                 { "Line", 0x2 },
6612                 { "CD", 0x4 },
6613         },
6614 };
6615
6616 static struct hda_input_mux alc883_3stack_6ch_intel = {
6617         .num_items = 4,
6618         .items = {
6619                 { "Mic", 0x1 },
6620                 { "Front Mic", 0x0 },
6621                 { "Line", 0x2 },
6622                 { "CD", 0x4 },
6623         },
6624 };
6625
6626 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6627         .num_items = 2,
6628         .items = {
6629                 { "Mic", 0x1 },
6630                 { "Line", 0x2 },
6631         },
6632 };
6633
6634 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6635         .num_items = 4,
6636         .items = {
6637                 { "Mic", 0x0 },
6638                 { "iMic", 0x1 },
6639                 { "Line", 0x2 },
6640                 { "CD", 0x4 },
6641         },
6642 };
6643
6644 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6645         .num_items = 2,
6646         .items = {
6647                 { "Mic", 0x0 },
6648                 { "Int Mic", 0x1 },
6649         },
6650 };
6651
6652 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6653         .num_items = 3,
6654         .items = {
6655                 { "Mic", 0x0 },
6656                 { "Front Mic", 0x1 },
6657                 { "Line", 0x4 },
6658         },
6659 };
6660
6661 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6662         .num_items = 2,
6663         .items = {
6664                 { "Mic", 0x0 },
6665                 { "Line", 0x2 },
6666         },
6667 };
6668
6669 static struct hda_input_mux alc889A_mb31_capture_source = {
6670         .num_items = 2,
6671         .items = {
6672                 { "Mic", 0x0 },
6673                 /* Front Mic (0x01) unused */
6674                 { "Line", 0x2 },
6675                 /* Line 2 (0x03) unused */
6676                 /* CD (0x04) unsused? */
6677         },
6678 };
6679
6680 /*
6681  * 2ch mode
6682  */
6683 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6684         { 2, NULL }
6685 };
6686
6687 /*
6688  * 2ch mode
6689  */
6690 static struct hda_verb alc882_3ST_ch2_init[] = {
6691         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6692         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6693         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6694         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6695         { } /* end */
6696 };
6697
6698 /*
6699  * 4ch mode
6700  */
6701 static struct hda_verb alc882_3ST_ch4_init[] = {
6702         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6703         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6704         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6705         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6706         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6707         { } /* end */
6708 };
6709
6710 /*
6711  * 6ch mode
6712  */
6713 static struct hda_verb alc882_3ST_ch6_init[] = {
6714         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6715         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6716         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6717         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6718         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6719         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6720         { } /* end */
6721 };
6722
6723 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
6724         { 2, alc882_3ST_ch2_init },
6725         { 4, alc882_3ST_ch4_init },
6726         { 6, alc882_3ST_ch6_init },
6727 };
6728
6729 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
6730
6731 /*
6732  * 2ch mode
6733  */
6734 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
6735         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
6736         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6737         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6738         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6739         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6740         { } /* end */
6741 };
6742
6743 /*
6744  * 4ch mode
6745  */
6746 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
6747         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6748         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6749         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6750         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6751         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6752         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6753         { } /* end */
6754 };
6755
6756 /*
6757  * 6ch mode
6758  */
6759 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
6760         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6761         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6762         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6763         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6764         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6765         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6766         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6767         { } /* end */
6768 };
6769
6770 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
6771         { 2, alc883_3ST_ch2_clevo_init },
6772         { 4, alc883_3ST_ch4_clevo_init },
6773         { 6, alc883_3ST_ch6_clevo_init },
6774 };
6775
6776
6777 /*
6778  * 6ch mode
6779  */
6780 static struct hda_verb alc882_sixstack_ch6_init[] = {
6781         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6782         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6783         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6784         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6785         { } /* end */
6786 };
6787
6788 /*
6789  * 8ch mode
6790  */
6791 static struct hda_verb alc882_sixstack_ch8_init[] = {
6792         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6793         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6794         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6795         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6796         { } /* end */
6797 };
6798
6799 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6800         { 6, alc882_sixstack_ch6_init },
6801         { 8, alc882_sixstack_ch8_init },
6802 };
6803
6804 /*
6805  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
6806  */
6807
6808 /*
6809  * 2ch mode
6810  */
6811 static struct hda_verb alc885_mbp_ch2_init[] = {
6812         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6813         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6814         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6815         { } /* end */
6816 };
6817
6818 /*
6819  * 4ch mode
6820  */
6821 static struct hda_verb alc885_mbp_ch4_init[] = {
6822         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6823         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6824         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6825         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6826         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6827         { } /* end */
6828 };
6829
6830 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
6831         { 2, alc885_mbp_ch2_init },
6832         { 4, alc885_mbp_ch4_init },
6833 };
6834
6835 /*
6836  * 2ch
6837  * Speakers/Woofer/HP = Front
6838  * LineIn = Input
6839  */
6840 static struct hda_verb alc885_mb5_ch2_init[] = {
6841         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6842         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6843         { } /* end */
6844 };
6845
6846 /*
6847  * 6ch mode
6848  * Speakers/HP = Front
6849  * Woofer = LFE
6850  * LineIn = Surround
6851  */
6852 static struct hda_verb alc885_mb5_ch6_init[] = {
6853         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6854         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6855         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6856         { } /* end */
6857 };
6858
6859 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
6860         { 2, alc885_mb5_ch2_init },
6861         { 6, alc885_mb5_ch6_init },
6862 };
6863
6864
6865 /*
6866  * 2ch mode
6867  */
6868 static struct hda_verb alc883_4ST_ch2_init[] = {
6869         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6870         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6871         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6872         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6873         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6874         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6875         { } /* end */
6876 };
6877
6878 /*
6879  * 4ch mode
6880  */
6881 static struct hda_verb alc883_4ST_ch4_init[] = {
6882         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6883         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6884         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6885         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6886         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6887         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6888         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6889         { } /* end */
6890 };
6891
6892 /*
6893  * 6ch mode
6894  */
6895 static struct hda_verb alc883_4ST_ch6_init[] = {
6896         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6897         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6898         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6899         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6900         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6901         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6902         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6903         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6904         { } /* end */
6905 };
6906
6907 /*
6908  * 8ch mode
6909  */
6910 static struct hda_verb alc883_4ST_ch8_init[] = {
6911         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6912         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6913         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6914         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6915         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6916         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6917         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6918         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6919         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6920         { } /* end */
6921 };
6922
6923 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
6924         { 2, alc883_4ST_ch2_init },
6925         { 4, alc883_4ST_ch4_init },
6926         { 6, alc883_4ST_ch6_init },
6927         { 8, alc883_4ST_ch8_init },
6928 };
6929
6930
6931 /*
6932  * 2ch mode
6933  */
6934 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
6935         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6936         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6937         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6938         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6939         { } /* end */
6940 };
6941
6942 /*
6943  * 4ch mode
6944  */
6945 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
6946         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6947         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6948         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6949         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6950         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6951         { } /* end */
6952 };
6953
6954 /*
6955  * 6ch mode
6956  */
6957 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
6958         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6959         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6960         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
6961         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6962         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6963         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6964         { } /* end */
6965 };
6966
6967 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
6968         { 2, alc883_3ST_ch2_intel_init },
6969         { 4, alc883_3ST_ch4_intel_init },
6970         { 6, alc883_3ST_ch6_intel_init },
6971 };
6972
6973 /*
6974  * 2ch mode
6975  */
6976 static struct hda_verb alc889_ch2_intel_init[] = {
6977         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
6978         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
6979         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
6980         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
6981         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6982         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6983         { } /* end */
6984 };
6985
6986 /*
6987  * 6ch mode
6988  */
6989 static struct hda_verb alc889_ch6_intel_init[] = {
6990         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
6991         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
6992         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
6993         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6994         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6995         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6996         { } /* end */
6997 };
6998
6999 /*
7000  * 8ch mode
7001  */
7002 static struct hda_verb alc889_ch8_intel_init[] = {
7003         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7004         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7005         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7006         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7007         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7008         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7009         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7010         { } /* end */
7011 };
7012
7013 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7014         { 2, alc889_ch2_intel_init },
7015         { 6, alc889_ch6_intel_init },
7016         { 8, alc889_ch8_intel_init },
7017 };
7018
7019 /*
7020  * 6ch mode
7021  */
7022 static struct hda_verb alc883_sixstack_ch6_init[] = {
7023         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7024         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7025         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7026         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7027         { } /* end */
7028 };
7029
7030 /*
7031  * 8ch mode
7032  */
7033 static struct hda_verb alc883_sixstack_ch8_init[] = {
7034         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7035         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7036         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7037         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7038         { } /* end */
7039 };
7040
7041 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7042         { 6, alc883_sixstack_ch6_init },
7043         { 8, alc883_sixstack_ch8_init },
7044 };
7045
7046
7047 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7048  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7049  */
7050 static struct snd_kcontrol_new alc882_base_mixer[] = {
7051         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7052         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7053         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7054         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7055         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7056         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7057         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7058         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7059         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7060         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7061         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7062         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7063         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7064         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7065         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7066         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7067         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7068         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7069         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7070         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7071         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7072         { } /* end */
7073 };
7074
7075 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7076         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7077         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7078         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7079         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7080         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7081         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7082         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7083         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7084         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7085         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7086         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7087         { } /* end */
7088 };
7089
7090 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7091         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7092         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7093         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7094         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7095         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7096         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7097         HDA_CODEC_VOLUME("HP Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7098         HDA_BIND_MUTE   ("HP Playback Switch", 0x0f, 0x02, HDA_INPUT),
7099         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7100         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7101         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7102         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7103         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7104         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7105         { } /* end */
7106 };
7107
7108 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7109         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7110         HDA_BIND_MUTE   ("Line-Out Playback Switch", 0x0c, 0x02, HDA_INPUT),
7111         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
7112         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7113         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7114         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7115         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7116         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7117         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7118         { } /* end */
7119 };
7120
7121
7122 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7123         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7124         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7125         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7126         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7127         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7128         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7129         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7130         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7131         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7132         { } /* end */
7133 };
7134
7135 static struct snd_kcontrol_new alc882_targa_mixer[] = {
7136         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7137         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7138         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7139         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7140         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7141         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7142         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7143         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7144         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7145         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7146         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7147         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7148         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7149         { } /* end */
7150 };
7151
7152 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
7153  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
7154  */
7155 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
7156         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7157         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7158         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7159         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
7160         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7161         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7162         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7163         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7164         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
7165         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
7166         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7167         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7168         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7169         { } /* end */
7170 };
7171
7172 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7173         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7174         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7175         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7176         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7177         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7178         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7179         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7180         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7181         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7182         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7183         { } /* end */
7184 };
7185
7186 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7187         {
7188                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7189                 .name = "Channel Mode",
7190                 .info = alc_ch_mode_info,
7191                 .get = alc_ch_mode_get,
7192                 .put = alc_ch_mode_put,
7193         },
7194         { } /* end */
7195 };
7196
7197 static struct hda_verb alc882_base_init_verbs[] = {
7198         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7199         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7200         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7201         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7202         /* Rear mixer */
7203         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7204         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7205         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7206         /* CLFE mixer */
7207         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7208         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7209         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7210         /* Side mixer */
7211         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7212         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7213         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7214
7215         /* mute analog input loopbacks */
7216         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7217         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7218         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7219         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7220         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7221
7222         /* Front Pin: output 0 (0x0c) */
7223         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7224         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7225         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7226         /* Rear Pin: output 1 (0x0d) */
7227         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7228         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7229         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7230         /* CLFE Pin: output 2 (0x0e) */
7231         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7232         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7233         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7234         /* Side Pin: output 3 (0x0f) */
7235         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7236         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7237         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7238         /* Mic (rear) pin: input vref at 80% */
7239         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7240         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7241         /* Front Mic pin: input vref at 80% */
7242         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7243         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7244         /* Line In pin: input */
7245         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7246         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7247         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7248         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7249         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7250         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7251         /* CD pin widget for input */
7252         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7253
7254         /* FIXME: use matrix-type input source selection */
7255         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7256         /* Input mixer2 */
7257         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7258         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7259         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7260         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7261         /* Input mixer3 */
7262         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7263         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7264         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7265         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7266         /* ADC2: mute amp left and right */
7267         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7268         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7269         /* ADC3: mute amp left and right */
7270         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7271         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7272
7273         { }
7274 };
7275
7276 static struct hda_verb alc882_adc1_init_verbs[] = {
7277         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7278         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7279         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7280         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7281         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7282         /* ADC1: mute amp left and right */
7283         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7284         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7285         { }
7286 };
7287
7288 static struct hda_verb alc882_eapd_verbs[] = {
7289         /* change to EAPD mode */
7290         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7291         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
7292         { }
7293 };
7294
7295 static struct hda_verb alc889_eapd_verbs[] = {
7296         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
7297         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
7298         { }
7299 };
7300
7301 static struct hda_verb alc_hp15_unsol_verbs[] = {
7302         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
7303         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7304         {}
7305 };
7306
7307 static struct hda_verb alc885_init_verbs[] = {
7308         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7309         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7310         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7311         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7312         /* Rear mixer */
7313         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7314         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7315         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7316         /* CLFE mixer */
7317         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7318         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7319         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7320         /* Side mixer */
7321         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7322         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7323         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7324
7325         /* mute analog input loopbacks */
7326         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7327         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7328         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7329
7330         /* Front HP Pin: output 0 (0x0c) */
7331         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7332         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7333         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7334         /* Front Pin: output 0 (0x0c) */
7335         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7336         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7337         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7338         /* Rear Pin: output 1 (0x0d) */
7339         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7340         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7341         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
7342         /* CLFE Pin: output 2 (0x0e) */
7343         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7344         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7345         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7346         /* Side Pin: output 3 (0x0f) */
7347         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7348         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7349         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7350         /* Mic (rear) pin: input vref at 80% */
7351         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7352         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7353         /* Front Mic pin: input vref at 80% */
7354         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7355         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7356         /* Line In pin: input */
7357         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7358         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7359
7360         /* Mixer elements: 0x18, , 0x1a, 0x1b */
7361         /* Input mixer1 */
7362         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7363         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7364         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7365         /* Input mixer2 */
7366         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7367         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7368         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7369         /* Input mixer3 */
7370         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7371         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7372         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7373         /* ADC2: mute amp left and right */
7374         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7375         /* ADC3: mute amp left and right */
7376         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7377
7378         { }
7379 };
7380
7381 static struct hda_verb alc885_init_input_verbs[] = {
7382         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7383         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7384         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7385         { }
7386 };
7387
7388
7389 /* Unmute Selector 24h and set the default input to front mic */
7390 static struct hda_verb alc889_init_input_verbs[] = {
7391         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
7392         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7393         { }
7394 };
7395
7396
7397 #define alc883_init_verbs       alc882_base_init_verbs
7398
7399 /* Mac Pro test */
7400 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
7401         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7402         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7403         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
7404         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
7405         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
7406         /* FIXME: this looks suspicious...
7407         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
7408         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
7409         */
7410         { } /* end */
7411 };
7412
7413 static struct hda_verb alc882_macpro_init_verbs[] = {
7414         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7415         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7416         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7417         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7418         /* Front Pin: output 0 (0x0c) */
7419         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7420         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7421         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7422         /* Front Mic pin: input vref at 80% */
7423         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7424         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7425         /* Speaker:  output */
7426         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7427         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7428         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
7429         /* Headphone output (output 0 - 0x0c) */
7430         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7431         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7432         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7433
7434         /* FIXME: use matrix-type input source selection */
7435         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7436         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7437         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7438         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7439         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7440         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7441         /* Input mixer2 */
7442         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7443         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7444         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7445         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7446         /* Input mixer3 */
7447         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7448         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7449         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7450         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7451         /* ADC1: mute amp left and right */
7452         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7453         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7454         /* ADC2: mute amp left and right */
7455         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7456         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7457         /* ADC3: mute amp left and right */
7458         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7459         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7460
7461         { }
7462 };
7463
7464 /* Macbook 5,1 */
7465 static struct hda_verb alc885_mb5_init_verbs[] = {
7466         /* DACs */
7467         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7468         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7469         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7470         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7471         /* Front mixer */
7472         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7473         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7474         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7475         /* Surround mixer */
7476         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7477         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7478         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7479         /* LFE mixer */
7480         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7481         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7482         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7483         /* HP mixer */
7484         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7485         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7486         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7487         /* Front Pin (0x0c) */
7488         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7489         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7490         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7491         /* LFE Pin (0x0e) */
7492         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7493         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7494         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7495         /* HP Pin (0x0f) */
7496         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7497         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7498         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7499         /* Front Mic pin: input vref at 80% */
7500         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7501         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7502         /* Line In pin */
7503         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7504         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7505
7506         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7507         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7508         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7509         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7510         { }
7511 };
7512
7513 /* Macbook Pro rev3 */
7514 static struct hda_verb alc885_mbp3_init_verbs[] = {
7515         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7516         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7517         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7518         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7519         /* Rear mixer */
7520         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7521         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7522         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7523         /* HP mixer */
7524         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7525         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7526         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7527         /* Front Pin: output 0 (0x0c) */
7528         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7529         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7530         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7531         /* HP Pin: output 0 (0x0e) */
7532         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7533         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7534         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
7535         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7536         /* Mic (rear) pin: input vref at 80% */
7537         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7538         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7539         /* Front Mic pin: input vref at 80% */
7540         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7541         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7542         /* Line In pin: use output 1 when in LineOut mode */
7543         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7544         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7545         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7546
7547         /* FIXME: use matrix-type input source selection */
7548         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7549         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7550         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7551         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7552         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7553         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7554         /* Input mixer2 */
7555         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7556         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7557         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7558         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7559         /* Input mixer3 */
7560         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7561         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7562         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7563         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7564         /* ADC1: mute amp left and right */
7565         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7566         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7567         /* ADC2: mute amp left and right */
7568         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7569         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7570         /* ADC3: mute amp left and right */
7571         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7572         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7573
7574         { }
7575 };
7576
7577 /* iMac 9,1 */
7578 static struct hda_verb alc885_imac91_init_verbs[] = {
7579         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
7580         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7581         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7582         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7583         /* Rear mixer */
7584         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7585         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7586         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7587         /* HP Pin: output 0 (0x0c) */
7588         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7589         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7590         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7591         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7592         /* Internal Speakers: output 0 (0x0d) */
7593         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7594         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7595         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7596         /* Mic (rear) pin: input vref at 80% */
7597         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7598         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7599         /* Front Mic pin: input vref at 80% */
7600         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7601         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7602         /* Line In pin: use output 1 when in LineOut mode */
7603         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7604         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7605         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7606
7607         /* FIXME: use matrix-type input source selection */
7608         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7609         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7610         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7611         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7612         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7613         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7614         /* Input mixer2 */
7615         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7616         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7617         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7618         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7619         /* Input mixer3 */
7620         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7621         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7622         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7623         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7624         /* ADC1: mute amp left and right */
7625         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7626         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7627         /* ADC2: mute amp left and right */
7628         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7629         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7630         /* ADC3: mute amp left and right */
7631         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7632         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7633
7634         { }
7635 };
7636
7637 /* iMac 24 mixer. */
7638 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
7639         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7640         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
7641         { } /* end */
7642 };
7643
7644 /* iMac 24 init verbs. */
7645 static struct hda_verb alc885_imac24_init_verbs[] = {
7646         /* Internal speakers: output 0 (0x0c) */
7647         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7648         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7649         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7650         /* Internal speakers: output 0 (0x0c) */
7651         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7652         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7653         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7654         /* Headphone: output 0 (0x0c) */
7655         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7656         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7657         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7658         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7659         /* Front Mic: input vref at 80% */
7660         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7661         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7662         { }
7663 };
7664
7665 /* Toggle speaker-output according to the hp-jack state */
7666 static void alc885_imac24_setup(struct hda_codec *codec)
7667 {
7668         struct alc_spec *spec = codec->spec;
7669
7670         spec->autocfg.hp_pins[0] = 0x14;
7671         spec->autocfg.speaker_pins[0] = 0x18;
7672         spec->autocfg.speaker_pins[1] = 0x1a;
7673 }
7674
7675 static void alc885_mbp3_setup(struct hda_codec *codec)
7676 {
7677         struct alc_spec *spec = codec->spec;
7678
7679         spec->autocfg.hp_pins[0] = 0x15;
7680         spec->autocfg.speaker_pins[0] = 0x14;
7681 }
7682
7683 static void alc885_imac91_automute(struct hda_codec *codec)
7684 {
7685         unsigned int present;
7686
7687         present = snd_hda_codec_read(codec, 0x14, 0,
7688                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7689         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7690                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7691         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
7692                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7693
7694 }
7695
7696 static void alc885_imac91_unsol_event(struct hda_codec *codec,
7697                                     unsigned int res)
7698 {
7699         /* Headphone insertion or removal. */
7700         if ((res >> 26) == ALC880_HP_EVENT)
7701                 alc885_imac91_automute(codec);
7702 }
7703
7704 static struct hda_verb alc882_targa_verbs[] = {
7705         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7706         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7707
7708         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7709         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7710
7711         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7712         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7713         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7714
7715         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7716         { } /* end */
7717 };
7718
7719 /* toggle speaker-output according to the hp-jack state */
7720 static void alc882_targa_automute(struct hda_codec *codec)
7721 {
7722         struct alc_spec *spec = codec->spec;
7723         alc_automute_amp(codec);
7724         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7725                                   spec->jack_present ? 1 : 3);
7726 }
7727
7728 static void alc882_targa_setup(struct hda_codec *codec)
7729 {
7730         struct alc_spec *spec = codec->spec;
7731
7732         spec->autocfg.hp_pins[0] = 0x14;
7733         spec->autocfg.speaker_pins[0] = 0x1b;
7734 }
7735
7736 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
7737 {
7738         if ((res >> 26) == ALC880_HP_EVENT)
7739                 alc882_targa_automute(codec);
7740 }
7741
7742 static struct hda_verb alc882_asus_a7j_verbs[] = {
7743         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7744         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7745
7746         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7747         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7748         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7749
7750         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7751         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7752         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7753
7754         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7755         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7756         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7757         { } /* end */
7758 };
7759
7760 static struct hda_verb alc882_asus_a7m_verbs[] = {
7761         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7762         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7763
7764         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7765         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7766         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7767
7768         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7769         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7770         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7771
7772         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7773         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7774         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7775         { } /* end */
7776 };
7777
7778 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
7779 {
7780         unsigned int gpiostate, gpiomask, gpiodir;
7781
7782         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
7783                                        AC_VERB_GET_GPIO_DATA, 0);
7784
7785         if (!muted)
7786                 gpiostate |= (1 << pin);
7787         else
7788                 gpiostate &= ~(1 << pin);
7789
7790         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
7791                                       AC_VERB_GET_GPIO_MASK, 0);
7792         gpiomask |= (1 << pin);
7793
7794         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
7795                                      AC_VERB_GET_GPIO_DIRECTION, 0);
7796         gpiodir |= (1 << pin);
7797
7798
7799         snd_hda_codec_write(codec, codec->afg, 0,
7800                             AC_VERB_SET_GPIO_MASK, gpiomask);
7801         snd_hda_codec_write(codec, codec->afg, 0,
7802                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
7803
7804         msleep(1);
7805
7806         snd_hda_codec_write(codec, codec->afg, 0,
7807                             AC_VERB_SET_GPIO_DATA, gpiostate);
7808 }
7809
7810 /* set up GPIO at initialization */
7811 static void alc885_macpro_init_hook(struct hda_codec *codec)
7812 {
7813         alc882_gpio_mute(codec, 0, 0);
7814         alc882_gpio_mute(codec, 1, 0);
7815 }
7816
7817 /* set up GPIO and update auto-muting at initialization */
7818 static void alc885_imac24_init_hook(struct hda_codec *codec)
7819 {
7820         alc885_macpro_init_hook(codec);
7821         alc_automute_amp(codec);
7822 }
7823
7824 /*
7825  * generic initialization of ADC, input mixers and output mixers
7826  */
7827 static struct hda_verb alc883_auto_init_verbs[] = {
7828         /*
7829          * Unmute ADC0-2 and set the default input to mic-in
7830          */
7831         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7832         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7833         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7834         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7835
7836         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7837          * mixer widget
7838          * Note: PASD motherboards uses the Line In 2 as the input for
7839          * front panel mic (mic 2)
7840          */
7841         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7842         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7843         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7844         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7845         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7846         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7847
7848         /*
7849          * Set up output mixers (0x0c - 0x0f)
7850          */
7851         /* set vol=0 to output mixers */
7852         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7853         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7854         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7855         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7856         /* set up input amps for analog loopback */
7857         /* Amp Indices: DAC = 0, mixer = 1 */
7858         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7859         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7860         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7861         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7862         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7863         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7864         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7865         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7866         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7867         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7868
7869         /* FIXME: use matrix-type input source selection */
7870         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7871         /* Input mixer2 */
7872         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7873         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7874         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7875         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7876         /* Input mixer3 */
7877         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7878         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7879         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7880         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7881
7882         { }
7883 };
7884
7885 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
7886 static struct hda_verb alc889A_mb31_ch2_init[] = {
7887         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7888         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7889         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7890         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7891         { } /* end */
7892 };
7893
7894 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
7895 static struct hda_verb alc889A_mb31_ch4_init[] = {
7896         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7897         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7898         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7899         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7900         { } /* end */
7901 };
7902
7903 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
7904 static struct hda_verb alc889A_mb31_ch5_init[] = {
7905         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
7906         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7907         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7908         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7909         { } /* end */
7910 };
7911
7912 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
7913 static struct hda_verb alc889A_mb31_ch6_init[] = {
7914         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
7915         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
7916         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7917         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7918         { } /* end */
7919 };
7920
7921 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
7922         { 2, alc889A_mb31_ch2_init },
7923         { 4, alc889A_mb31_ch4_init },
7924         { 5, alc889A_mb31_ch5_init },
7925         { 6, alc889A_mb31_ch6_init },
7926 };
7927
7928 static struct hda_verb alc883_medion_eapd_verbs[] = {
7929         /* eanable EAPD on medion laptop */
7930         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7931         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7932         { }
7933 };
7934
7935 #define alc883_base_mixer       alc882_base_mixer
7936
7937 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7938         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7939         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7940         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7941         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7942         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7943         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7944         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7945         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7946         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7947         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7948         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7949         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7950         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7951         { } /* end */
7952 };
7953
7954 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7955         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7956         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7957         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7958         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7959         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7960         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7961         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7962         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7963         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7964         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7965         { } /* end */
7966 };
7967
7968 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7969         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7970         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7971         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7972         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7973         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7974         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7975         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7976         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7977         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7978         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7979         { } /* end */
7980 };
7981
7982 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7983         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7984         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7985         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7986         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7987         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7988         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7989         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7990         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7991         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7992         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7993         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7994         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7995         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7996         { } /* end */
7997 };
7998
7999 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8000         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8001         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8002         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8003         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8004         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8005         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8006         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8007         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8008         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8009         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8010         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8011         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8012         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8013         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8014         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8015         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8016         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8017         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8018         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8019         { } /* end */
8020 };
8021
8022 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8023         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8024         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8025         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8026         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8027         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8028                               HDA_OUTPUT),
8029         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8030         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8031         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8032         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8033         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8034         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8035         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8036         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8037         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8038         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8039         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8040         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8041         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8042         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8043         { } /* end */
8044 };
8045
8046 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8047         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8048         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8049         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8050         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8051         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8052                               HDA_OUTPUT),
8053         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8054         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8055         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8056         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8057         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8058         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8059         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8060         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8061         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8062         HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
8063         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8064         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8065         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8066         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8067         { } /* end */
8068 };
8069
8070 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8071         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8072         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8073         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8074         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8075         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8076         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8077         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8078         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8079         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8080         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8081         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8082         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8083         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8084         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8085         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8086         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8087         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8088         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8089         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8090         { } /* end */
8091 };
8092
8093 static struct snd_kcontrol_new alc883_targa_mixer[] = {
8094         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8095         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8096         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8097         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8098         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8099         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8100         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8101         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8102         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8103         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8104         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8105         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8106         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8107         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8108         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8109         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8110         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8111         { } /* end */
8112 };
8113
8114 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
8115         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8116         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8117         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8118         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8119         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8120         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8121         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8122         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8123         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8124         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8125         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8126         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8127         { } /* end */
8128 };
8129
8130 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
8131         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8132         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8133         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8134         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8135         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8136         { } /* end */
8137 };
8138
8139 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
8140         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8141         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8142         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8143         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8144         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8145         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8146         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8147         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8148         { } /* end */
8149 };
8150
8151 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
8152         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8153         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
8154         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8155         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8156         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8157         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8158         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8159         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8160         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8161         { } /* end */
8162 };
8163
8164 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
8165         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8166         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8167         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8168         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8169         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8170         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8171         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8172         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8173         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8174         { } /* end */
8175 };
8176
8177 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
8178         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8179         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8180         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8181         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8182         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8183         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8184         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8185         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8186         { } /* end */
8187 };
8188
8189 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
8190         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8191         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8192         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8193         HDA_BIND_MUTE("LFE Playback Switch", 0x0f, 2, HDA_INPUT),
8194         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8195         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8196         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8197         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8198         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8199         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8200         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8201         { } /* end */
8202 };
8203
8204 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
8205         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8206         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8207         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8208         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
8209         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
8210                                                 0x0d, 1, 0x0, HDA_OUTPUT),
8211         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
8212         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
8213         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
8214         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8215         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8216         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8217         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8218         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8219         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8220         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8221         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8222         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8223         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8224         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8225         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8226         { } /* end */
8227 };
8228
8229 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
8230         /* Output mixers */
8231         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8232         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8233         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8234         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8235         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
8236                 HDA_OUTPUT),
8237         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
8238         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
8239         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
8240         /* Output switches */
8241         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
8242         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
8243         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
8244         /* Boost mixers */
8245         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
8246         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
8247         /* Input mixers */
8248         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8249         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8250         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8251         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8252         { } /* end */
8253 };
8254
8255 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
8256         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8257         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8258         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8259         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8260         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8261         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8262         { } /* end */
8263 };
8264
8265 static struct hda_bind_ctls alc883_bind_cap_vol = {
8266         .ops = &snd_hda_bind_vol,
8267         .values = {
8268                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8269                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8270                 0
8271         },
8272 };
8273
8274 static struct hda_bind_ctls alc883_bind_cap_switch = {
8275         .ops = &snd_hda_bind_sw,
8276         .values = {
8277                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8278                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8279                 0
8280         },
8281 };
8282
8283 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
8284         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8285         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8286         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8287         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8288         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8289         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8290         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8291         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8292         { } /* end */
8293 };
8294
8295 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
8296         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
8297         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
8298         {
8299                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8300                 /* .name = "Capture Source", */
8301                 .name = "Input Source",
8302                 .count = 1,
8303                 .info = alc_mux_enum_info,
8304                 .get = alc_mux_enum_get,
8305                 .put = alc_mux_enum_put,
8306         },
8307         { } /* end */
8308 };
8309
8310 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
8311         {
8312                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8313                 .name = "Channel Mode",
8314                 .info = alc_ch_mode_info,
8315                 .get = alc_ch_mode_get,
8316                 .put = alc_ch_mode_put,
8317         },
8318         { } /* end */
8319 };
8320
8321 /* toggle speaker-output according to the hp-jack state */
8322 static void alc883_mitac_setup(struct hda_codec *codec)
8323 {
8324         struct alc_spec *spec = codec->spec;
8325
8326         spec->autocfg.hp_pins[0] = 0x15;
8327         spec->autocfg.speaker_pins[0] = 0x14;
8328         spec->autocfg.speaker_pins[1] = 0x17;
8329 }
8330
8331 /* auto-toggle front mic */
8332 /*
8333 static void alc883_mitac_mic_automute(struct hda_codec *codec)
8334 {
8335         unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0;
8336
8337         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
8338 }
8339 */
8340
8341 static struct hda_verb alc883_mitac_verbs[] = {
8342         /* HP */
8343         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8344         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8345         /* Subwoofer */
8346         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8347         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8348
8349         /* enable unsolicited event */
8350         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8351         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8352
8353         { } /* end */
8354 };
8355
8356 static struct hda_verb alc883_clevo_m540r_verbs[] = {
8357         /* HP */
8358         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8359         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8360         /* Int speaker */
8361         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
8362
8363         /* enable unsolicited event */
8364         /*
8365         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8366         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8367         */
8368
8369         { } /* end */
8370 };
8371
8372 static struct hda_verb alc883_clevo_m720_verbs[] = {
8373         /* HP */
8374         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8375         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8376         /* Int speaker */
8377         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
8378         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8379
8380         /* enable unsolicited event */
8381         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8382         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8383
8384         { } /* end */
8385 };
8386
8387 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8388         /* HP */
8389         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8390         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8391         /* Subwoofer */
8392         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8393         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8394
8395         /* enable unsolicited event */
8396         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8397
8398         { } /* end */
8399 };
8400
8401 static struct hda_verb alc883_targa_verbs[] = {
8402         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8403         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8404
8405         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8406         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8407
8408 /* Connect Line-Out side jack (SPDIF) to Side */
8409         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8410         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8411         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8412 /* Connect Mic jack to CLFE */
8413         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8414         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8415         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
8416 /* Connect Line-in jack to Surround */
8417         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8418         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8419         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8420 /* Connect HP out jack to Front */
8421         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8422         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8423         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8424
8425         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8426
8427         { } /* end */
8428 };
8429
8430 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8431         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8432         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8433         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8434         { } /* end */
8435 };
8436
8437 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8438         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8439         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8440         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8441         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8442         { } /* end */
8443 };
8444
8445 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8446         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8447         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8448         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8449         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8450         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8451         { } /* end */
8452 };
8453
8454 static struct hda_verb alc883_haier_w66_verbs[] = {
8455         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8456         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8457
8458         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8459
8460         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8461         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8462         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8463         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8464         { } /* end */
8465 };
8466
8467 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8468         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8469         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8470         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8471         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8472         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8473         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8474         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8475         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8476         { } /* end */
8477 };
8478
8479 static struct hda_verb alc888_6st_dell_verbs[] = {
8480         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8481         { }
8482 };
8483
8484 static struct hda_verb alc883_vaiott_verbs[] = {
8485         /* HP */
8486         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8487         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8488
8489         /* enable unsolicited event */
8490         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8491
8492         { } /* end */
8493 };
8494
8495 static void alc888_3st_hp_setup(struct hda_codec *codec)
8496 {
8497         struct alc_spec *spec = codec->spec;
8498
8499         spec->autocfg.hp_pins[0] = 0x1b;
8500         spec->autocfg.speaker_pins[0] = 0x14;
8501         spec->autocfg.speaker_pins[1] = 0x16;
8502         spec->autocfg.speaker_pins[2] = 0x18;
8503 }
8504
8505 static struct hda_verb alc888_3st_hp_verbs[] = {
8506         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8507         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8508         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8509         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8510         { } /* end */
8511 };
8512
8513 /*
8514  * 2ch mode
8515  */
8516 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8517         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8518         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8519         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8520         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8521         { } /* end */
8522 };
8523
8524 /*
8525  * 4ch mode
8526  */
8527 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8528         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8529         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8530         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8531         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8532         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8533         { } /* end */
8534 };
8535
8536 /*
8537  * 6ch mode
8538  */
8539 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8540         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8541         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8542         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8543         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8544         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8545         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8546         { } /* end */
8547 };
8548
8549 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8550         { 2, alc888_3st_hp_2ch_init },
8551         { 4, alc888_3st_hp_4ch_init },
8552         { 6, alc888_3st_hp_6ch_init },
8553 };
8554
8555 /* toggle front-jack and RCA according to the hp-jack state */
8556 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8557 {
8558         unsigned int present = snd_hda_jack_detect(codec, 0x1b);
8559
8560         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8561                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8562         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8563                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8564 }
8565
8566 /* toggle RCA according to the front-jack state */
8567 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8568 {
8569         unsigned int present = snd_hda_jack_detect(codec, 0x14);
8570
8571         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8572                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8573 }
8574
8575 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8576                                              unsigned int res)
8577 {
8578         if ((res >> 26) == ALC880_HP_EVENT)
8579                 alc888_lenovo_ms7195_front_automute(codec);
8580         if ((res >> 26) == ALC880_FRONT_EVENT)
8581                 alc888_lenovo_ms7195_rca_automute(codec);
8582 }
8583
8584 static struct hda_verb alc883_medion_md2_verbs[] = {
8585         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8586         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8587
8588         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8589
8590         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8591         { } /* end */
8592 };
8593
8594 /* toggle speaker-output according to the hp-jack state */
8595 static void alc883_medion_md2_setup(struct hda_codec *codec)
8596 {
8597         struct alc_spec *spec = codec->spec;
8598
8599         spec->autocfg.hp_pins[0] = 0x14;
8600         spec->autocfg.speaker_pins[0] = 0x15;
8601 }
8602
8603 /* toggle speaker-output according to the hp-jack state */
8604 #define alc883_targa_init_hook          alc882_targa_init_hook
8605 #define alc883_targa_unsol_event        alc882_targa_unsol_event
8606
8607 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8608 {
8609         unsigned int present;
8610
8611         present = snd_hda_jack_detect(codec, 0x18);
8612         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8613                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8614 }
8615
8616 static void alc883_clevo_m720_setup(struct hda_codec *codec)
8617 {
8618         struct alc_spec *spec = codec->spec;
8619
8620         spec->autocfg.hp_pins[0] = 0x15;
8621         spec->autocfg.speaker_pins[0] = 0x14;
8622 }
8623
8624 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8625 {
8626         alc_automute_amp(codec);
8627         alc883_clevo_m720_mic_automute(codec);
8628 }
8629
8630 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8631                                            unsigned int res)
8632 {
8633         switch (res >> 26) {
8634         case ALC880_MIC_EVENT:
8635                 alc883_clevo_m720_mic_automute(codec);
8636                 break;
8637         default:
8638                 alc_automute_amp_unsol_event(codec, res);
8639                 break;
8640         }
8641 }
8642
8643 /* toggle speaker-output according to the hp-jack state */
8644 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
8645 {
8646         struct alc_spec *spec = codec->spec;
8647
8648         spec->autocfg.hp_pins[0] = 0x14;
8649         spec->autocfg.speaker_pins[0] = 0x15;
8650 }
8651
8652 static void alc883_haier_w66_setup(struct hda_codec *codec)
8653 {
8654         struct alc_spec *spec = codec->spec;
8655
8656         spec->autocfg.hp_pins[0] = 0x1b;
8657         spec->autocfg.speaker_pins[0] = 0x14;
8658 }
8659
8660 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8661 {
8662         int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
8663
8664         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8665                                  HDA_AMP_MUTE, bits);
8666 }
8667
8668 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8669 {
8670         int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
8671
8672         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8673                                  HDA_AMP_MUTE, bits);
8674         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8675                                  HDA_AMP_MUTE, bits);
8676 }
8677
8678 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8679                                            unsigned int res)
8680 {
8681         if ((res >> 26) == ALC880_HP_EVENT)
8682                 alc883_lenovo_101e_all_automute(codec);
8683         if ((res >> 26) == ALC880_FRONT_EVENT)
8684                 alc883_lenovo_101e_ispeaker_automute(codec);
8685 }
8686
8687 /* toggle speaker-output according to the hp-jack state */
8688 static void alc883_acer_aspire_setup(struct hda_codec *codec)
8689 {
8690         struct alc_spec *spec = codec->spec;
8691
8692         spec->autocfg.hp_pins[0] = 0x14;
8693         spec->autocfg.speaker_pins[0] = 0x15;
8694         spec->autocfg.speaker_pins[1] = 0x16;
8695 }
8696
8697 static struct hda_verb alc883_acer_eapd_verbs[] = {
8698         /* HP Pin: output 0 (0x0c) */
8699         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8700         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8701         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8702         /* Front Pin: output 0 (0x0c) */
8703         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8704         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8705         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8706         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8707         /* eanable EAPD on medion laptop */
8708         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8709         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8710         /* enable unsolicited event */
8711         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8712         { }
8713 };
8714
8715 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
8716         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8717         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8718         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8719         { } /* end */
8720 };
8721
8722 static void alc888_6st_dell_setup(struct hda_codec *codec)
8723 {
8724         struct alc_spec *spec = codec->spec;
8725
8726         spec->autocfg.hp_pins[0] = 0x1b;
8727         spec->autocfg.speaker_pins[0] = 0x14;
8728         spec->autocfg.speaker_pins[1] = 0x15;
8729         spec->autocfg.speaker_pins[2] = 0x16;
8730         spec->autocfg.speaker_pins[3] = 0x17;
8731 }
8732
8733 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
8734 {
8735         struct alc_spec *spec = codec->spec;
8736
8737         spec->autocfg.hp_pins[0] = 0x1b;
8738         spec->autocfg.speaker_pins[0] = 0x14;
8739         spec->autocfg.speaker_pins[1] = 0x15;
8740         spec->autocfg.speaker_pins[2] = 0x16;
8741         spec->autocfg.speaker_pins[3] = 0x17;
8742         spec->autocfg.speaker_pins[4] = 0x1a;
8743 }
8744
8745 static void alc883_vaiott_setup(struct hda_codec *codec)
8746 {
8747         struct alc_spec *spec = codec->spec;
8748
8749         spec->autocfg.hp_pins[0] = 0x15;
8750         spec->autocfg.speaker_pins[0] = 0x14;
8751         spec->autocfg.speaker_pins[1] = 0x17;
8752 }
8753
8754 static struct hda_verb alc888_asus_m90v_verbs[] = {
8755         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8756         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8757         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8758         /* enable unsolicited event */
8759         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8760         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8761         { } /* end */
8762 };
8763
8764 static void alc883_mode2_setup(struct hda_codec *codec)
8765 {
8766         struct alc_spec *spec = codec->spec;
8767
8768         spec->autocfg.hp_pins[0] = 0x1b;
8769         spec->autocfg.speaker_pins[0] = 0x14;
8770         spec->autocfg.speaker_pins[1] = 0x15;
8771         spec->autocfg.speaker_pins[2] = 0x16;
8772         spec->ext_mic.pin = 0x18;
8773         spec->int_mic.pin = 0x19;
8774         spec->ext_mic.mux_idx = 0;
8775         spec->int_mic.mux_idx = 1;
8776         spec->auto_mic = 1;
8777 }
8778
8779 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8780         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8781         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8782         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8783         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8784         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8785         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8786         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8787         /* enable unsolicited event */
8788         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8789         { } /* end */
8790 };
8791
8792 static void alc883_eee1601_inithook(struct hda_codec *codec)
8793 {
8794         struct alc_spec *spec = codec->spec;
8795
8796         spec->autocfg.hp_pins[0] = 0x14;
8797         spec->autocfg.speaker_pins[0] = 0x1b;
8798         alc_automute_pin(codec);
8799 }
8800
8801 static struct hda_verb alc889A_mb31_verbs[] = {
8802         /* Init rear pin (used as headphone output) */
8803         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
8804         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
8805         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8806         /* Init line pin (used as output in 4ch and 6ch mode) */
8807         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
8808         /* Init line 2 pin (used as headphone out by default) */
8809         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
8810         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
8811         { } /* end */
8812 };
8813
8814 /* Mute speakers according to the headphone jack state */
8815 static void alc889A_mb31_automute(struct hda_codec *codec)
8816 {
8817         unsigned int present;
8818
8819         /* Mute only in 2ch or 4ch mode */
8820         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
8821             == 0x00) {
8822                 present = snd_hda_jack_detect(codec, 0x15);
8823                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
8824                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8825                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8826                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8827         }
8828 }
8829
8830 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
8831 {
8832         if ((res >> 26) == ALC880_HP_EVENT)
8833                 alc889A_mb31_automute(codec);
8834 }
8835
8836
8837 #ifdef CONFIG_SND_HDA_POWER_SAVE
8838 #define alc882_loopbacks        alc880_loopbacks
8839 #endif
8840
8841 /* pcm configuration: identical with ALC880 */
8842 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
8843 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
8844 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
8845 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
8846
8847 static hda_nid_t alc883_slave_dig_outs[] = {
8848         ALC1200_DIGOUT_NID, 0,
8849 };
8850
8851 static hda_nid_t alc1200_slave_dig_outs[] = {
8852         ALC883_DIGOUT_NID, 0,
8853 };
8854
8855 /*
8856  * configuration and preset
8857  */
8858 static const char *alc882_models[ALC882_MODEL_LAST] = {
8859         [ALC882_3ST_DIG]        = "3stack-dig",
8860         [ALC882_6ST_DIG]        = "6stack-dig",
8861         [ALC882_ARIMA]          = "arima",
8862         [ALC882_W2JC]           = "w2jc",
8863         [ALC882_TARGA]          = "targa",
8864         [ALC882_ASUS_A7J]       = "asus-a7j",
8865         [ALC882_ASUS_A7M]       = "asus-a7m",
8866         [ALC885_MACPRO]         = "macpro",
8867         [ALC885_MB5]            = "mb5",
8868         [ALC885_MBP3]           = "mbp3",
8869         [ALC885_IMAC24]         = "imac24",
8870         [ALC885_IMAC91]         = "imac91",
8871         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
8872         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8873         [ALC883_3ST_6ch]        = "3stack-6ch",
8874         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
8875         [ALC883_TARGA_DIG]      = "targa-dig",
8876         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8877         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
8878         [ALC883_ACER]           = "acer",
8879         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8880         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8881         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
8882         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
8883         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
8884         [ALC883_MEDION]         = "medion",
8885         [ALC883_MEDION_MD2]     = "medion-md2",
8886         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8887         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8888         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8889         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8890         [ALC888_LENOVO_SKY] = "lenovo-sky",
8891         [ALC883_HAIER_W66]      = "haier-w66",
8892         [ALC888_3ST_HP]         = "3stack-hp",
8893         [ALC888_6ST_DELL]       = "6stack-dell",
8894         [ALC883_MITAC]          = "mitac",
8895         [ALC883_CLEVO_M540R]    = "clevo-m540r",
8896         [ALC883_CLEVO_M720]     = "clevo-m720",
8897         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8898         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8899         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8900         [ALC889A_INTEL]         = "intel-alc889a",
8901         [ALC889_INTEL]          = "intel-x58",
8902         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8903         [ALC889A_MB31]          = "mb31",
8904         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
8905         [ALC882_AUTO]           = "auto",
8906 };
8907
8908 static struct snd_pci_quirk alc882_cfg_tbl[] = {
8909         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
8910
8911         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8912         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8913         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
8914         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8915         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8916         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8917         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8918                 ALC888_ACER_ASPIRE_4930G),
8919         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8920                 ALC888_ACER_ASPIRE_4930G),
8921         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
8922                 ALC888_ACER_ASPIRE_8930G),
8923         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
8924                 ALC888_ACER_ASPIRE_8930G),
8925         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
8926         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
8927         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8928                 ALC888_ACER_ASPIRE_6530G),
8929         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8930                 ALC888_ACER_ASPIRE_6530G),
8931         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
8932                 ALC888_ACER_ASPIRE_7730G),
8933         /* default Acer -- disabled as it causes more problems.
8934          *    model=auto should work fine now
8935          */
8936         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
8937
8938         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8939
8940         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8941         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8942         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8943         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8944         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8945         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
8946
8947         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
8948         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
8949         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
8950         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8951         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
8952         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
8953         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
8954         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8955         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8956         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8957         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8958
8959         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
8960         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8961         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
8962         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8963         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8964         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8965         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8966         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8967         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
8968
8969         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8970         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8971         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8972         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
8973         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
8974         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
8975         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8976         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8977         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8978         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8979         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8980         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8981         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8982         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8983         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
8984         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8985         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8986         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8987         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
8988         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8989         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8990         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8991         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8992         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8993         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8994         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8995         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
8996         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8997         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
8998
8999         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9000         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9001         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9002         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9003         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9004         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9005         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9006         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9007         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9008                       ALC883_FUJITSU_PI2515),
9009         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9010                 ALC888_FUJITSU_XA3530),
9011         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9012         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9013         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9014         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9015         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9016         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
9017         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9018         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9019         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9020
9021         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9022         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9023         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9024         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9025         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9026         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9027         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
9028
9029         {}
9030 };
9031
9032 /* codec SSID table for Intel Mac */
9033 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9034         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9035         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9036         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9037         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9038         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9039         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9040         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9041         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9042         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9043         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9044         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9045         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9046         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9047          * so apparently no perfect solution yet
9048          */
9049         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9050         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9051         {} /* terminator */
9052 };
9053
9054 static struct alc_config_preset alc882_presets[] = {
9055         [ALC882_3ST_DIG] = {
9056                 .mixers = { alc882_base_mixer },
9057                 .init_verbs = { alc882_base_init_verbs,
9058                                 alc882_adc1_init_verbs },
9059                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9060                 .dac_nids = alc882_dac_nids,
9061                 .dig_out_nid = ALC882_DIGOUT_NID,
9062                 .dig_in_nid = ALC882_DIGIN_NID,
9063                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9064                 .channel_mode = alc882_ch_modes,
9065                 .need_dac_fix = 1,
9066                 .input_mux = &alc882_capture_source,
9067         },
9068         [ALC882_6ST_DIG] = {
9069                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9070                 .init_verbs = { alc882_base_init_verbs,
9071                                 alc882_adc1_init_verbs },
9072                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9073                 .dac_nids = alc882_dac_nids,
9074                 .dig_out_nid = ALC882_DIGOUT_NID,
9075                 .dig_in_nid = ALC882_DIGIN_NID,
9076                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9077                 .channel_mode = alc882_sixstack_modes,
9078                 .input_mux = &alc882_capture_source,
9079         },
9080         [ALC882_ARIMA] = {
9081                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9082                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9083                                 alc882_eapd_verbs },
9084                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9085                 .dac_nids = alc882_dac_nids,
9086                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9087                 .channel_mode = alc882_sixstack_modes,
9088                 .input_mux = &alc882_capture_source,
9089         },
9090         [ALC882_W2JC] = {
9091                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9092                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9093                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
9094                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9095                 .dac_nids = alc882_dac_nids,
9096                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9097                 .channel_mode = alc880_threestack_modes,
9098                 .need_dac_fix = 1,
9099                 .input_mux = &alc882_capture_source,
9100                 .dig_out_nid = ALC882_DIGOUT_NID,
9101         },
9102         [ALC885_MBP3] = {
9103                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9104                 .init_verbs = { alc885_mbp3_init_verbs,
9105                                 alc880_gpio1_init_verbs },
9106                 .num_dacs = 2,
9107                 .dac_nids = alc882_dac_nids,
9108                 .hp_nid = 0x04,
9109                 .channel_mode = alc885_mbp_4ch_modes,
9110                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9111                 .input_mux = &alc882_capture_source,
9112                 .dig_out_nid = ALC882_DIGOUT_NID,
9113                 .dig_in_nid = ALC882_DIGIN_NID,
9114                 .unsol_event = alc_automute_amp_unsol_event,
9115                 .setup = alc885_mbp3_setup,
9116                 .init_hook = alc_automute_amp,
9117         },
9118         [ALC885_MB5] = {
9119                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
9120                 .init_verbs = { alc885_mb5_init_verbs,
9121                                 alc880_gpio1_init_verbs },
9122                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9123                 .dac_nids = alc882_dac_nids,
9124                 .channel_mode = alc885_mb5_6ch_modes,
9125                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
9126                 .input_mux = &mb5_capture_source,
9127                 .dig_out_nid = ALC882_DIGOUT_NID,
9128                 .dig_in_nid = ALC882_DIGIN_NID,
9129         },
9130         [ALC885_MACPRO] = {
9131                 .mixers = { alc882_macpro_mixer },
9132                 .init_verbs = { alc882_macpro_init_verbs },
9133                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9134                 .dac_nids = alc882_dac_nids,
9135                 .dig_out_nid = ALC882_DIGOUT_NID,
9136                 .dig_in_nid = ALC882_DIGIN_NID,
9137                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9138                 .channel_mode = alc882_ch_modes,
9139                 .input_mux = &alc882_capture_source,
9140                 .init_hook = alc885_macpro_init_hook,
9141         },
9142         [ALC885_IMAC24] = {
9143                 .mixers = { alc885_imac24_mixer },
9144                 .init_verbs = { alc885_imac24_init_verbs },
9145                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9146                 .dac_nids = alc882_dac_nids,
9147                 .dig_out_nid = ALC882_DIGOUT_NID,
9148                 .dig_in_nid = ALC882_DIGIN_NID,
9149                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9150                 .channel_mode = alc882_ch_modes,
9151                 .input_mux = &alc882_capture_source,
9152                 .unsol_event = alc_automute_amp_unsol_event,
9153                 .setup = alc885_imac24_setup,
9154                 .init_hook = alc885_imac24_init_hook,
9155         },
9156         [ALC885_IMAC91] = {
9157                 .mixers = { alc885_imac91_mixer, alc882_chmode_mixer },
9158                 .init_verbs = { alc885_imac91_init_verbs,
9159                                 alc880_gpio1_init_verbs },
9160                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9161                 .dac_nids = alc882_dac_nids,
9162                 .channel_mode = alc885_mbp_4ch_modes,
9163                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9164                 .input_mux = &alc882_capture_source,
9165                 .dig_out_nid = ALC882_DIGOUT_NID,
9166                 .dig_in_nid = ALC882_DIGIN_NID,
9167                 .unsol_event = alc885_imac91_unsol_event,
9168                 .init_hook = alc885_imac91_automute,
9169         },
9170         [ALC882_TARGA] = {
9171                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
9172                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9173                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
9174                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9175                 .dac_nids = alc882_dac_nids,
9176                 .dig_out_nid = ALC882_DIGOUT_NID,
9177                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9178                 .adc_nids = alc882_adc_nids,
9179                 .capsrc_nids = alc882_capsrc_nids,
9180                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9181                 .channel_mode = alc882_3ST_6ch_modes,
9182                 .need_dac_fix = 1,
9183                 .input_mux = &alc882_capture_source,
9184                 .unsol_event = alc882_targa_unsol_event,
9185                 .setup = alc882_targa_setup,
9186                 .init_hook = alc882_targa_automute,
9187         },
9188         [ALC882_ASUS_A7J] = {
9189                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
9190                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9191                                 alc882_asus_a7j_verbs},
9192                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9193                 .dac_nids = alc882_dac_nids,
9194                 .dig_out_nid = ALC882_DIGOUT_NID,
9195                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9196                 .adc_nids = alc882_adc_nids,
9197                 .capsrc_nids = alc882_capsrc_nids,
9198                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9199                 .channel_mode = alc882_3ST_6ch_modes,
9200                 .need_dac_fix = 1,
9201                 .input_mux = &alc882_capture_source,
9202         },
9203         [ALC882_ASUS_A7M] = {
9204                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
9205                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9206                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
9207                                 alc882_asus_a7m_verbs },
9208                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9209                 .dac_nids = alc882_dac_nids,
9210                 .dig_out_nid = ALC882_DIGOUT_NID,
9211                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9212                 .channel_mode = alc880_threestack_modes,
9213                 .need_dac_fix = 1,
9214                 .input_mux = &alc882_capture_source,
9215         },
9216         [ALC883_3ST_2ch_DIG] = {
9217                 .mixers = { alc883_3ST_2ch_mixer },
9218                 .init_verbs = { alc883_init_verbs },
9219                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9220                 .dac_nids = alc883_dac_nids,
9221                 .dig_out_nid = ALC883_DIGOUT_NID,
9222                 .dig_in_nid = ALC883_DIGIN_NID,
9223                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9224                 .channel_mode = alc883_3ST_2ch_modes,
9225                 .input_mux = &alc883_capture_source,
9226         },
9227         [ALC883_3ST_6ch_DIG] = {
9228                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9229                 .init_verbs = { alc883_init_verbs },
9230                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9231                 .dac_nids = alc883_dac_nids,
9232                 .dig_out_nid = ALC883_DIGOUT_NID,
9233                 .dig_in_nid = ALC883_DIGIN_NID,
9234                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9235                 .channel_mode = alc883_3ST_6ch_modes,
9236                 .need_dac_fix = 1,
9237                 .input_mux = &alc883_capture_source,
9238         },
9239         [ALC883_3ST_6ch] = {
9240                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9241                 .init_verbs = { alc883_init_verbs },
9242                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9243                 .dac_nids = alc883_dac_nids,
9244                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9245                 .channel_mode = alc883_3ST_6ch_modes,
9246                 .need_dac_fix = 1,
9247                 .input_mux = &alc883_capture_source,
9248         },
9249         [ALC883_3ST_6ch_INTEL] = {
9250                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
9251                 .init_verbs = { alc883_init_verbs },
9252                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9253                 .dac_nids = alc883_dac_nids,
9254                 .dig_out_nid = ALC883_DIGOUT_NID,
9255                 .dig_in_nid = ALC883_DIGIN_NID,
9256                 .slave_dig_outs = alc883_slave_dig_outs,
9257                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
9258                 .channel_mode = alc883_3ST_6ch_intel_modes,
9259                 .need_dac_fix = 1,
9260                 .input_mux = &alc883_3stack_6ch_intel,
9261         },
9262         [ALC889A_INTEL] = {
9263                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9264                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
9265                                 alc_hp15_unsol_verbs },
9266                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9267                 .dac_nids = alc883_dac_nids,
9268                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9269                 .adc_nids = alc889_adc_nids,
9270                 .dig_out_nid = ALC883_DIGOUT_NID,
9271                 .dig_in_nid = ALC883_DIGIN_NID,
9272                 .slave_dig_outs = alc883_slave_dig_outs,
9273                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9274                 .channel_mode = alc889_8ch_intel_modes,
9275                 .capsrc_nids = alc889_capsrc_nids,
9276                 .input_mux = &alc889_capture_source,
9277                 .setup = alc889_automute_setup,
9278                 .init_hook = alc_automute_amp,
9279                 .unsol_event = alc_automute_amp_unsol_event,
9280                 .need_dac_fix = 1,
9281         },
9282         [ALC889_INTEL] = {
9283                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9284                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
9285                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
9286                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9287                 .dac_nids = alc883_dac_nids,
9288                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9289                 .adc_nids = alc889_adc_nids,
9290                 .capsrc_nids = alc889_capsrc_nids,
9291                 .capsrc_nids = alc889_capsrc_nids,
9292                 .dig_out_nid = ALC883_DIGOUT_NID,
9293                 .dig_in_nid = ALC883_DIGIN_NID,
9294                 .slave_dig_outs = alc883_slave_dig_outs,
9295                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9296                 .channel_mode = alc889_8ch_intel_modes,
9297                 .capsrc_nids = alc889_capsrc_nids,
9298                 .input_mux = &alc889_capture_source,
9299                 .setup = alc889_automute_setup,
9300                 .init_hook = alc889_intel_init_hook,
9301                 .unsol_event = alc_automute_amp_unsol_event,
9302                 .need_dac_fix = 1,
9303         },
9304         [ALC883_6ST_DIG] = {
9305                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9306                 .init_verbs = { alc883_init_verbs },
9307                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9308                 .dac_nids = alc883_dac_nids,
9309                 .dig_out_nid = ALC883_DIGOUT_NID,
9310                 .dig_in_nid = ALC883_DIGIN_NID,
9311                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9312                 .channel_mode = alc883_sixstack_modes,
9313                 .input_mux = &alc883_capture_source,
9314         },
9315         [ALC883_TARGA_DIG] = {
9316                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
9317                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9318                                 alc883_targa_verbs},
9319                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9320                 .dac_nids = alc883_dac_nids,
9321                 .dig_out_nid = ALC883_DIGOUT_NID,
9322                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9323                 .channel_mode = alc883_3ST_6ch_modes,
9324                 .need_dac_fix = 1,
9325                 .input_mux = &alc883_capture_source,
9326                 .unsol_event = alc883_targa_unsol_event,
9327                 .setup = alc882_targa_setup,
9328                 .init_hook = alc882_targa_automute,
9329         },
9330         [ALC883_TARGA_2ch_DIG] = {
9331                 .mixers = { alc883_targa_2ch_mixer},
9332                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9333                                 alc883_targa_verbs},
9334                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9335                 .dac_nids = alc883_dac_nids,
9336                 .adc_nids = alc883_adc_nids_alt,
9337                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9338                 .capsrc_nids = alc883_capsrc_nids,
9339                 .dig_out_nid = ALC883_DIGOUT_NID,
9340                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9341                 .channel_mode = alc883_3ST_2ch_modes,
9342                 .input_mux = &alc883_capture_source,
9343                 .unsol_event = alc883_targa_unsol_event,
9344                 .setup = alc882_targa_setup,
9345                 .init_hook = alc882_targa_automute,
9346         },
9347         [ALC883_TARGA_8ch_DIG] = {
9348                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
9349                             alc883_chmode_mixer },
9350                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9351                                 alc883_targa_verbs },
9352                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9353                 .dac_nids = alc883_dac_nids,
9354                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9355                 .adc_nids = alc883_adc_nids_rev,
9356                 .capsrc_nids = alc883_capsrc_nids_rev,
9357                 .dig_out_nid = ALC883_DIGOUT_NID,
9358                 .dig_in_nid = ALC883_DIGIN_NID,
9359                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
9360                 .channel_mode = alc883_4ST_8ch_modes,
9361                 .need_dac_fix = 1,
9362                 .input_mux = &alc883_capture_source,
9363                 .unsol_event = alc883_targa_unsol_event,
9364                 .setup = alc882_targa_setup,
9365                 .init_hook = alc882_targa_automute,
9366         },
9367         [ALC883_ACER] = {
9368                 .mixers = { alc883_base_mixer },
9369                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
9370                  * and the headphone jack.  Turn this on and rely on the
9371                  * standard mute methods whenever the user wants to turn
9372                  * these outputs off.
9373                  */
9374                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
9375                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9376                 .dac_nids = alc883_dac_nids,
9377                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9378                 .channel_mode = alc883_3ST_2ch_modes,
9379                 .input_mux = &alc883_capture_source,
9380         },
9381         [ALC883_ACER_ASPIRE] = {
9382                 .mixers = { alc883_acer_aspire_mixer },
9383                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
9384                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9385                 .dac_nids = alc883_dac_nids,
9386                 .dig_out_nid = ALC883_DIGOUT_NID,
9387                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9388                 .channel_mode = alc883_3ST_2ch_modes,
9389                 .input_mux = &alc883_capture_source,
9390                 .unsol_event = alc_automute_amp_unsol_event,
9391                 .setup = alc883_acer_aspire_setup,
9392                 .init_hook = alc_automute_amp,
9393         },
9394         [ALC888_ACER_ASPIRE_4930G] = {
9395                 .mixers = { alc888_base_mixer,
9396                                 alc883_chmode_mixer },
9397                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9398                                 alc888_acer_aspire_4930g_verbs },
9399                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9400                 .dac_nids = alc883_dac_nids,
9401                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9402                 .adc_nids = alc883_adc_nids_rev,
9403                 .capsrc_nids = alc883_capsrc_nids_rev,
9404                 .dig_out_nid = ALC883_DIGOUT_NID,
9405                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9406                 .channel_mode = alc883_3ST_6ch_modes,
9407                 .need_dac_fix = 1,
9408                 .num_mux_defs =
9409                         ARRAY_SIZE(alc888_2_capture_sources),
9410                 .input_mux = alc888_2_capture_sources,
9411                 .unsol_event = alc_automute_amp_unsol_event,
9412                 .setup = alc888_acer_aspire_4930g_setup,
9413                 .init_hook = alc_automute_amp,
9414         },
9415         [ALC888_ACER_ASPIRE_6530G] = {
9416                 .mixers = { alc888_acer_aspire_6530_mixer },
9417                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9418                                 alc888_acer_aspire_6530g_verbs },
9419                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9420                 .dac_nids = alc883_dac_nids,
9421                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9422                 .adc_nids = alc883_adc_nids_rev,
9423                 .capsrc_nids = alc883_capsrc_nids_rev,
9424                 .dig_out_nid = ALC883_DIGOUT_NID,
9425                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9426                 .channel_mode = alc883_3ST_2ch_modes,
9427                 .num_mux_defs =
9428                         ARRAY_SIZE(alc888_2_capture_sources),
9429                 .input_mux = alc888_acer_aspire_6530_sources,
9430                 .unsol_event = alc_automute_amp_unsol_event,
9431                 .setup = alc888_acer_aspire_6530g_setup,
9432                 .init_hook = alc_automute_amp,
9433         },
9434         [ALC888_ACER_ASPIRE_8930G] = {
9435                 .mixers = { alc889_acer_aspire_8930g_mixer,
9436                                 alc883_chmode_mixer },
9437                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9438                                 alc889_acer_aspire_8930g_verbs,
9439                                 alc889_eapd_verbs},
9440                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9441                 .dac_nids = alc883_dac_nids,
9442                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9443                 .adc_nids = alc889_adc_nids,
9444                 .capsrc_nids = alc889_capsrc_nids,
9445                 .dig_out_nid = ALC883_DIGOUT_NID,
9446                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9447                 .channel_mode = alc883_3ST_6ch_modes,
9448                 .need_dac_fix = 1,
9449                 .const_channel_count = 6,
9450                 .num_mux_defs =
9451                         ARRAY_SIZE(alc889_capture_sources),
9452                 .input_mux = alc889_capture_sources,
9453                 .unsol_event = alc_automute_amp_unsol_event,
9454                 .setup = alc889_acer_aspire_8930g_setup,
9455                 .init_hook = alc_automute_amp,
9456 #ifdef CONFIG_SND_HDA_POWER_SAVE
9457                 .power_hook = alc889_power_eapd,
9458 #endif
9459         },
9460         [ALC888_ACER_ASPIRE_7730G] = {
9461                 .mixers = { alc883_3ST_6ch_mixer,
9462                                 alc883_chmode_mixer },
9463                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9464                                 alc888_acer_aspire_7730G_verbs },
9465                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9466                 .dac_nids = alc883_dac_nids,
9467                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9468                 .adc_nids = alc883_adc_nids_rev,
9469                 .capsrc_nids = alc883_capsrc_nids_rev,
9470                 .dig_out_nid = ALC883_DIGOUT_NID,
9471                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9472                 .channel_mode = alc883_3ST_6ch_modes,
9473                 .need_dac_fix = 1,
9474                 .const_channel_count = 6,
9475                 .input_mux = &alc883_capture_source,
9476                 .unsol_event = alc_automute_amp_unsol_event,
9477                 .setup = alc888_acer_aspire_6530g_setup,
9478                 .init_hook = alc_automute_amp,
9479         },
9480         [ALC883_MEDION] = {
9481                 .mixers = { alc883_fivestack_mixer,
9482                             alc883_chmode_mixer },
9483                 .init_verbs = { alc883_init_verbs,
9484                                 alc883_medion_eapd_verbs },
9485                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9486                 .dac_nids = alc883_dac_nids,
9487                 .adc_nids = alc883_adc_nids_alt,
9488                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9489                 .capsrc_nids = alc883_capsrc_nids,
9490                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9491                 .channel_mode = alc883_sixstack_modes,
9492                 .input_mux = &alc883_capture_source,
9493         },
9494         [ALC883_MEDION_MD2] = {
9495                 .mixers = { alc883_medion_md2_mixer},
9496                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
9497                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9498                 .dac_nids = alc883_dac_nids,
9499                 .dig_out_nid = ALC883_DIGOUT_NID,
9500                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9501                 .channel_mode = alc883_3ST_2ch_modes,
9502                 .input_mux = &alc883_capture_source,
9503                 .unsol_event = alc_automute_amp_unsol_event,
9504                 .setup = alc883_medion_md2_setup,
9505                 .init_hook = alc_automute_amp,
9506         },
9507         [ALC883_LAPTOP_EAPD] = {
9508                 .mixers = { alc883_base_mixer },
9509                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
9510                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9511                 .dac_nids = alc883_dac_nids,
9512                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9513                 .channel_mode = alc883_3ST_2ch_modes,
9514                 .input_mux = &alc883_capture_source,
9515         },
9516         [ALC883_CLEVO_M540R] = {
9517                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9518                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
9519                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9520                 .dac_nids = alc883_dac_nids,
9521                 .dig_out_nid = ALC883_DIGOUT_NID,
9522                 .dig_in_nid = ALC883_DIGIN_NID,
9523                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
9524                 .channel_mode = alc883_3ST_6ch_clevo_modes,
9525                 .need_dac_fix = 1,
9526                 .input_mux = &alc883_capture_source,
9527                 /* This machine has the hardware HP auto-muting, thus
9528                  * we need no software mute via unsol event
9529                  */
9530         },
9531         [ALC883_CLEVO_M720] = {
9532                 .mixers = { alc883_clevo_m720_mixer },
9533                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
9534                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9535                 .dac_nids = alc883_dac_nids,
9536                 .dig_out_nid = ALC883_DIGOUT_NID,
9537                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9538                 .channel_mode = alc883_3ST_2ch_modes,
9539                 .input_mux = &alc883_capture_source,
9540                 .unsol_event = alc883_clevo_m720_unsol_event,
9541                 .setup = alc883_clevo_m720_setup,
9542                 .init_hook = alc883_clevo_m720_init_hook,
9543         },
9544         [ALC883_LENOVO_101E_2ch] = {
9545                 .mixers = { alc883_lenovo_101e_2ch_mixer},
9546                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
9547                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9548                 .dac_nids = alc883_dac_nids,
9549                 .adc_nids = alc883_adc_nids_alt,
9550                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9551                 .capsrc_nids = alc883_capsrc_nids,
9552                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9553                 .channel_mode = alc883_3ST_2ch_modes,
9554                 .input_mux = &alc883_lenovo_101e_capture_source,
9555                 .unsol_event = alc883_lenovo_101e_unsol_event,
9556                 .init_hook = alc883_lenovo_101e_all_automute,
9557         },
9558         [ALC883_LENOVO_NB0763] = {
9559                 .mixers = { alc883_lenovo_nb0763_mixer },
9560                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
9561                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9562                 .dac_nids = alc883_dac_nids,
9563                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9564                 .channel_mode = alc883_3ST_2ch_modes,
9565                 .need_dac_fix = 1,
9566                 .input_mux = &alc883_lenovo_nb0763_capture_source,
9567                 .unsol_event = alc_automute_amp_unsol_event,
9568                 .setup = alc883_medion_md2_setup,
9569                 .init_hook = alc_automute_amp,
9570         },
9571         [ALC888_LENOVO_MS7195_DIG] = {
9572                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9573                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
9574                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9575                 .dac_nids = alc883_dac_nids,
9576                 .dig_out_nid = ALC883_DIGOUT_NID,
9577                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9578                 .channel_mode = alc883_3ST_6ch_modes,
9579                 .need_dac_fix = 1,
9580                 .input_mux = &alc883_capture_source,
9581                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
9582                 .init_hook = alc888_lenovo_ms7195_front_automute,
9583         },
9584         [ALC883_HAIER_W66] = {
9585                 .mixers = { alc883_targa_2ch_mixer},
9586                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
9587                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9588                 .dac_nids = alc883_dac_nids,
9589                 .dig_out_nid = ALC883_DIGOUT_NID,
9590                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9591                 .channel_mode = alc883_3ST_2ch_modes,
9592                 .input_mux = &alc883_capture_source,
9593                 .unsol_event = alc_automute_amp_unsol_event,
9594                 .setup = alc883_haier_w66_setup,
9595                 .init_hook = alc_automute_amp,
9596         },
9597         [ALC888_3ST_HP] = {
9598                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9599                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9600                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9601                 .dac_nids = alc883_dac_nids,
9602                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9603                 .channel_mode = alc888_3st_hp_modes,
9604                 .need_dac_fix = 1,
9605                 .input_mux = &alc883_capture_source,
9606                 .unsol_event = alc_automute_amp_unsol_event,
9607                 .setup = alc888_3st_hp_setup,
9608                 .init_hook = alc_automute_amp,
9609         },
9610         [ALC888_6ST_DELL] = {
9611                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9612                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9613                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9614                 .dac_nids = alc883_dac_nids,
9615                 .dig_out_nid = ALC883_DIGOUT_NID,
9616                 .dig_in_nid = ALC883_DIGIN_NID,
9617                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9618                 .channel_mode = alc883_sixstack_modes,
9619                 .input_mux = &alc883_capture_source,
9620                 .unsol_event = alc_automute_amp_unsol_event,
9621                 .setup = alc888_6st_dell_setup,
9622                 .init_hook = alc_automute_amp,
9623         },
9624         [ALC883_MITAC] = {
9625                 .mixers = { alc883_mitac_mixer },
9626                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9627                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9628                 .dac_nids = alc883_dac_nids,
9629                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9630                 .channel_mode = alc883_3ST_2ch_modes,
9631                 .input_mux = &alc883_capture_source,
9632                 .unsol_event = alc_automute_amp_unsol_event,
9633                 .setup = alc883_mitac_setup,
9634                 .init_hook = alc_automute_amp,
9635         },
9636         [ALC883_FUJITSU_PI2515] = {
9637                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9638                 .init_verbs = { alc883_init_verbs,
9639                                 alc883_2ch_fujitsu_pi2515_verbs},
9640                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9641                 .dac_nids = alc883_dac_nids,
9642                 .dig_out_nid = ALC883_DIGOUT_NID,
9643                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9644                 .channel_mode = alc883_3ST_2ch_modes,
9645                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9646                 .unsol_event = alc_automute_amp_unsol_event,
9647                 .setup = alc883_2ch_fujitsu_pi2515_setup,
9648                 .init_hook = alc_automute_amp,
9649         },
9650         [ALC888_FUJITSU_XA3530] = {
9651                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
9652                 .init_verbs = { alc883_init_verbs,
9653                         alc888_fujitsu_xa3530_verbs },
9654                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9655                 .dac_nids = alc883_dac_nids,
9656                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9657                 .adc_nids = alc883_adc_nids_rev,
9658                 .capsrc_nids = alc883_capsrc_nids_rev,
9659                 .dig_out_nid = ALC883_DIGOUT_NID,
9660                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9661                 .channel_mode = alc888_4ST_8ch_intel_modes,
9662                 .num_mux_defs =
9663                         ARRAY_SIZE(alc888_2_capture_sources),
9664                 .input_mux = alc888_2_capture_sources,
9665                 .unsol_event = alc_automute_amp_unsol_event,
9666                 .setup = alc888_fujitsu_xa3530_setup,
9667                 .init_hook = alc_automute_amp,
9668         },
9669         [ALC888_LENOVO_SKY] = {
9670                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9671                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9672                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9673                 .dac_nids = alc883_dac_nids,
9674                 .dig_out_nid = ALC883_DIGOUT_NID,
9675                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9676                 .channel_mode = alc883_sixstack_modes,
9677                 .need_dac_fix = 1,
9678                 .input_mux = &alc883_lenovo_sky_capture_source,
9679                 .unsol_event = alc_automute_amp_unsol_event,
9680                 .setup = alc888_lenovo_sky_setup,
9681                 .init_hook = alc_automute_amp,
9682         },
9683         [ALC888_ASUS_M90V] = {
9684                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9685                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9686                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9687                 .dac_nids = alc883_dac_nids,
9688                 .dig_out_nid = ALC883_DIGOUT_NID,
9689                 .dig_in_nid = ALC883_DIGIN_NID,
9690                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9691                 .channel_mode = alc883_3ST_6ch_modes,
9692                 .need_dac_fix = 1,
9693                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9694                 .unsol_event = alc_sku_unsol_event,
9695                 .setup = alc883_mode2_setup,
9696                 .init_hook = alc_inithook,
9697         },
9698         [ALC888_ASUS_EEE1601] = {
9699                 .mixers = { alc883_asus_eee1601_mixer },
9700                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
9701                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9702                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9703                 .dac_nids = alc883_dac_nids,
9704                 .dig_out_nid = ALC883_DIGOUT_NID,
9705                 .dig_in_nid = ALC883_DIGIN_NID,
9706                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9707                 .channel_mode = alc883_3ST_2ch_modes,
9708                 .need_dac_fix = 1,
9709                 .input_mux = &alc883_asus_eee1601_capture_source,
9710                 .unsol_event = alc_sku_unsol_event,
9711                 .init_hook = alc883_eee1601_inithook,
9712         },
9713         [ALC1200_ASUS_P5Q] = {
9714                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9715                 .init_verbs = { alc883_init_verbs },
9716                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9717                 .dac_nids = alc883_dac_nids,
9718                 .dig_out_nid = ALC1200_DIGOUT_NID,
9719                 .dig_in_nid = ALC883_DIGIN_NID,
9720                 .slave_dig_outs = alc1200_slave_dig_outs,
9721                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9722                 .channel_mode = alc883_sixstack_modes,
9723                 .input_mux = &alc883_capture_source,
9724         },
9725         [ALC889A_MB31] = {
9726                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
9727                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
9728                         alc880_gpio1_init_verbs },
9729                 .adc_nids = alc883_adc_nids,
9730                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
9731                 .capsrc_nids = alc883_capsrc_nids,
9732                 .dac_nids = alc883_dac_nids,
9733                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9734                 .channel_mode = alc889A_mb31_6ch_modes,
9735                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
9736                 .input_mux = &alc889A_mb31_capture_source,
9737                 .dig_out_nid = ALC883_DIGOUT_NID,
9738                 .unsol_event = alc889A_mb31_unsol_event,
9739                 .init_hook = alc889A_mb31_automute,
9740         },
9741         [ALC883_SONY_VAIO_TT] = {
9742                 .mixers = { alc883_vaiott_mixer },
9743                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
9744                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9745                 .dac_nids = alc883_dac_nids,
9746                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9747                 .channel_mode = alc883_3ST_2ch_modes,
9748                 .input_mux = &alc883_capture_source,
9749                 .unsol_event = alc_automute_amp_unsol_event,
9750                 .setup = alc883_vaiott_setup,
9751                 .init_hook = alc_automute_amp,
9752         },
9753 };
9754
9755
9756 /*
9757  * Pin config fixes
9758  */
9759 enum {
9760         PINFIX_ABIT_AW9D_MAX
9761 };
9762
9763 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
9764         { 0x15, 0x01080104 }, /* side */
9765         { 0x16, 0x01011012 }, /* rear */
9766         { 0x17, 0x01016011 }, /* clfe */
9767         { }
9768 };
9769
9770 static const struct alc_fixup alc882_fixups[] = {
9771         [PINFIX_ABIT_AW9D_MAX] = {
9772                 .pins = alc882_abit_aw9d_pinfix
9773         },
9774 };
9775
9776 static struct snd_pci_quirk alc882_fixup_tbl[] = {
9777         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
9778         {}
9779 };
9780
9781 /*
9782  * BIOS auto configuration
9783  */
9784 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
9785                                                 const struct auto_pin_cfg *cfg)
9786 {
9787         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
9788 }
9789
9790 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
9791                                               hda_nid_t nid, int pin_type,
9792                                               int dac_idx)
9793 {
9794         /* set as output */
9795         struct alc_spec *spec = codec->spec;
9796         int idx;
9797
9798         alc_set_pin_output(codec, nid, pin_type);
9799         if (spec->multiout.dac_nids[dac_idx] == 0x25)
9800                 idx = 4;
9801         else
9802                 idx = spec->multiout.dac_nids[dac_idx] - 2;
9803         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9804
9805 }
9806
9807 static void alc882_auto_init_multi_out(struct hda_codec *codec)
9808 {
9809         struct alc_spec *spec = codec->spec;
9810         int i;
9811
9812         for (i = 0; i <= HDA_SIDE; i++) {
9813                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9814                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
9815                 if (nid)
9816                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
9817                                                           i);
9818         }
9819 }
9820
9821 static void alc882_auto_init_hp_out(struct hda_codec *codec)
9822 {
9823         struct alc_spec *spec = codec->spec;
9824         hda_nid_t pin;
9825
9826         pin = spec->autocfg.hp_pins[0];
9827         if (pin) /* connect to front */
9828                 /* use dac 0 */
9829                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9830         pin = spec->autocfg.speaker_pins[0];
9831         if (pin)
9832                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9833 }
9834
9835 static void alc882_auto_init_analog_input(struct hda_codec *codec)
9836 {
9837         struct alc_spec *spec = codec->spec;
9838         int i;
9839
9840         for (i = 0; i < AUTO_PIN_LAST; i++) {
9841                 hda_nid_t nid = spec->autocfg.input_pins[i];
9842                 if (!nid)
9843                         continue;
9844                 alc_set_input_pin(codec, nid, i);
9845                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
9846                         snd_hda_codec_write(codec, nid, 0,
9847                                             AC_VERB_SET_AMP_GAIN_MUTE,
9848                                             AMP_OUT_MUTE);
9849         }
9850 }
9851
9852 static void alc882_auto_init_input_src(struct hda_codec *codec)
9853 {
9854         struct alc_spec *spec = codec->spec;
9855         int c;
9856
9857         for (c = 0; c < spec->num_adc_nids; c++) {
9858                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
9859                 hda_nid_t nid = spec->capsrc_nids[c];
9860                 unsigned int mux_idx;
9861                 const struct hda_input_mux *imux;
9862                 int conns, mute, idx, item;
9863
9864                 conns = snd_hda_get_connections(codec, nid, conn_list,
9865                                                 ARRAY_SIZE(conn_list));
9866                 if (conns < 0)
9867                         continue;
9868                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
9869                 imux = &spec->input_mux[mux_idx];
9870                 for (idx = 0; idx < conns; idx++) {
9871                         /* if the current connection is the selected one,
9872                          * unmute it as default - otherwise mute it
9873                          */
9874                         mute = AMP_IN_MUTE(idx);
9875                         for (item = 0; item < imux->num_items; item++) {
9876                                 if (imux->items[item].index == idx) {
9877                                         if (spec->cur_mux[c] == item)
9878                                                 mute = AMP_IN_UNMUTE(idx);
9879                                         break;
9880                                 }
9881                         }
9882                         /* check if we have a selector or mixer
9883                          * we could check for the widget type instead, but
9884                          * just check for Amp-In presence (in case of mixer
9885                          * without amp-in there is something wrong, this
9886                          * function shouldn't be used or capsrc nid is wrong)
9887                          */
9888                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
9889                                 snd_hda_codec_write(codec, nid, 0,
9890                                                     AC_VERB_SET_AMP_GAIN_MUTE,
9891                                                     mute);
9892                         else if (mute != AMP_IN_MUTE(idx))
9893                                 snd_hda_codec_write(codec, nid, 0,
9894                                                     AC_VERB_SET_CONNECT_SEL,
9895                                                     idx);
9896                 }
9897         }
9898 }
9899
9900 /* add mic boosts if needed */
9901 static int alc_auto_add_mic_boost(struct hda_codec *codec)
9902 {
9903         struct alc_spec *spec = codec->spec;
9904         int err;
9905         hda_nid_t nid;
9906
9907         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
9908         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9909                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9910                                   "Mic Boost",
9911                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9912                 if (err < 0)
9913                         return err;
9914         }
9915         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
9916         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9917                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9918                                   "Front Mic Boost",
9919                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9920                 if (err < 0)
9921                         return err;
9922         }
9923         return 0;
9924 }
9925
9926 /* almost identical with ALC880 parser... */
9927 static int alc882_parse_auto_config(struct hda_codec *codec)
9928 {
9929         struct alc_spec *spec = codec->spec;
9930         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
9931         int i, err;
9932
9933         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
9934                                            alc882_ignore);
9935         if (err < 0)
9936                 return err;
9937         if (!spec->autocfg.line_outs)
9938                 return 0; /* can't find valid BIOS pin config */
9939
9940         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
9941         if (err < 0)
9942                 return err;
9943         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
9944         if (err < 0)
9945                 return err;
9946         err = alc880_auto_create_extra_out(spec,
9947                                            spec->autocfg.speaker_pins[0],
9948                                            "Speaker");
9949         if (err < 0)
9950                 return err;
9951         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
9952                                            "Headphone");
9953         if (err < 0)
9954                 return err;
9955         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
9956         if (err < 0)
9957                 return err;
9958
9959         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
9960
9961         /* check multiple SPDIF-out (for recent codecs) */
9962         for (i = 0; i < spec->autocfg.dig_outs; i++) {
9963                 hda_nid_t dig_nid;
9964                 err = snd_hda_get_connections(codec,
9965                                               spec->autocfg.dig_out_pins[i],
9966                                               &dig_nid, 1);
9967                 if (err < 0)
9968                         continue;
9969                 if (!i)
9970                         spec->multiout.dig_out_nid = dig_nid;
9971                 else {
9972                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
9973                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
9974                                 break;
9975                         spec->slave_dig_outs[i - 1] = dig_nid;
9976                 }
9977         }
9978         if (spec->autocfg.dig_in_pin)
9979                 spec->dig_in_nid = ALC880_DIGIN_NID;
9980
9981         if (spec->kctls.list)
9982                 add_mixer(spec, spec->kctls.list);
9983
9984         add_verb(spec, alc883_auto_init_verbs);
9985         /* if ADC 0x07 is available, initialize it, too */
9986         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
9987                 add_verb(spec, alc882_adc1_init_verbs);
9988
9989         spec->num_mux_defs = 1;
9990         spec->input_mux = &spec->private_imux[0];
9991
9992         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
9993
9994         err = alc_auto_add_mic_boost(codec);
9995         if (err < 0)
9996                 return err;
9997
9998         return 1; /* config found */
9999 }
10000
10001 /* additional initialization for auto-configuration model */
10002 static void alc882_auto_init(struct hda_codec *codec)
10003 {
10004         struct alc_spec *spec = codec->spec;
10005         alc882_auto_init_multi_out(codec);
10006         alc882_auto_init_hp_out(codec);
10007         alc882_auto_init_analog_input(codec);
10008         alc882_auto_init_input_src(codec);
10009         if (spec->unsol_event)
10010                 alc_inithook(codec);
10011 }
10012
10013 static int patch_alc882(struct hda_codec *codec)
10014 {
10015         struct alc_spec *spec;
10016         int err, board_config;
10017
10018         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10019         if (spec == NULL)
10020                 return -ENOMEM;
10021
10022         codec->spec = spec;
10023
10024         switch (codec->vendor_id) {
10025         case 0x10ec0882:
10026         case 0x10ec0885:
10027                 break;
10028         default:
10029                 /* ALC883 and variants */
10030                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10031                 break;
10032         }
10033
10034         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10035                                                   alc882_models,
10036                                                   alc882_cfg_tbl);
10037
10038         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10039                 board_config = snd_hda_check_board_codec_sid_config(codec,
10040                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10041
10042         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10043                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10044                        codec->chip_name);
10045                 board_config = ALC882_AUTO;
10046         }
10047
10048         alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups);
10049
10050         if (board_config == ALC882_AUTO) {
10051                 /* automatic parse from the BIOS config */
10052                 err = alc882_parse_auto_config(codec);
10053                 if (err < 0) {
10054                         alc_free(codec);
10055                         return err;
10056                 } else if (!err) {
10057                         printk(KERN_INFO
10058                                "hda_codec: Cannot set up configuration "
10059                                "from BIOS.  Using base mode...\n");
10060                         board_config = ALC882_3ST_DIG;
10061                 }
10062         }
10063
10064         err = snd_hda_attach_beep_device(codec, 0x1);
10065         if (err < 0) {
10066                 alc_free(codec);
10067                 return err;
10068         }
10069
10070         if (board_config != ALC882_AUTO)
10071                 setup_preset(codec, &alc882_presets[board_config]);
10072
10073         spec->stream_analog_playback = &alc882_pcm_analog_playback;
10074         spec->stream_analog_capture = &alc882_pcm_analog_capture;
10075         /* FIXME: setup DAC5 */
10076         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
10077         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
10078
10079         spec->stream_digital_playback = &alc882_pcm_digital_playback;
10080         spec->stream_digital_capture = &alc882_pcm_digital_capture;
10081
10082         if (codec->vendor_id == 0x10ec0888)
10083                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
10084
10085         if (!spec->adc_nids && spec->input_mux) {
10086                 int i, j;
10087                 spec->num_adc_nids = 0;
10088                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
10089                         const struct hda_input_mux *imux = spec->input_mux;
10090                         hda_nid_t cap;
10091                         hda_nid_t items[16];
10092                         hda_nid_t nid = alc882_adc_nids[i];
10093                         unsigned int wcap = get_wcaps(codec, nid);
10094                         /* get type */
10095                         wcap = get_wcaps_type(wcap);
10096                         if (wcap != AC_WID_AUD_IN)
10097                                 continue;
10098                         spec->private_adc_nids[spec->num_adc_nids] = nid;
10099                         err = snd_hda_get_connections(codec, nid, &cap, 1);
10100                         if (err < 0)
10101                                 continue;
10102                         err = snd_hda_get_connections(codec, cap, items,
10103                                                       ARRAY_SIZE(items));
10104                         if (err < 0)
10105                                 continue;
10106                         for (j = 0; j < imux->num_items; j++)
10107                                 if (imux->items[j].index >= err)
10108                                         break;
10109                         if (j < imux->num_items)
10110                                 continue;
10111                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
10112                         spec->num_adc_nids++;
10113                 }
10114                 spec->adc_nids = spec->private_adc_nids;
10115                 spec->capsrc_nids = spec->private_capsrc_nids;
10116         }
10117
10118         set_capture_mixer(codec);
10119         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
10120
10121         spec->vmaster_nid = 0x0c;
10122
10123         codec->patch_ops = alc_patch_ops;
10124         if (board_config == ALC882_AUTO)
10125                 spec->init_hook = alc882_auto_init;
10126 #ifdef CONFIG_SND_HDA_POWER_SAVE
10127         if (!spec->loopback.amplist)
10128                 spec->loopback.amplist = alc882_loopbacks;
10129 #endif
10130         codec->proc_widget_hook = print_realtek_coef;
10131
10132         return 0;
10133 }
10134
10135
10136 /*
10137  * ALC262 support
10138  */
10139
10140 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
10141 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
10142
10143 #define alc262_dac_nids         alc260_dac_nids
10144 #define alc262_adc_nids         alc882_adc_nids
10145 #define alc262_adc_nids_alt     alc882_adc_nids_alt
10146 #define alc262_capsrc_nids      alc882_capsrc_nids
10147 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
10148
10149 #define alc262_modes            alc260_modes
10150 #define alc262_capture_source   alc882_capture_source
10151
10152 static hda_nid_t alc262_dmic_adc_nids[1] = {
10153         /* ADC0 */
10154         0x09
10155 };
10156
10157 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
10158
10159 static struct snd_kcontrol_new alc262_base_mixer[] = {
10160         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10161         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10162         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10163         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10164         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10165         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10166         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10167         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10168         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10169         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10170         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10171         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10172         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
10173         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10174         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
10175         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
10176         { } /* end */
10177 };
10178
10179 /* update HP, line and mono-out pins according to the master switch */
10180 static void alc262_hp_master_update(struct hda_codec *codec)
10181 {
10182         struct alc_spec *spec = codec->spec;
10183         int val = spec->master_sw;
10184
10185         /* HP & line-out */
10186         snd_hda_codec_write_cache(codec, 0x1b, 0,
10187                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10188                                   val ? PIN_HP : 0);
10189         snd_hda_codec_write_cache(codec, 0x15, 0,
10190                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10191                                   val ? PIN_HP : 0);
10192         /* mono (speaker) depending on the HP jack sense */
10193         val = val && !spec->jack_present;
10194         snd_hda_codec_write_cache(codec, 0x16, 0,
10195                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10196                                   val ? PIN_OUT : 0);
10197 }
10198
10199 static void alc262_hp_bpc_automute(struct hda_codec *codec)
10200 {
10201         struct alc_spec *spec = codec->spec;
10202
10203         spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
10204         alc262_hp_master_update(codec);
10205 }
10206
10207 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
10208 {
10209         if ((res >> 26) != ALC880_HP_EVENT)
10210                 return;
10211         alc262_hp_bpc_automute(codec);
10212 }
10213
10214 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
10215 {
10216         struct alc_spec *spec = codec->spec;
10217
10218         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
10219         alc262_hp_master_update(codec);
10220 }
10221
10222 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
10223                                            unsigned int res)
10224 {
10225         if ((res >> 26) != ALC880_HP_EVENT)
10226                 return;
10227         alc262_hp_wildwest_automute(codec);
10228 }
10229
10230 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
10231
10232 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
10233                                    struct snd_ctl_elem_value *ucontrol)
10234 {
10235         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10236         struct alc_spec *spec = codec->spec;
10237         int val = !!*ucontrol->value.integer.value;
10238
10239         if (val == spec->master_sw)
10240                 return 0;
10241         spec->master_sw = val;
10242         alc262_hp_master_update(codec);
10243         return 1;
10244 }
10245
10246 #define ALC262_HP_MASTER_SWITCH                                 \
10247         {                                                       \
10248                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10249                 .name = "Master Playback Switch",               \
10250                 .info = snd_ctl_boolean_mono_info,              \
10251                 .get = alc262_hp_master_sw_get,                 \
10252                 .put = alc262_hp_master_sw_put,                 \
10253         }
10254
10255 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
10256         ALC262_HP_MASTER_SWITCH,
10257         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10258         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10259         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10260         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10261                               HDA_OUTPUT),
10262         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10263                             HDA_OUTPUT),
10264         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10265         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10266         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10267         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10268         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10269         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10270         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10271         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10272         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10273         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10274         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
10275         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
10276         { } /* end */
10277 };
10278
10279 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
10280         ALC262_HP_MASTER_SWITCH,
10281         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10282         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10283         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10284         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10285         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10286                               HDA_OUTPUT),
10287         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10288                             HDA_OUTPUT),
10289         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
10290         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
10291         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
10292         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10293         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10294         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10295         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10296         { } /* end */
10297 };
10298
10299 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
10300         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10301         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10302         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
10303         { } /* end */
10304 };
10305
10306 /* mute/unmute internal speaker according to the hp jack and mute state */
10307 static void alc262_hp_t5735_setup(struct hda_codec *codec)
10308 {
10309         struct alc_spec *spec = codec->spec;
10310
10311         spec->autocfg.hp_pins[0] = 0x15;
10312         spec->autocfg.speaker_pins[0] = 0x0c; /* HACK: not actually a pin */
10313 }
10314
10315 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
10316         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10317         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10318         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10319         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10320         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10321         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10322         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10323         { } /* end */
10324 };
10325
10326 static struct hda_verb alc262_hp_t5735_verbs[] = {
10327         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10328         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10329
10330         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10331         { }
10332 };
10333
10334 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
10335         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10336         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10337         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
10338         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
10339         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10340         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10341         { } /* end */
10342 };
10343
10344 static struct hda_verb alc262_hp_rp5700_verbs[] = {
10345         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10346         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10347         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10348         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10349         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10350         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10351         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10352         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10353         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10354         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10355         {}
10356 };
10357
10358 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
10359         .num_items = 1,
10360         .items = {
10361                 { "Line", 0x1 },
10362         },
10363 };
10364
10365 /* bind hp and internal speaker mute (with plug check) as master switch */
10366 static void alc262_hippo_master_update(struct hda_codec *codec)
10367 {
10368         struct alc_spec *spec = codec->spec;
10369         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10370         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
10371         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
10372         unsigned int mute;
10373
10374         /* HP */
10375         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
10376         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
10377                                  HDA_AMP_MUTE, mute);
10378         /* mute internal speaker per jack sense */
10379         if (spec->jack_present)
10380                 mute = HDA_AMP_MUTE;
10381         if (line_nid)
10382                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
10383                                          HDA_AMP_MUTE, mute);
10384         if (speaker_nid && speaker_nid != line_nid)
10385                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
10386                                          HDA_AMP_MUTE, mute);
10387 }
10388
10389 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
10390
10391 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
10392                                       struct snd_ctl_elem_value *ucontrol)
10393 {
10394         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10395         struct alc_spec *spec = codec->spec;
10396         int val = !!*ucontrol->value.integer.value;
10397
10398         if (val == spec->master_sw)
10399                 return 0;
10400         spec->master_sw = val;
10401         alc262_hippo_master_update(codec);
10402         return 1;
10403 }
10404
10405 #define ALC262_HIPPO_MASTER_SWITCH                              \
10406         {                                                       \
10407                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10408                 .name = "Master Playback Switch",               \
10409                 .info = snd_ctl_boolean_mono_info,              \
10410                 .get = alc262_hippo_master_sw_get,              \
10411                 .put = alc262_hippo_master_sw_put,              \
10412         }
10413
10414 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
10415         ALC262_HIPPO_MASTER_SWITCH,
10416         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10417         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10418         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10419         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10420         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10421         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10422         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10423         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10424         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10425         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10426         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10427         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10428         { } /* end */
10429 };
10430
10431 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
10432         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10433         ALC262_HIPPO_MASTER_SWITCH,
10434         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10435         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10436         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10437         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10438         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10439         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10440         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10441         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10442         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10443         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10444         { } /* end */
10445 };
10446
10447 /* mute/unmute internal speaker according to the hp jack and mute state */
10448 static void alc262_hippo_automute(struct hda_codec *codec)
10449 {
10450         struct alc_spec *spec = codec->spec;
10451         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10452
10453         spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
10454         alc262_hippo_master_update(codec);
10455 }
10456
10457 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
10458 {
10459         if ((res >> 26) != ALC880_HP_EVENT)
10460                 return;
10461         alc262_hippo_automute(codec);
10462 }
10463
10464 static void alc262_hippo_setup(struct hda_codec *codec)
10465 {
10466         struct alc_spec *spec = codec->spec;
10467
10468         spec->autocfg.hp_pins[0] = 0x15;
10469         spec->autocfg.speaker_pins[0] = 0x14;
10470 }
10471
10472 static void alc262_hippo1_setup(struct hda_codec *codec)
10473 {
10474         struct alc_spec *spec = codec->spec;
10475
10476         spec->autocfg.hp_pins[0] = 0x1b;
10477         spec->autocfg.speaker_pins[0] = 0x14;
10478 }
10479
10480
10481 static struct snd_kcontrol_new alc262_sony_mixer[] = {
10482         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10483         ALC262_HIPPO_MASTER_SWITCH,
10484         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10485         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10486         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10487         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10488         { } /* end */
10489 };
10490
10491 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
10492         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10493         ALC262_HIPPO_MASTER_SWITCH,
10494         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10495         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10496         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10497         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10498         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10499         { } /* end */
10500 };
10501
10502 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
10503         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10504         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10505         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
10506         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
10507         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10508         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10509         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10510         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10511         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10512         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10513         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10514         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10515         { } /* end */
10516 };
10517
10518 static struct hda_verb alc262_tyan_verbs[] = {
10519         /* Headphone automute */
10520         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10521         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10522         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10523
10524         /* P11 AUX_IN, white 4-pin connector */
10525         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10526         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
10527         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
10528         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
10529
10530         {}
10531 };
10532
10533 /* unsolicited event for HP jack sensing */
10534 static void alc262_tyan_setup(struct hda_codec *codec)
10535 {
10536         struct alc_spec *spec = codec->spec;
10537
10538         spec->autocfg.hp_pins[0] = 0x1b;
10539         spec->autocfg.speaker_pins[0] = 0x15;
10540 }
10541
10542
10543 #define alc262_capture_mixer            alc882_capture_mixer
10544 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
10545
10546 /*
10547  * generic initialization of ADC, input mixers and output mixers
10548  */
10549 static struct hda_verb alc262_init_verbs[] = {
10550         /*
10551          * Unmute ADC0-2 and set the default input to mic-in
10552          */
10553         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10554         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10555         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10556         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10557         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10558         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10559
10560         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10561          * mixer widget
10562          * Note: PASD motherboards uses the Line In 2 as the input for
10563          * front panel mic (mic 2)
10564          */
10565         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10566         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10567         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10568         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10569         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10570         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10571
10572         /*
10573          * Set up output mixers (0x0c - 0x0e)
10574          */
10575         /* set vol=0 to output mixers */
10576         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10577         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10578         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10579         /* set up input amps for analog loopback */
10580         /* Amp Indices: DAC = 0, mixer = 1 */
10581         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10582         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10583         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10584         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10585         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10586         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10587
10588         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10589         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10590         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10591         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10592         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10593         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10594
10595         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10596         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10597         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10598         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10599         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10600
10601         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10602         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10603
10604         /* FIXME: use matrix-type input source selection */
10605         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10606         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10607         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10608         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10609         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10610         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10611         /* Input mixer2 */
10612         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10613         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10614         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10615         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10616         /* Input mixer3 */
10617         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10618         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10619         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10620         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10621
10622         { }
10623 };
10624
10625 static struct hda_verb alc262_eapd_verbs[] = {
10626         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10627         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10628         { }
10629 };
10630
10631 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
10632         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10633         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10634         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10635
10636         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10637         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10638         {}
10639 };
10640
10641 static struct hda_verb alc262_sony_unsol_verbs[] = {
10642         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10643         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10644         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
10645
10646         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10647         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10648         {}
10649 };
10650
10651 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
10652         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10653         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10654         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10655         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10656         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10657         { } /* end */
10658 };
10659
10660 static struct hda_verb alc262_toshiba_s06_verbs[] = {
10661         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10662         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10663         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10664         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10665         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
10666         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10667         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10668         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10669         {}
10670 };
10671
10672 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
10673 {
10674         struct alc_spec *spec = codec->spec;
10675
10676         spec->autocfg.hp_pins[0] = 0x15;
10677         spec->autocfg.speaker_pins[0] = 0x14;
10678         spec->ext_mic.pin = 0x18;
10679         spec->ext_mic.mux_idx = 0;
10680         spec->int_mic.pin = 0x12;
10681         spec->int_mic.mux_idx = 9;
10682         spec->auto_mic = 1;
10683 }
10684
10685 /*
10686  * nec model
10687  *  0x15 = headphone
10688  *  0x16 = internal speaker
10689  *  0x18 = external mic
10690  */
10691
10692 static struct snd_kcontrol_new alc262_nec_mixer[] = {
10693         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
10694         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
10695
10696         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10697         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10698         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10699
10700         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10701         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10702         { } /* end */
10703 };
10704
10705 static struct hda_verb alc262_nec_verbs[] = {
10706         /* Unmute Speaker */
10707         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10708
10709         /* Headphone */
10710         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10711         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10712
10713         /* External mic to headphone */
10714         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10715         /* External mic to speaker */
10716         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10717         {}
10718 };
10719
10720 /*
10721  * fujitsu model
10722  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10723  *  0x1b = port replicator headphone out
10724  */
10725
10726 #define ALC_HP_EVENT    0x37
10727
10728 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10729         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10730         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10731         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10732         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10733         {}
10734 };
10735
10736 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10737         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10738         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10739         {}
10740 };
10741
10742 static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
10743         /* Front Mic pin: input vref at 50% */
10744         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
10745         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10746         {}
10747 };
10748
10749 static struct hda_input_mux alc262_fujitsu_capture_source = {
10750         .num_items = 3,
10751         .items = {
10752                 { "Mic", 0x0 },
10753                 { "Int Mic", 0x1 },
10754                 { "CD", 0x4 },
10755         },
10756 };
10757
10758 static struct hda_input_mux alc262_HP_capture_source = {
10759         .num_items = 5,
10760         .items = {
10761                 { "Mic", 0x0 },
10762                 { "Front Mic", 0x1 },
10763                 { "Line", 0x2 },
10764                 { "CD", 0x4 },
10765                 { "AUX IN", 0x6 },
10766         },
10767 };
10768
10769 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10770         .num_items = 4,
10771         .items = {
10772                 { "Mic", 0x0 },
10773                 { "Front Mic", 0x2 },
10774                 { "Line", 0x1 },
10775                 { "CD", 0x4 },
10776         },
10777 };
10778
10779 /* mute/unmute internal speaker according to the hp jacks and mute state */
10780 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10781 {
10782         struct alc_spec *spec = codec->spec;
10783         unsigned int mute;
10784
10785         if (force || !spec->sense_updated) {
10786                 spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
10787                                      snd_hda_jack_detect(codec, 0x1b);
10788                 spec->sense_updated = 1;
10789         }
10790         /* unmute internal speaker only if both HPs are unplugged and
10791          * master switch is on
10792          */
10793         if (spec->jack_present)
10794                 mute = HDA_AMP_MUTE;
10795         else
10796                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10797         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10798                                  HDA_AMP_MUTE, mute);
10799 }
10800
10801 /* unsolicited event for HP jack sensing */
10802 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10803                                        unsigned int res)
10804 {
10805         if ((res >> 26) != ALC_HP_EVENT)
10806                 return;
10807         alc262_fujitsu_automute(codec, 1);
10808 }
10809
10810 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10811 {
10812         alc262_fujitsu_automute(codec, 1);
10813 }
10814
10815 /* bind volumes of both NID 0x0c and 0x0d */
10816 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10817         .ops = &snd_hda_bind_vol,
10818         .values = {
10819                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10820                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10821                 0
10822         },
10823 };
10824
10825 /* mute/unmute internal speaker according to the hp jack and mute state */
10826 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10827 {
10828         struct alc_spec *spec = codec->spec;
10829         unsigned int mute;
10830
10831         if (force || !spec->sense_updated) {
10832                 spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
10833                 spec->sense_updated = 1;
10834         }
10835         if (spec->jack_present) {
10836                 /* mute internal speaker */
10837                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10838                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10839                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10840                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10841         } else {
10842                 /* unmute internal speaker if necessary */
10843                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10844                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10845                                          HDA_AMP_MUTE, mute);
10846                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10847                                          HDA_AMP_MUTE, mute);
10848         }
10849 }
10850
10851 /* unsolicited event for HP jack sensing */
10852 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10853                                        unsigned int res)
10854 {
10855         if ((res >> 26) != ALC_HP_EVENT)
10856                 return;
10857         alc262_lenovo_3000_automute(codec, 1);
10858 }
10859
10860 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
10861                                   int dir, int idx, long *valp)
10862 {
10863         int i, change = 0;
10864
10865         for (i = 0; i < 2; i++, valp++)
10866                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
10867                                                    HDA_AMP_MUTE,
10868                                                    *valp ? 0 : HDA_AMP_MUTE);
10869         return change;
10870 }
10871
10872 /* bind hp and internal speaker mute (with plug check) */
10873 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10874                                          struct snd_ctl_elem_value *ucontrol)
10875 {
10876         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10877         long *valp = ucontrol->value.integer.value;
10878         int change;
10879
10880         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
10881         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10882         if (change)
10883                 alc262_fujitsu_automute(codec, 0);
10884         return change;
10885 }
10886
10887 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10888         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10889         {
10890                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10891                 .name = "Master Playback Switch",
10892                 .info = snd_hda_mixer_amp_switch_info,
10893                 .get = snd_hda_mixer_amp_switch_get,
10894                 .put = alc262_fujitsu_master_sw_put,
10895                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10896         },
10897         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10898         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10899         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10900         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10901         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10902         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10903         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10904         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10905         { } /* end */
10906 };
10907
10908 /* bind hp and internal speaker mute (with plug check) */
10909 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10910                                          struct snd_ctl_elem_value *ucontrol)
10911 {
10912         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10913         long *valp = ucontrol->value.integer.value;
10914         int change;
10915
10916         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10917         if (change)
10918                 alc262_lenovo_3000_automute(codec, 0);
10919         return change;
10920 }
10921
10922 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10923         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10924         {
10925                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10926                 .name = "Master Playback Switch",
10927                 .info = snd_hda_mixer_amp_switch_info,
10928                 .get = snd_hda_mixer_amp_switch_get,
10929                 .put = alc262_lenovo_3000_master_sw_put,
10930                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10931         },
10932         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10933         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10934         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10935         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10936         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10937         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10938         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10939         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10940         { } /* end */
10941 };
10942
10943 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10944         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10945         ALC262_HIPPO_MASTER_SWITCH,
10946         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10947         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10948         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10949         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10950         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10951         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10952         { } /* end */
10953 };
10954
10955 /* additional init verbs for Benq laptops */
10956 static struct hda_verb alc262_EAPD_verbs[] = {
10957         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10958         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10959         {}
10960 };
10961
10962 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10963         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10964         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10965
10966         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10967         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10968         {}
10969 };
10970
10971 /* Samsung Q1 Ultra Vista model setup */
10972 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10973         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10974         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10975         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10976         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10977         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10978         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10979         { } /* end */
10980 };
10981
10982 static struct hda_verb alc262_ultra_verbs[] = {
10983         /* output mixer */
10984         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10985         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10986         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10987         /* speaker */
10988         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10989         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10990         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10991         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10992         /* HP */
10993         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10994         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10995         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10996         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10997         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10998         /* internal mic */
10999         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11000         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11001         /* ADC, choose mic */
11002         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11003         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11004         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11005         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11006         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11007         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11008         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11009         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11010         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11011         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11012         {}
11013 };
11014
11015 /* mute/unmute internal speaker according to the hp jack and mute state */
11016 static void alc262_ultra_automute(struct hda_codec *codec)
11017 {
11018         struct alc_spec *spec = codec->spec;
11019         unsigned int mute;
11020
11021         mute = 0;
11022         /* auto-mute only when HP is used as HP */
11023         if (!spec->cur_mux[0]) {
11024                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11025                 if (spec->jack_present)
11026                         mute = HDA_AMP_MUTE;
11027         }
11028         /* mute/unmute internal speaker */
11029         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11030                                  HDA_AMP_MUTE, mute);
11031         /* mute/unmute HP */
11032         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11033                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
11034 }
11035
11036 /* unsolicited event for HP jack sensing */
11037 static void alc262_ultra_unsol_event(struct hda_codec *codec,
11038                                        unsigned int res)
11039 {
11040         if ((res >> 26) != ALC880_HP_EVENT)
11041                 return;
11042         alc262_ultra_automute(codec);
11043 }
11044
11045 static struct hda_input_mux alc262_ultra_capture_source = {
11046         .num_items = 2,
11047         .items = {
11048                 { "Mic", 0x1 },
11049                 { "Headphone", 0x7 },
11050         },
11051 };
11052
11053 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
11054                                      struct snd_ctl_elem_value *ucontrol)
11055 {
11056         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11057         struct alc_spec *spec = codec->spec;
11058         int ret;
11059
11060         ret = alc_mux_enum_put(kcontrol, ucontrol);
11061         if (!ret)
11062                 return 0;
11063         /* reprogram the HP pin as mic or HP according to the input source */
11064         snd_hda_codec_write_cache(codec, 0x15, 0,
11065                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11066                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
11067         alc262_ultra_automute(codec); /* mute/unmute HP */
11068         return ret;
11069 }
11070
11071 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
11072         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
11073         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
11074         {
11075                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11076                 .name = "Capture Source",
11077                 .info = alc_mux_enum_info,
11078                 .get = alc_mux_enum_get,
11079                 .put = alc262_ultra_mux_enum_put,
11080         },
11081         { } /* end */
11082 };
11083
11084 /* We use two mixers depending on the output pin; 0x16 is a mono output
11085  * and thus it's bound with a different mixer.
11086  * This function returns which mixer amp should be used.
11087  */
11088 static int alc262_check_volbit(hda_nid_t nid)
11089 {
11090         if (!nid)
11091                 return 0;
11092         else if (nid == 0x16)
11093                 return 2;
11094         else
11095                 return 1;
11096 }
11097
11098 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
11099                                   const char *pfx, int *vbits)
11100 {
11101         unsigned long val;
11102         int vbit;
11103
11104         vbit = alc262_check_volbit(nid);
11105         if (!vbit)
11106                 return 0;
11107         if (*vbits & vbit) /* a volume control for this mixer already there */
11108                 return 0;
11109         *vbits |= vbit;
11110         if (vbit == 2)
11111                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
11112         else
11113                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
11114         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, val);
11115 }
11116
11117 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
11118                                  const char *pfx)
11119 {
11120         unsigned long val;
11121
11122         if (!nid)
11123                 return 0;
11124         if (nid == 0x16)
11125                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
11126         else
11127                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
11128         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, val);
11129 }
11130
11131 /* add playback controls from the parsed DAC table */
11132 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
11133                                              const struct auto_pin_cfg *cfg)
11134 {
11135         const char *pfx;
11136         int vbits;
11137         int err;
11138
11139         spec->multiout.num_dacs = 1;    /* only use one dac */
11140         spec->multiout.dac_nids = spec->private_dac_nids;
11141         spec->multiout.dac_nids[0] = 2;
11142
11143         if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
11144                 pfx = "Master";
11145         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11146                 pfx = "Speaker";
11147         else
11148                 pfx = "Front";
11149         err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[0], pfx);
11150         if (err < 0)
11151                 return err;
11152         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[0], "Speaker");
11153         if (err < 0)
11154                 return err;
11155         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[0], "Headphone");
11156         if (err < 0)
11157                 return err;
11158
11159         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
11160                 alc262_check_volbit(cfg->speaker_pins[0]) |
11161                 alc262_check_volbit(cfg->hp_pins[0]);
11162         if (vbits == 1 || vbits == 2)
11163                 pfx = "Master"; /* only one mixer is used */
11164         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11165                 pfx = "Speaker";
11166         else
11167                 pfx = "Front";
11168         vbits = 0;
11169         err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[0], pfx, &vbits);
11170         if (err < 0)
11171                 return err;
11172         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[0], "Speaker",
11173                                      &vbits);
11174         if (err < 0)
11175                 return err;
11176         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[0], "Headphone",
11177                                      &vbits);
11178         if (err < 0)
11179                 return err;
11180         return 0;
11181 }
11182
11183 #define alc262_auto_create_input_ctls \
11184         alc880_auto_create_input_ctls
11185
11186 /*
11187  * generic initialization of ADC, input mixers and output mixers
11188  */
11189 static struct hda_verb alc262_volume_init_verbs[] = {
11190         /*
11191          * Unmute ADC0-2 and set the default input to mic-in
11192          */
11193         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11194         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11195         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11196         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11197         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11198         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11199
11200         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11201          * mixer widget
11202          * Note: PASD motherboards uses the Line In 2 as the input for
11203          * front panel mic (mic 2)
11204          */
11205         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11206         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11207         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11208         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11209         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11210         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11211
11212         /*
11213          * Set up output mixers (0x0c - 0x0f)
11214          */
11215         /* set vol=0 to output mixers */
11216         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11217         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11218         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11219
11220         /* set up input amps for analog loopback */
11221         /* Amp Indices: DAC = 0, mixer = 1 */
11222         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11223         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11224         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11225         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11226         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11227         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11228
11229         /* FIXME: use matrix-type input source selection */
11230         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11231         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11232         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11233         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11234         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11235         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11236         /* Input mixer2 */
11237         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11238         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11239         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11240         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11241         /* Input mixer3 */
11242         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11243         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11244         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11245         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11246
11247         { }
11248 };
11249
11250 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
11251         /*
11252          * Unmute ADC0-2 and set the default input to mic-in
11253          */
11254         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11255         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11256         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11257         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11258         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11259         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11260
11261         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11262          * mixer widget
11263          * Note: PASD motherboards uses the Line In 2 as the input for
11264          * front panel mic (mic 2)
11265          */
11266         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11267         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11268         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11269         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11270         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11271         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11272         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11273         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11274
11275         /*
11276          * Set up output mixers (0x0c - 0x0e)
11277          */
11278         /* set vol=0 to output mixers */
11279         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11280         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11281         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11282
11283         /* set up input amps for analog loopback */
11284         /* Amp Indices: DAC = 0, mixer = 1 */
11285         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11286         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11287         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11288         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11289         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11290         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11291
11292         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11293         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11294         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11295
11296         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11297         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11298
11299         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11300         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11301
11302         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11303         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11304         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11305         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11306         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11307
11308         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11309         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11310         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11311         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11312         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11313         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11314
11315
11316         /* FIXME: use matrix-type input source selection */
11317         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
11318         /* Input mixer1: only unmute Mic */
11319         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11320         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11321         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11322         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11323         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11324         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11325         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11326         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11327         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11328         /* Input mixer2 */
11329         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11330         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11331         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11332         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11333         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11334         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11335         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11336         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11337         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11338         /* Input mixer3 */
11339         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11340         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11341         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11342         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11343         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11344         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11345         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11346         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11347         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11348
11349         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11350
11351         { }
11352 };
11353
11354 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
11355         /*
11356          * Unmute ADC0-2 and set the default input to mic-in
11357          */
11358         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11359         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11360         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11361         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11362         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11363         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11364
11365         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11366          * mixer widget
11367          * Note: PASD motherboards uses the Line In 2 as the input for front
11368          * panel mic (mic 2)
11369          */
11370         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11371         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11372         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11373         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11374         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11375         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11376         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11377         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11378         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11379         /*
11380          * Set up output mixers (0x0c - 0x0e)
11381          */
11382         /* set vol=0 to output mixers */
11383         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11384         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11385         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11386
11387         /* set up input amps for analog loopback */
11388         /* Amp Indices: DAC = 0, mixer = 1 */
11389         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11390         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11391         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11392         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11393         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11394         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11395
11396
11397         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
11398         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
11399         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
11400         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
11401         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11402         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
11403         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
11404
11405         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11406         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11407
11408         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11409         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11410
11411         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
11412         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11413         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11414         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
11415         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11416         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11417
11418         /* FIXME: use matrix-type input source selection */
11419         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11420         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11421         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
11422         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
11423         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
11424         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
11425         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
11426         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
11427         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
11428         /* Input mixer2 */
11429         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11430         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11431         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11432         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11433         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11434         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11435         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11436         /* Input mixer3 */
11437         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11438         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11439         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11440         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11441         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11442         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11443         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11444
11445         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11446
11447         { }
11448 };
11449
11450 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
11451
11452         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
11453         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11454         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
11455
11456         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
11457         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11458         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11459         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11460
11461         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
11462         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11463         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11464         {}
11465 };
11466
11467
11468 #ifdef CONFIG_SND_HDA_POWER_SAVE
11469 #define alc262_loopbacks        alc880_loopbacks
11470 #endif
11471
11472 /* pcm configuration: identical with ALC880 */
11473 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
11474 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
11475 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
11476 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
11477
11478 /*
11479  * BIOS auto configuration
11480  */
11481 static int alc262_parse_auto_config(struct hda_codec *codec)
11482 {
11483         struct alc_spec *spec = codec->spec;
11484         int err;
11485         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
11486
11487         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11488                                            alc262_ignore);
11489         if (err < 0)
11490                 return err;
11491         if (!spec->autocfg.line_outs) {
11492                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11493                         spec->multiout.max_channels = 2;
11494                         spec->no_analog = 1;
11495                         goto dig_only;
11496                 }
11497                 return 0; /* can't find valid BIOS pin config */
11498         }
11499         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
11500         if (err < 0)
11501                 return err;
11502         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
11503         if (err < 0)
11504                 return err;
11505
11506         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11507
11508  dig_only:
11509         if (spec->autocfg.dig_outs) {
11510                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
11511                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11512         }
11513         if (spec->autocfg.dig_in_pin)
11514                 spec->dig_in_nid = ALC262_DIGIN_NID;
11515
11516         if (spec->kctls.list)
11517                 add_mixer(spec, spec->kctls.list);
11518
11519         add_verb(spec, alc262_volume_init_verbs);
11520         spec->num_mux_defs = 1;
11521         spec->input_mux = &spec->private_imux[0];
11522
11523         err = alc_auto_add_mic_boost(codec);
11524         if (err < 0)
11525                 return err;
11526
11527         alc_ssid_check(codec, 0x15, 0x14, 0x1b);
11528
11529         return 1;
11530 }
11531
11532 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
11533 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
11534 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
11535 #define alc262_auto_init_input_src      alc882_auto_init_input_src
11536
11537
11538 /* init callback for auto-configuration model -- overriding the default init */
11539 static void alc262_auto_init(struct hda_codec *codec)
11540 {
11541         struct alc_spec *spec = codec->spec;
11542         alc262_auto_init_multi_out(codec);
11543         alc262_auto_init_hp_out(codec);
11544         alc262_auto_init_analog_input(codec);
11545         alc262_auto_init_input_src(codec);
11546         if (spec->unsol_event)
11547                 alc_inithook(codec);
11548 }
11549
11550 /*
11551  * configuration and preset
11552  */
11553 static const char *alc262_models[ALC262_MODEL_LAST] = {
11554         [ALC262_BASIC]          = "basic",
11555         [ALC262_HIPPO]          = "hippo",
11556         [ALC262_HIPPO_1]        = "hippo_1",
11557         [ALC262_FUJITSU]        = "fujitsu",
11558         [ALC262_HP_BPC]         = "hp-bpc",
11559         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
11560         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
11561         [ALC262_HP_RP5700]      = "hp-rp5700",
11562         [ALC262_BENQ_ED8]       = "benq",
11563         [ALC262_BENQ_T31]       = "benq-t31",
11564         [ALC262_SONY_ASSAMD]    = "sony-assamd",
11565         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
11566         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
11567         [ALC262_ULTRA]          = "ultra",
11568         [ALC262_LENOVO_3000]    = "lenovo-3000",
11569         [ALC262_NEC]            = "nec",
11570         [ALC262_TYAN]           = "tyan",
11571         [ALC262_AUTO]           = "auto",
11572 };
11573
11574 static struct snd_pci_quirk alc262_cfg_tbl[] = {
11575         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
11576         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
11577         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
11578                            ALC262_HP_BPC),
11579         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
11580                            ALC262_HP_BPC),
11581         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
11582                            ALC262_HP_BPC),
11583         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
11584         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
11585         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
11586         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
11587         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
11588         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
11589         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
11590         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
11591         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
11592         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
11593         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
11594         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
11595                       ALC262_HP_TC_T5735),
11596         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
11597         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11598         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
11599         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11600         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
11601         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
11602         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
11603         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
11604 #if 0 /* disable the quirk since model=auto works better in recent versions */
11605         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
11606                            ALC262_SONY_ASSAMD),
11607 #endif
11608         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
11609                       ALC262_TOSHIBA_RX1),
11610         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
11611         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
11612         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
11613         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
11614         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
11615                            ALC262_ULTRA),
11616         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
11617         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
11618         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
11619         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
11620         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
11621         {}
11622 };
11623
11624 static struct alc_config_preset alc262_presets[] = {
11625         [ALC262_BASIC] = {
11626                 .mixers = { alc262_base_mixer },
11627                 .init_verbs = { alc262_init_verbs },
11628                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11629                 .dac_nids = alc262_dac_nids,
11630                 .hp_nid = 0x03,
11631                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11632                 .channel_mode = alc262_modes,
11633                 .input_mux = &alc262_capture_source,
11634         },
11635         [ALC262_HIPPO] = {
11636                 .mixers = { alc262_hippo_mixer },
11637                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
11638                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11639                 .dac_nids = alc262_dac_nids,
11640                 .hp_nid = 0x03,
11641                 .dig_out_nid = ALC262_DIGOUT_NID,
11642                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11643                 .channel_mode = alc262_modes,
11644                 .input_mux = &alc262_capture_source,
11645                 .unsol_event = alc262_hippo_unsol_event,
11646                 .setup = alc262_hippo_setup,
11647                 .init_hook = alc262_hippo_automute,
11648         },
11649         [ALC262_HIPPO_1] = {
11650                 .mixers = { alc262_hippo1_mixer },
11651                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
11652                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11653                 .dac_nids = alc262_dac_nids,
11654                 .hp_nid = 0x02,
11655                 .dig_out_nid = ALC262_DIGOUT_NID,
11656                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11657                 .channel_mode = alc262_modes,
11658                 .input_mux = &alc262_capture_source,
11659                 .unsol_event = alc262_hippo_unsol_event,
11660                 .setup = alc262_hippo1_setup,
11661                 .init_hook = alc262_hippo_automute,
11662         },
11663         [ALC262_FUJITSU] = {
11664                 .mixers = { alc262_fujitsu_mixer },
11665                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11666                                 alc262_fujitsu_unsol_verbs },
11667                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11668                 .dac_nids = alc262_dac_nids,
11669                 .hp_nid = 0x03,
11670                 .dig_out_nid = ALC262_DIGOUT_NID,
11671                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11672                 .channel_mode = alc262_modes,
11673                 .input_mux = &alc262_fujitsu_capture_source,
11674                 .unsol_event = alc262_fujitsu_unsol_event,
11675                 .init_hook = alc262_fujitsu_init_hook,
11676         },
11677         [ALC262_HP_BPC] = {
11678                 .mixers = { alc262_HP_BPC_mixer },
11679                 .init_verbs = { alc262_HP_BPC_init_verbs },
11680                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11681                 .dac_nids = alc262_dac_nids,
11682                 .hp_nid = 0x03,
11683                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11684                 .channel_mode = alc262_modes,
11685                 .input_mux = &alc262_HP_capture_source,
11686                 .unsol_event = alc262_hp_bpc_unsol_event,
11687                 .init_hook = alc262_hp_bpc_automute,
11688         },
11689         [ALC262_HP_BPC_D7000_WF] = {
11690                 .mixers = { alc262_HP_BPC_WildWest_mixer },
11691                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11692                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11693                 .dac_nids = alc262_dac_nids,
11694                 .hp_nid = 0x03,
11695                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11696                 .channel_mode = alc262_modes,
11697                 .input_mux = &alc262_HP_D7000_capture_source,
11698                 .unsol_event = alc262_hp_wildwest_unsol_event,
11699                 .init_hook = alc262_hp_wildwest_automute,
11700         },
11701         [ALC262_HP_BPC_D7000_WL] = {
11702                 .mixers = { alc262_HP_BPC_WildWest_mixer,
11703                             alc262_HP_BPC_WildWest_option_mixer },
11704                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11705                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11706                 .dac_nids = alc262_dac_nids,
11707                 .hp_nid = 0x03,
11708                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11709                 .channel_mode = alc262_modes,
11710                 .input_mux = &alc262_HP_D7000_capture_source,
11711                 .unsol_event = alc262_hp_wildwest_unsol_event,
11712                 .init_hook = alc262_hp_wildwest_automute,
11713         },
11714         [ALC262_HP_TC_T5735] = {
11715                 .mixers = { alc262_hp_t5735_mixer },
11716                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
11717                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11718                 .dac_nids = alc262_dac_nids,
11719                 .hp_nid = 0x03,
11720                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11721                 .channel_mode = alc262_modes,
11722                 .input_mux = &alc262_capture_source,
11723                 .unsol_event = alc_automute_amp_unsol_event,
11724                 .setup = alc262_hp_t5735_setup,
11725                 .init_hook = alc_automute_amp,
11726         },
11727         [ALC262_HP_RP5700] = {
11728                 .mixers = { alc262_hp_rp5700_mixer },
11729                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11730                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11731                 .dac_nids = alc262_dac_nids,
11732                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11733                 .channel_mode = alc262_modes,
11734                 .input_mux = &alc262_hp_rp5700_capture_source,
11735         },
11736         [ALC262_BENQ_ED8] = {
11737                 .mixers = { alc262_base_mixer },
11738                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11739                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11740                 .dac_nids = alc262_dac_nids,
11741                 .hp_nid = 0x03,
11742                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11743                 .channel_mode = alc262_modes,
11744                 .input_mux = &alc262_capture_source,
11745         },
11746         [ALC262_SONY_ASSAMD] = {
11747                 .mixers = { alc262_sony_mixer },
11748                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11749                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11750                 .dac_nids = alc262_dac_nids,
11751                 .hp_nid = 0x02,
11752                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11753                 .channel_mode = alc262_modes,
11754                 .input_mux = &alc262_capture_source,
11755                 .unsol_event = alc262_hippo_unsol_event,
11756                 .setup = alc262_hippo_setup,
11757                 .init_hook = alc262_hippo_automute,
11758         },
11759         [ALC262_BENQ_T31] = {
11760                 .mixers = { alc262_benq_t31_mixer },
11761                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
11762                                 alc_hp15_unsol_verbs },
11763                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11764                 .dac_nids = alc262_dac_nids,
11765                 .hp_nid = 0x03,
11766                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11767                 .channel_mode = alc262_modes,
11768                 .input_mux = &alc262_capture_source,
11769                 .unsol_event = alc262_hippo_unsol_event,
11770                 .setup = alc262_hippo_setup,
11771                 .init_hook = alc262_hippo_automute,
11772         },
11773         [ALC262_ULTRA] = {
11774                 .mixers = { alc262_ultra_mixer },
11775                 .cap_mixer = alc262_ultra_capture_mixer,
11776                 .init_verbs = { alc262_ultra_verbs },
11777                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11778                 .dac_nids = alc262_dac_nids,
11779                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11780                 .channel_mode = alc262_modes,
11781                 .input_mux = &alc262_ultra_capture_source,
11782                 .adc_nids = alc262_adc_nids, /* ADC0 */
11783                 .capsrc_nids = alc262_capsrc_nids,
11784                 .num_adc_nids = 1, /* single ADC */
11785                 .unsol_event = alc262_ultra_unsol_event,
11786                 .init_hook = alc262_ultra_automute,
11787         },
11788         [ALC262_LENOVO_3000] = {
11789                 .mixers = { alc262_lenovo_3000_mixer },
11790                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11791                                 alc262_lenovo_3000_unsol_verbs,
11792                                 alc262_lenovo_3000_init_verbs },
11793                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11794                 .dac_nids = alc262_dac_nids,
11795                 .hp_nid = 0x03,
11796                 .dig_out_nid = ALC262_DIGOUT_NID,
11797                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11798                 .channel_mode = alc262_modes,
11799                 .input_mux = &alc262_fujitsu_capture_source,
11800                 .unsol_event = alc262_lenovo_3000_unsol_event,
11801         },
11802         [ALC262_NEC] = {
11803                 .mixers = { alc262_nec_mixer },
11804                 .init_verbs = { alc262_nec_verbs },
11805                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11806                 .dac_nids = alc262_dac_nids,
11807                 .hp_nid = 0x03,
11808                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11809                 .channel_mode = alc262_modes,
11810                 .input_mux = &alc262_capture_source,
11811         },
11812         [ALC262_TOSHIBA_S06] = {
11813                 .mixers = { alc262_toshiba_s06_mixer },
11814                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11815                                                         alc262_eapd_verbs },
11816                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11817                 .capsrc_nids = alc262_dmic_capsrc_nids,
11818                 .dac_nids = alc262_dac_nids,
11819                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11820                 .num_adc_nids = 1, /* single ADC */
11821                 .dig_out_nid = ALC262_DIGOUT_NID,
11822                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11823                 .channel_mode = alc262_modes,
11824                 .unsol_event = alc_sku_unsol_event,
11825                 .setup = alc262_toshiba_s06_setup,
11826                 .init_hook = alc_inithook,
11827         },
11828         [ALC262_TOSHIBA_RX1] = {
11829                 .mixers = { alc262_toshiba_rx1_mixer },
11830                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11831                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11832                 .dac_nids = alc262_dac_nids,
11833                 .hp_nid = 0x03,
11834                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11835                 .channel_mode = alc262_modes,
11836                 .input_mux = &alc262_capture_source,
11837                 .unsol_event = alc262_hippo_unsol_event,
11838                 .setup = alc262_hippo_setup,
11839                 .init_hook = alc262_hippo_automute,
11840         },
11841         [ALC262_TYAN] = {
11842                 .mixers = { alc262_tyan_mixer },
11843                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11844                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11845                 .dac_nids = alc262_dac_nids,
11846                 .hp_nid = 0x02,
11847                 .dig_out_nid = ALC262_DIGOUT_NID,
11848                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11849                 .channel_mode = alc262_modes,
11850                 .input_mux = &alc262_capture_source,
11851                 .unsol_event = alc_automute_amp_unsol_event,
11852                 .setup = alc262_tyan_setup,
11853                 .init_hook = alc_automute_amp,
11854         },
11855 };
11856
11857 static int patch_alc262(struct hda_codec *codec)
11858 {
11859         struct alc_spec *spec;
11860         int board_config;
11861         int err;
11862
11863         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11864         if (spec == NULL)
11865                 return -ENOMEM;
11866
11867         codec->spec = spec;
11868 #if 0
11869         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11870          * under-run
11871          */
11872         {
11873         int tmp;
11874         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11875         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11876         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11877         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11878         }
11879 #endif
11880
11881         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11882
11883         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11884                                                   alc262_models,
11885                                                   alc262_cfg_tbl);
11886
11887         if (board_config < 0) {
11888                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
11889                        codec->chip_name);
11890                 board_config = ALC262_AUTO;
11891         }
11892
11893         if (board_config == ALC262_AUTO) {
11894                 /* automatic parse from the BIOS config */
11895                 err = alc262_parse_auto_config(codec);
11896                 if (err < 0) {
11897                         alc_free(codec);
11898                         return err;
11899                 } else if (!err) {
11900                         printk(KERN_INFO
11901                                "hda_codec: Cannot set up configuration "
11902                                "from BIOS.  Using base mode...\n");
11903                         board_config = ALC262_BASIC;
11904                 }
11905         }
11906
11907         if (!spec->no_analog) {
11908                 err = snd_hda_attach_beep_device(codec, 0x1);
11909                 if (err < 0) {
11910                         alc_free(codec);
11911                         return err;
11912                 }
11913         }
11914
11915         if (board_config != ALC262_AUTO)
11916                 setup_preset(codec, &alc262_presets[board_config]);
11917
11918         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11919         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11920
11921         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11922         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11923
11924         if (!spec->adc_nids && spec->input_mux) {
11925                 int i;
11926                 /* check whether the digital-mic has to be supported */
11927                 for (i = 0; i < spec->input_mux->num_items; i++) {
11928                         if (spec->input_mux->items[i].index >= 9)
11929                                 break;
11930                 }
11931                 if (i < spec->input_mux->num_items) {
11932                         /* use only ADC0 */
11933                         spec->adc_nids = alc262_dmic_adc_nids;
11934                         spec->num_adc_nids = 1;
11935                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
11936                 } else {
11937                         /* all analog inputs */
11938                         /* check whether NID 0x07 is valid */
11939                         unsigned int wcap = get_wcaps(codec, 0x07);
11940
11941                         /* get type */
11942                         wcap = get_wcaps_type(wcap);
11943                         if (wcap != AC_WID_AUD_IN) {
11944                                 spec->adc_nids = alc262_adc_nids_alt;
11945                                 spec->num_adc_nids =
11946                                         ARRAY_SIZE(alc262_adc_nids_alt);
11947                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
11948                         } else {
11949                                 spec->adc_nids = alc262_adc_nids;
11950                                 spec->num_adc_nids =
11951                                         ARRAY_SIZE(alc262_adc_nids);
11952                                 spec->capsrc_nids = alc262_capsrc_nids;
11953                         }
11954                 }
11955         }
11956         if (!spec->cap_mixer && !spec->no_analog)
11957                 set_capture_mixer(codec);
11958         if (!spec->no_analog)
11959                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11960
11961         spec->vmaster_nid = 0x0c;
11962
11963         codec->patch_ops = alc_patch_ops;
11964         if (board_config == ALC262_AUTO)
11965                 spec->init_hook = alc262_auto_init;
11966 #ifdef CONFIG_SND_HDA_POWER_SAVE
11967         if (!spec->loopback.amplist)
11968                 spec->loopback.amplist = alc262_loopbacks;
11969 #endif
11970         codec->proc_widget_hook = print_realtek_coef;
11971
11972         return 0;
11973 }
11974
11975 /*
11976  *  ALC268 channel source setting (2 channel)
11977  */
11978 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
11979 #define alc268_modes            alc260_modes
11980
11981 static hda_nid_t alc268_dac_nids[2] = {
11982         /* front, hp */
11983         0x02, 0x03
11984 };
11985
11986 static hda_nid_t alc268_adc_nids[2] = {
11987         /* ADC0-1 */
11988         0x08, 0x07
11989 };
11990
11991 static hda_nid_t alc268_adc_nids_alt[1] = {
11992         /* ADC0 */
11993         0x08
11994 };
11995
11996 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11997
11998 static struct snd_kcontrol_new alc268_base_mixer[] = {
11999         /* output mixer control */
12000         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12001         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12002         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12003         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12004         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12005         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12006         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12007         { }
12008 };
12009
12010 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
12011         /* output mixer control */
12012         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12013         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12014         ALC262_HIPPO_MASTER_SWITCH,
12015         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12016         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12017         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12018         { }
12019 };
12020
12021 /* bind Beep switches of both NID 0x0f and 0x10 */
12022 static struct hda_bind_ctls alc268_bind_beep_sw = {
12023         .ops = &snd_hda_bind_sw,
12024         .values = {
12025                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
12026                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
12027                 0
12028         },
12029 };
12030
12031 static struct snd_kcontrol_new alc268_beep_mixer[] = {
12032         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
12033         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
12034         { }
12035 };
12036
12037 static struct hda_verb alc268_eapd_verbs[] = {
12038         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12039         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12040         { }
12041 };
12042
12043 /* Toshiba specific */
12044 static struct hda_verb alc268_toshiba_verbs[] = {
12045         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12046         { } /* end */
12047 };
12048
12049 /* Acer specific */
12050 /* bind volumes of both NID 0x02 and 0x03 */
12051 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
12052         .ops = &snd_hda_bind_vol,
12053         .values = {
12054                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12055                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12056                 0
12057         },
12058 };
12059
12060 /* mute/unmute internal speaker according to the hp jack and mute state */
12061 static void alc268_acer_automute(struct hda_codec *codec, int force)
12062 {
12063         struct alc_spec *spec = codec->spec;
12064         unsigned int mute;
12065
12066         if (force || !spec->sense_updated) {
12067                 spec->jack_present = snd_hda_jack_detect(codec, 0x14);
12068                 spec->sense_updated = 1;
12069         }
12070         if (spec->jack_present)
12071                 mute = HDA_AMP_MUTE; /* mute internal speaker */
12072         else /* unmute internal speaker if necessary */
12073                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
12074         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12075                                  HDA_AMP_MUTE, mute);
12076 }
12077
12078
12079 /* bind hp and internal speaker mute (with plug check) */
12080 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
12081                                      struct snd_ctl_elem_value *ucontrol)
12082 {
12083         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12084         long *valp = ucontrol->value.integer.value;
12085         int change;
12086
12087         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
12088         if (change)
12089                 alc268_acer_automute(codec, 0);
12090         return change;
12091 }
12092
12093 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
12094         /* output mixer control */
12095         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12096         {
12097                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12098                 .name = "Master Playback Switch",
12099                 .info = snd_hda_mixer_amp_switch_info,
12100                 .get = snd_hda_mixer_amp_switch_get,
12101                 .put = alc268_acer_master_sw_put,
12102                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12103         },
12104         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
12105         { }
12106 };
12107
12108 static struct snd_kcontrol_new alc268_acer_mixer[] = {
12109         /* output mixer control */
12110         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12111         {
12112                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12113                 .name = "Master Playback Switch",
12114                 .info = snd_hda_mixer_amp_switch_info,
12115                 .get = snd_hda_mixer_amp_switch_get,
12116                 .put = alc268_acer_master_sw_put,
12117                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12118         },
12119         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12120         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12121         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12122         { }
12123 };
12124
12125 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
12126         /* output mixer control */
12127         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12128         {
12129                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12130                 .name = "Master Playback Switch",
12131                 .info = snd_hda_mixer_amp_switch_info,
12132                 .get = snd_hda_mixer_amp_switch_get,
12133                 .put = alc268_acer_master_sw_put,
12134                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12135         },
12136         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12137         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12138         { }
12139 };
12140
12141 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
12142         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12143         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12144         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12145         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12146         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
12147         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
12148         { }
12149 };
12150
12151 static struct hda_verb alc268_acer_verbs[] = {
12152         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
12153         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12154         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12155         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12156         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12157         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12158         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12159         { }
12160 };
12161
12162 /* unsolicited event for HP jack sensing */
12163 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
12164 #define alc268_toshiba_setup            alc262_hippo_setup
12165 #define alc268_toshiba_automute         alc262_hippo_automute
12166
12167 static void alc268_acer_unsol_event(struct hda_codec *codec,
12168                                        unsigned int res)
12169 {
12170         if ((res >> 26) != ALC880_HP_EVENT)
12171                 return;
12172         alc268_acer_automute(codec, 1);
12173 }
12174
12175 static void alc268_acer_init_hook(struct hda_codec *codec)
12176 {
12177         alc268_acer_automute(codec, 1);
12178 }
12179
12180 /* toggle speaker-output according to the hp-jack state */
12181 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
12182 {
12183         unsigned int present;
12184         unsigned char bits;
12185
12186         present = snd_hda_jack_detect(codec, 0x15);
12187         bits = present ? AMP_IN_MUTE(0) : 0;
12188         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
12189                                 AMP_IN_MUTE(0), bits);
12190         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
12191                                 AMP_IN_MUTE(0), bits);
12192 }
12193
12194 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
12195                                     unsigned int res)
12196 {
12197         switch (res >> 26) {
12198         case ALC880_HP_EVENT:
12199                 alc268_aspire_one_speaker_automute(codec);
12200                 break;
12201         case ALC880_MIC_EVENT:
12202                 alc_mic_automute(codec);
12203                 break;
12204         }
12205 }
12206
12207 static void alc268_acer_lc_setup(struct hda_codec *codec)
12208 {
12209         struct alc_spec *spec = codec->spec;
12210         spec->ext_mic.pin = 0x18;
12211         spec->ext_mic.mux_idx = 0;
12212         spec->int_mic.pin = 0x12;
12213         spec->int_mic.mux_idx = 6;
12214         spec->auto_mic = 1;
12215 }
12216
12217 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
12218 {
12219         alc268_aspire_one_speaker_automute(codec);
12220         alc_mic_automute(codec);
12221 }
12222
12223 static struct snd_kcontrol_new alc268_dell_mixer[] = {
12224         /* output mixer control */
12225         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12226         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12227         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12228         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12229         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12230         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12231         { }
12232 };
12233
12234 static struct hda_verb alc268_dell_verbs[] = {
12235         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12236         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12237         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12238         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12239         { }
12240 };
12241
12242 /* mute/unmute internal speaker according to the hp jack and mute state */
12243 static void alc268_dell_setup(struct hda_codec *codec)
12244 {
12245         struct alc_spec *spec = codec->spec;
12246
12247         spec->autocfg.hp_pins[0] = 0x15;
12248         spec->autocfg.speaker_pins[0] = 0x14;
12249         spec->ext_mic.pin = 0x18;
12250         spec->ext_mic.mux_idx = 0;
12251         spec->int_mic.pin = 0x19;
12252         spec->int_mic.mux_idx = 1;
12253         spec->auto_mic = 1;
12254 }
12255
12256 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
12257         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12258         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12259         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12260         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12261         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12262         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
12263         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
12264         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
12265         { }
12266 };
12267
12268 static struct hda_verb alc267_quanta_il1_verbs[] = {
12269         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12270         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12271         { }
12272 };
12273
12274 static void alc267_quanta_il1_setup(struct hda_codec *codec)
12275 {
12276         struct alc_spec *spec = codec->spec;
12277         spec->autocfg.hp_pins[0] = 0x15;
12278         spec->autocfg.speaker_pins[0] = 0x14;
12279         spec->ext_mic.pin = 0x18;
12280         spec->ext_mic.mux_idx = 0;
12281         spec->int_mic.pin = 0x19;
12282         spec->int_mic.mux_idx = 1;
12283         spec->auto_mic = 1;
12284 }
12285
12286 /*
12287  * generic initialization of ADC, input mixers and output mixers
12288  */
12289 static struct hda_verb alc268_base_init_verbs[] = {
12290         /* Unmute DAC0-1 and set vol = 0 */
12291         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12292         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12293
12294         /*
12295          * Set up output mixers (0x0c - 0x0e)
12296          */
12297         /* set vol=0 to output mixers */
12298         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12299         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
12300
12301         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12302         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12303
12304         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12305         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
12306         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12307         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12308         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12309         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12310         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12311         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12312
12313         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12314         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12315         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12316         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12317         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12318
12319         /* set PCBEEP vol = 0, mute connections */
12320         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12321         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12322         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12323
12324         /* Unmute Selector 23h,24h and set the default input to mic-in */
12325
12326         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
12327         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12328         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
12329         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12330
12331         { }
12332 };
12333
12334 /*
12335  * generic initialization of ADC, input mixers and output mixers
12336  */
12337 static struct hda_verb alc268_volume_init_verbs[] = {
12338         /* set output DAC */
12339         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12340         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12341
12342         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12343         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12344         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12345         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12346         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12347
12348         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12349         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12350         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12351
12352         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12353         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12354
12355         /* set PCBEEP vol = 0, mute connections */
12356         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12357         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12358         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12359
12360         { }
12361 };
12362
12363 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
12364         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12365         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12366         { } /* end */
12367 };
12368
12369 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
12370         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12371         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12372         _DEFINE_CAPSRC(1),
12373         { } /* end */
12374 };
12375
12376 static struct snd_kcontrol_new alc268_capture_mixer[] = {
12377         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12378         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12379         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
12380         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
12381         _DEFINE_CAPSRC(2),
12382         { } /* end */
12383 };
12384
12385 static struct hda_input_mux alc268_capture_source = {
12386         .num_items = 4,
12387         .items = {
12388                 { "Mic", 0x0 },
12389                 { "Front Mic", 0x1 },
12390                 { "Line", 0x2 },
12391                 { "CD", 0x3 },
12392         },
12393 };
12394
12395 static struct hda_input_mux alc268_acer_capture_source = {
12396         .num_items = 3,
12397         .items = {
12398                 { "Mic", 0x0 },
12399                 { "Internal Mic", 0x1 },
12400                 { "Line", 0x2 },
12401         },
12402 };
12403
12404 static struct hda_input_mux alc268_acer_dmic_capture_source = {
12405         .num_items = 3,
12406         .items = {
12407                 { "Mic", 0x0 },
12408                 { "Internal Mic", 0x6 },
12409                 { "Line", 0x2 },
12410         },
12411 };
12412
12413 #ifdef CONFIG_SND_DEBUG
12414 static struct snd_kcontrol_new alc268_test_mixer[] = {
12415         /* Volume widgets */
12416         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12417         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12418         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
12419         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
12420         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
12421         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
12422         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
12423         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
12424         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
12425         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
12426         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
12427         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
12428         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
12429         /* The below appears problematic on some hardwares */
12430         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
12431         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12432         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
12433         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
12434         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
12435
12436         /* Modes for retasking pin widgets */
12437         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
12438         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
12439         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
12440         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
12441
12442         /* Controls for GPIO pins, assuming they are configured as outputs */
12443         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
12444         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
12445         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
12446         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
12447
12448         /* Switches to allow the digital SPDIF output pin to be enabled.
12449          * The ALC268 does not have an SPDIF input.
12450          */
12451         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
12452
12453         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
12454          * this output to turn on an external amplifier.
12455          */
12456         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
12457         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
12458
12459         { } /* end */
12460 };
12461 #endif
12462
12463 /* create input playback/capture controls for the given pin */
12464 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
12465                                     const char *ctlname, int idx)
12466 {
12467         hda_nid_t dac;
12468         int err;
12469
12470         switch (nid) {
12471         case 0x14:
12472         case 0x16:
12473                 dac = 0x02;
12474                 break;
12475         case 0x15:
12476                 dac = 0x03;
12477                 break;
12478         default:
12479                 return 0;
12480         }
12481         if (spec->multiout.dac_nids[0] != dac &&
12482             spec->multiout.dac_nids[1] != dac) {
12483                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
12484                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
12485                                                       HDA_OUTPUT));
12486                 if (err < 0)
12487                         return err;
12488                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
12489         }
12490
12491         if (nid != 0x16)
12492                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12493                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
12494         else /* mono */
12495                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12496                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
12497         if (err < 0)
12498                 return err;
12499         return 0;
12500 }
12501
12502 /* add playback controls from the parsed DAC table */
12503 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
12504                                              const struct auto_pin_cfg *cfg)
12505 {
12506         hda_nid_t nid;
12507         int err;
12508
12509         spec->multiout.dac_nids = spec->private_dac_nids;
12510
12511         nid = cfg->line_out_pins[0];
12512         if (nid) {
12513                 const char *name;
12514                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12515                         name = "Speaker";
12516                 else
12517                         name = "Front";
12518                 err = alc268_new_analog_output(spec, nid, name, 0);
12519                 if (err < 0)
12520                         return err;
12521         }
12522
12523         nid = cfg->speaker_pins[0];
12524         if (nid == 0x1d) {
12525                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
12526                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
12527                 if (err < 0)
12528                         return err;
12529         } else {
12530                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
12531                 if (err < 0)
12532                         return err;
12533         }
12534         nid = cfg->hp_pins[0];
12535         if (nid) {
12536                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
12537                 if (err < 0)
12538                         return err;
12539         }
12540
12541         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
12542         if (nid == 0x16) {
12543                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
12544                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
12545                 if (err < 0)
12546                         return err;
12547         }
12548         return 0;
12549 }
12550
12551 /* create playback/capture controls for input pins */
12552 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
12553                                                 const struct auto_pin_cfg *cfg)
12554 {
12555         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
12556 }
12557
12558 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
12559                                               hda_nid_t nid, int pin_type)
12560 {
12561         int idx;
12562
12563         alc_set_pin_output(codec, nid, pin_type);
12564         if (nid == 0x14 || nid == 0x16)
12565                 idx = 0;
12566         else
12567                 idx = 1;
12568         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
12569 }
12570
12571 static void alc268_auto_init_multi_out(struct hda_codec *codec)
12572 {
12573         struct alc_spec *spec = codec->spec;
12574         hda_nid_t nid = spec->autocfg.line_out_pins[0];
12575         if (nid) {
12576                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
12577                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
12578         }
12579 }
12580
12581 static void alc268_auto_init_hp_out(struct hda_codec *codec)
12582 {
12583         struct alc_spec *spec = codec->spec;
12584         hda_nid_t pin;
12585
12586         pin = spec->autocfg.hp_pins[0];
12587         if (pin)
12588                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
12589         pin = spec->autocfg.speaker_pins[0];
12590         if (pin)
12591                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
12592 }
12593
12594 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
12595 {
12596         struct alc_spec *spec = codec->spec;
12597         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
12598         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
12599         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
12600         unsigned int    dac_vol1, dac_vol2;
12601
12602         if (line_nid == 0x1d || speaker_nid == 0x1d) {
12603                 snd_hda_codec_write(codec, speaker_nid, 0,
12604                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
12605                 /* mute mixer inputs from 0x1d */
12606                 snd_hda_codec_write(codec, 0x0f, 0,
12607                                     AC_VERB_SET_AMP_GAIN_MUTE,
12608                                     AMP_IN_UNMUTE(1));
12609                 snd_hda_codec_write(codec, 0x10, 0,
12610                                     AC_VERB_SET_AMP_GAIN_MUTE,
12611                                     AMP_IN_UNMUTE(1));
12612         } else {
12613                 /* unmute mixer inputs from 0x1d */
12614                 snd_hda_codec_write(codec, 0x0f, 0,
12615                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12616                 snd_hda_codec_write(codec, 0x10, 0,
12617                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12618         }
12619
12620         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
12621         if (line_nid == 0x14)
12622                 dac_vol2 = AMP_OUT_ZERO;
12623         else if (line_nid == 0x15)
12624                 dac_vol1 = AMP_OUT_ZERO;
12625         if (hp_nid == 0x14)
12626                 dac_vol2 = AMP_OUT_ZERO;
12627         else if (hp_nid == 0x15)
12628                 dac_vol1 = AMP_OUT_ZERO;
12629         if (line_nid != 0x16 || hp_nid != 0x16 ||
12630             spec->autocfg.line_out_pins[1] != 0x16 ||
12631             spec->autocfg.line_out_pins[2] != 0x16)
12632                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
12633
12634         snd_hda_codec_write(codec, 0x02, 0,
12635                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
12636         snd_hda_codec_write(codec, 0x03, 0,
12637                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
12638 }
12639
12640 /* pcm configuration: identical with ALC880 */
12641 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
12642 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
12643 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
12644 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
12645
12646 /*
12647  * BIOS auto configuration
12648  */
12649 static int alc268_parse_auto_config(struct hda_codec *codec)
12650 {
12651         struct alc_spec *spec = codec->spec;
12652         int err;
12653         static hda_nid_t alc268_ignore[] = { 0 };
12654
12655         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12656                                            alc268_ignore);
12657         if (err < 0)
12658                 return err;
12659         if (!spec->autocfg.line_outs) {
12660                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12661                         spec->multiout.max_channels = 2;
12662                         spec->no_analog = 1;
12663                         goto dig_only;
12664                 }
12665                 return 0; /* can't find valid BIOS pin config */
12666         }
12667         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
12668         if (err < 0)
12669                 return err;
12670         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
12671         if (err < 0)
12672                 return err;
12673
12674         spec->multiout.max_channels = 2;
12675
12676  dig_only:
12677         /* digital only support output */
12678         if (spec->autocfg.dig_outs) {
12679                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
12680                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
12681         }
12682         if (spec->kctls.list)
12683                 add_mixer(spec, spec->kctls.list);
12684
12685         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
12686                 add_mixer(spec, alc268_beep_mixer);
12687
12688         add_verb(spec, alc268_volume_init_verbs);
12689         spec->num_mux_defs = 2;
12690         spec->input_mux = &spec->private_imux[0];
12691
12692         err = alc_auto_add_mic_boost(codec);
12693         if (err < 0)
12694                 return err;
12695
12696         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
12697
12698         return 1;
12699 }
12700
12701 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
12702
12703 /* init callback for auto-configuration model -- overriding the default init */
12704 static void alc268_auto_init(struct hda_codec *codec)
12705 {
12706         struct alc_spec *spec = codec->spec;
12707         alc268_auto_init_multi_out(codec);
12708         alc268_auto_init_hp_out(codec);
12709         alc268_auto_init_mono_speaker_out(codec);
12710         alc268_auto_init_analog_input(codec);
12711         if (spec->unsol_event)
12712                 alc_inithook(codec);
12713 }
12714
12715 /*
12716  * configuration and preset
12717  */
12718 static const char *alc268_models[ALC268_MODEL_LAST] = {
12719         [ALC267_QUANTA_IL1]     = "quanta-il1",
12720         [ALC268_3ST]            = "3stack",
12721         [ALC268_TOSHIBA]        = "toshiba",
12722         [ALC268_ACER]           = "acer",
12723         [ALC268_ACER_DMIC]      = "acer-dmic",
12724         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
12725         [ALC268_DELL]           = "dell",
12726         [ALC268_ZEPTO]          = "zepto",
12727 #ifdef CONFIG_SND_DEBUG
12728         [ALC268_TEST]           = "test",
12729 #endif
12730         [ALC268_AUTO]           = "auto",
12731 };
12732
12733 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12734         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12735         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12736         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12737         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12738         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12739         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12740                                                 ALC268_ACER_ASPIRE_ONE),
12741         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12742         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
12743                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
12744         /* almost compatible with toshiba but with optional digital outs;
12745          * auto-probing seems working fine
12746          */
12747         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
12748                            ALC268_AUTO),
12749         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12750         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12751         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12752         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12753         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12754         SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
12755         {}
12756 };
12757
12758 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
12759 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
12760         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
12761         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
12762         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
12763                            ALC268_TOSHIBA),
12764         {}
12765 };
12766
12767 static struct alc_config_preset alc268_presets[] = {
12768         [ALC267_QUANTA_IL1] = {
12769                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
12770                             alc268_capture_nosrc_mixer },
12771                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12772                                 alc267_quanta_il1_verbs },
12773                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12774                 .dac_nids = alc268_dac_nids,
12775                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12776                 .adc_nids = alc268_adc_nids_alt,
12777                 .hp_nid = 0x03,
12778                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12779                 .channel_mode = alc268_modes,
12780                 .unsol_event = alc_sku_unsol_event,
12781                 .setup = alc267_quanta_il1_setup,
12782                 .init_hook = alc_inithook,
12783         },
12784         [ALC268_3ST] = {
12785                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12786                             alc268_beep_mixer },
12787                 .init_verbs = { alc268_base_init_verbs },
12788                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12789                 .dac_nids = alc268_dac_nids,
12790                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12791                 .adc_nids = alc268_adc_nids_alt,
12792                 .capsrc_nids = alc268_capsrc_nids,
12793                 .hp_nid = 0x03,
12794                 .dig_out_nid = ALC268_DIGOUT_NID,
12795                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12796                 .channel_mode = alc268_modes,
12797                 .input_mux = &alc268_capture_source,
12798         },
12799         [ALC268_TOSHIBA] = {
12800                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
12801                             alc268_beep_mixer },
12802                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12803                                 alc268_toshiba_verbs },
12804                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12805                 .dac_nids = alc268_dac_nids,
12806                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12807                 .adc_nids = alc268_adc_nids_alt,
12808                 .capsrc_nids = alc268_capsrc_nids,
12809                 .hp_nid = 0x03,
12810                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12811                 .channel_mode = alc268_modes,
12812                 .input_mux = &alc268_capture_source,
12813                 .unsol_event = alc268_toshiba_unsol_event,
12814                 .setup = alc268_toshiba_setup,
12815                 .init_hook = alc268_toshiba_automute,
12816         },
12817         [ALC268_ACER] = {
12818                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12819                             alc268_beep_mixer },
12820                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12821                                 alc268_acer_verbs },
12822                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12823                 .dac_nids = alc268_dac_nids,
12824                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12825                 .adc_nids = alc268_adc_nids_alt,
12826                 .capsrc_nids = alc268_capsrc_nids,
12827                 .hp_nid = 0x02,
12828                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12829                 .channel_mode = alc268_modes,
12830                 .input_mux = &alc268_acer_capture_source,
12831                 .unsol_event = alc268_acer_unsol_event,
12832                 .init_hook = alc268_acer_init_hook,
12833         },
12834         [ALC268_ACER_DMIC] = {
12835                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12836                             alc268_beep_mixer },
12837                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12838                                 alc268_acer_verbs },
12839                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12840                 .dac_nids = alc268_dac_nids,
12841                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12842                 .adc_nids = alc268_adc_nids_alt,
12843                 .capsrc_nids = alc268_capsrc_nids,
12844                 .hp_nid = 0x02,
12845                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12846                 .channel_mode = alc268_modes,
12847                 .input_mux = &alc268_acer_dmic_capture_source,
12848                 .unsol_event = alc268_acer_unsol_event,
12849                 .init_hook = alc268_acer_init_hook,
12850         },
12851         [ALC268_ACER_ASPIRE_ONE] = {
12852                 .mixers = { alc268_acer_aspire_one_mixer,
12853                             alc268_beep_mixer,
12854                             alc268_capture_nosrc_mixer },
12855                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12856                                 alc268_acer_aspire_one_verbs },
12857                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12858                 .dac_nids = alc268_dac_nids,
12859                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12860                 .adc_nids = alc268_adc_nids_alt,
12861                 .capsrc_nids = alc268_capsrc_nids,
12862                 .hp_nid = 0x03,
12863                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12864                 .channel_mode = alc268_modes,
12865                 .unsol_event = alc268_acer_lc_unsol_event,
12866                 .setup = alc268_acer_lc_setup,
12867                 .init_hook = alc268_acer_lc_init_hook,
12868         },
12869         [ALC268_DELL] = {
12870                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
12871                             alc268_capture_nosrc_mixer },
12872                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12873                                 alc268_dell_verbs },
12874                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12875                 .dac_nids = alc268_dac_nids,
12876                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12877                 .adc_nids = alc268_adc_nids_alt,
12878                 .capsrc_nids = alc268_capsrc_nids,
12879                 .hp_nid = 0x02,
12880                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12881                 .channel_mode = alc268_modes,
12882                 .unsol_event = alc_sku_unsol_event,
12883                 .setup = alc268_dell_setup,
12884                 .init_hook = alc_inithook,
12885         },
12886         [ALC268_ZEPTO] = {
12887                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12888                             alc268_beep_mixer },
12889                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12890                                 alc268_toshiba_verbs },
12891                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12892                 .dac_nids = alc268_dac_nids,
12893                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12894                 .adc_nids = alc268_adc_nids_alt,
12895                 .capsrc_nids = alc268_capsrc_nids,
12896                 .hp_nid = 0x03,
12897                 .dig_out_nid = ALC268_DIGOUT_NID,
12898                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12899                 .channel_mode = alc268_modes,
12900                 .input_mux = &alc268_capture_source,
12901                 .setup = alc268_toshiba_setup,
12902                 .init_hook = alc268_toshiba_automute,
12903         },
12904 #ifdef CONFIG_SND_DEBUG
12905         [ALC268_TEST] = {
12906                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
12907                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12908                                 alc268_volume_init_verbs },
12909                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12910                 .dac_nids = alc268_dac_nids,
12911                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12912                 .adc_nids = alc268_adc_nids_alt,
12913                 .capsrc_nids = alc268_capsrc_nids,
12914                 .hp_nid = 0x03,
12915                 .dig_out_nid = ALC268_DIGOUT_NID,
12916                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12917                 .channel_mode = alc268_modes,
12918                 .input_mux = &alc268_capture_source,
12919         },
12920 #endif
12921 };
12922
12923 static int patch_alc268(struct hda_codec *codec)
12924 {
12925         struct alc_spec *spec;
12926         int board_config;
12927         int i, has_beep, err;
12928
12929         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12930         if (spec == NULL)
12931                 return -ENOMEM;
12932
12933         codec->spec = spec;
12934
12935         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12936                                                   alc268_models,
12937                                                   alc268_cfg_tbl);
12938
12939         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
12940                 board_config = snd_hda_check_board_codec_sid_config(codec,
12941                         ALC882_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
12942
12943         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12944                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12945                        codec->chip_name);
12946                 board_config = ALC268_AUTO;
12947         }
12948
12949         if (board_config == ALC268_AUTO) {
12950                 /* automatic parse from the BIOS config */
12951                 err = alc268_parse_auto_config(codec);
12952                 if (err < 0) {
12953                         alc_free(codec);
12954                         return err;
12955                 } else if (!err) {
12956                         printk(KERN_INFO
12957                                "hda_codec: Cannot set up configuration "
12958                                "from BIOS.  Using base mode...\n");
12959                         board_config = ALC268_3ST;
12960                 }
12961         }
12962
12963         if (board_config != ALC268_AUTO)
12964                 setup_preset(codec, &alc268_presets[board_config]);
12965
12966         spec->stream_analog_playback = &alc268_pcm_analog_playback;
12967         spec->stream_analog_capture = &alc268_pcm_analog_capture;
12968         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12969
12970         spec->stream_digital_playback = &alc268_pcm_digital_playback;
12971
12972         has_beep = 0;
12973         for (i = 0; i < spec->num_mixers; i++) {
12974                 if (spec->mixers[i] == alc268_beep_mixer) {
12975                         has_beep = 1;
12976                         break;
12977                 }
12978         }
12979
12980         if (has_beep) {
12981                 err = snd_hda_attach_beep_device(codec, 0x1);
12982                 if (err < 0) {
12983                         alc_free(codec);
12984                         return err;
12985                 }
12986                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12987                         /* override the amp caps for beep generator */
12988                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12989                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12990                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12991                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12992                                           (0 << AC_AMPCAP_MUTE_SHIFT));
12993         }
12994
12995         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12996                 /* check whether NID 0x07 is valid */
12997                 unsigned int wcap = get_wcaps(codec, 0x07);
12998                 int i;
12999
13000                 spec->capsrc_nids = alc268_capsrc_nids;
13001                 /* get type */
13002                 wcap = get_wcaps_type(wcap);
13003                 if (spec->auto_mic ||
13004                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
13005                         spec->adc_nids = alc268_adc_nids_alt;
13006                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
13007                         if (spec->auto_mic)
13008                                 fixup_automic_adc(codec);
13009                         if (spec->auto_mic || spec->input_mux->num_items == 1)
13010                                 add_mixer(spec, alc268_capture_nosrc_mixer);
13011                         else
13012                                 add_mixer(spec, alc268_capture_alt_mixer);
13013                 } else {
13014                         spec->adc_nids = alc268_adc_nids;
13015                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
13016                         add_mixer(spec, alc268_capture_mixer);
13017                 }
13018                 /* set default input source */
13019                 for (i = 0; i < spec->num_adc_nids; i++)
13020                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
13021                                 0, AC_VERB_SET_CONNECT_SEL,
13022                                 i < spec->num_mux_defs ?
13023                                 spec->input_mux[i].items[0].index :
13024                                 spec->input_mux->items[0].index);
13025         }
13026
13027         spec->vmaster_nid = 0x02;
13028
13029         codec->patch_ops = alc_patch_ops;
13030         if (board_config == ALC268_AUTO)
13031                 spec->init_hook = alc268_auto_init;
13032
13033         codec->proc_widget_hook = print_realtek_coef;
13034
13035         return 0;
13036 }
13037
13038 /*
13039  *  ALC269 channel source setting (2 channel)
13040  */
13041 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
13042
13043 #define alc269_dac_nids         alc260_dac_nids
13044
13045 static hda_nid_t alc269_adc_nids[1] = {
13046         /* ADC1 */
13047         0x08,
13048 };
13049
13050 static hda_nid_t alc269_capsrc_nids[1] = {
13051         0x23,
13052 };
13053
13054 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
13055  *       not a mux!
13056  */
13057
13058 #define alc269_modes            alc260_modes
13059 #define alc269_capture_source   alc880_lg_lw_capture_source
13060
13061 static struct snd_kcontrol_new alc269_base_mixer[] = {
13062         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13063         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13064         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13065         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13066         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13067         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13068         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13069         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13070         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13071         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13072         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13073         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
13074         { } /* end */
13075 };
13076
13077 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
13078         /* output mixer control */
13079         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13080         {
13081                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13082                 .name = "Master Playback Switch",
13083                 .info = snd_hda_mixer_amp_switch_info,
13084                 .get = snd_hda_mixer_amp_switch_get,
13085                 .put = alc268_acer_master_sw_put,
13086                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13087         },
13088         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13089         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13090         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13091         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13092         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13093         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13094         { }
13095 };
13096
13097 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
13098         /* output mixer control */
13099         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13100         {
13101                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13102                 .name = "Master Playback Switch",
13103                 .info = snd_hda_mixer_amp_switch_info,
13104                 .get = snd_hda_mixer_amp_switch_get,
13105                 .put = alc268_acer_master_sw_put,
13106                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13107         },
13108         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13109         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13110         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13111         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13112         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13113         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13114         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
13115         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
13116         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
13117         { }
13118 };
13119
13120 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
13121         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13122         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13123         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13124         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13125         { } /* end */
13126 };
13127
13128 /* capture mixer elements */
13129 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
13130         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13131         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13132         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13133         { } /* end */
13134 };
13135
13136 /* FSC amilo */
13137 #define alc269_fujitsu_mixer    alc269_eeepc_mixer
13138
13139 static struct hda_verb alc269_quanta_fl1_verbs[] = {
13140         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13141         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13142         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13143         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13144         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13145         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13146         { }
13147 };
13148
13149 static struct hda_verb alc269_lifebook_verbs[] = {
13150         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13151         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
13152         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13153         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13154         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13155         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13156         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13157         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13158         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13159         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13160         { }
13161 };
13162
13163 /* toggle speaker-output according to the hp-jack state */
13164 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
13165 {
13166         unsigned int present;
13167         unsigned char bits;
13168
13169         present = snd_hda_jack_detect(codec, 0x15);
13170         bits = present ? AMP_IN_MUTE(0) : 0;
13171         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13172                         AMP_IN_MUTE(0), bits);
13173         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13174                         AMP_IN_MUTE(0), bits);
13175
13176         snd_hda_codec_write(codec, 0x20, 0,
13177                         AC_VERB_SET_COEF_INDEX, 0x0c);
13178         snd_hda_codec_write(codec, 0x20, 0,
13179                         AC_VERB_SET_PROC_COEF, 0x680);
13180
13181         snd_hda_codec_write(codec, 0x20, 0,
13182                         AC_VERB_SET_COEF_INDEX, 0x0c);
13183         snd_hda_codec_write(codec, 0x20, 0,
13184                         AC_VERB_SET_PROC_COEF, 0x480);
13185 }
13186
13187 /* toggle speaker-output according to the hp-jacks state */
13188 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
13189 {
13190         unsigned int present;
13191         unsigned char bits;
13192
13193         /* Check laptop headphone socket */
13194         present = snd_hda_jack_detect(codec, 0x15);
13195
13196         /* Check port replicator headphone socket */
13197         present |= snd_hda_jack_detect(codec, 0x1a);
13198
13199         bits = present ? AMP_IN_MUTE(0) : 0;
13200         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13201                         AMP_IN_MUTE(0), bits);
13202         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13203                         AMP_IN_MUTE(0), bits);
13204
13205         snd_hda_codec_write(codec, 0x20, 0,
13206                         AC_VERB_SET_COEF_INDEX, 0x0c);
13207         snd_hda_codec_write(codec, 0x20, 0,
13208                         AC_VERB_SET_PROC_COEF, 0x680);
13209
13210         snd_hda_codec_write(codec, 0x20, 0,
13211                         AC_VERB_SET_COEF_INDEX, 0x0c);
13212         snd_hda_codec_write(codec, 0x20, 0,
13213                         AC_VERB_SET_PROC_COEF, 0x480);
13214 }
13215
13216 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
13217 {
13218         unsigned int present_laptop;
13219         unsigned int present_dock;
13220
13221         present_laptop  = snd_hda_jack_detect(codec, 0x18);
13222         present_dock    = snd_hda_jack_detect(codec, 0x1b);
13223
13224         /* Laptop mic port overrides dock mic port, design decision */
13225         if (present_dock)
13226                 snd_hda_codec_write(codec, 0x23, 0,
13227                                 AC_VERB_SET_CONNECT_SEL, 0x3);
13228         if (present_laptop)
13229                 snd_hda_codec_write(codec, 0x23, 0,
13230                                 AC_VERB_SET_CONNECT_SEL, 0x0);
13231         if (!present_dock && !present_laptop)
13232                 snd_hda_codec_write(codec, 0x23, 0,
13233                                 AC_VERB_SET_CONNECT_SEL, 0x1);
13234 }
13235
13236 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
13237                                     unsigned int res)
13238 {
13239         switch (res >> 26) {
13240         case ALC880_HP_EVENT:
13241                 alc269_quanta_fl1_speaker_automute(codec);
13242                 break;
13243         case ALC880_MIC_EVENT:
13244                 alc_mic_automute(codec);
13245                 break;
13246         }
13247 }
13248
13249 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
13250                                         unsigned int res)
13251 {
13252         if ((res >> 26) == ALC880_HP_EVENT)
13253                 alc269_lifebook_speaker_automute(codec);
13254         if ((res >> 26) == ALC880_MIC_EVENT)
13255                 alc269_lifebook_mic_autoswitch(codec);
13256 }
13257
13258 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
13259 {
13260         struct alc_spec *spec = codec->spec;
13261         spec->ext_mic.pin = 0x18;
13262         spec->ext_mic.mux_idx = 0;
13263         spec->int_mic.pin = 0x19;
13264         spec->int_mic.mux_idx = 1;
13265         spec->auto_mic = 1;
13266 }
13267
13268 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
13269 {
13270         alc269_quanta_fl1_speaker_automute(codec);
13271         alc_mic_automute(codec);
13272 }
13273
13274 static void alc269_lifebook_init_hook(struct hda_codec *codec)
13275 {
13276         alc269_lifebook_speaker_automute(codec);
13277         alc269_lifebook_mic_autoswitch(codec);
13278 }
13279
13280 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
13281         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13282         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
13283         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13284         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13285         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13286         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13287         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13288         {}
13289 };
13290
13291 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
13292         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13293         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
13294         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13295         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
13296         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13297         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13298         {}
13299 };
13300
13301 /* toggle speaker-output according to the hp-jack state */
13302 static void alc269_speaker_automute(struct hda_codec *codec)
13303 {
13304         struct alc_spec *spec = codec->spec;
13305         unsigned int nid = spec->autocfg.hp_pins[0];
13306         unsigned int present;
13307         unsigned char bits;
13308
13309         present = snd_hda_jack_detect(codec, nid);
13310         bits = present ? AMP_IN_MUTE(0) : 0;
13311         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13312                                 AMP_IN_MUTE(0), bits);
13313         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13314                                 AMP_IN_MUTE(0), bits);
13315 }
13316
13317 /* unsolicited event for HP jack sensing */
13318 static void alc269_eeepc_unsol_event(struct hda_codec *codec,
13319                                      unsigned int res)
13320 {
13321         switch (res >> 26) {
13322         case ALC880_HP_EVENT:
13323                 alc269_speaker_automute(codec);
13324                 break;
13325         case ALC880_MIC_EVENT:
13326                 alc_mic_automute(codec);
13327                 break;
13328         }
13329 }
13330
13331 static void alc269_eeepc_dmic_setup(struct hda_codec *codec)
13332 {
13333         struct alc_spec *spec = codec->spec;
13334         spec->ext_mic.pin = 0x18;
13335         spec->ext_mic.mux_idx = 0;
13336         spec->int_mic.pin = 0x12;
13337         spec->int_mic.mux_idx = 5;
13338         spec->auto_mic = 1;
13339 }
13340
13341 static void alc269_eeepc_amic_setup(struct hda_codec *codec)
13342 {
13343         struct alc_spec *spec = codec->spec;
13344         spec->ext_mic.pin = 0x18;
13345         spec->ext_mic.mux_idx = 0;
13346         spec->int_mic.pin = 0x19;
13347         spec->int_mic.mux_idx = 1;
13348         spec->auto_mic = 1;
13349 }
13350
13351 static void alc269_eeepc_inithook(struct hda_codec *codec)
13352 {
13353         alc269_speaker_automute(codec);
13354         alc_mic_automute(codec);
13355 }
13356
13357 /*
13358  * generic initialization of ADC, input mixers and output mixers
13359  */
13360 static struct hda_verb alc269_init_verbs[] = {
13361         /*
13362          * Unmute ADC0 and set the default input to mic-in
13363          */
13364         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13365
13366         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
13367          * analog-loopback mixer widget
13368          * Note: PASD motherboards uses the Line In 2 as the input for
13369          * front panel mic (mic 2)
13370          */
13371         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13372         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13373         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13374         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13375         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13376         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13377
13378         /*
13379          * Set up output mixers (0x0c - 0x0e)
13380          */
13381         /* set vol=0 to output mixers */
13382         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13383         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13384
13385         /* set up input amps for analog loopback */
13386         /* Amp Indices: DAC = 0, mixer = 1 */
13387         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13388         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13389         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13390         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13391         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13392         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13393
13394         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13395         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13396         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13397         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13398         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13399         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13400         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13401
13402         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13403         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13404         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13405         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13406         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13407         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13408         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13409
13410         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13411         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
13412
13413         /* FIXME: use matrix-type input source selection */
13414         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13415         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13416         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13417         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13418         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13419         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13420
13421         /* set EAPD */
13422         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13423         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13424         { }
13425 };
13426
13427 #define alc269_auto_create_multi_out_ctls \
13428         alc268_auto_create_multi_out_ctls
13429 #define alc269_auto_create_input_ctls \
13430         alc268_auto_create_input_ctls
13431
13432 #ifdef CONFIG_SND_HDA_POWER_SAVE
13433 #define alc269_loopbacks        alc880_loopbacks
13434 #endif
13435
13436 /* pcm configuration: identical with ALC880 */
13437 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
13438 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
13439 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
13440 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
13441
13442 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
13443         .substreams = 1,
13444         .channels_min = 2,
13445         .channels_max = 8,
13446         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13447         /* NID is set in alc_build_pcms */
13448         .ops = {
13449                 .open = alc880_playback_pcm_open,
13450                 .prepare = alc880_playback_pcm_prepare,
13451                 .cleanup = alc880_playback_pcm_cleanup
13452         },
13453 };
13454
13455 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
13456         .substreams = 1,
13457         .channels_min = 2,
13458         .channels_max = 2,
13459         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13460         /* NID is set in alc_build_pcms */
13461 };
13462
13463 /*
13464  * BIOS auto configuration
13465  */
13466 static int alc269_parse_auto_config(struct hda_codec *codec)
13467 {
13468         struct alc_spec *spec = codec->spec;
13469         int err;
13470         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
13471
13472         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13473                                            alc269_ignore);
13474         if (err < 0)
13475                 return err;
13476
13477         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
13478         if (err < 0)
13479                 return err;
13480         err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
13481         if (err < 0)
13482                 return err;
13483
13484         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13485
13486         if (spec->autocfg.dig_outs)
13487                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
13488
13489         if (spec->kctls.list)
13490                 add_mixer(spec, spec->kctls.list);
13491
13492         add_verb(spec, alc269_init_verbs);
13493         spec->num_mux_defs = 1;
13494         spec->input_mux = &spec->private_imux[0];
13495         /* set default input source */
13496         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
13497                                   0, AC_VERB_SET_CONNECT_SEL,
13498                                   spec->input_mux->items[0].index);
13499
13500         err = alc_auto_add_mic_boost(codec);
13501         if (err < 0)
13502                 return err;
13503
13504         if (!spec->cap_mixer && !spec->no_analog)
13505                 set_capture_mixer(codec);
13506
13507         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
13508
13509         return 1;
13510 }
13511
13512 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
13513 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
13514 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
13515
13516
13517 /* init callback for auto-configuration model -- overriding the default init */
13518 static void alc269_auto_init(struct hda_codec *codec)
13519 {
13520         struct alc_spec *spec = codec->spec;
13521         alc269_auto_init_multi_out(codec);
13522         alc269_auto_init_hp_out(codec);
13523         alc269_auto_init_analog_input(codec);
13524         if (spec->unsol_event)
13525                 alc_inithook(codec);
13526 }
13527
13528 /*
13529  * configuration and preset
13530  */
13531 static const char *alc269_models[ALC269_MODEL_LAST] = {
13532         [ALC269_BASIC]                  = "basic",
13533         [ALC269_QUANTA_FL1]             = "quanta",
13534         [ALC269_ASUS_AMIC]              = "asus-amic",
13535         [ALC269_ASUS_DMIC]              = "asus-dmic",
13536         [ALC269_FUJITSU]                = "fujitsu",
13537         [ALC269_LIFEBOOK]               = "lifebook",
13538         [ALC269_AUTO]                   = "auto",
13539 };
13540
13541 static struct snd_pci_quirk alc269_cfg_tbl[] = {
13542         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
13543         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
13544                       ALC269_ASUS_AMIC),
13545         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_ASUS_AMIC),
13546         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80JT", ALC269_ASUS_AMIC),
13547         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_ASUS_AMIC),
13548         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_ASUS_AMIC),
13549         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_ASUS_AMIC),
13550         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_ASUS_AMIC),
13551         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_ASUS_AMIC),
13552         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_ASUS_AMIC),
13553         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_ASUS_AMIC),
13554         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_ASUS_AMIC),
13555         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_ASUS_AMIC),
13556         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_ASUS_AMIC),
13557         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_ASUS_AMIC),
13558         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_ASUS_AMIC),
13559         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_ASUS_AMIC),
13560         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_ASUS_AMIC),
13561         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_ASUS_AMIC),
13562         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_ASUS_AMIC),
13563         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_ASUS_AMIC),
13564         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_ASUS_AMIC),
13565         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_ASUS_AMIC),
13566         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_ASUS_AMIC),
13567         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_ASUS_AMIC),
13568         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_ASUS_DMIC),
13569         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_ASUS_AMIC),
13570         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_ASUS_AMIC),
13571         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_ASUS_AMIC),
13572         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_ASUS_AMIC),
13573         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
13574                       ALC269_ASUS_DMIC),
13575         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
13576                       ALC269_ASUS_DMIC),
13577         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_ASUS_DMIC),
13578         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_ASUS_DMIC),
13579         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
13580         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
13581         {}
13582 };
13583
13584 static struct alc_config_preset alc269_presets[] = {
13585         [ALC269_BASIC] = {
13586                 .mixers = { alc269_base_mixer },
13587                 .init_verbs = { alc269_init_verbs },
13588                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13589                 .dac_nids = alc269_dac_nids,
13590                 .hp_nid = 0x03,
13591                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13592                 .channel_mode = alc269_modes,
13593                 .input_mux = &alc269_capture_source,
13594         },
13595         [ALC269_QUANTA_FL1] = {
13596                 .mixers = { alc269_quanta_fl1_mixer },
13597                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
13598                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13599                 .dac_nids = alc269_dac_nids,
13600                 .hp_nid = 0x03,
13601                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13602                 .channel_mode = alc269_modes,
13603                 .input_mux = &alc269_capture_source,
13604                 .unsol_event = alc269_quanta_fl1_unsol_event,
13605                 .setup = alc269_quanta_fl1_setup,
13606                 .init_hook = alc269_quanta_fl1_init_hook,
13607         },
13608         [ALC269_ASUS_AMIC] = {
13609                 .mixers = { alc269_eeepc_mixer },
13610                 .cap_mixer = alc269_epc_capture_mixer,
13611                 .init_verbs = { alc269_init_verbs,
13612                                 alc269_eeepc_amic_init_verbs },
13613                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13614                 .dac_nids = alc269_dac_nids,
13615                 .hp_nid = 0x03,
13616                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13617                 .channel_mode = alc269_modes,
13618                 .unsol_event = alc269_eeepc_unsol_event,
13619                 .setup = alc269_eeepc_amic_setup,
13620                 .init_hook = alc269_eeepc_inithook,
13621         },
13622         [ALC269_ASUS_DMIC] = {
13623                 .mixers = { alc269_eeepc_mixer },
13624                 .cap_mixer = alc269_epc_capture_mixer,
13625                 .init_verbs = { alc269_init_verbs,
13626                                 alc269_eeepc_dmic_init_verbs },
13627                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13628                 .dac_nids = alc269_dac_nids,
13629                 .hp_nid = 0x03,
13630                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13631                 .channel_mode = alc269_modes,
13632                 .unsol_event = alc269_eeepc_unsol_event,
13633                 .setup = alc269_eeepc_dmic_setup,
13634                 .init_hook = alc269_eeepc_inithook,
13635         },
13636         [ALC269_FUJITSU] = {
13637                 .mixers = { alc269_fujitsu_mixer },
13638                 .cap_mixer = alc269_epc_capture_mixer,
13639                 .init_verbs = { alc269_init_verbs,
13640                                 alc269_eeepc_dmic_init_verbs },
13641                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13642                 .dac_nids = alc269_dac_nids,
13643                 .hp_nid = 0x03,
13644                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13645                 .channel_mode = alc269_modes,
13646                 .unsol_event = alc269_eeepc_unsol_event,
13647                 .setup = alc269_eeepc_dmic_setup,
13648                 .init_hook = alc269_eeepc_inithook,
13649         },
13650         [ALC269_LIFEBOOK] = {
13651                 .mixers = { alc269_lifebook_mixer },
13652                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13653                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13654                 .dac_nids = alc269_dac_nids,
13655                 .hp_nid = 0x03,
13656                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13657                 .channel_mode = alc269_modes,
13658                 .input_mux = &alc269_capture_source,
13659                 .unsol_event = alc269_lifebook_unsol_event,
13660                 .init_hook = alc269_lifebook_init_hook,
13661         },
13662 };
13663
13664 static int patch_alc269(struct hda_codec *codec)
13665 {
13666         struct alc_spec *spec;
13667         int board_config;
13668         int err;
13669
13670         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13671         if (spec == NULL)
13672                 return -ENOMEM;
13673
13674         codec->spec = spec;
13675
13676         alc_fix_pll_init(codec, 0x20, 0x04, 15);
13677
13678         if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010){
13679                 kfree(codec->chip_name);
13680                 codec->chip_name = kstrdup("ALC259", GFP_KERNEL);
13681                 if (!codec->chip_name) {
13682                         alc_free(codec);
13683                         return -ENOMEM;
13684                 }
13685         }
13686
13687         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13688                                                   alc269_models,
13689                                                   alc269_cfg_tbl);
13690
13691         if (board_config < 0) {
13692                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13693                        codec->chip_name);
13694                 board_config = ALC269_AUTO;
13695         }
13696
13697         if (board_config == ALC269_AUTO) {
13698                 /* automatic parse from the BIOS config */
13699                 err = alc269_parse_auto_config(codec);
13700                 if (err < 0) {
13701                         alc_free(codec);
13702                         return err;
13703                 } else if (!err) {
13704                         printk(KERN_INFO
13705                                "hda_codec: Cannot set up configuration "
13706                                "from BIOS.  Using base mode...\n");
13707                         board_config = ALC269_BASIC;
13708                 }
13709         }
13710
13711         err = snd_hda_attach_beep_device(codec, 0x1);
13712         if (err < 0) {
13713                 alc_free(codec);
13714                 return err;
13715         }
13716
13717         if (board_config != ALC269_AUTO)
13718                 setup_preset(codec, &alc269_presets[board_config]);
13719
13720         if (codec->subsystem_id == 0x17aa3bf8) {
13721                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
13722                  * fix the sample rate of analog I/O to 44.1kHz
13723                  */
13724                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
13725                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
13726         } else {
13727                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
13728                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
13729         }
13730         spec->stream_digital_playback = &alc269_pcm_digital_playback;
13731         spec->stream_digital_capture = &alc269_pcm_digital_capture;
13732
13733         spec->adc_nids = alc269_adc_nids;
13734         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13735         spec->capsrc_nids = alc269_capsrc_nids;
13736         if (!spec->cap_mixer)
13737                 set_capture_mixer(codec);
13738         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13739
13740         spec->vmaster_nid = 0x02;
13741
13742         codec->patch_ops = alc_patch_ops;
13743         if (board_config == ALC269_AUTO)
13744                 spec->init_hook = alc269_auto_init;
13745 #ifdef CONFIG_SND_HDA_POWER_SAVE
13746         if (!spec->loopback.amplist)
13747                 spec->loopback.amplist = alc269_loopbacks;
13748 #endif
13749         codec->proc_widget_hook = print_realtek_coef;
13750
13751         return 0;
13752 }
13753
13754 /*
13755  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13756  */
13757
13758 /*
13759  * set the path ways for 2 channel output
13760  * need to set the codec line out and mic 1 pin widgets to inputs
13761  */
13762 static struct hda_verb alc861_threestack_ch2_init[] = {
13763         /* set pin widget 1Ah (line in) for input */
13764         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13765         /* set pin widget 18h (mic1/2) for input, for mic also enable
13766          * the vref
13767          */
13768         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13769
13770         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13771 #if 0
13772         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13773         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13774 #endif
13775         { } /* end */
13776 };
13777 /*
13778  * 6ch mode
13779  * need to set the codec line out and mic 1 pin widgets to outputs
13780  */
13781 static struct hda_verb alc861_threestack_ch6_init[] = {
13782         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13783         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13784         /* set pin widget 18h (mic1) for output (CLFE)*/
13785         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13786
13787         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13788         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13789
13790         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13791 #if 0
13792         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13793         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13794 #endif
13795         { } /* end */
13796 };
13797
13798 static struct hda_channel_mode alc861_threestack_modes[2] = {
13799         { 2, alc861_threestack_ch2_init },
13800         { 6, alc861_threestack_ch6_init },
13801 };
13802 /* Set mic1 as input and unmute the mixer */
13803 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13804         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13805         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13806         { } /* end */
13807 };
13808 /* Set mic1 as output and mute mixer */
13809 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13810         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13811         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13812         { } /* end */
13813 };
13814
13815 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13816         { 2, alc861_uniwill_m31_ch2_init },
13817         { 4, alc861_uniwill_m31_ch4_init },
13818 };
13819
13820 /* Set mic1 and line-in as input and unmute the mixer */
13821 static struct hda_verb alc861_asus_ch2_init[] = {
13822         /* set pin widget 1Ah (line in) for input */
13823         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13824         /* set pin widget 18h (mic1/2) for input, for mic also enable
13825          * the vref
13826          */
13827         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13828
13829         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13830 #if 0
13831         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13832         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13833 #endif
13834         { } /* end */
13835 };
13836 /* Set mic1 nad line-in as output and mute mixer */
13837 static struct hda_verb alc861_asus_ch6_init[] = {
13838         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13839         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13840         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13841         /* set pin widget 18h (mic1) for output (CLFE)*/
13842         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13843         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13844         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13845         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13846
13847         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13848 #if 0
13849         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13850         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13851 #endif
13852         { } /* end */
13853 };
13854
13855 static struct hda_channel_mode alc861_asus_modes[2] = {
13856         { 2, alc861_asus_ch2_init },
13857         { 6, alc861_asus_ch6_init },
13858 };
13859
13860 /* patch-ALC861 */
13861
13862 static struct snd_kcontrol_new alc861_base_mixer[] = {
13863         /* output mixer control */
13864         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13865         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13866         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13867         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13868         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13869
13870         /*Input mixer control */
13871         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13872            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13873         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13874         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13875         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13876         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13877         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13878         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13879         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13880         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13881
13882         { } /* end */
13883 };
13884
13885 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13886         /* output mixer control */
13887         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13888         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13889         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13890         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13891         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13892
13893         /* Input mixer control */
13894         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13895            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13896         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13897         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13898         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13899         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13900         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13901         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13902         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13903         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13904
13905         {
13906                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13907                 .name = "Channel Mode",
13908                 .info = alc_ch_mode_info,
13909                 .get = alc_ch_mode_get,
13910                 .put = alc_ch_mode_put,
13911                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13912         },
13913         { } /* end */
13914 };
13915
13916 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13917         /* output mixer control */
13918         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13919         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13920         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13921
13922         { } /* end */
13923 };
13924
13925 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13926         /* output mixer control */
13927         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13928         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13929         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13930         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13931         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13932
13933         /* Input mixer control */
13934         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13935            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13936         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13937         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13938         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13939         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13940         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13941         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13942         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13943         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13944
13945         {
13946                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13947                 .name = "Channel Mode",
13948                 .info = alc_ch_mode_info,
13949                 .get = alc_ch_mode_get,
13950                 .put = alc_ch_mode_put,
13951                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13952         },
13953         { } /* end */
13954 };
13955
13956 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13957         /* output mixer control */
13958         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13959         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13960         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13961         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13962         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13963
13964         /* Input mixer control */
13965         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13966         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13967         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13968         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13969         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13970         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13971         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13972         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13973         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13974         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13975
13976         {
13977                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13978                 .name = "Channel Mode",
13979                 .info = alc_ch_mode_info,
13980                 .get = alc_ch_mode_get,
13981                 .put = alc_ch_mode_put,
13982                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13983         },
13984         { }
13985 };
13986
13987 /* additional mixer */
13988 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13989         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13990         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13991         { }
13992 };
13993
13994 /*
13995  * generic initialization of ADC, input mixers and output mixers
13996  */
13997 static struct hda_verb alc861_base_init_verbs[] = {
13998         /*
13999          * Unmute ADC0 and set the default input to mic-in
14000          */
14001         /* port-A for surround (rear panel) */
14002         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14003         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
14004         /* port-B for mic-in (rear panel) with vref */
14005         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14006         /* port-C for line-in (rear panel) */
14007         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14008         /* port-D for Front */
14009         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14010         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14011         /* port-E for HP out (front panel) */
14012         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14013         /* route front PCM to HP */
14014         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14015         /* port-F for mic-in (front panel) with vref */
14016         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14017         /* port-G for CLFE (rear panel) */
14018         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14019         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14020         /* port-H for side (rear panel) */
14021         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14022         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
14023         /* CD-in */
14024         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14025         /* route front mic to ADC1*/
14026         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14027         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14028
14029         /* Unmute DAC0~3 & spdif out*/
14030         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14031         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14032         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14033         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14034         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14035
14036         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14037         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14038         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14039         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14040         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14041
14042         /* Unmute Stereo Mixer 15 */
14043         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14044         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14045         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14046         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14047
14048         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14049         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14050         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14051         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14052         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14053         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14054         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14055         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14056         /* hp used DAC 3 (Front) */
14057         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14058         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14059
14060         { }
14061 };
14062
14063 static struct hda_verb alc861_threestack_init_verbs[] = {
14064         /*
14065          * Unmute ADC0 and set the default input to mic-in
14066          */
14067         /* port-A for surround (rear panel) */
14068         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14069         /* port-B for mic-in (rear panel) with vref */
14070         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14071         /* port-C for line-in (rear panel) */
14072         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14073         /* port-D for Front */
14074         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14075         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14076         /* port-E for HP out (front panel) */
14077         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14078         /* route front PCM to HP */
14079         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14080         /* port-F for mic-in (front panel) with vref */
14081         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14082         /* port-G for CLFE (rear panel) */
14083         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14084         /* port-H for side (rear panel) */
14085         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14086         /* CD-in */
14087         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14088         /* route front mic to ADC1*/
14089         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14090         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14091         /* Unmute DAC0~3 & spdif out*/
14092         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14093         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14094         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14095         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14096         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14097
14098         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14099         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14100         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14101         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14102         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14103
14104         /* Unmute Stereo Mixer 15 */
14105         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14106         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14107         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14108         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14109
14110         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14111         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14112         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14113         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14114         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14115         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14116         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14117         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14118         /* hp used DAC 3 (Front) */
14119         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14120         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14121         { }
14122 };
14123
14124 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
14125         /*
14126          * Unmute ADC0 and set the default input to mic-in
14127          */
14128         /* port-A for surround (rear panel) */
14129         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14130         /* port-B for mic-in (rear panel) with vref */
14131         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14132         /* port-C for line-in (rear panel) */
14133         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14134         /* port-D for Front */
14135         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14136         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14137         /* port-E for HP out (front panel) */
14138         /* this has to be set to VREF80 */
14139         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14140         /* route front PCM to HP */
14141         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14142         /* port-F for mic-in (front panel) with vref */
14143         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14144         /* port-G for CLFE (rear panel) */
14145         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14146         /* port-H for side (rear panel) */
14147         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14148         /* CD-in */
14149         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14150         /* route front mic to ADC1*/
14151         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14152         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14153         /* Unmute DAC0~3 & spdif out*/
14154         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14155         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14156         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14157         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14158         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14159
14160         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14161         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14162         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14163         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14164         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14165
14166         /* Unmute Stereo Mixer 15 */
14167         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14168         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14169         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14170         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14171
14172         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14173         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14174         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14175         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14176         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14177         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14178         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14179         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14180         /* hp used DAC 3 (Front) */
14181         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14182         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14183         { }
14184 };
14185
14186 static struct hda_verb alc861_asus_init_verbs[] = {
14187         /*
14188          * Unmute ADC0 and set the default input to mic-in
14189          */
14190         /* port-A for surround (rear panel)
14191          * according to codec#0 this is the HP jack
14192          */
14193         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
14194         /* route front PCM to HP */
14195         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
14196         /* port-B for mic-in (rear panel) with vref */
14197         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14198         /* port-C for line-in (rear panel) */
14199         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14200         /* port-D for Front */
14201         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14202         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14203         /* port-E for HP out (front panel) */
14204         /* this has to be set to VREF80 */
14205         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14206         /* route front PCM to HP */
14207         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14208         /* port-F for mic-in (front panel) with vref */
14209         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14210         /* port-G for CLFE (rear panel) */
14211         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14212         /* port-H for side (rear panel) */
14213         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14214         /* CD-in */
14215         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14216         /* route front mic to ADC1*/
14217         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14218         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14219         /* Unmute DAC0~3 & spdif out*/
14220         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14221         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14222         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14223         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14224         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14225         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14226         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14227         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14228         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14229         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14230
14231         /* Unmute Stereo Mixer 15 */
14232         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14233         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14234         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14235         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14236
14237         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14238         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14239         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14240         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14241         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14242         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14243         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14244         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14245         /* hp used DAC 3 (Front) */
14246         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14247         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14248         { }
14249 };
14250
14251 /* additional init verbs for ASUS laptops */
14252 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
14253         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
14254         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
14255         { }
14256 };
14257
14258 /*
14259  * generic initialization of ADC, input mixers and output mixers
14260  */
14261 static struct hda_verb alc861_auto_init_verbs[] = {
14262         /*
14263          * Unmute ADC0 and set the default input to mic-in
14264          */
14265         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
14266         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14267
14268         /* Unmute DAC0~3 & spdif out*/
14269         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14270         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14271         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14272         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14273         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14274
14275         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14276         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14277         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14278         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14279         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14280
14281         /* Unmute Stereo Mixer 15 */
14282         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14283         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14284         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14285         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
14286
14287         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14288         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14289         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14290         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14291         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14292         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14293         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14294         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14295
14296         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14297         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14298         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14299         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14300         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14301         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14302         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14303         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14304
14305         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
14306
14307         { }
14308 };
14309
14310 static struct hda_verb alc861_toshiba_init_verbs[] = {
14311         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14312
14313         { }
14314 };
14315
14316 /* toggle speaker-output according to the hp-jack state */
14317 static void alc861_toshiba_automute(struct hda_codec *codec)
14318 {
14319         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
14320
14321         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
14322                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14323         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
14324                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
14325 }
14326
14327 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
14328                                        unsigned int res)
14329 {
14330         if ((res >> 26) == ALC880_HP_EVENT)
14331                 alc861_toshiba_automute(codec);
14332 }
14333
14334 /* pcm configuration: identical with ALC880 */
14335 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
14336 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
14337 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
14338 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
14339
14340
14341 #define ALC861_DIGOUT_NID       0x07
14342
14343 static struct hda_channel_mode alc861_8ch_modes[1] = {
14344         { 8, NULL }
14345 };
14346
14347 static hda_nid_t alc861_dac_nids[4] = {
14348         /* front, surround, clfe, side */
14349         0x03, 0x06, 0x05, 0x04
14350 };
14351
14352 static hda_nid_t alc660_dac_nids[3] = {
14353         /* front, clfe, surround */
14354         0x03, 0x05, 0x06
14355 };
14356
14357 static hda_nid_t alc861_adc_nids[1] = {
14358         /* ADC0-2 */
14359         0x08,
14360 };
14361
14362 static struct hda_input_mux alc861_capture_source = {
14363         .num_items = 5,
14364         .items = {
14365                 { "Mic", 0x0 },
14366                 { "Front Mic", 0x3 },
14367                 { "Line", 0x1 },
14368                 { "CD", 0x4 },
14369                 { "Mixer", 0x5 },
14370         },
14371 };
14372
14373 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
14374 {
14375         struct alc_spec *spec = codec->spec;
14376         hda_nid_t mix, srcs[5];
14377         int i, j, num;
14378
14379         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
14380                 return 0;
14381         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14382         if (num < 0)
14383                 return 0;
14384         for (i = 0; i < num; i++) {
14385                 unsigned int type;
14386                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
14387                 if (type != AC_WID_AUD_OUT)
14388                         continue;
14389                 for (j = 0; j < spec->multiout.num_dacs; j++)
14390                         if (spec->multiout.dac_nids[j] == srcs[i])
14391                                 break;
14392                 if (j >= spec->multiout.num_dacs)
14393                         return srcs[i];
14394         }
14395         return 0;
14396 }
14397
14398 /* fill in the dac_nids table from the parsed pin configuration */
14399 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
14400                                      const struct auto_pin_cfg *cfg)
14401 {
14402         struct alc_spec *spec = codec->spec;
14403         int i;
14404         hda_nid_t nid, dac;
14405
14406         spec->multiout.dac_nids = spec->private_dac_nids;
14407         for (i = 0; i < cfg->line_outs; i++) {
14408                 nid = cfg->line_out_pins[i];
14409                 dac = alc861_look_for_dac(codec, nid);
14410                 if (!dac)
14411                         continue;
14412                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
14413         }
14414         return 0;
14415 }
14416
14417 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
14418                                 hda_nid_t nid, unsigned int chs)
14419 {
14420         return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
14421                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
14422 }
14423
14424 /* add playback controls from the parsed DAC table */
14425 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
14426                                              const struct auto_pin_cfg *cfg)
14427 {
14428         struct alc_spec *spec = codec->spec;
14429         static const char *chname[4] = {
14430                 "Front", "Surround", NULL /*CLFE*/, "Side"
14431         };
14432         hda_nid_t nid;
14433         int i, err;
14434
14435         if (cfg->line_outs == 1) {
14436                 const char *pfx = NULL;
14437                 if (!cfg->hp_outs)
14438                         pfx = "Master";
14439                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
14440                         pfx = "Speaker";
14441                 if (pfx) {
14442                         nid = spec->multiout.dac_nids[0];
14443                         return alc861_create_out_sw(codec, pfx, nid, 3);
14444                 }
14445         }
14446
14447         for (i = 0; i < cfg->line_outs; i++) {
14448                 nid = spec->multiout.dac_nids[i];
14449                 if (!nid)
14450                         continue;
14451                 if (i == 2) {
14452                         /* Center/LFE */
14453                         err = alc861_create_out_sw(codec, "Center", nid, 1);
14454                         if (err < 0)
14455                                 return err;
14456                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
14457                         if (err < 0)
14458                                 return err;
14459                 } else {
14460                         err = alc861_create_out_sw(codec, chname[i], nid, 3);
14461                         if (err < 0)
14462                                 return err;
14463                 }
14464         }
14465         return 0;
14466 }
14467
14468 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
14469 {
14470         struct alc_spec *spec = codec->spec;
14471         int err;
14472         hda_nid_t nid;
14473
14474         if (!pin)
14475                 return 0;
14476
14477         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
14478                 nid = alc861_look_for_dac(codec, pin);
14479                 if (nid) {
14480                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
14481                         if (err < 0)
14482                                 return err;
14483                         spec->multiout.hp_nid = nid;
14484                 }
14485         }
14486         return 0;
14487 }
14488
14489 /* create playback/capture controls for input pins */
14490 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
14491                                                 const struct auto_pin_cfg *cfg)
14492 {
14493         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
14494 }
14495
14496 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
14497                                               hda_nid_t nid,
14498                                               int pin_type, hda_nid_t dac)
14499 {
14500         hda_nid_t mix, srcs[5];
14501         int i, num;
14502
14503         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
14504                             pin_type);
14505         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14506                             AMP_OUT_UNMUTE);
14507         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
14508                 return;
14509         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14510         if (num < 0)
14511                 return;
14512         for (i = 0; i < num; i++) {
14513                 unsigned int mute;
14514                 if (srcs[i] == dac || srcs[i] == 0x15)
14515                         mute = AMP_IN_UNMUTE(i);
14516                 else
14517                         mute = AMP_IN_MUTE(i);
14518                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14519                                     mute);
14520         }
14521 }
14522
14523 static void alc861_auto_init_multi_out(struct hda_codec *codec)
14524 {
14525         struct alc_spec *spec = codec->spec;
14526         int i;
14527
14528         for (i = 0; i < spec->autocfg.line_outs; i++) {
14529                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14530                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14531                 if (nid)
14532                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
14533                                                           spec->multiout.dac_nids[i]);
14534         }
14535 }
14536
14537 static void alc861_auto_init_hp_out(struct hda_codec *codec)
14538 {
14539         struct alc_spec *spec = codec->spec;
14540
14541         if (spec->autocfg.hp_outs)
14542                 alc861_auto_set_output_and_unmute(codec,
14543                                                   spec->autocfg.hp_pins[0],
14544                                                   PIN_HP,
14545                                                   spec->multiout.hp_nid);
14546         if (spec->autocfg.speaker_outs)
14547                 alc861_auto_set_output_and_unmute(codec,
14548                                                   spec->autocfg.speaker_pins[0],
14549                                                   PIN_OUT,
14550                                                   spec->multiout.dac_nids[0]);
14551 }
14552
14553 static void alc861_auto_init_analog_input(struct hda_codec *codec)
14554 {
14555         struct alc_spec *spec = codec->spec;
14556         int i;
14557
14558         for (i = 0; i < AUTO_PIN_LAST; i++) {
14559                 hda_nid_t nid = spec->autocfg.input_pins[i];
14560                 if (nid >= 0x0c && nid <= 0x11)
14561                         alc_set_input_pin(codec, nid, i);
14562         }
14563 }
14564
14565 /* parse the BIOS configuration and set up the alc_spec */
14566 /* return 1 if successful, 0 if the proper config is not found,
14567  * or a negative error code
14568  */
14569 static int alc861_parse_auto_config(struct hda_codec *codec)
14570 {
14571         struct alc_spec *spec = codec->spec;
14572         int err;
14573         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
14574
14575         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14576                                            alc861_ignore);
14577         if (err < 0)
14578                 return err;
14579         if (!spec->autocfg.line_outs)
14580                 return 0; /* can't find valid BIOS pin config */
14581
14582         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
14583         if (err < 0)
14584                 return err;
14585         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
14586         if (err < 0)
14587                 return err;
14588         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
14589         if (err < 0)
14590                 return err;
14591         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
14592         if (err < 0)
14593                 return err;
14594
14595         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14596
14597         if (spec->autocfg.dig_outs)
14598                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
14599
14600         if (spec->kctls.list)
14601                 add_mixer(spec, spec->kctls.list);
14602
14603         add_verb(spec, alc861_auto_init_verbs);
14604
14605         spec->num_mux_defs = 1;
14606         spec->input_mux = &spec->private_imux[0];
14607
14608         spec->adc_nids = alc861_adc_nids;
14609         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
14610         set_capture_mixer(codec);
14611
14612         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b);
14613
14614         return 1;
14615 }
14616
14617 /* additional initialization for auto-configuration model */
14618 static void alc861_auto_init(struct hda_codec *codec)
14619 {
14620         struct alc_spec *spec = codec->spec;
14621         alc861_auto_init_multi_out(codec);
14622         alc861_auto_init_hp_out(codec);
14623         alc861_auto_init_analog_input(codec);
14624         if (spec->unsol_event)
14625                 alc_inithook(codec);
14626 }
14627
14628 #ifdef CONFIG_SND_HDA_POWER_SAVE
14629 static struct hda_amp_list alc861_loopbacks[] = {
14630         { 0x15, HDA_INPUT, 0 },
14631         { 0x15, HDA_INPUT, 1 },
14632         { 0x15, HDA_INPUT, 2 },
14633         { 0x15, HDA_INPUT, 3 },
14634         { } /* end */
14635 };
14636 #endif
14637
14638
14639 /*
14640  * configuration and preset
14641  */
14642 static const char *alc861_models[ALC861_MODEL_LAST] = {
14643         [ALC861_3ST]            = "3stack",
14644         [ALC660_3ST]            = "3stack-660",
14645         [ALC861_3ST_DIG]        = "3stack-dig",
14646         [ALC861_6ST_DIG]        = "6stack-dig",
14647         [ALC861_UNIWILL_M31]    = "uniwill-m31",
14648         [ALC861_TOSHIBA]        = "toshiba",
14649         [ALC861_ASUS]           = "asus",
14650         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
14651         [ALC861_AUTO]           = "auto",
14652 };
14653
14654 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14655         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14656         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14657         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14658         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14659         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14660         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14661         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14662         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14663          *        Any other models that need this preset?
14664          */
14665         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14666         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14667         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14668         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14669         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14670         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14671         /* FIXME: the below seems conflict */
14672         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14673         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14674         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14675         {}
14676 };
14677
14678 static struct alc_config_preset alc861_presets[] = {
14679         [ALC861_3ST] = {
14680                 .mixers = { alc861_3ST_mixer },
14681                 .init_verbs = { alc861_threestack_init_verbs },
14682                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14683                 .dac_nids = alc861_dac_nids,
14684                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14685                 .channel_mode = alc861_threestack_modes,
14686                 .need_dac_fix = 1,
14687                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14688                 .adc_nids = alc861_adc_nids,
14689                 .input_mux = &alc861_capture_source,
14690         },
14691         [ALC861_3ST_DIG] = {
14692                 .mixers = { alc861_base_mixer },
14693                 .init_verbs = { alc861_threestack_init_verbs },
14694                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14695                 .dac_nids = alc861_dac_nids,
14696                 .dig_out_nid = ALC861_DIGOUT_NID,
14697                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14698                 .channel_mode = alc861_threestack_modes,
14699                 .need_dac_fix = 1,
14700                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14701                 .adc_nids = alc861_adc_nids,
14702                 .input_mux = &alc861_capture_source,
14703         },
14704         [ALC861_6ST_DIG] = {
14705                 .mixers = { alc861_base_mixer },
14706                 .init_verbs = { alc861_base_init_verbs },
14707                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14708                 .dac_nids = alc861_dac_nids,
14709                 .dig_out_nid = ALC861_DIGOUT_NID,
14710                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14711                 .channel_mode = alc861_8ch_modes,
14712                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14713                 .adc_nids = alc861_adc_nids,
14714                 .input_mux = &alc861_capture_source,
14715         },
14716         [ALC660_3ST] = {
14717                 .mixers = { alc861_3ST_mixer },
14718                 .init_verbs = { alc861_threestack_init_verbs },
14719                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
14720                 .dac_nids = alc660_dac_nids,
14721                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14722                 .channel_mode = alc861_threestack_modes,
14723                 .need_dac_fix = 1,
14724                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14725                 .adc_nids = alc861_adc_nids,
14726                 .input_mux = &alc861_capture_source,
14727         },
14728         [ALC861_UNIWILL_M31] = {
14729                 .mixers = { alc861_uniwill_m31_mixer },
14730                 .init_verbs = { alc861_uniwill_m31_init_verbs },
14731                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14732                 .dac_nids = alc861_dac_nids,
14733                 .dig_out_nid = ALC861_DIGOUT_NID,
14734                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14735                 .channel_mode = alc861_uniwill_m31_modes,
14736                 .need_dac_fix = 1,
14737                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14738                 .adc_nids = alc861_adc_nids,
14739                 .input_mux = &alc861_capture_source,
14740         },
14741         [ALC861_TOSHIBA] = {
14742                 .mixers = { alc861_toshiba_mixer },
14743                 .init_verbs = { alc861_base_init_verbs,
14744                                 alc861_toshiba_init_verbs },
14745                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14746                 .dac_nids = alc861_dac_nids,
14747                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14748                 .channel_mode = alc883_3ST_2ch_modes,
14749                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14750                 .adc_nids = alc861_adc_nids,
14751                 .input_mux = &alc861_capture_source,
14752                 .unsol_event = alc861_toshiba_unsol_event,
14753                 .init_hook = alc861_toshiba_automute,
14754         },
14755         [ALC861_ASUS] = {
14756                 .mixers = { alc861_asus_mixer },
14757                 .init_verbs = { alc861_asus_init_verbs },
14758                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14759                 .dac_nids = alc861_dac_nids,
14760                 .dig_out_nid = ALC861_DIGOUT_NID,
14761                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14762                 .channel_mode = alc861_asus_modes,
14763                 .need_dac_fix = 1,
14764                 .hp_nid = 0x06,
14765                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14766                 .adc_nids = alc861_adc_nids,
14767                 .input_mux = &alc861_capture_source,
14768         },
14769         [ALC861_ASUS_LAPTOP] = {
14770                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14771                 .init_verbs = { alc861_asus_init_verbs,
14772                                 alc861_asus_laptop_init_verbs },
14773                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14774                 .dac_nids = alc861_dac_nids,
14775                 .dig_out_nid = ALC861_DIGOUT_NID,
14776                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14777                 .channel_mode = alc883_3ST_2ch_modes,
14778                 .need_dac_fix = 1,
14779                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14780                 .adc_nids = alc861_adc_nids,
14781                 .input_mux = &alc861_capture_source,
14782         },
14783 };
14784
14785 /* Pin config fixes */
14786 enum {
14787         PINFIX_FSC_AMILO_PI1505,
14788 };
14789
14790 static struct alc_pincfg alc861_fsc_amilo_pi1505_pinfix[] = {
14791         { 0x0b, 0x0221101f }, /* HP */
14792         { 0x0f, 0x90170310 }, /* speaker */
14793         { }
14794 };
14795
14796 static const struct alc_fixup alc861_fixups[] = {
14797         [PINFIX_FSC_AMILO_PI1505] = {
14798                 .pins = alc861_fsc_amilo_pi1505_pinfix
14799         },
14800 };
14801
14802 static struct snd_pci_quirk alc861_fixup_tbl[] = {
14803         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
14804         {}
14805 };
14806
14807 static int patch_alc861(struct hda_codec *codec)
14808 {
14809         struct alc_spec *spec;
14810         int board_config;
14811         int err;
14812
14813         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14814         if (spec == NULL)
14815                 return -ENOMEM;
14816
14817         codec->spec = spec;
14818
14819         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14820                                                   alc861_models,
14821                                                   alc861_cfg_tbl);
14822
14823         if (board_config < 0) {
14824                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14825                        codec->chip_name);
14826                 board_config = ALC861_AUTO;
14827         }
14828
14829         alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups);
14830
14831         if (board_config == ALC861_AUTO) {
14832                 /* automatic parse from the BIOS config */
14833                 err = alc861_parse_auto_config(codec);
14834                 if (err < 0) {
14835                         alc_free(codec);
14836                         return err;
14837                 } else if (!err) {
14838                         printk(KERN_INFO
14839                                "hda_codec: Cannot set up configuration "
14840                                "from BIOS.  Using base mode...\n");
14841                    board_config = ALC861_3ST_DIG;
14842                 }
14843         }
14844
14845         err = snd_hda_attach_beep_device(codec, 0x23);
14846         if (err < 0) {
14847                 alc_free(codec);
14848                 return err;
14849         }
14850
14851         if (board_config != ALC861_AUTO)
14852                 setup_preset(codec, &alc861_presets[board_config]);
14853
14854         spec->stream_analog_playback = &alc861_pcm_analog_playback;
14855         spec->stream_analog_capture = &alc861_pcm_analog_capture;
14856
14857         spec->stream_digital_playback = &alc861_pcm_digital_playback;
14858         spec->stream_digital_capture = &alc861_pcm_digital_capture;
14859
14860         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14861
14862         spec->vmaster_nid = 0x03;
14863
14864         codec->patch_ops = alc_patch_ops;
14865         if (board_config == ALC861_AUTO)
14866                 spec->init_hook = alc861_auto_init;
14867 #ifdef CONFIG_SND_HDA_POWER_SAVE
14868         if (!spec->loopback.amplist)
14869                 spec->loopback.amplist = alc861_loopbacks;
14870 #endif
14871         codec->proc_widget_hook = print_realtek_coef;
14872
14873         return 0;
14874 }
14875
14876 /*
14877  * ALC861-VD support
14878  *
14879  * Based on ALC882
14880  *
14881  * In addition, an independent DAC
14882  */
14883 #define ALC861VD_DIGOUT_NID     0x06
14884
14885 static hda_nid_t alc861vd_dac_nids[4] = {
14886         /* front, surr, clfe, side surr */
14887         0x02, 0x03, 0x04, 0x05
14888 };
14889
14890 /* dac_nids for ALC660vd are in a different order - according to
14891  * Realtek's driver.
14892  * This should probably result in a different mixer for 6stack models
14893  * of ALC660vd codecs, but for now there is only 3stack mixer
14894  * - and it is the same as in 861vd.
14895  * adc_nids in ALC660vd are (is) the same as in 861vd
14896  */
14897 static hda_nid_t alc660vd_dac_nids[3] = {
14898         /* front, rear, clfe, rear_surr */
14899         0x02, 0x04, 0x03
14900 };
14901
14902 static hda_nid_t alc861vd_adc_nids[1] = {
14903         /* ADC0 */
14904         0x09,
14905 };
14906
14907 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14908
14909 /* input MUX */
14910 /* FIXME: should be a matrix-type input source selection */
14911 static struct hda_input_mux alc861vd_capture_source = {
14912         .num_items = 4,
14913         .items = {
14914                 { "Mic", 0x0 },
14915                 { "Front Mic", 0x1 },
14916                 { "Line", 0x2 },
14917                 { "CD", 0x4 },
14918         },
14919 };
14920
14921 static struct hda_input_mux alc861vd_dallas_capture_source = {
14922         .num_items = 2,
14923         .items = {
14924                 { "Ext Mic", 0x0 },
14925                 { "Int Mic", 0x1 },
14926         },
14927 };
14928
14929 static struct hda_input_mux alc861vd_hp_capture_source = {
14930         .num_items = 2,
14931         .items = {
14932                 { "Front Mic", 0x0 },
14933                 { "ATAPI Mic", 0x1 },
14934         },
14935 };
14936
14937 /*
14938  * 2ch mode
14939  */
14940 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14941         { 2, NULL }
14942 };
14943
14944 /*
14945  * 6ch mode
14946  */
14947 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14948         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14949         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14950         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14951         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14952         { } /* end */
14953 };
14954
14955 /*
14956  * 8ch mode
14957  */
14958 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14959         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14960         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14961         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14962         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14963         { } /* end */
14964 };
14965
14966 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14967         { 6, alc861vd_6stack_ch6_init },
14968         { 8, alc861vd_6stack_ch8_init },
14969 };
14970
14971 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14972         {
14973                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14974                 .name = "Channel Mode",
14975                 .info = alc_ch_mode_info,
14976                 .get = alc_ch_mode_get,
14977                 .put = alc_ch_mode_put,
14978         },
14979         { } /* end */
14980 };
14981
14982 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14983  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14984  */
14985 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14986         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14987         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14988
14989         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14990         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14991
14992         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14993                                 HDA_OUTPUT),
14994         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14995                                 HDA_OUTPUT),
14996         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14997         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14998
14999         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
15000         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
15001
15002         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15003
15004         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15005         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15006         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15007
15008         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15009         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15010         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15011
15012         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15013         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15014
15015         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15016         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15017
15018         { } /* end */
15019 };
15020
15021 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
15022         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15023         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15024
15025         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15026
15027         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15028         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15029         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15030
15031         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15032         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15033         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15034
15035         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15036         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15037
15038         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15039         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15040
15041         { } /* end */
15042 };
15043
15044 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
15045         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15046         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
15047         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15048
15049         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15050
15051         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15052         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15053         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15054
15055         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15056         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15057         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15058
15059         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15060         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15061
15062         { } /* end */
15063 };
15064
15065 /* Pin assignment: Speaker=0x14, HP = 0x15,
15066  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
15067  */
15068 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
15069         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15070         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
15071         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15072         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15073         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
15074         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15075         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15076         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
15077         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15078         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15079         { } /* end */
15080 };
15081
15082 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
15083  *                 Front Mic=0x18, ATAPI Mic = 0x19,
15084  */
15085 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
15086         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15087         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15088         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15089         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15090         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15091         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15092         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15093         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15094
15095         { } /* end */
15096 };
15097
15098 /*
15099  * generic initialization of ADC, input mixers and output mixers
15100  */
15101 static struct hda_verb alc861vd_volume_init_verbs[] = {
15102         /*
15103          * Unmute ADC0 and set the default input to mic-in
15104          */
15105         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15106         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15107
15108         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
15109          * the analog-loopback mixer widget
15110          */
15111         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15112         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15113         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15114         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15115         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15116         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15117
15118         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
15119         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15120         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15121         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15122         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15123
15124         /*
15125          * Set up output mixers (0x02 - 0x05)
15126          */
15127         /* set vol=0 to output mixers */
15128         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15129         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15130         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15131         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15132
15133         /* set up input amps for analog loopback */
15134         /* Amp Indices: DAC = 0, mixer = 1 */
15135         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15136         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15137         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15138         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15139         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15140         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15141         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15142         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15143
15144         { }
15145 };
15146
15147 /*
15148  * 3-stack pin configuration:
15149  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
15150  */
15151 static struct hda_verb alc861vd_3stack_init_verbs[] = {
15152         /*
15153          * Set pin mode and muting
15154          */
15155         /* set front pin widgets 0x14 for output */
15156         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15157         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15158         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15159
15160         /* Mic (rear) pin: input vref at 80% */
15161         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15162         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15163         /* Front Mic pin: input vref at 80% */
15164         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15165         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15166         /* Line In pin: input */
15167         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15168         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15169         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15170         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15171         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15172         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15173         /* CD pin widget for input */
15174         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15175
15176         { }
15177 };
15178
15179 /*
15180  * 6-stack pin configuration:
15181  */
15182 static struct hda_verb alc861vd_6stack_init_verbs[] = {
15183         /*
15184          * Set pin mode and muting
15185          */
15186         /* set front pin widgets 0x14 for output */
15187         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15188         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15189         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15190
15191         /* Rear Pin: output 1 (0x0d) */
15192         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15193         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15194         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
15195         /* CLFE Pin: output 2 (0x0e) */
15196         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15197         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15198         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
15199         /* Side Pin: output 3 (0x0f) */
15200         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15201         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15202         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
15203
15204         /* Mic (rear) pin: input vref at 80% */
15205         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15206         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15207         /* Front Mic pin: input vref at 80% */
15208         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15209         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15210         /* Line In pin: input */
15211         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15212         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15213         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15214         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15215         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15216         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15217         /* CD pin widget for input */
15218         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15219
15220         { }
15221 };
15222
15223 static struct hda_verb alc861vd_eapd_verbs[] = {
15224         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15225         { }
15226 };
15227
15228 static struct hda_verb alc660vd_eapd_verbs[] = {
15229         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15230         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15231         { }
15232 };
15233
15234 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
15235         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15236         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15237         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
15238         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15239         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15240         {}
15241 };
15242
15243 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
15244 {
15245         unsigned int present;
15246         unsigned char bits;
15247
15248         present = snd_hda_jack_detect(codec, 0x18);
15249         bits = present ? HDA_AMP_MUTE : 0;
15250
15251         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
15252                                  HDA_AMP_MUTE, bits);
15253 }
15254
15255 static void alc861vd_lenovo_setup(struct hda_codec *codec)
15256 {
15257         struct alc_spec *spec = codec->spec;
15258         spec->autocfg.hp_pins[0] = 0x1b;
15259         spec->autocfg.speaker_pins[0] = 0x14;
15260 }
15261
15262 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
15263 {
15264         alc_automute_amp(codec);
15265         alc861vd_lenovo_mic_automute(codec);
15266 }
15267
15268 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
15269                                         unsigned int res)
15270 {
15271         switch (res >> 26) {
15272         case ALC880_MIC_EVENT:
15273                 alc861vd_lenovo_mic_automute(codec);
15274                 break;
15275         default:
15276                 alc_automute_amp_unsol_event(codec, res);
15277                 break;
15278         }
15279 }
15280
15281 static struct hda_verb alc861vd_dallas_verbs[] = {
15282         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15283         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15284         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15285         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15286
15287         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15288         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15289         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15290         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15291         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15292         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15293         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15294         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15295
15296         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15297         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15298         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15299         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15300         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15301         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15302         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15303         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15304
15305         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15306         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15307         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15308         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15309         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15310         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15311         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15312         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15313
15314         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15315         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15316         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15317         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15318
15319         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15320         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15321         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15322
15323         { } /* end */
15324 };
15325
15326 /* toggle speaker-output according to the hp-jack state */
15327 static void alc861vd_dallas_setup(struct hda_codec *codec)
15328 {
15329         struct alc_spec *spec = codec->spec;
15330
15331         spec->autocfg.hp_pins[0] = 0x15;
15332         spec->autocfg.speaker_pins[0] = 0x14;
15333 }
15334
15335 #ifdef CONFIG_SND_HDA_POWER_SAVE
15336 #define alc861vd_loopbacks      alc880_loopbacks
15337 #endif
15338
15339 /* pcm configuration: identical with ALC880 */
15340 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
15341 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
15342 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
15343 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
15344
15345 /*
15346  * configuration and preset
15347  */
15348 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
15349         [ALC660VD_3ST]          = "3stack-660",
15350         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
15351         [ALC660VD_ASUS_V1S]     = "asus-v1s",
15352         [ALC861VD_3ST]          = "3stack",
15353         [ALC861VD_3ST_DIG]      = "3stack-digout",
15354         [ALC861VD_6ST_DIG]      = "6stack-digout",
15355         [ALC861VD_LENOVO]       = "lenovo",
15356         [ALC861VD_DALLAS]       = "dallas",
15357         [ALC861VD_HP]           = "hp",
15358         [ALC861VD_AUTO]         = "auto",
15359 };
15360
15361 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
15362         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
15363         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
15364         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
15365         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
15366         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
15367         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
15368         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
15369         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
15370         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
15371         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
15372         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
15373         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
15374         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
15375         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
15376         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
15377         {}
15378 };
15379
15380 static struct alc_config_preset alc861vd_presets[] = {
15381         [ALC660VD_3ST] = {
15382                 .mixers = { alc861vd_3st_mixer },
15383                 .init_verbs = { alc861vd_volume_init_verbs,
15384                                  alc861vd_3stack_init_verbs },
15385                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15386                 .dac_nids = alc660vd_dac_nids,
15387                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15388                 .channel_mode = alc861vd_3stack_2ch_modes,
15389                 .input_mux = &alc861vd_capture_source,
15390         },
15391         [ALC660VD_3ST_DIG] = {
15392                 .mixers = { alc861vd_3st_mixer },
15393                 .init_verbs = { alc861vd_volume_init_verbs,
15394                                  alc861vd_3stack_init_verbs },
15395                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15396                 .dac_nids = alc660vd_dac_nids,
15397                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15398                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15399                 .channel_mode = alc861vd_3stack_2ch_modes,
15400                 .input_mux = &alc861vd_capture_source,
15401         },
15402         [ALC861VD_3ST] = {
15403                 .mixers = { alc861vd_3st_mixer },
15404                 .init_verbs = { alc861vd_volume_init_verbs,
15405                                  alc861vd_3stack_init_verbs },
15406                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15407                 .dac_nids = alc861vd_dac_nids,
15408                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15409                 .channel_mode = alc861vd_3stack_2ch_modes,
15410                 .input_mux = &alc861vd_capture_source,
15411         },
15412         [ALC861VD_3ST_DIG] = {
15413                 .mixers = { alc861vd_3st_mixer },
15414                 .init_verbs = { alc861vd_volume_init_verbs,
15415                                  alc861vd_3stack_init_verbs },
15416                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15417                 .dac_nids = alc861vd_dac_nids,
15418                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15419                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15420                 .channel_mode = alc861vd_3stack_2ch_modes,
15421                 .input_mux = &alc861vd_capture_source,
15422         },
15423         [ALC861VD_6ST_DIG] = {
15424                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
15425                 .init_verbs = { alc861vd_volume_init_verbs,
15426                                 alc861vd_6stack_init_verbs },
15427                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15428                 .dac_nids = alc861vd_dac_nids,
15429                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15430                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
15431                 .channel_mode = alc861vd_6stack_modes,
15432                 .input_mux = &alc861vd_capture_source,
15433         },
15434         [ALC861VD_LENOVO] = {
15435                 .mixers = { alc861vd_lenovo_mixer },
15436                 .init_verbs = { alc861vd_volume_init_verbs,
15437                                 alc861vd_3stack_init_verbs,
15438                                 alc861vd_eapd_verbs,
15439                                 alc861vd_lenovo_unsol_verbs },
15440                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15441                 .dac_nids = alc660vd_dac_nids,
15442                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15443                 .channel_mode = alc861vd_3stack_2ch_modes,
15444                 .input_mux = &alc861vd_capture_source,
15445                 .unsol_event = alc861vd_lenovo_unsol_event,
15446                 .setup = alc861vd_lenovo_setup,
15447                 .init_hook = alc861vd_lenovo_init_hook,
15448         },
15449         [ALC861VD_DALLAS] = {
15450                 .mixers = { alc861vd_dallas_mixer },
15451                 .init_verbs = { alc861vd_dallas_verbs },
15452                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15453                 .dac_nids = alc861vd_dac_nids,
15454                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15455                 .channel_mode = alc861vd_3stack_2ch_modes,
15456                 .input_mux = &alc861vd_dallas_capture_source,
15457                 .unsol_event = alc_automute_amp_unsol_event,
15458                 .setup = alc861vd_dallas_setup,
15459                 .init_hook = alc_automute_amp,
15460         },
15461         [ALC861VD_HP] = {
15462                 .mixers = { alc861vd_hp_mixer },
15463                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
15464                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15465                 .dac_nids = alc861vd_dac_nids,
15466                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15467                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15468                 .channel_mode = alc861vd_3stack_2ch_modes,
15469                 .input_mux = &alc861vd_hp_capture_source,
15470                 .unsol_event = alc_automute_amp_unsol_event,
15471                 .setup = alc861vd_dallas_setup,
15472                 .init_hook = alc_automute_amp,
15473         },
15474         [ALC660VD_ASUS_V1S] = {
15475                 .mixers = { alc861vd_lenovo_mixer },
15476                 .init_verbs = { alc861vd_volume_init_verbs,
15477                                 alc861vd_3stack_init_verbs,
15478                                 alc861vd_eapd_verbs,
15479                                 alc861vd_lenovo_unsol_verbs },
15480                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15481                 .dac_nids = alc660vd_dac_nids,
15482                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15483                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15484                 .channel_mode = alc861vd_3stack_2ch_modes,
15485                 .input_mux = &alc861vd_capture_source,
15486                 .unsol_event = alc861vd_lenovo_unsol_event,
15487                 .setup = alc861vd_lenovo_setup,
15488                 .init_hook = alc861vd_lenovo_init_hook,
15489         },
15490 };
15491
15492 /*
15493  * BIOS auto configuration
15494  */
15495 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
15496                                                 const struct auto_pin_cfg *cfg)
15497 {
15498         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x09, 0);
15499 }
15500
15501
15502 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
15503                                 hda_nid_t nid, int pin_type, int dac_idx)
15504 {
15505         alc_set_pin_output(codec, nid, pin_type);
15506 }
15507
15508 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
15509 {
15510         struct alc_spec *spec = codec->spec;
15511         int i;
15512
15513         for (i = 0; i <= HDA_SIDE; i++) {
15514                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
15515                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
15516                 if (nid)
15517                         alc861vd_auto_set_output_and_unmute(codec, nid,
15518                                                             pin_type, i);
15519         }
15520 }
15521
15522
15523 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
15524 {
15525         struct alc_spec *spec = codec->spec;
15526         hda_nid_t pin;
15527
15528         pin = spec->autocfg.hp_pins[0];
15529         if (pin) /* connect to front and use dac 0 */
15530                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
15531         pin = spec->autocfg.speaker_pins[0];
15532         if (pin)
15533                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
15534 }
15535
15536 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
15537
15538 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
15539 {
15540         struct alc_spec *spec = codec->spec;
15541         int i;
15542
15543         for (i = 0; i < AUTO_PIN_LAST; i++) {
15544                 hda_nid_t nid = spec->autocfg.input_pins[i];
15545                 if (alc_is_input_pin(codec, nid)) {
15546                         alc_set_input_pin(codec, nid, i);
15547                         if (nid != ALC861VD_PIN_CD_NID &&
15548                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
15549                                 snd_hda_codec_write(codec, nid, 0,
15550                                                 AC_VERB_SET_AMP_GAIN_MUTE,
15551                                                 AMP_OUT_MUTE);
15552                 }
15553         }
15554 }
15555
15556 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
15557
15558 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
15559 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
15560
15561 /* add playback controls from the parsed DAC table */
15562 /* Based on ALC880 version. But ALC861VD has separate,
15563  * different NIDs for mute/unmute switch and volume control */
15564 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
15565                                              const struct auto_pin_cfg *cfg)
15566 {
15567         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
15568         hda_nid_t nid_v, nid_s;
15569         int i, err;
15570
15571         for (i = 0; i < cfg->line_outs; i++) {
15572                 if (!spec->multiout.dac_nids[i])
15573                         continue;
15574                 nid_v = alc861vd_idx_to_mixer_vol(
15575                                 alc880_dac_to_idx(
15576                                         spec->multiout.dac_nids[i]));
15577                 nid_s = alc861vd_idx_to_mixer_switch(
15578                                 alc880_dac_to_idx(
15579                                         spec->multiout.dac_nids[i]));
15580
15581                 if (i == 2) {
15582                         /* Center/LFE */
15583                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
15584                                               "Center",
15585                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
15586                                                               HDA_OUTPUT));
15587                         if (err < 0)
15588                                 return err;
15589                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
15590                                               "LFE",
15591                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
15592                                                               HDA_OUTPUT));
15593                         if (err < 0)
15594                                 return err;
15595                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
15596                                              "Center",
15597                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
15598                                                               HDA_INPUT));
15599                         if (err < 0)
15600                                 return err;
15601                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
15602                                              "LFE",
15603                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
15604                                                               HDA_INPUT));
15605                         if (err < 0)
15606                                 return err;
15607                 } else {
15608                         const char *pfx;
15609                         if (cfg->line_outs == 1 &&
15610                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
15611                                 if (!cfg->hp_pins)
15612                                         pfx = "Speaker";
15613                                 else
15614                                         pfx = "PCM";
15615                         } else
15616                                 pfx = chname[i];
15617                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
15618                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
15619                                                               HDA_OUTPUT));
15620                         if (err < 0)
15621                                 return err;
15622                         if (cfg->line_outs == 1 &&
15623                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
15624                                 pfx = "Speaker";
15625                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
15626                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
15627                                                               HDA_INPUT));
15628                         if (err < 0)
15629                                 return err;
15630                 }
15631         }
15632         return 0;
15633 }
15634
15635 /* add playback controls for speaker and HP outputs */
15636 /* Based on ALC880 version. But ALC861VD has separate,
15637  * different NIDs for mute/unmute switch and volume control */
15638 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
15639                                         hda_nid_t pin, const char *pfx)
15640 {
15641         hda_nid_t nid_v, nid_s;
15642         int err;
15643
15644         if (!pin)
15645                 return 0;
15646
15647         if (alc880_is_fixed_pin(pin)) {
15648                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
15649                 /* specify the DAC as the extra output */
15650                 if (!spec->multiout.hp_nid)
15651                         spec->multiout.hp_nid = nid_v;
15652                 else
15653                         spec->multiout.extra_out_nid[0] = nid_v;
15654                 /* control HP volume/switch on the output mixer amp */
15655                 nid_v = alc861vd_idx_to_mixer_vol(
15656                                 alc880_fixed_pin_idx(pin));
15657                 nid_s = alc861vd_idx_to_mixer_switch(
15658                                 alc880_fixed_pin_idx(pin));
15659
15660                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
15661                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
15662                 if (err < 0)
15663                         return err;
15664                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
15665                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
15666                 if (err < 0)
15667                         return err;
15668         } else if (alc880_is_multi_pin(pin)) {
15669                 /* set manual connection */
15670                 /* we have only a switch on HP-out PIN */
15671                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
15672                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15673                 if (err < 0)
15674                         return err;
15675         }
15676         return 0;
15677 }
15678
15679 /* parse the BIOS configuration and set up the alc_spec
15680  * return 1 if successful, 0 if the proper config is not found,
15681  * or a negative error code
15682  * Based on ALC880 version - had to change it to override
15683  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15684 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15685 {
15686         struct alc_spec *spec = codec->spec;
15687         int err;
15688         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15689
15690         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15691                                            alc861vd_ignore);
15692         if (err < 0)
15693                 return err;
15694         if (!spec->autocfg.line_outs)
15695                 return 0; /* can't find valid BIOS pin config */
15696
15697         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15698         if (err < 0)
15699                 return err;
15700         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15701         if (err < 0)
15702                 return err;
15703         err = alc861vd_auto_create_extra_out(spec,
15704                                              spec->autocfg.speaker_pins[0],
15705                                              "Speaker");
15706         if (err < 0)
15707                 return err;
15708         err = alc861vd_auto_create_extra_out(spec,
15709                                              spec->autocfg.hp_pins[0],
15710                                              "Headphone");
15711         if (err < 0)
15712                 return err;
15713         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
15714         if (err < 0)
15715                 return err;
15716
15717         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15718
15719         if (spec->autocfg.dig_outs)
15720                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15721
15722         if (spec->kctls.list)
15723                 add_mixer(spec, spec->kctls.list);
15724
15725         add_verb(spec, alc861vd_volume_init_verbs);
15726
15727         spec->num_mux_defs = 1;
15728         spec->input_mux = &spec->private_imux[0];
15729
15730         err = alc_auto_add_mic_boost(codec);
15731         if (err < 0)
15732                 return err;
15733
15734         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
15735
15736         return 1;
15737 }
15738
15739 /* additional initialization for auto-configuration model */
15740 static void alc861vd_auto_init(struct hda_codec *codec)
15741 {
15742         struct alc_spec *spec = codec->spec;
15743         alc861vd_auto_init_multi_out(codec);
15744         alc861vd_auto_init_hp_out(codec);
15745         alc861vd_auto_init_analog_input(codec);
15746         alc861vd_auto_init_input_src(codec);
15747         if (spec->unsol_event)
15748                 alc_inithook(codec);
15749 }
15750
15751 enum {
15752         ALC660VD_FIX_ASUS_GPIO1
15753 };
15754
15755 /* reset GPIO1 */
15756 static const struct hda_verb alc660vd_fix_asus_gpio1_verbs[] = {
15757         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
15758         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
15759         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
15760         { }
15761 };
15762
15763 static const struct alc_fixup alc861vd_fixups[] = {
15764         [ALC660VD_FIX_ASUS_GPIO1] = {
15765                 .verbs = alc660vd_fix_asus_gpio1_verbs,
15766         },
15767 };
15768
15769 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
15770         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
15771         {}
15772 };
15773
15774 static int patch_alc861vd(struct hda_codec *codec)
15775 {
15776         struct alc_spec *spec;
15777         int err, board_config;
15778
15779         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15780         if (spec == NULL)
15781                 return -ENOMEM;
15782
15783         codec->spec = spec;
15784
15785         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15786                                                   alc861vd_models,
15787                                                   alc861vd_cfg_tbl);
15788
15789         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15790                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15791                        codec->chip_name);
15792                 board_config = ALC861VD_AUTO;
15793         }
15794
15795         alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups);
15796
15797         if (board_config == ALC861VD_AUTO) {
15798                 /* automatic parse from the BIOS config */
15799                 err = alc861vd_parse_auto_config(codec);
15800                 if (err < 0) {
15801                         alc_free(codec);
15802                         return err;
15803                 } else if (!err) {
15804                         printk(KERN_INFO
15805                                "hda_codec: Cannot set up configuration "
15806                                "from BIOS.  Using base mode...\n");
15807                         board_config = ALC861VD_3ST;
15808                 }
15809         }
15810
15811         err = snd_hda_attach_beep_device(codec, 0x23);
15812         if (err < 0) {
15813                 alc_free(codec);
15814                 return err;
15815         }
15816
15817         if (board_config != ALC861VD_AUTO)
15818                 setup_preset(codec, &alc861vd_presets[board_config]);
15819
15820         if (codec->vendor_id == 0x10ec0660) {
15821                 /* always turn on EAPD */
15822                 add_verb(spec, alc660vd_eapd_verbs);
15823         }
15824
15825         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15826         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15827
15828         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15829         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15830
15831         if (!spec->adc_nids) {
15832                 spec->adc_nids = alc861vd_adc_nids;
15833                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15834         }
15835         if (!spec->capsrc_nids)
15836                 spec->capsrc_nids = alc861vd_capsrc_nids;
15837
15838         set_capture_mixer(codec);
15839         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15840
15841         spec->vmaster_nid = 0x02;
15842
15843         codec->patch_ops = alc_patch_ops;
15844
15845         if (board_config == ALC861VD_AUTO)
15846                 spec->init_hook = alc861vd_auto_init;
15847 #ifdef CONFIG_SND_HDA_POWER_SAVE
15848         if (!spec->loopback.amplist)
15849                 spec->loopback.amplist = alc861vd_loopbacks;
15850 #endif
15851         codec->proc_widget_hook = print_realtek_coef;
15852
15853         return 0;
15854 }
15855
15856 /*
15857  * ALC662 support
15858  *
15859  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15860  * configuration.  Each pin widget can choose any input DACs and a mixer.
15861  * Each ADC is connected from a mixer of all inputs.  This makes possible
15862  * 6-channel independent captures.
15863  *
15864  * In addition, an independent DAC for the multi-playback (not used in this
15865  * driver yet).
15866  */
15867 #define ALC662_DIGOUT_NID       0x06
15868 #define ALC662_DIGIN_NID        0x0a
15869
15870 static hda_nid_t alc662_dac_nids[4] = {
15871         /* front, rear, clfe, rear_surr */
15872         0x02, 0x03, 0x04
15873 };
15874
15875 static hda_nid_t alc272_dac_nids[2] = {
15876         0x02, 0x03
15877 };
15878
15879 static hda_nid_t alc662_adc_nids[2] = {
15880         /* ADC1-2 */
15881         0x09, 0x08
15882 };
15883
15884 static hda_nid_t alc272_adc_nids[1] = {
15885         /* ADC1-2 */
15886         0x08,
15887 };
15888
15889 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
15890 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
15891
15892
15893 /* input MUX */
15894 /* FIXME: should be a matrix-type input source selection */
15895 static struct hda_input_mux alc662_capture_source = {
15896         .num_items = 4,
15897         .items = {
15898                 { "Mic", 0x0 },
15899                 { "Front Mic", 0x1 },
15900                 { "Line", 0x2 },
15901                 { "CD", 0x4 },
15902         },
15903 };
15904
15905 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15906         .num_items = 2,
15907         .items = {
15908                 { "Mic", 0x1 },
15909                 { "Line", 0x2 },
15910         },
15911 };
15912
15913 static struct hda_input_mux alc663_capture_source = {
15914         .num_items = 3,
15915         .items = {
15916                 { "Mic", 0x0 },
15917                 { "Front Mic", 0x1 },
15918                 { "Line", 0x2 },
15919         },
15920 };
15921
15922 #if 0 /* set to 1 for testing other input sources below */
15923 static struct hda_input_mux alc272_nc10_capture_source = {
15924         .num_items = 16,
15925         .items = {
15926                 { "Autoselect Mic", 0x0 },
15927                 { "Internal Mic", 0x1 },
15928                 { "In-0x02", 0x2 },
15929                 { "In-0x03", 0x3 },
15930                 { "In-0x04", 0x4 },
15931                 { "In-0x05", 0x5 },
15932                 { "In-0x06", 0x6 },
15933                 { "In-0x07", 0x7 },
15934                 { "In-0x08", 0x8 },
15935                 { "In-0x09", 0x9 },
15936                 { "In-0x0a", 0x0a },
15937                 { "In-0x0b", 0x0b },
15938                 { "In-0x0c", 0x0c },
15939                 { "In-0x0d", 0x0d },
15940                 { "In-0x0e", 0x0e },
15941                 { "In-0x0f", 0x0f },
15942         },
15943 };
15944 #endif
15945
15946 /*
15947  * 2ch mode
15948  */
15949 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15950         { 2, NULL }
15951 };
15952
15953 /*
15954  * 2ch mode
15955  */
15956 static struct hda_verb alc662_3ST_ch2_init[] = {
15957         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15958         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15959         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15960         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15961         { } /* end */
15962 };
15963
15964 /*
15965  * 6ch mode
15966  */
15967 static struct hda_verb alc662_3ST_ch6_init[] = {
15968         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15969         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15970         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15971         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15972         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15973         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15974         { } /* end */
15975 };
15976
15977 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15978         { 2, alc662_3ST_ch2_init },
15979         { 6, alc662_3ST_ch6_init },
15980 };
15981
15982 /*
15983  * 2ch mode
15984  */
15985 static struct hda_verb alc662_sixstack_ch6_init[] = {
15986         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15987         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15988         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15989         { } /* end */
15990 };
15991
15992 /*
15993  * 6ch mode
15994  */
15995 static struct hda_verb alc662_sixstack_ch8_init[] = {
15996         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15997         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15998         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15999         { } /* end */
16000 };
16001
16002 static struct hda_channel_mode alc662_5stack_modes[2] = {
16003         { 2, alc662_sixstack_ch6_init },
16004         { 6, alc662_sixstack_ch8_init },
16005 };
16006
16007 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16008  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16009  */
16010
16011 static struct snd_kcontrol_new alc662_base_mixer[] = {
16012         /* output mixer control */
16013         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
16014         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16015         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
16016         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16017         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16018         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16019         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16020         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16021         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16022
16023         /*Input mixer control */
16024         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
16025         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
16026         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
16027         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
16028         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
16029         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
16030         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
16031         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
16032         { } /* end */
16033 };
16034
16035 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
16036         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16037         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16038         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16039         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16040         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16041         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16042         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16043         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16044         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16045         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16046         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16047         { } /* end */
16048 };
16049
16050 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
16051         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16052         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16053         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16054         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16055         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16056         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16057         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16058         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16059         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16060         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16061         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16062         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16063         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16064         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16065         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16066         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16067         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16068         { } /* end */
16069 };
16070
16071 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
16072         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16073         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
16074         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16075         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
16076         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16077         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16078         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16079         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16080         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16081         { } /* end */
16082 };
16083
16084 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
16085         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16086         ALC262_HIPPO_MASTER_SWITCH,
16087
16088         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
16089         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16090         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16091
16092         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16093         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16094         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16095         { } /* end */
16096 };
16097
16098 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
16099         ALC262_HIPPO_MASTER_SWITCH,
16100         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16101         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16102         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16103         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16104         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
16105         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16106         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16107         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16108         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16109         { } /* end */
16110 };
16111
16112 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
16113         .ops = &snd_hda_bind_vol,
16114         .values = {
16115                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16116                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
16117                 0
16118         },
16119 };
16120
16121 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
16122         .ops = &snd_hda_bind_sw,
16123         .values = {
16124                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16125                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16126                 0
16127         },
16128 };
16129
16130 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
16131         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16132         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
16133         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16134         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16135         { } /* end */
16136 };
16137
16138 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
16139         .ops = &snd_hda_bind_sw,
16140         .values = {
16141                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16142                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16143                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16144                 0
16145         },
16146 };
16147
16148 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
16149         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16150         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
16151         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16152         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16153         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16154         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16155
16156         { } /* end */
16157 };
16158
16159 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
16160         .ops = &snd_hda_bind_sw,
16161         .values = {
16162                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16163                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16164                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16165                 0
16166         },
16167 };
16168
16169 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
16170         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16171         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
16172         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16173         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16174         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16175         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16176         { } /* end */
16177 };
16178
16179 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
16180         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16181         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16182         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16183         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16184         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16185         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16186         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16187         { } /* end */
16188 };
16189
16190 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
16191         .ops = &snd_hda_bind_vol,
16192         .values = {
16193                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16194                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
16195                 0
16196         },
16197 };
16198
16199 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
16200         .ops = &snd_hda_bind_sw,
16201         .values = {
16202                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16203                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
16204                 0
16205         },
16206 };
16207
16208 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
16209         HDA_BIND_VOL("Master Playback Volume",
16210                                 &alc663_asus_two_bind_master_vol),
16211         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16212         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16213         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16214         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16215         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16216         { } /* end */
16217 };
16218
16219 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
16220         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16221         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16222         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16223         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16224         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16225         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16226         { } /* end */
16227 };
16228
16229 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
16230         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16231         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16232         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16233         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16234         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16235
16236         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16237         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16238         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16239         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16240         { } /* end */
16241 };
16242
16243 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
16244         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16245         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16246         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16247
16248         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16249         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16250         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16251         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16252         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16253         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16254         { } /* end */
16255 };
16256
16257 static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
16258         .ops = &snd_hda_bind_sw,
16259         .values = {
16260                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16261                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16262                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
16263                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16264                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16265                 0
16266         },
16267 };
16268
16269 static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
16270         .ops = &snd_hda_bind_sw,
16271         .values = {
16272                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16273                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
16274                 0
16275         },
16276 };
16277
16278 static struct snd_kcontrol_new alc663_mode7_mixer[] = {
16279         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
16280         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
16281         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
16282         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16283         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16284         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16285         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16286         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16287         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16288         { } /* end */
16289 };
16290
16291 static struct snd_kcontrol_new alc663_mode8_mixer[] = {
16292         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
16293         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
16294         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
16295         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16296         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16297         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16298         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16299         { } /* end */
16300 };
16301
16302
16303 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
16304         {
16305                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16306                 .name = "Channel Mode",
16307                 .info = alc_ch_mode_info,
16308                 .get = alc_ch_mode_get,
16309                 .put = alc_ch_mode_put,
16310         },
16311         { } /* end */
16312 };
16313
16314 static struct hda_verb alc662_init_verbs[] = {
16315         /* ADC: mute amp left and right */
16316         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16317         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16318         /* Front mixer: unmute input/output amp left and right (volume = 0) */
16319
16320         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16321         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16322         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16323         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16324         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16325
16326         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16327         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16328         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16329         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16330         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16331         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16332
16333         /* Front Pin: output 0 (0x0c) */
16334         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16335         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16336
16337         /* Rear Pin: output 1 (0x0d) */
16338         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16339         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16340
16341         /* CLFE Pin: output 2 (0x0e) */
16342         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16343         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16344
16345         /* Mic (rear) pin: input vref at 80% */
16346         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16347         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16348         /* Front Mic pin: input vref at 80% */
16349         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16350         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16351         /* Line In pin: input */
16352         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16353         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16354         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16355         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16356         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16357         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16358         /* CD pin widget for input */
16359         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16360
16361         /* FIXME: use matrix-type input source selection */
16362         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16363         /* Input mixer */
16364         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16365         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16366
16367         /* always trun on EAPD */
16368         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16369         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16370
16371         { }
16372 };
16373
16374 static struct hda_verb alc662_sue_init_verbs[] = {
16375         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16376         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16377         {}
16378 };
16379
16380 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
16381         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16382         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16383         {}
16384 };
16385
16386 /* Set Unsolicited Event*/
16387 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
16388         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16389         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16390         {}
16391 };
16392
16393 /*
16394  * generic initialization of ADC, input mixers and output mixers
16395  */
16396 static struct hda_verb alc662_auto_init_verbs[] = {
16397         /*
16398          * Unmute ADC and set the default input to mic-in
16399          */
16400         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16401         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16402
16403         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
16404          * mixer widget
16405          * Note: PASD motherboards uses the Line In 2 as the input for front
16406          * panel mic (mic 2)
16407          */
16408         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16409         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16410         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16411         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16412         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16413         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16414
16415         /*
16416          * Set up output mixers (0x0c - 0x0f)
16417          */
16418         /* set vol=0 to output mixers */
16419         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16420         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16421         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16422
16423         /* set up input amps for analog loopback */
16424         /* Amp Indices: DAC = 0, mixer = 1 */
16425         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16426         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16427         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16428         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16429         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16430         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16431
16432
16433         /* FIXME: use matrix-type input source selection */
16434         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16435         /* Input mixer */
16436         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16437         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16438         { }
16439 };
16440
16441 /* additional verbs for ALC663 */
16442 static struct hda_verb alc663_auto_init_verbs[] = {
16443         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16444         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16445         { }
16446 };
16447
16448 static struct hda_verb alc663_m51va_init_verbs[] = {
16449         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16450         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16451         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16452         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16453         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16454         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16455         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16456         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16457         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16458         {}
16459 };
16460
16461 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
16462         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16463         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16464         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16465         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16466         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16467         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16468         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16469         {}
16470 };
16471
16472 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
16473         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16474         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16475         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16476         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16477         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16478         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16479         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16480         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16481         {}
16482 };
16483
16484 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
16485         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16486         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16487         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16488         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16489         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16490         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16491         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16492         {}
16493 };
16494
16495 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
16496         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16497         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16498         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16499         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16500         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16501         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16502         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16503         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16504         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16505         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16506         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16507         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16508         {}
16509 };
16510
16511 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
16512         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16513         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16514         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16515         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16516         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16517         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16518         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16519         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16520         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16521         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16522         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16523         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16524         {}
16525 };
16526
16527 static struct hda_verb alc663_g71v_init_verbs[] = {
16528         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16529         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
16530         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
16531
16532         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16533         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16534         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16535
16536         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16537         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
16538         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16539         {}
16540 };
16541
16542 static struct hda_verb alc663_g50v_init_verbs[] = {
16543         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16544         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16545         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16546
16547         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16548         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16549         {}
16550 };
16551
16552 static struct hda_verb alc662_ecs_init_verbs[] = {
16553         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
16554         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16555         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16556         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16557         {}
16558 };
16559
16560 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
16561         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16562         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16563         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16564         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16565         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16566         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16567         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16568         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16569         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16570         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16571         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16572         {}
16573 };
16574
16575 static struct hda_verb alc272_dell_init_verbs[] = {
16576         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16577         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16578         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16579         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16580         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16581         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16582         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16583         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16584         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16585         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16586         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16587         {}
16588 };
16589
16590 static struct hda_verb alc663_mode7_init_verbs[] = {
16591         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16592         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16593         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16594         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16595         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16596         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16597         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
16598         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16599         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16600         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16601         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16602         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16603         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16604         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16605         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16606         {}
16607 };
16608
16609 static struct hda_verb alc663_mode8_init_verbs[] = {
16610         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16611         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16612         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16613         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16614         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16615         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16616         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16617         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16618         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16619         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16620         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16621         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16622         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16623         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16624         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16625         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16626         {}
16627 };
16628
16629 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
16630         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
16631         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
16632         { } /* end */
16633 };
16634
16635 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
16636         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
16637         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
16638         { } /* end */
16639 };
16640
16641 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
16642 {
16643         unsigned int present;
16644         unsigned char bits;
16645
16646         present = snd_hda_jack_detect(codec, 0x14);
16647         bits = present ? HDA_AMP_MUTE : 0;
16648
16649         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16650                                  HDA_AMP_MUTE, bits);
16651 }
16652
16653 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
16654 {
16655         unsigned int present;
16656         unsigned char bits;
16657
16658         present = snd_hda_jack_detect(codec, 0x1b);
16659         bits = present ? HDA_AMP_MUTE : 0;
16660
16661         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16662                                  HDA_AMP_MUTE, bits);
16663         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16664                                  HDA_AMP_MUTE, bits);
16665 }
16666
16667 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
16668                                            unsigned int res)
16669 {
16670         if ((res >> 26) == ALC880_HP_EVENT)
16671                 alc662_lenovo_101e_all_automute(codec);
16672         if ((res >> 26) == ALC880_FRONT_EVENT)
16673                 alc662_lenovo_101e_ispeaker_automute(codec);
16674 }
16675
16676 /* unsolicited event for HP jack sensing */
16677 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
16678                                      unsigned int res)
16679 {
16680         if ((res >> 26) == ALC880_MIC_EVENT)
16681                 alc_mic_automute(codec);
16682         else
16683                 alc262_hippo_unsol_event(codec, res);
16684 }
16685
16686 static void alc662_eeepc_setup(struct hda_codec *codec)
16687 {
16688         struct alc_spec *spec = codec->spec;
16689
16690         alc262_hippo1_setup(codec);
16691         spec->ext_mic.pin = 0x18;
16692         spec->ext_mic.mux_idx = 0;
16693         spec->int_mic.pin = 0x19;
16694         spec->int_mic.mux_idx = 1;
16695         spec->auto_mic = 1;
16696 }
16697
16698 static void alc662_eeepc_inithook(struct hda_codec *codec)
16699 {
16700         alc262_hippo_automute(codec);
16701         alc_mic_automute(codec);
16702 }
16703
16704 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
16705 {
16706         struct alc_spec *spec = codec->spec;
16707
16708         spec->autocfg.hp_pins[0] = 0x14;
16709         spec->autocfg.speaker_pins[0] = 0x1b;
16710 }
16711
16712 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
16713
16714 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
16715 {
16716         unsigned int present;
16717         unsigned char bits;
16718
16719         present = snd_hda_jack_detect(codec, 0x21);
16720         bits = present ? HDA_AMP_MUTE : 0;
16721         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16722                                 AMP_IN_MUTE(0), bits);
16723         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16724                                 AMP_IN_MUTE(0), bits);
16725 }
16726
16727 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
16728 {
16729         unsigned int present;
16730         unsigned char bits;
16731
16732         present = snd_hda_jack_detect(codec, 0x21);
16733         bits = present ? HDA_AMP_MUTE : 0;
16734         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16735                                 AMP_IN_MUTE(0), bits);
16736         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16737                                 AMP_IN_MUTE(0), bits);
16738         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16739                                 AMP_IN_MUTE(0), bits);
16740         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16741                                 AMP_IN_MUTE(0), bits);
16742 }
16743
16744 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
16745 {
16746         unsigned int present;
16747         unsigned char bits;
16748
16749         present = snd_hda_jack_detect(codec, 0x15);
16750         bits = present ? HDA_AMP_MUTE : 0;
16751         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16752                                 AMP_IN_MUTE(0), bits);
16753         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16754                                 AMP_IN_MUTE(0), bits);
16755         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16756                                 AMP_IN_MUTE(0), bits);
16757         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16758                                 AMP_IN_MUTE(0), bits);
16759 }
16760
16761 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
16762 {
16763         unsigned int present;
16764         unsigned char bits;
16765
16766         present = snd_hda_jack_detect(codec, 0x1b);
16767         bits = present ? 0 : PIN_OUT;
16768         snd_hda_codec_write(codec, 0x14, 0,
16769                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
16770 }
16771
16772 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
16773 {
16774         unsigned int present1, present2;
16775
16776         present1 = snd_hda_jack_detect(codec, 0x21);
16777         present2 = snd_hda_jack_detect(codec, 0x15);
16778
16779         if (present1 || present2) {
16780                 snd_hda_codec_write_cache(codec, 0x14, 0,
16781                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16782         } else {
16783                 snd_hda_codec_write_cache(codec, 0x14, 0,
16784                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16785         }
16786 }
16787
16788 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16789 {
16790         unsigned int present1, present2;
16791
16792         present1 = snd_hda_jack_detect(codec, 0x1b);
16793         present2 = snd_hda_jack_detect(codec, 0x15);
16794
16795         if (present1 || present2) {
16796                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16797                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16798                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16799                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16800         } else {
16801                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16802                                 AMP_IN_MUTE(0), 0);
16803                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16804                                 AMP_IN_MUTE(0), 0);
16805         }
16806 }
16807
16808 static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
16809 {
16810         unsigned int present1, present2;
16811
16812         present1 = snd_hda_codec_read(codec, 0x1b, 0,
16813                         AC_VERB_GET_PIN_SENSE, 0)
16814                         & AC_PINSENSE_PRESENCE;
16815         present2 = snd_hda_codec_read(codec, 0x21, 0,
16816                         AC_VERB_GET_PIN_SENSE, 0)
16817                         & AC_PINSENSE_PRESENCE;
16818
16819         if (present1 || present2) {
16820                 snd_hda_codec_write_cache(codec, 0x14, 0,
16821                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16822                 snd_hda_codec_write_cache(codec, 0x17, 0,
16823                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16824         } else {
16825                 snd_hda_codec_write_cache(codec, 0x14, 0,
16826                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16827                 snd_hda_codec_write_cache(codec, 0x17, 0,
16828                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16829         }
16830 }
16831
16832 static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
16833 {
16834         unsigned int present1, present2;
16835
16836         present1 = snd_hda_codec_read(codec, 0x21, 0,
16837                         AC_VERB_GET_PIN_SENSE, 0)
16838                         & AC_PINSENSE_PRESENCE;
16839         present2 = snd_hda_codec_read(codec, 0x15, 0,
16840                         AC_VERB_GET_PIN_SENSE, 0)
16841                         & AC_PINSENSE_PRESENCE;
16842
16843         if (present1 || present2) {
16844                 snd_hda_codec_write_cache(codec, 0x14, 0,
16845                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16846                 snd_hda_codec_write_cache(codec, 0x17, 0,
16847                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16848         } else {
16849                 snd_hda_codec_write_cache(codec, 0x14, 0,
16850                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16851                 snd_hda_codec_write_cache(codec, 0x17, 0,
16852                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16853         }
16854 }
16855
16856 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16857                                            unsigned int res)
16858 {
16859         switch (res >> 26) {
16860         case ALC880_HP_EVENT:
16861                 alc663_m51va_speaker_automute(codec);
16862                 break;
16863         case ALC880_MIC_EVENT:
16864                 alc_mic_automute(codec);
16865                 break;
16866         }
16867 }
16868
16869 static void alc663_m51va_setup(struct hda_codec *codec)
16870 {
16871         struct alc_spec *spec = codec->spec;
16872         spec->ext_mic.pin = 0x18;
16873         spec->ext_mic.mux_idx = 0;
16874         spec->int_mic.pin = 0x12;
16875         spec->int_mic.mux_idx = 9;
16876         spec->auto_mic = 1;
16877 }
16878
16879 static void alc663_m51va_inithook(struct hda_codec *codec)
16880 {
16881         alc663_m51va_speaker_automute(codec);
16882         alc_mic_automute(codec);
16883 }
16884
16885 /* ***************** Mode1 ******************************/
16886 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
16887
16888 static void alc663_mode1_setup(struct hda_codec *codec)
16889 {
16890         struct alc_spec *spec = codec->spec;
16891         spec->ext_mic.pin = 0x18;
16892         spec->ext_mic.mux_idx = 0;
16893         spec->int_mic.pin = 0x19;
16894         spec->int_mic.mux_idx = 1;
16895         spec->auto_mic = 1;
16896 }
16897
16898 #define alc663_mode1_inithook           alc663_m51va_inithook
16899
16900 /* ***************** Mode2 ******************************/
16901 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16902                                            unsigned int res)
16903 {
16904         switch (res >> 26) {
16905         case ALC880_HP_EVENT:
16906                 alc662_f5z_speaker_automute(codec);
16907                 break;
16908         case ALC880_MIC_EVENT:
16909                 alc_mic_automute(codec);
16910                 break;
16911         }
16912 }
16913
16914 #define alc662_mode2_setup      alc663_mode1_setup
16915
16916 static void alc662_mode2_inithook(struct hda_codec *codec)
16917 {
16918         alc662_f5z_speaker_automute(codec);
16919         alc_mic_automute(codec);
16920 }
16921 /* ***************** Mode3 ******************************/
16922 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16923                                            unsigned int res)
16924 {
16925         switch (res >> 26) {
16926         case ALC880_HP_EVENT:
16927                 alc663_two_hp_m1_speaker_automute(codec);
16928                 break;
16929         case ALC880_MIC_EVENT:
16930                 alc_mic_automute(codec);
16931                 break;
16932         }
16933 }
16934
16935 #define alc663_mode3_setup      alc663_mode1_setup
16936
16937 static void alc663_mode3_inithook(struct hda_codec *codec)
16938 {
16939         alc663_two_hp_m1_speaker_automute(codec);
16940         alc_mic_automute(codec);
16941 }
16942 /* ***************** Mode4 ******************************/
16943 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16944                                            unsigned int res)
16945 {
16946         switch (res >> 26) {
16947         case ALC880_HP_EVENT:
16948                 alc663_21jd_two_speaker_automute(codec);
16949                 break;
16950         case ALC880_MIC_EVENT:
16951                 alc_mic_automute(codec);
16952                 break;
16953         }
16954 }
16955
16956 #define alc663_mode4_setup      alc663_mode1_setup
16957
16958 static void alc663_mode4_inithook(struct hda_codec *codec)
16959 {
16960         alc663_21jd_two_speaker_automute(codec);
16961         alc_mic_automute(codec);
16962 }
16963 /* ***************** Mode5 ******************************/
16964 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16965                                            unsigned int res)
16966 {
16967         switch (res >> 26) {
16968         case ALC880_HP_EVENT:
16969                 alc663_15jd_two_speaker_automute(codec);
16970                 break;
16971         case ALC880_MIC_EVENT:
16972                 alc_mic_automute(codec);
16973                 break;
16974         }
16975 }
16976
16977 #define alc663_mode5_setup      alc663_mode1_setup
16978
16979 static void alc663_mode5_inithook(struct hda_codec *codec)
16980 {
16981         alc663_15jd_two_speaker_automute(codec);
16982         alc_mic_automute(codec);
16983 }
16984 /* ***************** Mode6 ******************************/
16985 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16986                                            unsigned int res)
16987 {
16988         switch (res >> 26) {
16989         case ALC880_HP_EVENT:
16990                 alc663_two_hp_m2_speaker_automute(codec);
16991                 break;
16992         case ALC880_MIC_EVENT:
16993                 alc_mic_automute(codec);
16994                 break;
16995         }
16996 }
16997
16998 #define alc663_mode6_setup      alc663_mode1_setup
16999
17000 static void alc663_mode6_inithook(struct hda_codec *codec)
17001 {
17002         alc663_two_hp_m2_speaker_automute(codec);
17003         alc_mic_automute(codec);
17004 }
17005
17006 /* ***************** Mode7 ******************************/
17007 static void alc663_mode7_unsol_event(struct hda_codec *codec,
17008                                            unsigned int res)
17009 {
17010         switch (res >> 26) {
17011         case ALC880_HP_EVENT:
17012                 alc663_two_hp_m7_speaker_automute(codec);
17013                 break;
17014         case ALC880_MIC_EVENT:
17015                 alc_mic_automute(codec);
17016                 break;
17017         }
17018 }
17019
17020 #define alc663_mode7_setup      alc663_mode1_setup
17021
17022 static void alc663_mode7_inithook(struct hda_codec *codec)
17023 {
17024         alc663_two_hp_m7_speaker_automute(codec);
17025         alc_mic_automute(codec);
17026 }
17027
17028 /* ***************** Mode8 ******************************/
17029 static void alc663_mode8_unsol_event(struct hda_codec *codec,
17030                                            unsigned int res)
17031 {
17032         switch (res >> 26) {
17033         case ALC880_HP_EVENT:
17034                 alc663_two_hp_m8_speaker_automute(codec);
17035                 break;
17036         case ALC880_MIC_EVENT:
17037                 alc_mic_automute(codec);
17038                 break;
17039         }
17040 }
17041
17042 #define alc663_mode8_setup      alc663_m51va_setup
17043
17044 static void alc663_mode8_inithook(struct hda_codec *codec)
17045 {
17046         alc663_two_hp_m8_speaker_automute(codec);
17047         alc_mic_automute(codec);
17048 }
17049
17050 static void alc663_g71v_hp_automute(struct hda_codec *codec)
17051 {
17052         unsigned int present;
17053         unsigned char bits;
17054
17055         present = snd_hda_jack_detect(codec, 0x21);
17056         bits = present ? HDA_AMP_MUTE : 0;
17057         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17058                                  HDA_AMP_MUTE, bits);
17059         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17060                                  HDA_AMP_MUTE, bits);
17061 }
17062
17063 static void alc663_g71v_front_automute(struct hda_codec *codec)
17064 {
17065         unsigned int present;
17066         unsigned char bits;
17067
17068         present = snd_hda_jack_detect(codec, 0x15);
17069         bits = present ? HDA_AMP_MUTE : 0;
17070         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17071                                  HDA_AMP_MUTE, bits);
17072 }
17073
17074 static void alc663_g71v_unsol_event(struct hda_codec *codec,
17075                                            unsigned int res)
17076 {
17077         switch (res >> 26) {
17078         case ALC880_HP_EVENT:
17079                 alc663_g71v_hp_automute(codec);
17080                 break;
17081         case ALC880_FRONT_EVENT:
17082                 alc663_g71v_front_automute(codec);
17083                 break;
17084         case ALC880_MIC_EVENT:
17085                 alc_mic_automute(codec);
17086                 break;
17087         }
17088 }
17089
17090 #define alc663_g71v_setup       alc663_m51va_setup
17091
17092 static void alc663_g71v_inithook(struct hda_codec *codec)
17093 {
17094         alc663_g71v_front_automute(codec);
17095         alc663_g71v_hp_automute(codec);
17096         alc_mic_automute(codec);
17097 }
17098
17099 static void alc663_g50v_unsol_event(struct hda_codec *codec,
17100                                            unsigned int res)
17101 {
17102         switch (res >> 26) {
17103         case ALC880_HP_EVENT:
17104                 alc663_m51va_speaker_automute(codec);
17105                 break;
17106         case ALC880_MIC_EVENT:
17107                 alc_mic_automute(codec);
17108                 break;
17109         }
17110 }
17111
17112 #define alc663_g50v_setup       alc663_m51va_setup
17113
17114 static void alc663_g50v_inithook(struct hda_codec *codec)
17115 {
17116         alc663_m51va_speaker_automute(codec);
17117         alc_mic_automute(codec);
17118 }
17119
17120 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
17121         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17122         ALC262_HIPPO_MASTER_SWITCH,
17123
17124         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
17125         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
17126         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
17127
17128         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
17129         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17130         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17131         { } /* end */
17132 };
17133
17134 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
17135         /* Master Playback automatically created from Speaker and Headphone */
17136         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17137         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17138         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17139         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17140
17141         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17142         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17143         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
17144
17145         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17146         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17147         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
17148         { } /* end */
17149 };
17150
17151 #ifdef CONFIG_SND_HDA_POWER_SAVE
17152 #define alc662_loopbacks        alc880_loopbacks
17153 #endif
17154
17155
17156 /* pcm configuration: identical with ALC880 */
17157 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
17158 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
17159 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
17160 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
17161
17162 /*
17163  * configuration and preset
17164  */
17165 static const char *alc662_models[ALC662_MODEL_LAST] = {
17166         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
17167         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
17168         [ALC662_3ST_6ch]        = "3stack-6ch",
17169         [ALC662_5ST_DIG]        = "6stack-dig",
17170         [ALC662_LENOVO_101E]    = "lenovo-101e",
17171         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
17172         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
17173         [ALC662_ECS] = "ecs",
17174         [ALC663_ASUS_M51VA] = "m51va",
17175         [ALC663_ASUS_G71V] = "g71v",
17176         [ALC663_ASUS_H13] = "h13",
17177         [ALC663_ASUS_G50V] = "g50v",
17178         [ALC663_ASUS_MODE1] = "asus-mode1",
17179         [ALC662_ASUS_MODE2] = "asus-mode2",
17180         [ALC663_ASUS_MODE3] = "asus-mode3",
17181         [ALC663_ASUS_MODE4] = "asus-mode4",
17182         [ALC663_ASUS_MODE5] = "asus-mode5",
17183         [ALC663_ASUS_MODE6] = "asus-mode6",
17184         [ALC663_ASUS_MODE7] = "asus-mode7",
17185         [ALC663_ASUS_MODE8] = "asus-mode8",
17186         [ALC272_DELL]           = "dell",
17187         [ALC272_DELL_ZM1]       = "dell-zm1",
17188         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
17189         [ALC662_AUTO]           = "auto",
17190 };
17191
17192 static struct snd_pci_quirk alc662_cfg_tbl[] = {
17193         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
17194         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
17195         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
17196         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
17197         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
17198         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
17199         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
17200         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
17201         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
17202         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
17203         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
17204         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
17205         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
17206         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
17207         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
17208         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
17209         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
17210         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
17211         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
17212         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
17213         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
17214         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
17215         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
17216         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
17217         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
17218         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
17219         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
17220         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
17221         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
17222         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
17223         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
17224         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
17225         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
17226         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
17227         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
17228         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
17229         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
17230         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
17231         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
17232         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
17233         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
17234         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
17235         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
17236         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
17237         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
17238         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
17239         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
17240         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
17241         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
17242         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
17243         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
17244         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
17245         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
17246         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
17247         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
17248         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
17249         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
17250         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
17251         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
17252         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
17253         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
17254         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
17255                       ALC662_3ST_6ch_DIG),
17256         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB200", ALC663_ASUS_MODE4),
17257         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
17258         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
17259                       ALC662_3ST_6ch_DIG),
17260         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
17261         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
17262         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
17263         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
17264                                         ALC662_3ST_6ch_DIG),
17265         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
17266                            ALC663_ASUS_H13),
17267         SND_PCI_QUIRK(0x8086, 0xd604, "Intel mobo", ALC662_3ST_2ch_DIG),
17268         {}
17269 };
17270
17271 static struct alc_config_preset alc662_presets[] = {
17272         [ALC662_3ST_2ch_DIG] = {
17273                 .mixers = { alc662_3ST_2ch_mixer },
17274                 .init_verbs = { alc662_init_verbs },
17275                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17276                 .dac_nids = alc662_dac_nids,
17277                 .dig_out_nid = ALC662_DIGOUT_NID,
17278                 .dig_in_nid = ALC662_DIGIN_NID,
17279                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17280                 .channel_mode = alc662_3ST_2ch_modes,
17281                 .input_mux = &alc662_capture_source,
17282         },
17283         [ALC662_3ST_6ch_DIG] = {
17284                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17285                 .init_verbs = { alc662_init_verbs },
17286                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17287                 .dac_nids = alc662_dac_nids,
17288                 .dig_out_nid = ALC662_DIGOUT_NID,
17289                 .dig_in_nid = ALC662_DIGIN_NID,
17290                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17291                 .channel_mode = alc662_3ST_6ch_modes,
17292                 .need_dac_fix = 1,
17293                 .input_mux = &alc662_capture_source,
17294         },
17295         [ALC662_3ST_6ch] = {
17296                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17297                 .init_verbs = { alc662_init_verbs },
17298                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17299                 .dac_nids = alc662_dac_nids,
17300                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17301                 .channel_mode = alc662_3ST_6ch_modes,
17302                 .need_dac_fix = 1,
17303                 .input_mux = &alc662_capture_source,
17304         },
17305         [ALC662_5ST_DIG] = {
17306                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
17307                 .init_verbs = { alc662_init_verbs },
17308                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17309                 .dac_nids = alc662_dac_nids,
17310                 .dig_out_nid = ALC662_DIGOUT_NID,
17311                 .dig_in_nid = ALC662_DIGIN_NID,
17312                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
17313                 .channel_mode = alc662_5stack_modes,
17314                 .input_mux = &alc662_capture_source,
17315         },
17316         [ALC662_LENOVO_101E] = {
17317                 .mixers = { alc662_lenovo_101e_mixer },
17318                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
17319                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17320                 .dac_nids = alc662_dac_nids,
17321                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17322                 .channel_mode = alc662_3ST_2ch_modes,
17323                 .input_mux = &alc662_lenovo_101e_capture_source,
17324                 .unsol_event = alc662_lenovo_101e_unsol_event,
17325                 .init_hook = alc662_lenovo_101e_all_automute,
17326         },
17327         [ALC662_ASUS_EEEPC_P701] = {
17328                 .mixers = { alc662_eeepc_p701_mixer },
17329                 .init_verbs = { alc662_init_verbs,
17330                                 alc662_eeepc_sue_init_verbs },
17331                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17332                 .dac_nids = alc662_dac_nids,
17333                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17334                 .channel_mode = alc662_3ST_2ch_modes,
17335                 .unsol_event = alc662_eeepc_unsol_event,
17336                 .setup = alc662_eeepc_setup,
17337                 .init_hook = alc662_eeepc_inithook,
17338         },
17339         [ALC662_ASUS_EEEPC_EP20] = {
17340                 .mixers = { alc662_eeepc_ep20_mixer,
17341                             alc662_chmode_mixer },
17342                 .init_verbs = { alc662_init_verbs,
17343                                 alc662_eeepc_ep20_sue_init_verbs },
17344                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17345                 .dac_nids = alc662_dac_nids,
17346                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17347                 .channel_mode = alc662_3ST_6ch_modes,
17348                 .input_mux = &alc662_lenovo_101e_capture_source,
17349                 .unsol_event = alc662_eeepc_unsol_event,
17350                 .setup = alc662_eeepc_ep20_setup,
17351                 .init_hook = alc662_eeepc_ep20_inithook,
17352         },
17353         [ALC662_ECS] = {
17354                 .mixers = { alc662_ecs_mixer },
17355                 .init_verbs = { alc662_init_verbs,
17356                                 alc662_ecs_init_verbs },
17357                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17358                 .dac_nids = alc662_dac_nids,
17359                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17360                 .channel_mode = alc662_3ST_2ch_modes,
17361                 .unsol_event = alc662_eeepc_unsol_event,
17362                 .setup = alc662_eeepc_setup,
17363                 .init_hook = alc662_eeepc_inithook,
17364         },
17365         [ALC663_ASUS_M51VA] = {
17366                 .mixers = { alc663_m51va_mixer },
17367                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17368                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17369                 .dac_nids = alc662_dac_nids,
17370                 .dig_out_nid = ALC662_DIGOUT_NID,
17371                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17372                 .channel_mode = alc662_3ST_2ch_modes,
17373                 .unsol_event = alc663_m51va_unsol_event,
17374                 .setup = alc663_m51va_setup,
17375                 .init_hook = alc663_m51va_inithook,
17376         },
17377         [ALC663_ASUS_G71V] = {
17378                 .mixers = { alc663_g71v_mixer },
17379                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
17380                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17381                 .dac_nids = alc662_dac_nids,
17382                 .dig_out_nid = ALC662_DIGOUT_NID,
17383                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17384                 .channel_mode = alc662_3ST_2ch_modes,
17385                 .unsol_event = alc663_g71v_unsol_event,
17386                 .setup = alc663_g71v_setup,
17387                 .init_hook = alc663_g71v_inithook,
17388         },
17389         [ALC663_ASUS_H13] = {
17390                 .mixers = { alc663_m51va_mixer },
17391                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17392                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17393                 .dac_nids = alc662_dac_nids,
17394                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17395                 .channel_mode = alc662_3ST_2ch_modes,
17396                 .unsol_event = alc663_m51va_unsol_event,
17397                 .init_hook = alc663_m51va_inithook,
17398         },
17399         [ALC663_ASUS_G50V] = {
17400                 .mixers = { alc663_g50v_mixer },
17401                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
17402                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17403                 .dac_nids = alc662_dac_nids,
17404                 .dig_out_nid = ALC662_DIGOUT_NID,
17405                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17406                 .channel_mode = alc662_3ST_6ch_modes,
17407                 .input_mux = &alc663_capture_source,
17408                 .unsol_event = alc663_g50v_unsol_event,
17409                 .setup = alc663_g50v_setup,
17410                 .init_hook = alc663_g50v_inithook,
17411         },
17412         [ALC663_ASUS_MODE1] = {
17413                 .mixers = { alc663_m51va_mixer },
17414                 .cap_mixer = alc662_auto_capture_mixer,
17415                 .init_verbs = { alc662_init_verbs,
17416                                 alc663_21jd_amic_init_verbs },
17417                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17418                 .hp_nid = 0x03,
17419                 .dac_nids = alc662_dac_nids,
17420                 .dig_out_nid = ALC662_DIGOUT_NID,
17421                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17422                 .channel_mode = alc662_3ST_2ch_modes,
17423                 .unsol_event = alc663_mode1_unsol_event,
17424                 .setup = alc663_mode1_setup,
17425                 .init_hook = alc663_mode1_inithook,
17426         },
17427         [ALC662_ASUS_MODE2] = {
17428                 .mixers = { alc662_1bjd_mixer },
17429                 .cap_mixer = alc662_auto_capture_mixer,
17430                 .init_verbs = { alc662_init_verbs,
17431                                 alc662_1bjd_amic_init_verbs },
17432                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17433                 .dac_nids = alc662_dac_nids,
17434                 .dig_out_nid = ALC662_DIGOUT_NID,
17435                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17436                 .channel_mode = alc662_3ST_2ch_modes,
17437                 .unsol_event = alc662_mode2_unsol_event,
17438                 .setup = alc662_mode2_setup,
17439                 .init_hook = alc662_mode2_inithook,
17440         },
17441         [ALC663_ASUS_MODE3] = {
17442                 .mixers = { alc663_two_hp_m1_mixer },
17443                 .cap_mixer = alc662_auto_capture_mixer,
17444                 .init_verbs = { alc662_init_verbs,
17445                                 alc663_two_hp_amic_m1_init_verbs },
17446                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17447                 .hp_nid = 0x03,
17448                 .dac_nids = alc662_dac_nids,
17449                 .dig_out_nid = ALC662_DIGOUT_NID,
17450                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17451                 .channel_mode = alc662_3ST_2ch_modes,
17452                 .unsol_event = alc663_mode3_unsol_event,
17453                 .setup = alc663_mode3_setup,
17454                 .init_hook = alc663_mode3_inithook,
17455         },
17456         [ALC663_ASUS_MODE4] = {
17457                 .mixers = { alc663_asus_21jd_clfe_mixer },
17458                 .cap_mixer = alc662_auto_capture_mixer,
17459                 .init_verbs = { alc662_init_verbs,
17460                                 alc663_21jd_amic_init_verbs},
17461                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17462                 .hp_nid = 0x03,
17463                 .dac_nids = alc662_dac_nids,
17464                 .dig_out_nid = ALC662_DIGOUT_NID,
17465                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17466                 .channel_mode = alc662_3ST_2ch_modes,
17467                 .unsol_event = alc663_mode4_unsol_event,
17468                 .setup = alc663_mode4_setup,
17469                 .init_hook = alc663_mode4_inithook,
17470         },
17471         [ALC663_ASUS_MODE5] = {
17472                 .mixers = { alc663_asus_15jd_clfe_mixer },
17473                 .cap_mixer = alc662_auto_capture_mixer,
17474                 .init_verbs = { alc662_init_verbs,
17475                                 alc663_15jd_amic_init_verbs },
17476                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17477                 .hp_nid = 0x03,
17478                 .dac_nids = alc662_dac_nids,
17479                 .dig_out_nid = ALC662_DIGOUT_NID,
17480                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17481                 .channel_mode = alc662_3ST_2ch_modes,
17482                 .unsol_event = alc663_mode5_unsol_event,
17483                 .setup = alc663_mode5_setup,
17484                 .init_hook = alc663_mode5_inithook,
17485         },
17486         [ALC663_ASUS_MODE6] = {
17487                 .mixers = { alc663_two_hp_m2_mixer },
17488                 .cap_mixer = alc662_auto_capture_mixer,
17489                 .init_verbs = { alc662_init_verbs,
17490                                 alc663_two_hp_amic_m2_init_verbs },
17491                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17492                 .hp_nid = 0x03,
17493                 .dac_nids = alc662_dac_nids,
17494                 .dig_out_nid = ALC662_DIGOUT_NID,
17495                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17496                 .channel_mode = alc662_3ST_2ch_modes,
17497                 .unsol_event = alc663_mode6_unsol_event,
17498                 .setup = alc663_mode6_setup,
17499                 .init_hook = alc663_mode6_inithook,
17500         },
17501         [ALC663_ASUS_MODE7] = {
17502                 .mixers = { alc663_mode7_mixer },
17503                 .cap_mixer = alc662_auto_capture_mixer,
17504                 .init_verbs = { alc662_init_verbs,
17505                                 alc663_mode7_init_verbs },
17506                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17507                 .hp_nid = 0x03,
17508                 .dac_nids = alc662_dac_nids,
17509                 .dig_out_nid = ALC662_DIGOUT_NID,
17510                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17511                 .channel_mode = alc662_3ST_2ch_modes,
17512                 .unsol_event = alc663_mode7_unsol_event,
17513                 .setup = alc663_mode7_setup,
17514                 .init_hook = alc663_mode7_inithook,
17515         },
17516         [ALC663_ASUS_MODE8] = {
17517                 .mixers = { alc663_mode8_mixer },
17518                 .cap_mixer = alc662_auto_capture_mixer,
17519                 .init_verbs = { alc662_init_verbs,
17520                                 alc663_mode8_init_verbs },
17521                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17522                 .hp_nid = 0x03,
17523                 .dac_nids = alc662_dac_nids,
17524                 .dig_out_nid = ALC662_DIGOUT_NID,
17525                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17526                 .channel_mode = alc662_3ST_2ch_modes,
17527                 .unsol_event = alc663_mode8_unsol_event,
17528                 .setup = alc663_mode8_setup,
17529                 .init_hook = alc663_mode8_inithook,
17530         },
17531         [ALC272_DELL] = {
17532                 .mixers = { alc663_m51va_mixer },
17533                 .cap_mixer = alc272_auto_capture_mixer,
17534                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
17535                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17536                 .dac_nids = alc662_dac_nids,
17537                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17538                 .adc_nids = alc272_adc_nids,
17539                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
17540                 .capsrc_nids = alc272_capsrc_nids,
17541                 .channel_mode = alc662_3ST_2ch_modes,
17542                 .unsol_event = alc663_m51va_unsol_event,
17543                 .setup = alc663_m51va_setup,
17544                 .init_hook = alc663_m51va_inithook,
17545         },
17546         [ALC272_DELL_ZM1] = {
17547                 .mixers = { alc663_m51va_mixer },
17548                 .cap_mixer = alc662_auto_capture_mixer,
17549                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
17550                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17551                 .dac_nids = alc662_dac_nids,
17552                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17553                 .adc_nids = alc662_adc_nids,
17554                 .num_adc_nids = 1,
17555                 .capsrc_nids = alc662_capsrc_nids,
17556                 .channel_mode = alc662_3ST_2ch_modes,
17557                 .unsol_event = alc663_m51va_unsol_event,
17558                 .setup = alc663_m51va_setup,
17559                 .init_hook = alc663_m51va_inithook,
17560         },
17561         [ALC272_SAMSUNG_NC10] = {
17562                 .mixers = { alc272_nc10_mixer },
17563                 .init_verbs = { alc662_init_verbs,
17564                                 alc663_21jd_amic_init_verbs },
17565                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17566                 .dac_nids = alc272_dac_nids,
17567                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17568                 .channel_mode = alc662_3ST_2ch_modes,
17569                 /*.input_mux = &alc272_nc10_capture_source,*/
17570                 .unsol_event = alc663_mode4_unsol_event,
17571                 .setup = alc663_mode4_setup,
17572                 .init_hook = alc663_mode4_inithook,
17573         },
17574 };
17575
17576
17577 /*
17578  * BIOS auto configuration
17579  */
17580
17581 /* convert from MIX nid to DAC */
17582 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
17583 {
17584         if (nid == 0x0f)
17585                 return 0x02;
17586         else if (nid >= 0x0c && nid <= 0x0e)
17587                 return nid - 0x0c + 0x02;
17588         else
17589                 return 0;
17590 }
17591
17592 /* get MIX nid connected to the given pin targeted to DAC */
17593 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
17594                                    hda_nid_t dac)
17595 {
17596         hda_nid_t mix[4];
17597         int i, num;
17598
17599         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
17600         for (i = 0; i < num; i++) {
17601                 if (alc662_mix_to_dac(mix[i]) == dac)
17602                         return mix[i];
17603         }
17604         return 0;
17605 }
17606
17607 /* look for an empty DAC slot */
17608 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
17609 {
17610         struct alc_spec *spec = codec->spec;
17611         hda_nid_t srcs[5];
17612         int i, j, num;
17613
17614         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
17615         if (num < 0)
17616                 return 0;
17617         for (i = 0; i < num; i++) {
17618                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
17619                 if (!nid)
17620                         continue;
17621                 for (j = 0; j < spec->multiout.num_dacs; j++)
17622                         if (spec->multiout.dac_nids[j] == nid)
17623                                 break;
17624                 if (j >= spec->multiout.num_dacs)
17625                         return nid;
17626         }
17627         return 0;
17628 }
17629
17630 /* fill in the dac_nids table from the parsed pin configuration */
17631 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
17632                                      const struct auto_pin_cfg *cfg)
17633 {
17634         struct alc_spec *spec = codec->spec;
17635         int i;
17636         hda_nid_t dac;
17637
17638         spec->multiout.dac_nids = spec->private_dac_nids;
17639         for (i = 0; i < cfg->line_outs; i++) {
17640                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
17641                 if (!dac)
17642                         continue;
17643                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
17644         }
17645         return 0;
17646 }
17647
17648 static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
17649                               hda_nid_t nid, unsigned int chs)
17650 {
17651         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17652                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
17653 }
17654
17655 static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
17656                              hda_nid_t nid, unsigned int chs)
17657 {
17658         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17659                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
17660 }
17661
17662 #define alc662_add_stereo_vol(spec, pfx, nid) \
17663         alc662_add_vol_ctl(spec, pfx, nid, 3)
17664 #define alc662_add_stereo_sw(spec, pfx, nid) \
17665         alc662_add_sw_ctl(spec, pfx, nid, 3)
17666
17667 /* add playback controls from the parsed DAC table */
17668 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
17669                                              const struct auto_pin_cfg *cfg)
17670 {
17671         struct alc_spec *spec = codec->spec;
17672         static const char *chname[4] = {
17673                 "Front", "Surround", NULL /*CLFE*/, "Side"
17674         };
17675         hda_nid_t nid, mix;
17676         int i, err;
17677
17678         for (i = 0; i < cfg->line_outs; i++) {
17679                 nid = spec->multiout.dac_nids[i];
17680                 if (!nid)
17681                         continue;
17682                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
17683                 if (!mix)
17684                         continue;
17685                 if (i == 2) {
17686                         /* Center/LFE */
17687                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
17688                         if (err < 0)
17689                                 return err;
17690                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
17691                         if (err < 0)
17692                                 return err;
17693                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
17694                         if (err < 0)
17695                                 return err;
17696                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
17697                         if (err < 0)
17698                                 return err;
17699                 } else {
17700                         const char *pfx;
17701                         if (cfg->line_outs == 1 &&
17702                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
17703                                 if (cfg->hp_outs)
17704                                         pfx = "Speaker";
17705                                 else
17706                                         pfx = "PCM";
17707                         } else
17708                                 pfx = chname[i];
17709                         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
17710                         if (err < 0)
17711                                 return err;
17712                         if (cfg->line_outs == 1 &&
17713                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
17714                                 pfx = "Speaker";
17715                         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
17716                         if (err < 0)
17717                                 return err;
17718                 }
17719         }
17720         return 0;
17721 }
17722
17723 /* add playback controls for speaker and HP outputs */
17724 /* return DAC nid if any new DAC is assigned */
17725 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
17726                                         const char *pfx)
17727 {
17728         struct alc_spec *spec = codec->spec;
17729         hda_nid_t nid, mix;
17730         int err;
17731
17732         if (!pin)
17733                 return 0;
17734         nid = alc662_look_for_dac(codec, pin);
17735         if (!nid) {
17736                 /* the corresponding DAC is already occupied */
17737                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
17738                         return 0; /* no way */
17739                 /* create a switch only */
17740                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17741                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17742         }
17743
17744         mix = alc662_dac_to_mix(codec, pin, nid);
17745         if (!mix)
17746                 return 0;
17747         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
17748         if (err < 0)
17749                 return err;
17750         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
17751         if (err < 0)
17752                 return err;
17753         return nid;
17754 }
17755
17756 /* create playback/capture controls for input pins */
17757 #define alc662_auto_create_input_ctls \
17758         alc882_auto_create_input_ctls
17759
17760 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
17761                                               hda_nid_t nid, int pin_type,
17762                                               hda_nid_t dac)
17763 {
17764         int i, num;
17765         hda_nid_t srcs[4];
17766
17767         alc_set_pin_output(codec, nid, pin_type);
17768         /* need the manual connection? */
17769         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
17770         if (num <= 1)
17771                 return;
17772         for (i = 0; i < num; i++) {
17773                 if (alc662_mix_to_dac(srcs[i]) != dac)
17774                         continue;
17775                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
17776                 return;
17777         }
17778 }
17779
17780 static void alc662_auto_init_multi_out(struct hda_codec *codec)
17781 {
17782         struct alc_spec *spec = codec->spec;
17783         int pin_type = get_pin_type(spec->autocfg.line_out_type);
17784         int i;
17785
17786         for (i = 0; i <= HDA_SIDE; i++) {
17787                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
17788                 if (nid)
17789                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
17790                                         spec->multiout.dac_nids[i]);
17791         }
17792 }
17793
17794 static void alc662_auto_init_hp_out(struct hda_codec *codec)
17795 {
17796         struct alc_spec *spec = codec->spec;
17797         hda_nid_t pin;
17798
17799         pin = spec->autocfg.hp_pins[0];
17800         if (pin)
17801                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
17802                                                   spec->multiout.hp_nid);
17803         pin = spec->autocfg.speaker_pins[0];
17804         if (pin)
17805                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
17806                                         spec->multiout.extra_out_nid[0]);
17807 }
17808
17809 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
17810
17811 static void alc662_auto_init_analog_input(struct hda_codec *codec)
17812 {
17813         struct alc_spec *spec = codec->spec;
17814         int i;
17815
17816         for (i = 0; i < AUTO_PIN_LAST; i++) {
17817                 hda_nid_t nid = spec->autocfg.input_pins[i];
17818                 if (alc_is_input_pin(codec, nid)) {
17819                         alc_set_input_pin(codec, nid, i);
17820                         if (nid != ALC662_PIN_CD_NID &&
17821                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17822                                 snd_hda_codec_write(codec, nid, 0,
17823                                                     AC_VERB_SET_AMP_GAIN_MUTE,
17824                                                     AMP_OUT_MUTE);
17825                 }
17826         }
17827 }
17828
17829 #define alc662_auto_init_input_src      alc882_auto_init_input_src
17830
17831 static int alc662_parse_auto_config(struct hda_codec *codec)
17832 {
17833         struct alc_spec *spec = codec->spec;
17834         int err;
17835         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
17836
17837         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17838                                            alc662_ignore);
17839         if (err < 0)
17840                 return err;
17841         if (!spec->autocfg.line_outs)
17842                 return 0; /* can't find valid BIOS pin config */
17843
17844         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
17845         if (err < 0)
17846                 return err;
17847         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
17848         if (err < 0)
17849                 return err;
17850         err = alc662_auto_create_extra_out(codec,
17851                                            spec->autocfg.speaker_pins[0],
17852                                            "Speaker");
17853         if (err < 0)
17854                 return err;
17855         if (err)
17856                 spec->multiout.extra_out_nid[0] = err;
17857         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
17858                                            "Headphone");
17859         if (err < 0)
17860                 return err;
17861         if (err)
17862                 spec->multiout.hp_nid = err;
17863         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
17864         if (err < 0)
17865                 return err;
17866
17867         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17868
17869         if (spec->autocfg.dig_outs)
17870                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
17871
17872         if (spec->kctls.list)
17873                 add_mixer(spec, spec->kctls.list);
17874
17875         spec->num_mux_defs = 1;
17876         spec->input_mux = &spec->private_imux[0];
17877
17878         add_verb(spec, alc662_auto_init_verbs);
17879         if (codec->vendor_id == 0x10ec0663)
17880                 add_verb(spec, alc663_auto_init_verbs);
17881
17882         err = alc_auto_add_mic_boost(codec);
17883         if (err < 0)
17884                 return err;
17885
17886         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
17887
17888         return 1;
17889 }
17890
17891 /* additional initialization for auto-configuration model */
17892 static void alc662_auto_init(struct hda_codec *codec)
17893 {
17894         struct alc_spec *spec = codec->spec;
17895         alc662_auto_init_multi_out(codec);
17896         alc662_auto_init_hp_out(codec);
17897         alc662_auto_init_analog_input(codec);
17898         alc662_auto_init_input_src(codec);
17899         if (spec->unsol_event)
17900                 alc_inithook(codec);
17901 }
17902
17903 static int patch_alc662(struct hda_codec *codec)
17904 {
17905         struct alc_spec *spec;
17906         int err, board_config;
17907
17908         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17909         if (!spec)
17910                 return -ENOMEM;
17911
17912         codec->spec = spec;
17913
17914         alc_fix_pll_init(codec, 0x20, 0x04, 15);
17915
17916         if (alc_read_coef_idx(codec, 0)==0x8020){
17917                 kfree(codec->chip_name);
17918                 codec->chip_name = kstrdup("ALC661", GFP_KERNEL);
17919                 if (!codec->chip_name) {
17920                         alc_free(codec);
17921                         return -ENOMEM;
17922                 }
17923         }
17924
17925         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
17926                                                   alc662_models,
17927                                                   alc662_cfg_tbl);
17928         if (board_config < 0) {
17929                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17930                        codec->chip_name);
17931                 board_config = ALC662_AUTO;
17932         }
17933
17934         if (board_config == ALC662_AUTO) {
17935                 /* automatic parse from the BIOS config */
17936                 err = alc662_parse_auto_config(codec);
17937                 if (err < 0) {
17938                         alc_free(codec);
17939                         return err;
17940                 } else if (!err) {
17941                         printk(KERN_INFO
17942                                "hda_codec: Cannot set up configuration "
17943                                "from BIOS.  Using base mode...\n");
17944                         board_config = ALC662_3ST_2ch_DIG;
17945                 }
17946         }
17947
17948         err = snd_hda_attach_beep_device(codec, 0x1);
17949         if (err < 0) {
17950                 alc_free(codec);
17951                 return err;
17952         }
17953
17954         if (board_config != ALC662_AUTO)
17955                 setup_preset(codec, &alc662_presets[board_config]);
17956
17957         spec->stream_analog_playback = &alc662_pcm_analog_playback;
17958         spec->stream_analog_capture = &alc662_pcm_analog_capture;
17959
17960         spec->stream_digital_playback = &alc662_pcm_digital_playback;
17961         spec->stream_digital_capture = &alc662_pcm_digital_capture;
17962
17963         if (!spec->adc_nids) {
17964                 spec->adc_nids = alc662_adc_nids;
17965                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
17966         }
17967         if (!spec->capsrc_nids)
17968                 spec->capsrc_nids = alc662_capsrc_nids;
17969
17970         if (!spec->cap_mixer)
17971                 set_capture_mixer(codec);
17972         if (codec->vendor_id == 0x10ec0662)
17973                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17974         else
17975                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
17976
17977         spec->vmaster_nid = 0x02;
17978
17979         codec->patch_ops = alc_patch_ops;
17980         if (board_config == ALC662_AUTO)
17981                 spec->init_hook = alc662_auto_init;
17982 #ifdef CONFIG_SND_HDA_POWER_SAVE
17983         if (!spec->loopback.amplist)
17984                 spec->loopback.amplist = alc662_loopbacks;
17985 #endif
17986         codec->proc_widget_hook = print_realtek_coef;
17987
17988         return 0;
17989 }
17990
17991 static int patch_alc888(struct hda_codec *codec)
17992 {
17993         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
17994                 kfree(codec->chip_name);
17995                 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
17996                 if (!codec->chip_name) {
17997                         alc_free(codec);
17998                         return -ENOMEM;
17999                 }
18000                 return patch_alc662(codec);
18001         }
18002         return patch_alc882(codec);
18003 }
18004
18005 /*
18006  * patch entries
18007  */
18008 static struct hda_codec_preset snd_hda_preset_realtek[] = {
18009         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
18010         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
18011         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
18012         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
18013         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
18014         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
18015         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
18016         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
18017         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
18018           .patch = patch_alc861 },
18019         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
18020         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
18021         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
18022         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
18023           .patch = patch_alc882 },
18024         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
18025           .patch = patch_alc662 },
18026         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
18027         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
18028         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
18029         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
18030         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
18031           .patch = patch_alc882 },
18032         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
18033           .patch = patch_alc882 },
18034         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
18035         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
18036         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
18037           .patch = patch_alc882 },
18038         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
18039         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
18040         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
18041         {} /* terminator */
18042 };
18043
18044 MODULE_ALIAS("snd-hda-codec-id:10ec*");
18045
18046 MODULE_LICENSE("GPL");
18047 MODULE_DESCRIPTION("Realtek HD-audio codec");
18048
18049 static struct hda_codec_preset_list realtek_list = {
18050         .preset = snd_hda_preset_realtek,
18051         .owner = THIS_MODULE,
18052 };
18053
18054 static int __init patch_realtek_init(void)
18055 {
18056         return snd_hda_add_codec_preset(&realtek_list);
18057 }
18058
18059 static void __exit patch_realtek_exit(void)
18060 {
18061         snd_hda_delete_codec_preset(&realtek_list);
18062 }
18063
18064 module_init(patch_realtek_init)
18065 module_exit(patch_realtek_exit)