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 <sound/driver.h>
  27 #include <linux/init.h>
  28 #include <linux/delay.h>
  29 #include <linux/slab.h>
  30 #include <linux/pci.h>
  31 #include <sound/core.h>
  32 #include "hda_codec.h"
  33 #include "hda_local.h"
  34
  35
  36 /* ALC880 board config type */
  37 enum {
  38         ALC880_3ST,
  39         ALC880_3ST_DIG,
  40         ALC880_5ST,
  41         ALC880_5ST_DIG,
  42         ALC880_W810,
  43         ALC880_Z71V,
  44         ALC880_6ST,
  45         ALC880_6ST_DIG,
  46         ALC880_F1734,
  47         ALC880_ASUS,
  48         ALC880_ASUS_DIG,
  49         ALC880_ASUS_W1V,
  50         ALC880_ASUS_DIG2,
  51         ALC880_UNIWILL_DIG,
  52         ALC880_CLEVO,
  53         ALC880_TCL_S700,
  54         ALC880_LG,
  55         ALC880_LG_LW,
  56 #ifdef CONFIG_SND_DEBUG
  57         ALC880_TEST,
  58 #endif
  59         ALC880_AUTO,
  60         ALC880_MODEL_LAST /* last tag */
  61 };
  62
  63 /* ALC260 models */
  64 enum {
  65         ALC260_BASIC,
  66         ALC260_HP,
  67         ALC260_HP_3013,
  68         ALC260_FUJITSU_S702X,
  69         ALC260_ACER,
  70 #ifdef CONFIG_SND_DEBUG
  71         ALC260_TEST,
  72 #endif
  73         ALC260_AUTO,
  74         ALC260_MODEL_LAST /* last tag */
  75 };
  76
  77 /* ALC262 models */
  78 enum {
  79         ALC262_BASIC,
  80         ALC262_FUJITSU,
  81         ALC262_AUTO,
  82         ALC262_MODEL_LAST /* last tag */
  83 };
  84
  85 /* ALC861 models */
  86 enum {
  87         ALC861_3ST,
  88         ALC861_3ST_DIG,
  89         ALC861_6ST_DIG,
  90         ALC861_AUTO,
  91         ALC861_MODEL_LAST,
  92 };
  93
  94 /* ALC882 models */
  95 enum {
  96         ALC882_3ST_DIG,
  97         ALC882_6ST_DIG,
  98         ALC882_AUTO,
  99         ALC882_MODEL_LAST,
 100 };
 101
 102 /* for GPIO Poll */
 103 #define GPIO_MASK       0x03
 104
 105 struct alc_spec {
 106         /* codec parameterization */
 107         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 108         unsigned int num_mixers;
 109
 110         const struct hda_verb *init_verbs[5];   /* initialization verbs
 111                                                  * don't forget NULL termination!
 112                                                  */
 113         unsigned int num_init_verbs;
 114
 115         char *stream_name_analog;       /* analog PCM stream */
 116         struct hda_pcm_stream *stream_analog_playback;
 117         struct hda_pcm_stream *stream_analog_capture;
 118
 119         char *stream_name_digital;      /* digital PCM stream */
 120         struct hda_pcm_stream *stream_digital_playback;
 121         struct hda_pcm_stream *stream_digital_capture;
 122
 123         /* playback */
 124         struct hda_multi_out multiout;  /* playback set-up
 125                                          * max_channels, dacs must be set
 126                                          * dig_out_nid and hp_nid are optional
 127                                          */
 128
 129         /* capture */
 130         unsigned int num_adc_nids;
 131         hda_nid_t *adc_nids;
 132         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 133
 134         /* capture source */
 135         unsigned int num_mux_defs;
 136         const struct hda_input_mux *input_mux;
 137         unsigned int cur_mux[3];
 138
 139         /* channel model */
 140         const struct hda_channel_mode *channel_mode;
 141         int num_channel_mode;
 142
 143         /* PCM information */
 144         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 145
 146         /* dynamic controls, init_verbs and input_mux */
 147         struct auto_pin_cfg autocfg;
 148         unsigned int num_kctl_alloc, num_kctl_used;
 149         struct snd_kcontrol_new *kctl_alloc;
 150         struct hda_input_mux private_imux;
 151         hda_nid_t private_dac_nids[5];
 152
 153         /* hooks */
 154         void (*init_hook)(struct hda_codec *codec);
 155         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 156
 157         /* for pin sensing */
 158         unsigned int sense_updated: 1;
 159         unsigned int jack_present: 1;
 160 };
 161
 162 /*
 163  * configuration template - to be copied to the spec instance
 164  */
 165 struct alc_config_preset {
 166         struct snd_kcontrol_new *mixers[5]; /* should be identical size with spec */
 167         const struct hda_verb *init_verbs[5];
 168         unsigned int num_dacs;
 169         hda_nid_t *dac_nids;
 170         hda_nid_t dig_out_nid;          /* optional */
 171         hda_nid_t hp_nid;               /* optional */
 172         unsigned int num_adc_nids;
 173         hda_nid_t *adc_nids;
 174         hda_nid_t dig_in_nid;
 175         unsigned int num_channel_mode;
 176         const struct hda_channel_mode *channel_mode;
 177         unsigned int num_mux_defs;
 178         const struct hda_input_mux *input_mux;
 179         void (*unsol_event)(struct hda_codec *, unsigned int);
 180         void (*init_hook)(struct hda_codec *);
 181 };
 182
 183
 184 /*
 185  * input MUX handling
 186  */
 187 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 188 {
 189         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 190         struct alc_spec *spec = codec->spec;
 191         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 192         if (mux_idx >= spec->num_mux_defs)
 193                 mux_idx = 0;
 194         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 195 }
 196
 197 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 198 {
 199         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 200         struct alc_spec *spec = codec->spec;
 201         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 202
 203         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 204         return 0;
 205 }
 206
 207 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 208 {
 209         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 210         struct alc_spec *spec = codec->spec;
 211         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 212         unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 213         return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol,
 214                                      spec->adc_nids[adc_idx], &spec->cur_mux[adc_idx]);
 215 }
 216
 217
 218 /*
 219  * channel mode setting
 220  */
 221 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 222 {
 223         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 224         struct alc_spec *spec = codec->spec;
 225         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 226                                     spec->num_channel_mode);
 227 }
 228
 229 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 230 {
 231         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 232         struct alc_spec *spec = codec->spec;
 233         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 234                                    spec->num_channel_mode, spec->multiout.max_channels);
 235 }
 236
 237 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 238 {
 239         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 240         struct alc_spec *spec = codec->spec;
 241         return snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 242                                    spec->num_channel_mode, &spec->multiout.max_channels);
 243 }
 244
 245 /*
 246  * Control the mode of pin widget settings via the mixer.  "pc" is used
 247  * instead of "%" to avoid consequences of accidently treating the % as
 248  * being part of a format specifier.  Maximum allowed length of a value is
 249  * 63 characters plus NULL terminator.
 250  *
 251  * Note: some retasking pin complexes seem to ignore requests for input
 252  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 253  * are requested.  Therefore order this list so that this behaviour will not
 254  * cause problems when mixer clients move through the enum sequentially.
 255  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 256  * March 2006.
 257  */
 258 static char *alc_pin_mode_names[] = {
 259         "Mic 50pc bias", "Mic 80pc bias",
 260         "Line in", "Line out", "Headphone out",
 261 };
 262 static unsigned char alc_pin_mode_values[] = {
 263         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 264 };
 265 /* The control can present all 5 options, or it can limit the options based
 266  * in the pin being assumed to be exclusively an input or an output pin.  In
 267  * addition, "input" pins may or may not process the mic bias option
 268  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 269  * accept requests for bias as of chip versions up to March 2006) and/or
 270  * wiring in the computer.
 271  */
 272 #define ALC_PIN_DIR_IN              0x00
 273 #define ALC_PIN_DIR_OUT             0x01
 274 #define ALC_PIN_DIR_INOUT           0x02
 275 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 276 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 277
 278 /* Info about the pin modes supported by the different pin direction modes.
 279  * For each direction the minimum and maximum values are given.
 280  */
 281 static signed char alc_pin_mode_dir_info[5][2] = {
 282         { 0, 2 },    /* ALC_PIN_DIR_IN */
 283         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 284         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 285         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 286         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 287 };
 288 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 289 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 290 #define alc_pin_mode_n_items(_dir) \
 291         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 292
 293 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 294 {
 295         unsigned int item_num = uinfo->value.enumerated.item;
 296         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 297
 298         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 299         uinfo->count = 1;
 300         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 301
 302         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 303                 item_num = alc_pin_mode_min(dir);
 304         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 305         return 0;
 306 }
 307
 308 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 309 {
 310         unsigned int i;
 311         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 312         hda_nid_t nid = kcontrol->private_value & 0xffff;
 313         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 314         long *valp = ucontrol->value.integer.value;
 315         unsigned int pinctl = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_PIN_WIDGET_CONTROL,0x00);
 316
 317         /* Find enumerated value for current pinctl setting */
 318         i = alc_pin_mode_min(dir);
 319         while (alc_pin_mode_values[i]!=pinctl && i<=alc_pin_mode_max(dir))
 320                 i++;
 321         *valp = i<=alc_pin_mode_max(dir)?i:alc_pin_mode_min(dir);
 322         return 0;
 323 }
 324
 325 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 326 {
 327         signed int change;
 328         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 329         hda_nid_t nid = kcontrol->private_value & 0xffff;
 330         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 331         long val = *ucontrol->value.integer.value;
 332         unsigned int pinctl = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_PIN_WIDGET_CONTROL,0x00);
 333
 334         if (val<alc_pin_mode_min(dir) || val>alc_pin_mode_max(dir))
 335                 val = alc_pin_mode_min(dir);
 336
 337         change = pinctl != alc_pin_mode_values[val];
 338         if (change) {
 339                 /* Set pin mode to that requested */
 340                 snd_hda_codec_write(codec,nid,0,AC_VERB_SET_PIN_WIDGET_CONTROL,
 341                         alc_pin_mode_values[val]);
 342
 343                 /* Also enable the retasking pin's input/output as required
 344                  * for the requested pin mode.  Enum values of 2 or less are
 345                  * input modes.
 346                  *
 347                  * Dynamically switching the input/output buffers probably
 348                  * reduces noise slightly (particularly on input) so we'll
 349                  * do it.  However, having both input and output buffers
 350                  * enabled simultaneously doesn't seem to be problematic if
 351                  * this turns out to be necessary in the future.
 352                  */
 353                 if (val <= 2) {
 354                         snd_hda_codec_write(codec,nid,0,AC_VERB_SET_AMP_GAIN_MUTE,
 355                                 AMP_OUT_MUTE);
 356                         snd_hda_codec_write(codec,nid,0,AC_VERB_SET_AMP_GAIN_MUTE,
 357                                 AMP_IN_UNMUTE(0));
 358                 } else {
 359                         snd_hda_codec_write(codec,nid,0,AC_VERB_SET_AMP_GAIN_MUTE,
 360                                 AMP_IN_MUTE(0));
 361                         snd_hda_codec_write(codec,nid,0,AC_VERB_SET_AMP_GAIN_MUTE,
 362                                 AMP_OUT_UNMUTE);
 363                 }
 364         }
 365         return change;
 366 }
 367
 368 #define ALC_PIN_MODE(xname, nid, dir) \
 369         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 370           .info = alc_pin_mode_info, \
 371           .get = alc_pin_mode_get, \
 372           .put = alc_pin_mode_put, \
 373           .private_value = nid | (dir<<16) }
 374
 375 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 376  * together using a mask with more than one bit set.  This control is
 377  * currently used only by the ALC260 test model.  At this stage they are not
 378  * needed for any "production" models.
 379  */
 380 #ifdef CONFIG_SND_DEBUG
 381 static int alc_gpio_data_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 382 {
 383         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 384         uinfo->count = 1;
 385         uinfo->value.integer.min = 0;
 386         uinfo->value.integer.max = 1;
 387         return 0;
 388 }
 389 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 390 {
 391         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 392         hda_nid_t nid = kcontrol->private_value & 0xffff;
 393         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 394         long *valp = ucontrol->value.integer.value;
 395         unsigned int val = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_GPIO_DATA,0x00);
 396
 397         *valp = (val & mask) != 0;
 398         return 0;
 399 }
 400 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 401 {
 402         signed int change;
 403         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 404         hda_nid_t nid = kcontrol->private_value & 0xffff;
 405         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 406         long val = *ucontrol->value.integer.value;
 407         unsigned int gpio_data = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_GPIO_DATA,0x00);
 408
 409         /* Set/unset the masked GPIO bit(s) as needed */
 410         change = (val==0?0:mask) != (gpio_data & mask);
 411         if (val==0)
 412                 gpio_data &= ~mask;
 413         else
 414                 gpio_data |= mask;
 415         snd_hda_codec_write(codec,nid,0,AC_VERB_SET_GPIO_DATA,gpio_data);
 416
 417         return change;
 418 }
 419 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 420         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 421           .info = alc_gpio_data_info, \
 422           .get = alc_gpio_data_get, \
 423           .put = alc_gpio_data_put, \
 424           .private_value = nid | (mask<<16) }
 425 #endif   /* CONFIG_SND_DEBUG */
 426
 427 /* A switch control to allow the enabling of the digital IO pins on the
 428  * ALC260.  This is incredibly simplistic; the intention of this control is
 429  * to provide something in the test model allowing digital outputs to be
 430  * identified if present.  If models are found which can utilise these
 431  * outputs a more complete mixer control can be devised for those models if
 432  * necessary.
 433  */
 434 #ifdef CONFIG_SND_DEBUG
 435 static int alc_spdif_ctrl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 436 {
 437         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 438         uinfo->count = 1;
 439         uinfo->value.integer.min = 0;
 440         uinfo->value.integer.max = 1;
 441         return 0;
 442 }
 443 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 444 {
 445         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 446         hda_nid_t nid = kcontrol->private_value & 0xffff;
 447         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 448         long *valp = ucontrol->value.integer.value;
 449         unsigned int val = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_DIGI_CONVERT,0x00);
 450
 451         *valp = (val & mask) != 0;
 452         return 0;
 453 }
 454 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 455 {
 456         signed int change;
 457         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 458         hda_nid_t nid = kcontrol->private_value & 0xffff;
 459         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 460         long val = *ucontrol->value.integer.value;
 461         unsigned int ctrl_data = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_DIGI_CONVERT,0x00);
 462
 463         /* Set/unset the masked control bit(s) as needed */
 464         change = (val==0?0:mask) != (ctrl_data & mask);
 465         if (val==0)
 466                 ctrl_data &= ~mask;
 467         else
 468                 ctrl_data |= mask;
 469         snd_hda_codec_write(codec,nid,0,AC_VERB_SET_DIGI_CONVERT_1,ctrl_data);
 470
 471         return change;
 472 }
 473 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 474         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 475           .info = alc_spdif_ctrl_info, \
 476           .get = alc_spdif_ctrl_get, \
 477           .put = alc_spdif_ctrl_put, \
 478           .private_value = nid | (mask<<16) }
 479 #endif   /* CONFIG_SND_DEBUG */
 480
 481 /*
 482  * set up from the preset table
 483  */
 484 static void setup_preset(struct alc_spec *spec, const struct alc_config_preset *preset)
 485 {
 486         int i;
 487
 488         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 489                 spec->mixers[spec->num_mixers++] = preset->mixers[i];
 490         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i]; i++)
 491                 spec->init_verbs[spec->num_init_verbs++] = preset->init_verbs[i];
 492
 493         spec->channel_mode = preset->channel_mode;
 494         spec->num_channel_mode = preset->num_channel_mode;
 495
 496         spec->multiout.max_channels = spec->channel_mode[0].channels;
 497
 498         spec->multiout.num_dacs = preset->num_dacs;
 499         spec->multiout.dac_nids = preset->dac_nids;
 500         spec->multiout.dig_out_nid = preset->dig_out_nid;
 501         spec->multiout.hp_nid = preset->hp_nid;
 502
 503         spec->num_mux_defs = preset->num_mux_defs;
 504         if (! spec->num_mux_defs)
 505                 spec->num_mux_defs = 1;
 506         spec->input_mux = preset->input_mux;
 507
 508         spec->num_adc_nids = preset->num_adc_nids;
 509         spec->adc_nids = preset->adc_nids;
 510         spec->dig_in_nid = preset->dig_in_nid;
 511
 512         spec->unsol_event = preset->unsol_event;
 513         spec->init_hook = preset->init_hook;
 514 }
 515
 516 /*
 517  * ALC880 3-stack model
 518  *
 519  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
 520  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18, F-Mic = 0x1b
 521  *                 HP = 0x19
 522  */
 523
 524 static hda_nid_t alc880_dac_nids[4] = {
 525         /* front, rear, clfe, rear_surr */
 526         0x02, 0x05, 0x04, 0x03
 527 };
 528
 529 static hda_nid_t alc880_adc_nids[3] = {
 530         /* ADC0-2 */
 531         0x07, 0x08, 0x09,
 532 };
 533
 534 /* The datasheet says the node 0x07 is connected from inputs,
 535  * but it shows zero connection in the real implementation on some devices.
 536  * Note: this is a 915GAV bug, fixed on 915GLV
 537  */
 538 static hda_nid_t alc880_adc_nids_alt[2] = {
 539         /* ADC1-2 */
 540         0x08, 0x09,
 541 };
 542
 543 #define ALC880_DIGOUT_NID       0x06
 544 #define ALC880_DIGIN_NID        0x0a
 545
 546 static struct hda_input_mux alc880_capture_source = {
 547         .num_items = 4,
 548         .items = {
 549                 { "Mic", 0x0 },
 550                 { "Front Mic", 0x3 },
 551                 { "Line", 0x2 },
 552                 { "CD", 0x4 },
 553         },
 554 };
 555
 556 /* channel source setting (2/6 channel selection for 3-stack) */
 557 /* 2ch mode */
 558 static struct hda_verb alc880_threestack_ch2_init[] = {
 559         /* set line-in to input, mute it */
 560         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
 561         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
 562         /* set mic-in to input vref 80%, mute it */
 563         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
 564         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
 565         { } /* end */
 566 };
 567
 568 /* 6ch mode */
 569 static struct hda_verb alc880_threestack_ch6_init[] = {
 570         /* set line-in to output, unmute it */
 571         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 572         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
 573         /* set mic-in to output, unmute it */
 574         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 575         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
 576         { } /* end */
 577 };
 578
 579 static struct hda_channel_mode alc880_threestack_modes[2] = {
 580         { 2, alc880_threestack_ch2_init },
 581         { 6, alc880_threestack_ch6_init },
 582 };
 583
 584 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
 585         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 586         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 587         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
 588         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
 589         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 590         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 591         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 592         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 593         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 594         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 595         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 596         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 597         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 598         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 599         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
 600         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
 601         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
 602         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
 603         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
 604         {
 605                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 606                 .name = "Channel Mode",
 607                 .info = alc_ch_mode_info,
 608                 .get = alc_ch_mode_get,
 609                 .put = alc_ch_mode_put,
 610         },
 611         { } /* end */
 612 };
 613
 614 /* capture mixer elements */
 615 static struct snd_kcontrol_new alc880_capture_mixer[] = {
 616         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
 617         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
 618         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
 619         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
 620         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
 621         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
 622         {
 623                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 624                 /* The multiple "Capture Source" controls confuse alsamixer
 625                  * So call somewhat different..
 626                  * FIXME: the controls appear in the "playback" view!
 627                  */
 628                 /* .name = "Capture Source", */
 629                 .name = "Input Source",
 630                 .count = 3,
 631                 .info = alc_mux_enum_info,
 632                 .get = alc_mux_enum_get,
 633                 .put = alc_mux_enum_put,
 634         },
 635         { } /* end */
 636 };
 637
 638 /* capture mixer elements (in case NID 0x07 not available) */
 639 static struct snd_kcontrol_new alc880_capture_alt_mixer[] = {
 640         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
 641         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
 642         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
 643         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
 644         {
 645                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 646                 /* The multiple "Capture Source" controls confuse alsamixer
 647                  * So call somewhat different..
 648                  * FIXME: the controls appear in the "playback" view!
 649                  */
 650                 /* .name = "Capture Source", */
 651                 .name = "Input Source",
 652                 .count = 2,
 653                 .info = alc_mux_enum_info,
 654                 .get = alc_mux_enum_get,
 655                 .put = alc_mux_enum_put,
 656         },
 657         { } /* end */
 658 };
 659
 660
 661
 662 /*
 663  * ALC880 5-stack model
 664  *
 665  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d), Side = 0x02 (0xd)
 666  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
 667  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
 668  */
 669
 670 /* additional mixers to alc880_three_stack_mixer */
 671 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
 672         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 673         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
 674         { } /* end */
 675 };
 676
 677 /* channel source setting (6/8 channel selection for 5-stack) */
 678 /* 6ch mode */
 679 static struct hda_verb alc880_fivestack_ch6_init[] = {
 680         /* set line-in to input, mute it */
 681         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
 682         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
 683         { } /* end */
 684 };
 685
 686 /* 8ch mode */
 687 static struct hda_verb alc880_fivestack_ch8_init[] = {
 688         /* set line-in to output, unmute it */
 689         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 690         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
 691         { } /* end */
 692 };
 693
 694 static struct hda_channel_mode alc880_fivestack_modes[2] = {
 695         { 6, alc880_fivestack_ch6_init },
 696         { 8, alc880_fivestack_ch8_init },
 697 };
 698
 699
 700 /*
 701  * ALC880 6-stack model
 702  *
 703  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e), Side = 0x05 (0x0f)
 704  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
 705  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
 706  */
 707
 708 static hda_nid_t alc880_6st_dac_nids[4] = {
 709         /* front, rear, clfe, rear_surr */
 710         0x02, 0x03, 0x04, 0x05
 711 };
 712
 713 static struct hda_input_mux alc880_6stack_capture_source = {
 714         .num_items = 4,
 715         .items = {
 716                 { "Mic", 0x0 },
 717                 { "Front Mic", 0x1 },
 718                 { "Line", 0x2 },
 719                 { "CD", 0x4 },
 720         },
 721 };
 722
 723 /* fixed 8-channels */
 724 static struct hda_channel_mode alc880_sixstack_modes[1] = {
 725         { 8, NULL },
 726 };
 727
 728 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
 729         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 730         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 731         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 732         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
 733         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 734         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 735         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 736         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 737         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
 738         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
 739         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 740         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 741         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 742         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 743         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 744         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 745         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 746         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
 747         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
 748         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
 749         {
 750                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 751                 .name = "Channel Mode",
 752                 .info = alc_ch_mode_info,
 753                 .get = alc_ch_mode_get,
 754                 .put = alc_ch_mode_put,
 755         },
 756         { } /* end */
 757 };
 758
 759
 760 /*
 761  * ALC880 W810 model
 762  *
 763  * W810 has rear IO for:
 764  * Front (DAC 02)
 765  * Surround (DAC 03)
 766  * Center/LFE (DAC 04)
 767  * Digital out (06)
 768  *
 769  * The system also has a pair of internal speakers, and a headphone jack.
 770  * These are both connected to Line2 on the codec, hence to DAC 02.
 771  *
 772  * There is a variable resistor to control the speaker or headphone
 773  * volume. This is a hardware-only device without a software API.
 774  *
 775  * Plugging headphones in will disable the internal speakers. This is
 776  * implemented in hardware, not via the driver using jack sense. In
 777  * a similar fashion, plugging into the rear socket marked "front" will
 778  * disable both the speakers and headphones.
 779  *
 780  * For input, there's a microphone jack, and an "audio in" jack.
 781  * These may not do anything useful with this driver yet, because I
 782  * haven't setup any initialization verbs for these yet...
 783  */
 784
 785 static hda_nid_t alc880_w810_dac_nids[3] = {
 786         /* front, rear/surround, clfe */
 787         0x02, 0x03, 0x04
 788 };
 789
 790 /* fixed 6 channels */
 791 static struct hda_channel_mode alc880_w810_modes[1] = {
 792         { 6, NULL }
 793 };
 794
 795 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
 796 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
 797         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 798         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 799         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 800         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
 801         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 802         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 803         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 804         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 805         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
 806         { } /* end */
 807 };
 808
 809
 810 /*
 811  * Z710V model
 812  *
 813  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
 814  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?), Line = 0x1a
 815  */
 816
 817 static hda_nid_t alc880_z71v_dac_nids[1] = {
 818         0x02
 819 };
 820 #define ALC880_Z71V_HP_DAC      0x03
 821
 822 /* fixed 2 channels */
 823 static struct hda_channel_mode alc880_2_jack_modes[1] = {
 824         { 2, NULL }
 825 };
 826
 827 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
 828         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 829         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 830         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 831         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
 832         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 833         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 834         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 835         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 836         { } /* end */
 837 };
 838
 839
 840 /* FIXME! */
 841 /*
 842  * ALC880 F1734 model
 843  *
 844  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
 845  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
 846  */
 847
 848 static hda_nid_t alc880_f1734_dac_nids[1] = {
 849         0x03
 850 };
 851 #define ALC880_F1734_HP_DAC     0x02
 852
 853 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
 854         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 855         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
 856         HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 857         HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
 858         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 859         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 860         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 861         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 862         { } /* end */
 863 };
 864
 865
 866 /* FIXME! */
 867 /*
 868  * ALC880 ASUS model
 869  *
 870  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
 871  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
 872  *  Mic = 0x18, Line = 0x1a
 873  */
 874
 875 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
 876 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
 877
 878 static struct snd_kcontrol_new alc880_asus_mixer[] = {
 879         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 880         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 881         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 882         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
 883         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 884         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 885         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 886         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 887         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 888         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 889         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 890         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 891         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 892         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 893         {
 894                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 895                 .name = "Channel Mode",
 896                 .info = alc_ch_mode_info,
 897                 .get = alc_ch_mode_get,
 898                 .put = alc_ch_mode_put,
 899         },
 900         { } /* end */
 901 };
 902
 903 /* FIXME! */
 904 /*
 905  * ALC880 ASUS W1V model
 906  *
 907  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
 908  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
 909  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
 910  */
 911
 912 /* additional mixers to alc880_asus_mixer */
 913 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
 914         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
 915         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
 916         { } /* end */
 917 };
 918
 919 /* additional mixers to alc880_asus_mixer */
 920 static struct snd_kcontrol_new alc880_pcbeep_mixer[] = {
 921         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
 922         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
 923         { } /* end */
 924 };
 925
 926 /* TCL S700 */
 927 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
 928         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 929         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
 930         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
 931         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
 932         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
 933         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
 934         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
 935         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
 936         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
 937         {
 938                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 939                 /* The multiple "Capture Source" controls confuse alsamixer
 940                  * So call somewhat different..
 941                  * FIXME: the controls appear in the "playback" view!
 942                  */
 943                 /* .name = "Capture Source", */
 944                 .name = "Input Source",
 945                 .count = 1,
 946                 .info = alc_mux_enum_info,
 947                 .get = alc_mux_enum_get,
 948                 .put = alc_mux_enum_put,
 949         },
 950         { } /* end */
 951 };
 952
 953 /*
 954  * build control elements
 955  */
 956 static int alc_build_controls(struct hda_codec *codec)
 957 {
 958         struct alc_spec *spec = codec->spec;
 959         int err;
 960         int i;
 961
 962         for (i = 0; i < spec->num_mixers; i++) {
 963                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
 964                 if (err < 0)
 965                         return err;
 966         }
 967
 968         if (spec->multiout.dig_out_nid) {
 969                 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
 970                 if (err < 0)
 971                         return err;
 972         }
 973         if (spec->dig_in_nid) {
 974                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
 975                 if (err < 0)
 976                         return err;
 977         }
 978         return 0;
 979 }
 980
 981
 982 /*
 983  * initialize the codec volumes, etc
 984  */
 985
 986 /*
 987  * generic initialization of ADC, input mixers and output mixers
 988  */
 989 static struct hda_verb alc880_volume_init_verbs[] = {
 990         /*
 991          * Unmute ADC0-2 and set the default input to mic-in
 992          */
 993         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 994         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 995         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
 996         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 997         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
 998         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 999
1000         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1001          * mixer widget
1002          * Note: PASD motherboards uses the Line In 2 as the input for front panel
1003          * mic (mic 2)
1004          */
1005         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
1006         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1007         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1008         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1009         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1010         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1011
1012         /*
1013          * Set up output mixers (0x0c - 0x0f)
1014          */
1015         /* set vol=0 to output mixers */
1016         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1017         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1018         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1019         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1020         /* set up input amps for analog loopback */
1021         /* Amp Indices: DAC = 0, mixer = 1 */
1022         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1023         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1024         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1025         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1026         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1027         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1028         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1029         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1030
1031         { }
1032 };
1033
1034 /*
1035  * 3-stack pin configuration:
1036  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
1037  */
1038 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
1039         /*
1040          * preset connection lists of input pins
1041          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1042          */
1043         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
1044         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1045         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
1046
1047         /*
1048          * Set pin mode and muting
1049          */
1050         /* set front pin widgets 0x14 for output */
1051         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1052         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1053         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1054         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1055         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1056         /* Mic2 (as headphone out) for HP output */
1057         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1058         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1059         /* Line In pin widget for input */
1060         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1061         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1062         /* Line2 (as front mic) pin widget for input and vref at 80% */
1063         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1064         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1065         /* CD pin widget for input */
1066         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1067
1068         { }
1069 };
1070
1071 /*
1072  * 5-stack pin configuration:
1073  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
1074  * line-in/side = 0x1a, f-mic = 0x1b
1075  */
1076 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
1077         /*
1078          * preset connection lists of input pins
1079          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1080          */
1081         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1082         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
1083
1084         /*
1085          * Set pin mode and muting
1086          */
1087         /* set pin widgets 0x14-0x17 for output */
1088         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1089         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1090         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1091         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1092         /* unmute pins for output (no gain on this amp) */
1093         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1094         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1095         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1096         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1097
1098         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1099         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1100         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1101         /* Mic2 (as headphone out) for HP output */
1102         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1103         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1104         /* Line In pin widget for input */
1105         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1106         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1107         /* Line2 (as front mic) pin widget for input and vref at 80% */
1108         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1109         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1110         /* CD pin widget for input */
1111         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1112
1113         { }
1114 };
1115
1116 /*
1117  * W810 pin configuration:
1118  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
1119  */
1120 static struct hda_verb alc880_pin_w810_init_verbs[] = {
1121         /* hphone/speaker input selector: front DAC */
1122         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
1123
1124         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1125         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1126         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1127         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1128         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1129         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1130
1131         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1132         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1133
1134         { }
1135 };
1136
1137 /*
1138  * Z71V pin configuration:
1139  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
1140  */
1141 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
1142         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1143         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1144         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1145         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1146
1147         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1148         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1149         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1150         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1151
1152         { }
1153 };
1154
1155 /*
1156  * 6-stack pin configuration:
1157  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18, f-mic = 0x19,
1158  * line = 0x1a, HP = 0x1b
1159  */
1160 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
1161         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1162
1163         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1164         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1165         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1166         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1167         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1168         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1169         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1170         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1171
1172         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1173         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1174         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1175         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1176         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1177         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1178         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1179         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1180         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1181
1182         { }
1183 };
1184
1185 /* FIXME! */
1186 /*
1187  * F1734 pin configuration:
1188  * HP = 0x14, speaker-out = 0x15, mic = 0x18
1189  */
1190 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
1191         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
1192         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
1193         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
1194         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
1195
1196         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1197         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1198         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1199         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1200
1201         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1202         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1203         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1204         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1205         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1206         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1207         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1208         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1209         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1210
1211         { }
1212 };
1213
1214 /* FIXME! */
1215 /*
1216  * ASUS pin configuration:
1217  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
1218  */
1219 static struct hda_verb alc880_pin_asus_init_verbs[] = {
1220         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
1221         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
1222         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
1223         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
1224
1225         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1226         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1227         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1228         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1229         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1230         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1231         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1232         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1233
1234         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1235         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1236         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1237         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1238         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1239         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1240         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1241         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1242         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1243
1244         { }
1245 };
1246
1247 /* Enable GPIO mask and set output */
1248 static struct hda_verb alc880_gpio1_init_verbs[] = {
1249         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
1250         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
1251         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
1252
1253         { }
1254 };
1255
1256 /* Enable GPIO mask and set output */
1257 static struct hda_verb alc880_gpio2_init_verbs[] = {
1258         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
1259         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
1260         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
1261
1262         { }
1263 };
1264
1265 /* Clevo m520g init */
1266 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
1267         /* headphone output */
1268         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
1269         /* line-out */
1270         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1271         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1272         /* Line-in */
1273         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1274         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1275         /* CD */
1276         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1277         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1278         /* Mic1 (rear panel) */
1279         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1280         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1281         /* Mic2 (front panel) */
1282         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1283         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1284         /* headphone */
1285         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1286         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1287         /* change to EAPD mode */
1288         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
1289         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
1290
1291         { }
1292 };
1293
1294 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
1295         /* Headphone output */
1296         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1297         /* Front output*/
1298         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1299         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1300
1301         /* Line In pin widget for input */
1302         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1303         /* CD pin widget for input */
1304         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1305         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1306         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1307
1308         /* change to EAPD mode */
1309         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
1310         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
1311
1312         { }
1313 };
1314
1315 /*
1316  * LG m1 express dual
1317  *
1318  * Pin assignment:
1319  *   Rear Line-In/Out (blue): 0x14
1320  *   Build-in Mic-In: 0x15
1321  *   Speaker-out: 0x17
1322  *   HP-Out (green): 0x1b
1323  *   Mic-In/Out (red): 0x19
1324  *   SPDIF-Out: 0x1e
1325  */
1326
1327 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
1328 static hda_nid_t alc880_lg_dac_nids[3] = {
1329         0x05, 0x02, 0x03
1330 };
1331
1332 /* seems analog CD is not working */
1333 static struct hda_input_mux alc880_lg_capture_source = {
1334         .num_items = 3,
1335         .items = {
1336                 { "Mic", 0x1 },
1337                 { "Line", 0x5 },
1338                 { "Internal Mic", 0x6 },
1339         },
1340 };
1341
1342 /* 2,4,6 channel modes */
1343 static struct hda_verb alc880_lg_ch2_init[] = {
1344         /* set line-in and mic-in to input */
1345         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1346         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1347         { }
1348 };
1349
1350 static struct hda_verb alc880_lg_ch4_init[] = {
1351         /* set line-in to out and mic-in to input */
1352         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
1353         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1354         { }
1355 };
1356
1357 static struct hda_verb alc880_lg_ch6_init[] = {
1358         /* set line-in and mic-in to output */
1359         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
1360         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
1361         { }
1362 };
1363
1364 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
1365         { 2, alc880_lg_ch2_init },
1366         { 4, alc880_lg_ch4_init },
1367         { 6, alc880_lg_ch6_init },
1368 };
1369
1370 static struct snd_kcontrol_new alc880_lg_mixer[] = {
1371         /* FIXME: it's not really "master" but front channels */
1372         HDA_CODEC_VOLUME("Master Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1373         HDA_BIND_MUTE("Master Playback Switch", 0x0f, 2, HDA_INPUT),
1374         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1375         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
1376         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
1377         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
1378         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
1379         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
1380         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1381         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1382         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
1383         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
1384         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
1385         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
1386         {
1387                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1388                 .name = "Channel Mode",
1389                 .info = alc_ch_mode_info,
1390                 .get = alc_ch_mode_get,
1391                 .put = alc_ch_mode_put,
1392         },
1393         { } /* end */
1394 };
1395
1396 static struct hda_verb alc880_lg_init_verbs[] = {
1397         /* set capture source to mic-in */
1398         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1399         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1400         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1401         /* mute all amp mixer inputs */
1402         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
1403         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(6)},
1404         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(7)},
1405         /* line-in to input */
1406         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1407         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1408         /* built-in mic */
1409         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1410         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1411         /* speaker-out */
1412         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1413         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1414         /* mic-in to input */
1415         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
1416         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1417         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1418         /* HP-out */
1419         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
1420         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1421         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1422         /* jack sense */
1423         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
1424         { }
1425 };
1426
1427 /* toggle speaker-output according to the hp-jack state */
1428 static void alc880_lg_automute(struct hda_codec *codec)
1429 {
1430         unsigned int present;
1431
1432         present = snd_hda_codec_read(codec, 0x1b, 0,
1433                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1434         snd_hda_codec_amp_update(codec, 0x17, 0, HDA_OUTPUT, 0,
1435                                  0x80, present ? 0x80 : 0);
1436         snd_hda_codec_amp_update(codec, 0x17, 1, HDA_OUTPUT, 0,
1437                                  0x80, present ? 0x80 : 0);
1438 }
1439
1440 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
1441 {
1442         /* Looks like the unsol event is incompatible with the standard
1443          * definition.  4bit tag is placed at 28 bit!
1444          */
1445         if ((res >> 28) == 0x01)
1446                 alc880_lg_automute(codec);
1447 }
1448
1449 /*
1450  * LG LW20
1451  *
1452  * Pin assignment:
1453  *   Speaker-out: 0x14
1454  *   Mic-In: 0x18
1455  *   Built-in Mic-In: 0x19 (?)
1456  *   HP-Out: 0x1b
1457  *   SPDIF-Out: 0x1e
1458  */
1459
1460 /* seems analog CD is not working */
1461 static struct hda_input_mux alc880_lg_lw_capture_source = {
1462         .num_items = 2,
1463         .items = {
1464                 { "Mic", 0x0 },
1465                 { "Internal Mic", 0x1 },
1466         },
1467 };
1468
1469 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
1470         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1471         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
1472         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1473         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1474         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
1475         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
1476         { } /* end */
1477 };
1478
1479 static struct hda_verb alc880_lg_lw_init_verbs[] = {
1480         /* set capture source to mic-in */
1481         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1482         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1483         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1484         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(7)},
1485         /* speaker-out */
1486         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1487         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1488         /* HP-out */
1489         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
1490         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1491         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1492         /* mic-in to input */
1493         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1494         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1495         /* built-in mic */
1496         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1497         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1498         /* jack sense */
1499         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
1500         { }
1501 };
1502
1503 /* toggle speaker-output according to the hp-jack state */
1504 static void alc880_lg_lw_automute(struct hda_codec *codec)
1505 {
1506         unsigned int present;
1507
1508         present = snd_hda_codec_read(codec, 0x1b, 0,
1509                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1510         snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
1511                                  0x80, present ? 0x80 : 0);
1512         snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
1513                                  0x80, present ? 0x80 : 0);
1514 }
1515
1516 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
1517 {
1518         /* Looks like the unsol event is incompatible with the standard
1519          * definition.  4bit tag is placed at 28 bit!
1520          */
1521         if ((res >> 28) == 0x01)
1522                 alc880_lg_lw_automute(codec);
1523 }
1524
1525 /*
1526  * Common callbacks
1527  */
1528
1529 static int alc_init(struct hda_codec *codec)
1530 {
1531         struct alc_spec *spec = codec->spec;
1532         unsigned int i;
1533
1534         for (i = 0; i < spec->num_init_verbs; i++)
1535                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
1536
1537         if (spec->init_hook)
1538                 spec->init_hook(codec);
1539
1540         return 0;
1541 }
1542
1543 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
1544 {
1545         struct alc_spec *spec = codec->spec;
1546
1547         if (spec->unsol_event)
1548                 spec->unsol_event(codec, res);
1549 }
1550
1551 #ifdef CONFIG_PM
1552 /*
1553  * resume
1554  */
1555 static int alc_resume(struct hda_codec *codec)
1556 {
1557         struct alc_spec *spec = codec->spec;
1558         int i;
1559
1560         alc_init(codec);
1561         for (i = 0; i < spec->num_mixers; i++)
1562                 snd_hda_resume_ctls(codec, spec->mixers[i]);
1563         if (spec->multiout.dig_out_nid)
1564                 snd_hda_resume_spdif_out(codec);
1565         if (spec->dig_in_nid)
1566                 snd_hda_resume_spdif_in(codec);
1567
1568         return 0;
1569 }
1570 #endif
1571
1572 /*
1573  * Analog playback callbacks
1574  */
1575 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
1576                                     struct hda_codec *codec,
1577                                     struct snd_pcm_substream *substream)
1578 {
1579         struct alc_spec *spec = codec->spec;
1580         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
1581 }
1582
1583 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1584                                        struct hda_codec *codec,
1585                                        unsigned int stream_tag,
1586                                        unsigned int format,
1587                                        struct snd_pcm_substream *substream)
1588 {
1589         struct alc_spec *spec = codec->spec;
1590         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
1591                                                 format, substream);
1592 }
1593
1594 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1595                                        struct hda_codec *codec,
1596                                        struct snd_pcm_substream *substream)
1597 {
1598         struct alc_spec *spec = codec->spec;
1599         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1600 }
1601
1602 /*
1603  * Digital out
1604  */
1605 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1606                                         struct hda_codec *codec,
1607                                         struct snd_pcm_substream *substream)
1608 {
1609         struct alc_spec *spec = codec->spec;
1610         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1611 }
1612
1613 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1614                                          struct hda_codec *codec,
1615                                          struct snd_pcm_substream *substream)
1616 {
1617         struct alc_spec *spec = codec->spec;
1618         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1619 }
1620
1621 /*
1622  * Analog capture
1623  */
1624 static int alc880_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1625                                       struct hda_codec *codec,
1626                                       unsigned int stream_tag,
1627                                       unsigned int format,
1628                                       struct snd_pcm_substream *substream)
1629 {
1630         struct alc_spec *spec = codec->spec;
1631
1632         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1633                                    stream_tag, 0, format);
1634         return 0;
1635 }
1636
1637 static int alc880_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1638                                       struct hda_codec *codec,
1639                                       struct snd_pcm_substream *substream)
1640 {
1641         struct alc_spec *spec = codec->spec;
1642
1643         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
1644         return 0;
1645 }
1646
1647
1648 /*
1649  */
1650 static struct hda_pcm_stream alc880_pcm_analog_playback = {
1651         .substreams = 1,
1652         .channels_min = 2,
1653         .channels_max = 8,
1654         /* NID is set in alc_build_pcms */
1655         .ops = {
1656                 .open = alc880_playback_pcm_open,
1657                 .prepare = alc880_playback_pcm_prepare,
1658                 .cleanup = alc880_playback_pcm_cleanup
1659         },
1660 };
1661
1662 static struct hda_pcm_stream alc880_pcm_analog_capture = {
1663         .substreams = 2,
1664         .channels_min = 2,
1665         .channels_max = 2,
1666         /* NID is set in alc_build_pcms */
1667         .ops = {
1668                 .prepare = alc880_capture_pcm_prepare,
1669                 .cleanup = alc880_capture_pcm_cleanup
1670         },
1671 };
1672
1673 static struct hda_pcm_stream alc880_pcm_digital_playback = {
1674         .substreams = 1,
1675         .channels_min = 2,
1676         .channels_max = 2,
1677         /* NID is set in alc_build_pcms */
1678         .ops = {
1679                 .open = alc880_dig_playback_pcm_open,
1680                 .close = alc880_dig_playback_pcm_close
1681         },
1682 };
1683
1684 static struct hda_pcm_stream alc880_pcm_digital_capture = {
1685         .substreams = 1,
1686         .channels_min = 2,
1687         .channels_max = 2,
1688         /* NID is set in alc_build_pcms */
1689 };
1690
1691 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
1692 static struct hda_pcm_stream alc_pcm_null_playback = {
1693         .substreams = 0,
1694         .channels_min = 0,
1695         .channels_max = 0,
1696 };
1697
1698 static int alc_build_pcms(struct hda_codec *codec)
1699 {
1700         struct alc_spec *spec = codec->spec;
1701         struct hda_pcm *info = spec->pcm_rec;
1702         int i;
1703
1704         codec->num_pcms = 1;
1705         codec->pcm_info = info;
1706
1707         info->name = spec->stream_name_analog;
1708         if (spec->stream_analog_playback) {
1709                 snd_assert(spec->multiout.dac_nids, return -EINVAL);
1710                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
1711                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
1712         }
1713         if (spec->stream_analog_capture) {
1714                 snd_assert(spec->adc_nids, return -EINVAL);
1715                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
1716                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1717         }
1718
1719         if (spec->channel_mode) {
1720                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
1721                 for (i = 0; i < spec->num_channel_mode; i++) {
1722                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
1723                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
1724                         }
1725                 }
1726         }
1727
1728         /* If the use of more than one ADC is requested for the current
1729          * model, configure a second analog capture-only PCM.
1730          */
1731         if (spec->num_adc_nids > 1) {
1732                 codec->num_pcms++;
1733                 info++;
1734                 info->name = spec->stream_name_analog;
1735                 /* No playback stream for second PCM */
1736                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = alc_pcm_null_playback;
1737                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
1738                 if (spec->stream_analog_capture) {
1739                         snd_assert(spec->adc_nids, return -EINVAL);
1740                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
1741                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[1];
1742                 }
1743         }
1744
1745         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1746                 codec->num_pcms++;
1747                 info++;
1748                 info->name = spec->stream_name_digital;
1749                 if (spec->multiout.dig_out_nid &&
1750                     spec->stream_digital_playback) {
1751                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
1752                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
1753                 }
1754                 if (spec->dig_in_nid &&
1755                     spec->stream_digital_capture) {
1756                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
1757                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
1758                 }
1759         }
1760
1761         return 0;
1762 }
1763
1764 static void alc_free(struct hda_codec *codec)
1765 {
1766         struct alc_spec *spec = codec->spec;
1767         unsigned int i;
1768
1769         if (! spec)
1770                 return;
1771
1772         if (spec->kctl_alloc) {
1773                 for (i = 0; i < spec->num_kctl_used; i++)
1774                         kfree(spec->kctl_alloc[i].name);
1775                 kfree(spec->kctl_alloc);
1776         }
1777         kfree(spec);
1778 }
1779
1780 /*
1781  */
1782 static struct hda_codec_ops alc_patch_ops = {
1783         .build_controls = alc_build_controls,
1784         .build_pcms = alc_build_pcms,
1785         .init = alc_init,
1786         .free = alc_free,
1787         .unsol_event = alc_unsol_event,
1788 #ifdef CONFIG_PM
1789         .resume = alc_resume,
1790 #endif
1791 };
1792
1793
1794 /*
1795  * Test configuration for debugging
1796  *
1797  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
1798  * enum controls.
1799  */
1800 #ifdef CONFIG_SND_DEBUG
1801 static hda_nid_t alc880_test_dac_nids[4] = {
1802         0x02, 0x03, 0x04, 0x05
1803 };
1804
1805 static struct hda_input_mux alc880_test_capture_source = {
1806         .num_items = 7,
1807         .items = {
1808                 { "In-1", 0x0 },
1809                 { "In-2", 0x1 },
1810                 { "In-3", 0x2 },
1811                 { "In-4", 0x3 },
1812                 { "CD", 0x4 },
1813                 { "Front", 0x5 },
1814                 { "Surround", 0x6 },
1815         },
1816 };
1817
1818 static struct hda_channel_mode alc880_test_modes[4] = {
1819         { 2, NULL },
1820         { 4, NULL },
1821         { 6, NULL },
1822         { 8, NULL },
1823 };
1824
1825 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1826 {
1827         static char *texts[] = {
1828                 "N/A", "Line Out", "HP Out",
1829                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
1830         };
1831         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1832         uinfo->count = 1;
1833         uinfo->value.enumerated.items = 8;
1834         if (uinfo->value.enumerated.item >= 8)
1835                 uinfo->value.enumerated.item = 7;
1836         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1837         return 0;
1838 }
1839
1840 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1841 {
1842         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1843         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
1844         unsigned int pin_ctl, item = 0;
1845
1846         pin_ctl = snd_hda_codec_read(codec, nid, 0,
1847                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
1848         if (pin_ctl & AC_PINCTL_OUT_EN) {
1849                 if (pin_ctl & AC_PINCTL_HP_EN)
1850                         item = 2;
1851                 else
1852                         item = 1;
1853         } else if (pin_ctl & AC_PINCTL_IN_EN) {
1854                 switch (pin_ctl & AC_PINCTL_VREFEN) {
1855                 case AC_PINCTL_VREF_HIZ: item = 3; break;
1856                 case AC_PINCTL_VREF_50:  item = 4; break;
1857                 case AC_PINCTL_VREF_GRD: item = 5; break;
1858                 case AC_PINCTL_VREF_80:  item = 6; break;
1859                 case AC_PINCTL_VREF_100: item = 7; break;
1860                 }
1861         }
1862         ucontrol->value.enumerated.item[0] = item;
1863         return 0;
1864 }
1865
1866 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1867 {
1868         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1869         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
1870         static unsigned int ctls[] = {
1871                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
1872                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
1873                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
1874                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
1875                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
1876                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
1877         };
1878         unsigned int old_ctl, new_ctl;
1879
1880         old_ctl = snd_hda_codec_read(codec, nid, 0,
1881                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
1882         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
1883         if (old_ctl != new_ctl) {
1884                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, new_ctl);
1885                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
1886                                     ucontrol->value.enumerated.item[0] >= 3 ? 0xb080 : 0xb000);
1887                 return 1;
1888         }
1889         return 0;
1890 }
1891
1892 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1893 {
1894         static char *texts[] = {
1895                 "Front", "Surround", "CLFE", "Side"
1896         };
1897         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1898         uinfo->count = 1;
1899         uinfo->value.enumerated.items = 4;
1900         if (uinfo->value.enumerated.item >= 4)
1901                 uinfo->value.enumerated.item = 3;
1902         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1903         return 0;
1904 }
1905
1906 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1907 {
1908         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1909         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
1910         unsigned int sel;
1911
1912         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
1913         ucontrol->value.enumerated.item[0] = sel & 3;
1914         return 0;
1915 }
1916
1917 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1918 {
1919         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1920         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
1921         unsigned int sel;
1922
1923         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
1924         if (ucontrol->value.enumerated.item[0] != sel) {
1925                 sel = ucontrol->value.enumerated.item[0] & 3;
1926                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, sel);
1927                 return 1;
1928         }
1929         return 0;
1930 }
1931
1932 #define PIN_CTL_TEST(xname,nid) {                       \
1933                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
1934                         .name = xname,                 \
1935                         .info = alc_test_pin_ctl_info, \
1936                         .get = alc_test_pin_ctl_get,   \
1937                         .put = alc_test_pin_ctl_put,   \
1938                         .private_value = nid           \
1939                         }
1940
1941 #define PIN_SRC_TEST(xname,nid) {                       \
1942                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
1943                         .name = xname,                 \
1944                         .info = alc_test_pin_src_info, \
1945                         .get = alc_test_pin_src_get,   \
1946                         .put = alc_test_pin_src_put,   \
1947                         .private_value = nid           \
1948                         }
1949
1950 static struct snd_kcontrol_new alc880_test_mixer[] = {
1951         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1952         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1953         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
1954         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1955         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1956         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1957         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
1958         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1959         PIN_CTL_TEST("Front Pin Mode", 0x14),
1960         PIN_CTL_TEST("Surround Pin Mode", 0x15),
1961         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
1962         PIN_CTL_TEST("Side Pin Mode", 0x17),
1963         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
1964         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
1965         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
1966         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
1967         PIN_SRC_TEST("In-1 Pin Source", 0x18),
1968         PIN_SRC_TEST("In-2 Pin Source", 0x19),
1969         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
1970         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
1971         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
1972         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
1973         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
1974         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
1975         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
1976         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
1977         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
1978         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
1979         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
1980         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
1981         {
1982                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1983                 .name = "Channel Mode",
1984                 .info = alc_ch_mode_info,
1985                 .get = alc_ch_mode_get,
1986                 .put = alc_ch_mode_put,
1987         },
1988         { } /* end */
1989 };
1990
1991 static struct hda_verb alc880_test_init_verbs[] = {
1992         /* Unmute inputs of 0x0c - 0x0f */
1993         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1994         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1995         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1996         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1997         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1998         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1999         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2000         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2001         /* Vol output for 0x0c-0x0f */
2002         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2003         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2004         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2005         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2006         /* Set output pins 0x14-0x17 */
2007         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2008         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2009         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2010         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2011         /* Unmute output pins 0x14-0x17 */
2012         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2013         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2014         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2015         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2016         /* Set input pins 0x18-0x1c */
2017         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2018         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2019         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2020         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2021         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2022         /* Mute input pins 0x18-0x1b */
2023         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2024         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2025         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2026         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2027         /* ADC set up */
2028         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2029         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2030         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2031         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2032         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2033         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2034         /* Analog input/passthru */
2035         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2036         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2037         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2038         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2039         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2040         { }
2041 };
2042 #endif
2043
2044 /*
2045  */
2046
2047 static struct hda_board_config alc880_cfg_tbl[] = {
2048         /* Back 3 jack, front 2 jack */
2049         { .modelname = "3stack", .config = ALC880_3ST },
2050         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe200, .config = ALC880_3ST },
2051         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe201, .config = ALC880_3ST },
2052         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe202, .config = ALC880_3ST },
2053         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe203, .config = ALC880_3ST },
2054         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe204, .config = ALC880_3ST },
2055         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe205, .config = ALC880_3ST },
2056         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe206, .config = ALC880_3ST },
2057         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe207, .config = ALC880_3ST },
2058         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe208, .config = ALC880_3ST },
2059         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe209, .config = ALC880_3ST },
2060         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20a, .config = ALC880_3ST },
2061         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20b, .config = ALC880_3ST },
2062         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20c, .config = ALC880_3ST },
2063         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20d, .config = ALC880_3ST },
2064         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20e, .config = ALC880_3ST },
2065         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20f, .config = ALC880_3ST },
2066         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe210, .config = ALC880_3ST },
2067         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe211, .config = ALC880_3ST },
2068         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe214, .config = ALC880_3ST },
2069         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe302, .config = ALC880_3ST },
2070         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe303, .config = ALC880_3ST },
2071         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe304, .config = ALC880_3ST },
2072         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe306, .config = ALC880_3ST },
2073         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe307, .config = ALC880_3ST },
2074         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe404, .config = ALC880_3ST },
2075         { .pci_subvendor = 0x8086, .pci_subdevice = 0xa101, .config = ALC880_3ST },
2076         { .pci_subvendor = 0x107b, .pci_subdevice = 0x3031, .config = ALC880_3ST },
2077         { .pci_subvendor = 0x107b, .pci_subdevice = 0x4036, .config = ALC880_3ST },
2078         { .pci_subvendor = 0x107b, .pci_subdevice = 0x4037, .config = ALC880_3ST },
2079         { .pci_subvendor = 0x107b, .pci_subdevice = 0x4038, .config = ALC880_3ST },
2080         { .pci_subvendor = 0x107b, .pci_subdevice = 0x4040, .config = ALC880_3ST },
2081         { .pci_subvendor = 0x107b, .pci_subdevice = 0x4041, .config = ALC880_3ST },
2082         /* TCL S700 */
2083         { .pci_subvendor = 0x19db, .pci_subdevice = 0x4188, .config = ALC880_TCL_S700 },
2084
2085         /* Back 3 jack, front 2 jack (Internal add Aux-In) */
2086         { .pci_subvendor = 0x1025, .pci_subdevice = 0xe310, .config = ALC880_3ST },
2087         { .pci_subvendor = 0x104d, .pci_subdevice = 0x81d6, .config = ALC880_3ST },
2088         { .pci_subvendor = 0x104d, .pci_subdevice = 0x81a0, .config = ALC880_3ST },
2089
2090         /* Back 3 jack plus 1 SPDIF out jack, front 2 jack */
2091         { .modelname = "3stack-digout", .config = ALC880_3ST_DIG },
2092         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe308, .config = ALC880_3ST_DIG },
2093         { .pci_subvendor = 0x1025, .pci_subdevice = 0x0070, .config = ALC880_3ST_DIG },
2094         /* Clevo m520G NB */
2095         { .pci_subvendor = 0x1558, .pci_subdevice = 0x0520, .config = ALC880_CLEVO },
2096
2097         /* Back 3 jack plus 1 SPDIF out jack, front 2 jack (Internal add Aux-In)*/
2098         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe305, .config = ALC880_3ST_DIG },
2099         { .pci_subvendor = 0x8086, .pci_subdevice = 0xd402, .config = ALC880_3ST_DIG },
2100         { .pci_subvendor = 0x1025, .pci_subdevice = 0xe309, .config = ALC880_3ST_DIG },
2101
2102         /* Back 5 jack, front 2 jack */
2103         { .modelname = "5stack", .config = ALC880_5ST },
2104         { .pci_subvendor = 0x107b, .pci_subdevice = 0x3033, .config = ALC880_5ST },
2105         { .pci_subvendor = 0x107b, .pci_subdevice = 0x4039, .config = ALC880_5ST },
2106         { .pci_subvendor = 0x107b, .pci_subdevice = 0x3032, .config = ALC880_5ST },
2107         { .pci_subvendor = 0x103c, .pci_subdevice = 0x2a09, .config = ALC880_5ST },
2108         { .pci_subvendor = 0x1043, .pci_subdevice = 0x814e, .config = ALC880_5ST },
2109
2110         /* Back 5 jack plus 1 SPDIF out jack, front 2 jack */
2111         { .modelname = "5stack-digout", .config = ALC880_5ST_DIG },
2112         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe224, .config = ALC880_5ST_DIG },
2113         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe400, .config = ALC880_5ST_DIG },
2114         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe401, .config = ALC880_5ST_DIG },
2115         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe402, .config = ALC880_5ST_DIG },
2116         { .pci_subvendor = 0x8086, .pci_subdevice = 0xd400, .config = ALC880_5ST_DIG },
2117         { .pci_subvendor = 0x8086, .pci_subdevice = 0xd401, .config = ALC880_5ST_DIG },
2118         { .pci_subvendor = 0x8086, .pci_subdevice = 0xa100, .config = ALC880_5ST_DIG },
2119         { .pci_subvendor = 0x1565, .pci_subdevice = 0x8202, .config = ALC880_5ST_DIG },
2120         { .pci_subvendor = 0x1019, .pci_subdevice = 0xa880, .config = ALC880_5ST_DIG },
2121         { .pci_subvendor = 0xa0a0, .pci_subdevice = 0x0560,
2122           .config = ALC880_5ST_DIG }, /* Aopen i915GMm-HFS */
2123         /* { .pci_subvendor = 0x1019, .pci_subdevice = 0xa884, .config = ALC880_5ST_DIG }, */ /* conflict with 6stack */
2124         { .pci_subvendor = 0x1695, .pci_subdevice = 0x400d, .config = ALC880_5ST_DIG },
2125         /* note subvendor = 0 below */
2126         /* { .pci_subvendor = 0x0000, .pci_subdevice = 0x8086, .config = ALC880_5ST_DIG }, */
2127
2128         { .modelname = "w810", .config = ALC880_W810 },
2129         { .pci_subvendor = 0x161f, .pci_subdevice = 0x203d, .config = ALC880_W810 },
2130
2131         { .modelname = "z71v", .config = ALC880_Z71V },
2132         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1964, .config = ALC880_Z71V },
2133
2134         { .modelname = "6stack", .config = ALC880_6ST },
2135         { .pci_subvendor = 0x1043, .pci_subdevice = 0x8196, .config = ALC880_6ST }, /* ASUS P5GD1-HVM */
2136         { .pci_subvendor = 0x1043, .pci_subdevice = 0x81b4, .config = ALC880_6ST },
2137         { .pci_subvendor = 0x1019, .pci_subdevice = 0xa884, .config = ALC880_6ST }, /* Acer APFV */
2138         { .pci_subvendor = 0x1458, .pci_subdevice = 0xa102, .config = ALC880_6ST }, /* Gigabyte K8N51 */
2139
2140         { .modelname = "6stack-digout", .config = ALC880_6ST_DIG },
2141         { .pci_subvendor = 0x2668, .pci_subdevice = 0x8086, .config = ALC880_6ST_DIG },
2142         { .pci_subvendor = 0x8086, .pci_subdevice = 0x2668, .config = ALC880_6ST_DIG },
2143         { .pci_subvendor = 0x1462, .pci_subdevice = 0x1150, .config = ALC880_6ST_DIG },
2144         { .pci_subvendor = 0xe803, .pci_subdevice = 0x1019, .config = ALC880_6ST_DIG },
2145         { .pci_subvendor = 0x1039, .pci_subdevice = 0x1234, .config = ALC880_6ST_DIG },
2146         { .pci_subvendor = 0x1025, .pci_subdevice = 0x0077, .config = ALC880_6ST_DIG },
2147         { .pci_subvendor = 0x1025, .pci_subdevice = 0x0078, .config = ALC880_6ST_DIG },
2148         { .pci_subvendor = 0x1025, .pci_subdevice = 0x0087, .config = ALC880_6ST_DIG },
2149         { .pci_subvendor = 0x1297, .pci_subdevice = 0xc790, .config = ALC880_6ST_DIG }, /* Shuttle ST20G5 */
2150         { .pci_subvendor = 0x1509, .pci_subdevice = 0x925d, .config = ALC880_6ST_DIG }, /* FIC P4M-915GD1 */
2151         { .pci_subvendor = 0x1695, .pci_subdevice = 0x4012, .config = ALC880_5ST_DIG }, /* Epox EP-5LDA+ GLi */
2152
2153         { .modelname = "asus", .config = ALC880_ASUS },
2154         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1964, .config = ALC880_ASUS_DIG },
2155         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1973, .config = ALC880_ASUS_DIG },
2156         { .pci_subvendor = 0x1043, .pci_subdevice = 0x19b3, .config = ALC880_ASUS_DIG },
2157         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1113, .config = ALC880_ASUS_DIG },
2158         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1173, .config = ALC880_ASUS_DIG },
2159         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1993, .config = ALC880_ASUS },
2160         { .pci_subvendor = 0x1043, .pci_subdevice = 0x10c3, .config = ALC880_ASUS_DIG },
2161         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1133, .config = ALC880_ASUS },
2162         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1123, .config = ALC880_ASUS_DIG },
2163         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1143, .config = ALC880_ASUS },
2164         { .pci_subvendor = 0x1043, .pci_subdevice = 0x10b3, .config = ALC880_ASUS_W1V },
2165         { .pci_subvendor = 0x1043, .pci_subdevice = 0x8181, .config = ALC880_ASUS_DIG }, /* ASUS P4GPL-X */
2166         { .pci_subvendor = 0x1558, .pci_subdevice = 0x5401, .config = ALC880_ASUS_DIG2 },
2167
2168         { .modelname = "uniwill", .config = ALC880_UNIWILL_DIG },
2169         { .pci_subvendor = 0x1584, .pci_subdevice = 0x9050, .config = ALC880_UNIWILL_DIG },
2170
2171         { .modelname = "F1734", .config = ALC880_F1734 },
2172         { .pci_subvendor = 0x1734, .pci_subdevice = 0x107c, .config = ALC880_F1734 },
2173         { .pci_subvendor = 0x1584, .pci_subdevice = 0x9054, .config = ALC880_F1734 },
2174
2175         { .modelname = "lg", .config = ALC880_LG },
2176         { .pci_subvendor = 0x1854, .pci_subdevice = 0x003b, .config = ALC880_LG },
2177         { .pci_subvendor = 0x1854, .pci_subdevice = 0x0068, .config = ALC880_LG },
2178
2179         { .modelname = "lg-lw", .config = ALC880_LG_LW },
2180         { .pci_subvendor = 0x1854, .pci_subdevice = 0x0018, .config = ALC880_LG_LW },
2181
2182 #ifdef CONFIG_SND_DEBUG
2183         { .modelname = "test", .config = ALC880_TEST },
2184 #endif
2185         { .modelname = "auto", .config = ALC880_AUTO },
2186
2187         {}
2188 };
2189
2190 /*
2191  * ALC880 codec presets
2192  */
2193 static struct alc_config_preset alc880_presets[] = {
2194         [ALC880_3ST] = {
2195                 .mixers = { alc880_three_stack_mixer },
2196                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_3stack_init_verbs },
2197                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2198                 .dac_nids = alc880_dac_nids,
2199                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
2200                 .channel_mode = alc880_threestack_modes,
2201                 .input_mux = &alc880_capture_source,
2202         },
2203         [ALC880_3ST_DIG] = {
2204                 .mixers = { alc880_three_stack_mixer },
2205                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_3stack_init_verbs },
2206                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2207                 .dac_nids = alc880_dac_nids,
2208                 .dig_out_nid = ALC880_DIGOUT_NID,
2209                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
2210                 .channel_mode = alc880_threestack_modes,
2211                 .input_mux = &alc880_capture_source,
2212         },
2213         [ALC880_TCL_S700] = {
2214                 .mixers = { alc880_tcl_s700_mixer },
2215                 .init_verbs = { alc880_volume_init_verbs,
2216                                 alc880_pin_tcl_S700_init_verbs,
2217                                 alc880_gpio2_init_verbs },
2218                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2219                 .dac_nids = alc880_dac_nids,
2220                 .hp_nid = 0x03,
2221                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
2222                 .channel_mode = alc880_2_jack_modes,
2223                 .input_mux = &alc880_capture_source,
2224         },
2225         [ALC880_5ST] = {
2226                 .mixers = { alc880_three_stack_mixer, alc880_five_stack_mixer},
2227                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_5stack_init_verbs },
2228                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2229                 .dac_nids = alc880_dac_nids,
2230                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
2231                 .channel_mode = alc880_fivestack_modes,
2232                 .input_mux = &alc880_capture_source,
2233         },
2234         [ALC880_5ST_DIG] = {
2235                 .mixers = { alc880_three_stack_mixer, alc880_five_stack_mixer },
2236                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_5stack_init_verbs },
2237                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2238                 .dac_nids = alc880_dac_nids,
2239                 .dig_out_nid = ALC880_DIGOUT_NID,
2240                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
2241                 .channel_mode = alc880_fivestack_modes,
2242                 .input_mux = &alc880_capture_source,
2243         },
2244         [ALC880_6ST] = {
2245                 .mixers = { alc880_six_stack_mixer },
2246                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_6stack_init_verbs },
2247                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
2248                 .dac_nids = alc880_6st_dac_nids,
2249                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
2250                 .channel_mode = alc880_sixstack_modes,
2251                 .input_mux = &alc880_6stack_capture_source,
2252         },
2253         [ALC880_6ST_DIG] = {
2254                 .mixers = { alc880_six_stack_mixer },
2255                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_6stack_init_verbs },
2256                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
2257                 .dac_nids = alc880_6st_dac_nids,
2258                 .dig_out_nid = ALC880_DIGOUT_NID,
2259                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
2260                 .channel_mode = alc880_sixstack_modes,
2261                 .input_mux = &alc880_6stack_capture_source,
2262         },
2263         [ALC880_W810] = {
2264                 .mixers = { alc880_w810_base_mixer },
2265                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_w810_init_verbs,
2266                                 alc880_gpio2_init_verbs },
2267                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
2268                 .dac_nids = alc880_w810_dac_nids,
2269                 .dig_out_nid = ALC880_DIGOUT_NID,
2270                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
2271                 .channel_mode = alc880_w810_modes,
2272                 .input_mux = &alc880_capture_source,
2273         },
2274         [ALC880_Z71V] = {
2275                 .mixers = { alc880_z71v_mixer },
2276                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_z71v_init_verbs },
2277                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
2278                 .dac_nids = alc880_z71v_dac_nids,
2279                 .dig_out_nid = ALC880_DIGOUT_NID,
2280                 .hp_nid = 0x03,
2281                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
2282                 .channel_mode = alc880_2_jack_modes,
2283                 .input_mux = &alc880_capture_source,
2284         },
2285         [ALC880_F1734] = {
2286                 .mixers = { alc880_f1734_mixer },
2287                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_f1734_init_verbs },
2288                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
2289                 .dac_nids = alc880_f1734_dac_nids,
2290                 .hp_nid = 0x02,
2291                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
2292                 .channel_mode = alc880_2_jack_modes,
2293                 .input_mux = &alc880_capture_source,
2294         },
2295         [ALC880_ASUS] = {
2296                 .mixers = { alc880_asus_mixer },
2297                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
2298                                 alc880_gpio1_init_verbs },
2299                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2300                 .dac_nids = alc880_asus_dac_nids,
2301                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2302                 .channel_mode = alc880_asus_modes,
2303                 .input_mux = &alc880_capture_source,
2304         },
2305         [ALC880_ASUS_DIG] = {
2306                 .mixers = { alc880_asus_mixer },
2307                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
2308                                 alc880_gpio1_init_verbs },
2309                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2310                 .dac_nids = alc880_asus_dac_nids,
2311                 .dig_out_nid = ALC880_DIGOUT_NID,
2312                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2313                 .channel_mode = alc880_asus_modes,
2314                 .input_mux = &alc880_capture_source,
2315         },
2316         [ALC880_ASUS_DIG2] = {
2317                 .mixers = { alc880_asus_mixer },
2318                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
2319                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
2320                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2321                 .dac_nids = alc880_asus_dac_nids,
2322                 .dig_out_nid = ALC880_DIGOUT_NID,
2323                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2324                 .channel_mode = alc880_asus_modes,
2325                 .input_mux = &alc880_capture_source,
2326         },
2327         [ALC880_ASUS_W1V] = {
2328                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
2329                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
2330                                 alc880_gpio1_init_verbs },
2331                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2332                 .dac_nids = alc880_asus_dac_nids,
2333                 .dig_out_nid = ALC880_DIGOUT_NID,
2334                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2335                 .channel_mode = alc880_asus_modes,
2336                 .input_mux = &alc880_capture_source,
2337         },
2338         [ALC880_UNIWILL_DIG] = {
2339                 .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
2340                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs },
2341                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2342                 .dac_nids = alc880_asus_dac_nids,
2343                 .dig_out_nid = ALC880_DIGOUT_NID,
2344                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2345                 .channel_mode = alc880_asus_modes,
2346                 .input_mux = &alc880_capture_source,
2347         },
2348         [ALC880_CLEVO] = {
2349                 .mixers = { alc880_three_stack_mixer },
2350                 .init_verbs = { alc880_volume_init_verbs,
2351                                 alc880_pin_clevo_init_verbs },
2352                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2353                 .dac_nids = alc880_dac_nids,
2354                 .hp_nid = 0x03,
2355                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
2356                 .channel_mode = alc880_threestack_modes,
2357                 .input_mux = &alc880_capture_source,
2358         },
2359         [ALC880_LG] = {
2360                 .mixers = { alc880_lg_mixer },
2361                 .init_verbs = { alc880_volume_init_verbs,
2362                                 alc880_lg_init_verbs },
2363                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
2364                 .dac_nids = alc880_lg_dac_nids,
2365                 .dig_out_nid = ALC880_DIGOUT_NID,
2366                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
2367                 .channel_mode = alc880_lg_ch_modes,
2368                 .input_mux = &alc880_lg_capture_source,
2369                 .unsol_event = alc880_lg_unsol_event,
2370                 .init_hook = alc880_lg_automute,
2371         },
2372         [ALC880_LG_LW] = {
2373                 .mixers = { alc880_lg_lw_mixer },
2374                 .init_verbs = { alc880_volume_init_verbs,
2375                                 alc880_lg_lw_init_verbs },
2376                 .num_dacs = 1,
2377                 .dac_nids = alc880_dac_nids,
2378                 .dig_out_nid = ALC880_DIGOUT_NID,
2379                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
2380                 .channel_mode = alc880_2_jack_modes,
2381                 .input_mux = &alc880_lg_lw_capture_source,
2382                 .unsol_event = alc880_lg_lw_unsol_event,
2383                 .init_hook = alc880_lg_lw_automute,
2384         },
2385 #ifdef CONFIG_SND_DEBUG
2386         [ALC880_TEST] = {
2387                 .mixers = { alc880_test_mixer },
2388                 .init_verbs = { alc880_test_init_verbs },
2389                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
2390                 .dac_nids = alc880_test_dac_nids,
2391                 .dig_out_nid = ALC880_DIGOUT_NID,
2392                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
2393                 .channel_mode = alc880_test_modes,
2394                 .input_mux = &alc880_test_capture_source,
2395         },
2396 #endif
2397 };
2398
2399 /*
2400  * Automatic parse of I/O pins from the BIOS configuration
2401  */
2402
2403 #define NUM_CONTROL_ALLOC       32
2404 #define NUM_VERB_ALLOC          32
2405
2406 enum {
2407         ALC_CTL_WIDGET_VOL,
2408         ALC_CTL_WIDGET_MUTE,
2409         ALC_CTL_BIND_MUTE,
2410 };
2411 static struct snd_kcontrol_new alc880_control_templates[] = {
2412         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2413         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2414         HDA_BIND_MUTE(NULL, 0, 0, 0),
2415 };
2416
2417 /* add dynamic controls */
2418 static int add_control(struct alc_spec *spec, int type, const char *name, unsigned long val)
2419 {
2420         struct snd_kcontrol_new *knew;
2421
2422         if (spec->num_kctl_used >= spec->num_kctl_alloc) {
2423                 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
2424
2425                 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
2426                 if (! knew)
2427                         return -ENOMEM;
2428                 if (spec->kctl_alloc) {
2429                         memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
2430                         kfree(spec->kctl_alloc);
2431                 }
2432                 spec->kctl_alloc = knew;
2433                 spec->num_kctl_alloc = num;
2434         }
2435
2436         knew = &spec->kctl_alloc[spec->num_kctl_used];
2437         *knew = alc880_control_templates[type];
2438         knew->name = kstrdup(name, GFP_KERNEL);
2439         if (! knew->name)
2440                 return -ENOMEM;
2441         knew->private_value = val;
2442         spec->num_kctl_used++;
2443         return 0;
2444 }
2445
2446 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
2447 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
2448 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
2449 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
2450 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
2451 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
2452 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
2453 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
2454 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
2455 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
2456 #define ALC880_PIN_CD_NID               0x1c
2457
2458 /* fill in the dac_nids table from the parsed pin configuration */
2459 static int alc880_auto_fill_dac_nids(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
2460 {
2461         hda_nid_t nid;
2462         int assigned[4];
2463         int i, j;
2464
2465         memset(assigned, 0, sizeof(assigned));
2466         spec->multiout.dac_nids = spec->private_dac_nids;
2467
2468         /* check the pins hardwired to audio widget */
2469         for (i = 0; i < cfg->line_outs; i++) {
2470                 nid = cfg->line_out_pins[i];
2471                 if (alc880_is_fixed_pin(nid)) {
2472                         int idx = alc880_fixed_pin_idx(nid);
2473                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
2474                         assigned[idx] = 1;
2475                 }
2476         }
2477         /* left pins can be connect to any audio widget */
2478         for (i = 0; i < cfg->line_outs; i++) {
2479                 nid = cfg->line_out_pins[i];
2480                 if (alc880_is_fixed_pin(nid))
2481                         continue;
2482                 /* search for an empty channel */
2483                 for (j = 0; j < cfg->line_outs; j++) {
2484                         if (! assigned[j]) {
2485                                 spec->multiout.dac_nids[i] = alc880_idx_to_dac(j);
2486                                 assigned[j] = 1;
2487                                 break;
2488                         }
2489                 }
2490         }
2491         spec->multiout.num_dacs = cfg->line_outs;
2492         return 0;
2493 }
2494
2495 /* add playback controls from the parsed DAC table */
2496 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
2497                                              const struct auto_pin_cfg *cfg)
2498 {
2499         char name[32];
2500         static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
2501         hda_nid_t nid;
2502         int i, err;
2503
2504         for (i = 0; i < cfg->line_outs; i++) {
2505                 if (! spec->multiout.dac_nids[i])
2506                         continue;
2507                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
2508                 if (i == 2) {
2509                         /* Center/LFE */
2510                         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Center Playback Volume",
2511                                                HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0)
2512                                 return err;
2513                         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "LFE Playback Volume",
2514                                                HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
2515                                 return err;
2516                         if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "Center Playback Switch",
2517                                                HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT))) < 0)
2518                                 return err;
2519                         if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "LFE Playback Switch",
2520                                                HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT))) < 0)
2521                                 return err;
2522                 } else {
2523                         sprintf(name, "%s Playback Volume", chname[i]);
2524                         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
2525                                                HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
2526                                 return err;
2527                         sprintf(name, "%s Playback Switch", chname[i]);
2528                         if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
2529                                                HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2530                                 return err;
2531                 }
2532         }
2533         return 0;
2534 }
2535
2536 /* add playback controls for speaker and HP outputs */
2537 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
2538                                         const char *pfx)
2539 {
2540         hda_nid_t nid;
2541         int err;
2542         char name[32];
2543
2544         if (! pin)
2545                 return 0;
2546
2547         if (alc880_is_fixed_pin(pin)) {
2548                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
2549                 /* specify the DAC as the extra output */
2550                 if (! spec->multiout.hp_nid)
2551                         spec->multiout.hp_nid = nid;
2552                 else
2553                         spec->multiout.extra_out_nid[0] = nid;
2554                 /* control HP volume/switch on the output mixer amp */
2555                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
2556                 sprintf(name, "%s Playback Volume", pfx);
2557                 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
2558                                        HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
2559                         return err;
2560                 sprintf(name, "%s Playback Switch", pfx);
2561                 if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
2562                                        HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2563                         return err;
2564         } else if (alc880_is_multi_pin(pin)) {
2565                 /* set manual connection */
2566                 /* we have only a switch on HP-out PIN */
2567                 sprintf(name, "%s Playback Switch", pfx);
2568                 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
2569                                        HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT))) < 0)
2570                         return err;
2571         }
2572         return 0;
2573 }
2574
2575 /* create input playback/capture controls for the given pin */
2576 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, const char *ctlname,
2577                             int idx, hda_nid_t mix_nid)
2578 {
2579         char name[32];
2580         int err;
2581
2582         sprintf(name, "%s Playback Volume", ctlname);
2583         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
2584                                HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT))) < 0)
2585                 return err;
2586         sprintf(name, "%s Playback Switch", ctlname);
2587         if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
2588                                HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT))) < 0)
2589                 return err;
2590         return 0;
2591 }
2592
2593 /* create playback/capture controls for input pins */
2594 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
2595                                                 const struct auto_pin_cfg *cfg)
2596 {
2597         struct hda_input_mux *imux = &spec->private_imux;
2598         int i, err, idx;
2599
2600         for (i = 0; i < AUTO_PIN_LAST; i++) {
2601                 if (alc880_is_input_pin(cfg->input_pins[i])) {
2602                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
2603                         err = new_analog_input(spec, cfg->input_pins[i],
2604                                                auto_pin_cfg_labels[i],
2605                                                idx, 0x0b);
2606                         if (err < 0)
2607                                 return err;
2608                         imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2609                         imux->items[imux->num_items].index = alc880_input_pin_idx(cfg->input_pins[i]);
2610                         imux->num_items++;
2611                 }
2612         }
2613         return 0;
2614 }
2615
2616 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
2617                                               hda_nid_t nid, int pin_type,
2618                                               int dac_idx)
2619 {
2620         /* set as output */
2621         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2622         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
2623         /* need the manual connection? */
2624         if (alc880_is_multi_pin(nid)) {
2625                 struct alc_spec *spec = codec->spec;
2626                 int idx = alc880_multi_pin_idx(nid);
2627                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
2628                                     AC_VERB_SET_CONNECT_SEL,
2629                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
2630         }
2631 }
2632
2633 static void alc880_auto_init_multi_out(struct hda_codec *codec)
2634 {
2635         struct alc_spec *spec = codec->spec;
2636         int i;
2637
2638         for (i = 0; i < spec->autocfg.line_outs; i++) {
2639                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2640                 alc880_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
2641         }
2642 }
2643
2644 static void alc880_auto_init_extra_out(struct hda_codec *codec)
2645 {
2646         struct alc_spec *spec = codec->spec;
2647         hda_nid_t pin;
2648
2649         pin = spec->autocfg.speaker_pins[0];
2650         if (pin) /* connect to front */
2651                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
2652         pin = spec->autocfg.hp_pin;
2653         if (pin) /* connect to front */
2654                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
2655 }
2656
2657 static void alc880_auto_init_analog_input(struct hda_codec *codec)
2658 {
2659         struct alc_spec *spec = codec->spec;
2660         int i;
2661
2662         for (i = 0; i < AUTO_PIN_LAST; i++) {
2663                 hda_nid_t nid = spec->autocfg.input_pins[i];
2664                 if (alc880_is_input_pin(nid)) {
2665                         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2666                                             i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
2667                         if (nid != ALC880_PIN_CD_NID)
2668                                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2669                                                     AMP_OUT_MUTE);
2670                 }
2671         }
2672 }
2673
2674 /* parse the BIOS configuration and set up the alc_spec */
2675 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
2676 static int alc880_parse_auto_config(struct hda_codec *codec)
2677 {
2678         struct alc_spec *spec = codec->spec;
2679         int err;
2680         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
2681
2682         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
2683                                                 alc880_ignore)) < 0)
2684                 return err;
2685         if (! spec->autocfg.line_outs)
2686                 return 0; /* can't find valid BIOS pin config */
2687
2688         if ((err = alc880_auto_fill_dac_nids(spec, &spec->autocfg)) < 0 ||
2689             (err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
2690             (err = alc880_auto_create_extra_out(spec,
2691                                                 spec->autocfg.speaker_pins[0],
2692                                                 "Speaker")) < 0 ||
2693             (err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pin,
2694                                                 "Headphone")) < 0 ||
2695             (err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
2696                 return err;
2697
2698         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2699
2700         if (spec->autocfg.dig_out_pin)
2701                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
2702         if (spec->autocfg.dig_in_pin)
2703                 spec->dig_in_nid = ALC880_DIGIN_NID;
2704
2705         if (spec->kctl_alloc)
2706                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2707
2708         spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs;
2709
2710         spec->num_mux_defs = 1;
2711         spec->input_mux = &spec->private_imux;
2712
2713         return 1;
2714 }
2715
2716 /* additional initialization for auto-configuration model */
2717 static void alc880_auto_init(struct hda_codec *codec)
2718 {
2719         alc880_auto_init_multi_out(codec);
2720         alc880_auto_init_extra_out(codec);
2721         alc880_auto_init_analog_input(codec);
2722 }
2723
2724 /*
2725  * OK, here we have finally the patch for ALC880
2726  */
2727
2728 static int patch_alc880(struct hda_codec *codec)
2729 {
2730         struct alc_spec *spec;
2731         int board_config;
2732         int err;
2733
2734         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2735         if (spec == NULL)
2736                 return -ENOMEM;
2737
2738         codec->spec = spec;
2739
2740         board_config = snd_hda_check_board_config(codec, alc880_cfg_tbl);
2741         if (board_config < 0 || board_config >= ALC880_MODEL_LAST) {
2742                 printk(KERN_INFO "hda_codec: Unknown model for ALC880, trying auto-probe from BIOS...\n");
2743                 board_config = ALC880_AUTO;
2744         }
2745
2746         if (board_config == ALC880_AUTO) {
2747                 /* automatic parse from the BIOS config */
2748                 err = alc880_parse_auto_config(codec);
2749                 if (err < 0) {
2750                         alc_free(codec);
2751                         return err;
2752                 } else if (! err) {
2753                         printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using 3-stack mode...\n");
2754                         board_config = ALC880_3ST;
2755                 }
2756         }
2757
2758         if (board_config != ALC880_AUTO)
2759                 setup_preset(spec, &alc880_presets[board_config]);
2760
2761         spec->stream_name_analog = "ALC880 Analog";
2762         spec->stream_analog_playback = &alc880_pcm_analog_playback;
2763         spec->stream_analog_capture = &alc880_pcm_analog_capture;
2764
2765         spec->stream_name_digital = "ALC880 Digital";
2766         spec->stream_digital_playback = &alc880_pcm_digital_playback;
2767         spec->stream_digital_capture = &alc880_pcm_digital_capture;
2768
2769         if (! spec->adc_nids && spec->input_mux) {
2770                 /* check whether NID 0x07 is valid */
2771                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
2772                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
2773                 if (wcap != AC_WID_AUD_IN) {
2774                         spec->adc_nids = alc880_adc_nids_alt;
2775                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
2776                         spec->mixers[spec->num_mixers] = alc880_capture_alt_mixer;
2777                         spec->num_mixers++;
2778                 } else {
2779                         spec->adc_nids = alc880_adc_nids;
2780                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
2781                         spec->mixers[spec->num_mixers] = alc880_capture_mixer;
2782                         spec->num_mixers++;
2783                 }
2784         }
2785
2786         codec->patch_ops = alc_patch_ops;
2787         if (board_config == ALC880_AUTO)
2788                 spec->init_hook = alc880_auto_init;
2789
2790         return 0;
2791 }
2792
2793
2794 /*
2795  * ALC260 support
2796  */
2797
2798 static hda_nid_t alc260_dac_nids[1] = {
2799         /* front */
2800         0x02,
2801 };
2802
2803 static hda_nid_t alc260_adc_nids[1] = {
2804         /* ADC0 */
2805         0x04,
2806 };
2807
2808 static hda_nid_t alc260_adc_nids_alt[1] = {
2809         /* ADC1 */
2810         0x05,
2811 };
2812
2813 static hda_nid_t alc260_hp_adc_nids[2] = {
2814         /* ADC1, 0 */
2815         0x05, 0x04
2816 };
2817
2818 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
2819  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
2820  */
2821 static hda_nid_t alc260_dual_adc_nids[2] = {
2822         /* ADC0, ADC1 */
2823         0x04, 0x05
2824 };
2825
2826 #define ALC260_DIGOUT_NID       0x03
2827 #define ALC260_DIGIN_NID        0x06
2828
2829 static struct hda_input_mux alc260_capture_source = {
2830         .num_items = 4,
2831         .items = {
2832                 { "Mic", 0x0 },
2833                 { "Front Mic", 0x1 },
2834                 { "Line", 0x2 },
2835                 { "CD", 0x4 },
2836         },
2837 };
2838
2839 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
2840  * headphone jack and the internal CD lines since these are the only pins at
2841  * which audio can appear.  For flexibility, also allow the option of
2842  * recording the mixer output on the second ADC (ADC0 doesn't have a
2843  * connection to the mixer output).
2844  */
2845 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
2846         {
2847                 .num_items = 3,
2848                 .items = {
2849                         { "Mic/Line", 0x0 },
2850                         { "CD", 0x4 },
2851                         { "Headphone", 0x2 },
2852                 },
2853         },
2854         {
2855                 .num_items = 4,
2856                 .items = {
2857                         { "Mic/Line", 0x0 },
2858                         { "CD", 0x4 },
2859                         { "Headphone", 0x2 },
2860                         { "Mixer", 0x5 },
2861                 },
2862         },
2863
2864 };
2865
2866 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
2867  * the Fujitsu S702x, but jacks are marked differently.
2868  */
2869 static struct hda_input_mux alc260_acer_capture_sources[2] = {
2870         {
2871                 .num_items = 4,
2872                 .items = {
2873                         { "Mic", 0x0 },
2874                         { "Line", 0x2 },
2875                         { "CD", 0x4 },
2876                         { "Headphone", 0x5 },
2877                 },
2878         },
2879         {
2880                 .num_items = 5,
2881                 .items = {
2882                         { "Mic", 0x0 },
2883                         { "Line", 0x2 },
2884                         { "CD", 0x4 },
2885                         { "Headphone", 0x6 },
2886                         { "Mixer", 0x5 },
2887                 },
2888         },
2889 };
2890 /*
2891  * This is just place-holder, so there's something for alc_build_pcms to look
2892  * at when it calculates the maximum number of channels. ALC260 has no mixer
2893  * element which allows changing the channel mode, so the verb list is
2894  * never used.
2895  */
2896 static struct hda_channel_mode alc260_modes[1] = {
2897         { 2, NULL },
2898 };
2899
2900
2901 /* Mixer combinations
2902  *
2903  * basic: base_output + input + pc_beep + capture
2904  * HP: base_output + input + capture_alt
2905  * HP_3013: hp_3013 + input + capture
2906  * fujitsu: fujitsu + capture
2907  * acer: acer + capture
2908  */
2909
2910 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
2911         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
2912         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
2913         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
2914         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
2915         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
2916         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
2917         { } /* end */
2918 };
2919
2920 static struct snd_kcontrol_new alc260_input_mixer[] = {
2921         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
2922         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
2923         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
2924         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
2925         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
2926         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
2927         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
2928         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
2929         { } /* end */
2930 };
2931
2932 static struct snd_kcontrol_new alc260_pc_beep_mixer[] = {
2933         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
2934         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
2935         { } /* end */
2936 };
2937
2938 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
2939         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
2940         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
2941         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
2942         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
2943         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
2944         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
2945         HDA_CODEC_VOLUME_MONO("iSpeaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
2946         HDA_CODEC_MUTE_MONO("iSpeaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
2947         { } /* end */
2948 };
2949
2950 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
2951  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
2952  */
2953 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
2954         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
2955         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
2956         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
2957         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
2958         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
2959         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
2960         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
2961         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
2962         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
2963         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
2964         HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
2965         HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x09, 2, HDA_INPUT),
2966         { } /* end */
2967 };
2968
2969 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
2970  * versions of the ALC260 don't act on requests to enable mic bias from NID
2971  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
2972  * datasheet doesn't mention this restriction.  At this stage it's not clear
2973  * whether this behaviour is intentional or is a hardware bug in chip
2974  * revisions available in early 2006.  Therefore for now allow the
2975  * "Headphone Jack Mode" control to span all choices, but if it turns out
2976  * that the lack of mic bias for this NID is intentional we could change the
2977  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
2978  *
2979  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
2980  * don't appear to make the mic bias available from the "line" jack, even
2981  * though the NID used for this jack (0x14) can supply it.  The theory is
2982  * that perhaps Acer have included blocking capacitors between the ALC260
2983  * and the output jack.  If this turns out to be the case for all such
2984  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
2985  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
2986  */
2987 static struct snd_kcontrol_new alc260_acer_mixer[] = {
2988         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
2989         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
2990         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
2991         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
2992         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
2993         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
2994         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
2995         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
2996         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
2997         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
2998         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
2999         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
3000         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
3001         { } /* end */
3002 };
3003
3004 /* capture mixer elements */
3005 static struct snd_kcontrol_new alc260_capture_mixer[] = {
3006         HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
3007         HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
3008         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT),
3009         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT),
3010         {
3011                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3012                 /* The multiple "Capture Source" controls confuse alsamixer
3013                  * So call somewhat different..
3014                  * FIXME: the controls appear in the "playback" view!
3015                  */
3016                 /* .name = "Capture Source", */
3017                 .name = "Input Source",
3018                 .count = 2,
3019                 .info = alc_mux_enum_info,
3020                 .get = alc_mux_enum_get,
3021                 .put = alc_mux_enum_put,
3022         },
3023         { } /* end */
3024 };
3025
3026 static struct snd_kcontrol_new alc260_capture_alt_mixer[] = {
3027         HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
3028         HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
3029         {
3030                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3031                 /* The multiple "Capture Source" controls confuse alsamixer
3032                  * So call somewhat different..
3033                  * FIXME: the controls appear in the "playback" view!
3034                  */
3035                 /* .name = "Capture Source", */
3036                 .name = "Input Source",
3037                 .count = 1,
3038                 .info = alc_mux_enum_info,
3039                 .get = alc_mux_enum_get,
3040                 .put = alc_mux_enum_put,
3041         },
3042         { } /* end */
3043 };
3044
3045 /*
3046  * initialization verbs
3047  */
3048 static struct hda_verb alc260_init_verbs[] = {
3049         /* Line In pin widget for input */
3050         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3051         /* CD pin widget for input */
3052         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3053         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3054         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3055         /* Mic2 (front panel) pin widget for input and vref at 80% */
3056         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3057         /* LINE-2 is used for line-out in rear */
3058         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3059         /* select line-out */
3060         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
3061         /* LINE-OUT pin */
3062         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3063         /* enable HP */
3064         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3065         /* enable Mono */
3066         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3067         /* mute capture amp left and right */
3068         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3069         /* set connection select to line in (default select for this ADC) */
3070         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
3071         /* mute capture amp left and right */
3072         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3073         /* set connection select to line in (default select for this ADC) */
3074         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
3075         /* set vol=0 Line-Out mixer amp left and right */
3076         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3077         /* unmute pin widget amp left and right (no gain on this amp) */
3078         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3079         /* set vol=0 HP mixer amp left and right */
3080         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3081         /* unmute pin widget amp left and right (no gain on this amp) */
3082         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3083         /* set vol=0 Mono mixer amp left and right */
3084         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3085         /* unmute pin widget amp left and right (no gain on this amp) */
3086         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3087         /* unmute LINE-2 out pin */
3088         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3089         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
3090         /* mute CD */
3091         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
3092         /* mute Line In */
3093         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
3094         /* mute Mic */
3095         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3096         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
3097         /* mute Front out path */
3098         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3099         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3100         /* mute Headphone out path */
3101         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3102         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3103         /* mute Mono out path */
3104         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3105         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3106         { }
3107 };
3108
3109 static struct hda_verb alc260_hp_init_verbs[] = {
3110         /* Headphone and output */
3111         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
3112         /* mono output */
3113         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3114         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3115         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3116         /* Mic2 (front panel) pin widget for input and vref at 80% */
3117         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3118         /* Line In pin widget for input */
3119         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3120         /* Line-2 pin widget for output */
3121         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3122         /* CD pin widget for input */
3123         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3124         /* unmute amp left and right */
3125         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
3126         /* set connection select to line in (default select for this ADC) */
3127         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
3128         /* unmute Line-Out mixer amp left and right (volume = 0) */
3129         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3130         /* mute pin widget amp left and right (no gain on this amp) */
3131         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3132         /* unmute HP mixer amp left and right (volume = 0) */
3133         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3134         /* mute pin widget amp left and right (no gain on this amp) */
3135         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3136         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
3137         /* unmute CD */
3138         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
3139         /* unmute Line In */
3140         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
3141         /* unmute Mic */
3142         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3143         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
3144         /* Unmute Front out path */
3145         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3146         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3147         /* Unmute Headphone out path */
3148         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3149         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3150         /* Unmute Mono out path */
3151         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3152         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3153         { }
3154 };
3155
3156 static struct hda_verb alc260_hp_3013_init_verbs[] = {
3157         /* Line out and output */
3158         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3159         /* mono output */
3160         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3161         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3162         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3163         /* Mic2 (front panel) pin widget for input and vref at 80% */
3164         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3165         /* Line In pin widget for input */
3166         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3167         /* Headphone pin widget for output */
3168         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
3169         /* CD pin widget for input */
3170         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3171         /* unmute amp left and right */
3172         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
3173         /* set connection select to line in (default select for this ADC) */
3174         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
3175         /* unmute Line-Out mixer amp left and right (volume = 0) */
3176         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3177         /* mute pin widget amp left and right (no gain on this amp) */
3178         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3179         /* unmute HP mixer amp left and right (volume = 0) */
3180         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3181         /* mute pin widget amp left and right (no gain on this amp) */
3182         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3183         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
3184         /* unmute CD */
3185         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
3186         /* unmute Line In */
3187         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
3188         /* unmute Mic */
3189         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3190         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
3191         /* Unmute Front out path */
3192         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3193         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3194         /* Unmute Headphone out path */
3195         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3196         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3197         /* Unmute Mono out path */
3198         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3199         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3200         { }
3201 };
3202
3203 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
3204  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
3205  * audio = 0x16, internal speaker = 0x10.
3206  */
3207 static struct hda_verb alc260_fujitsu_init_verbs[] = {
3208         /* Disable all GPIOs */
3209         {0x01, AC_VERB_SET_GPIO_MASK, 0},
3210         /* Internal speaker is connected to headphone pin */
3211         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3212         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
3213         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3214         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
3215         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3216         /* Ensure all other unused pins are disabled and muted. */
3217         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3218         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3219         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3220         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3221         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3222         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3223         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3224         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3225
3226         /* Disable digital (SPDIF) pins */
3227         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
3228         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
3229
3230         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
3231          * when acting as an output.
3232          */
3233         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
3234
3235         /* Start with output sum widgets muted and their output gains at min */
3236         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3237         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3238         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3239         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3240         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3241         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3242         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3243         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3244         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3245
3246         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
3247         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3248         /* Unmute Line1 pin widget output buffer since it starts as an output.
3249          * If the pin mode is changed by the user the pin mode control will
3250          * take care of enabling the pin's input/output buffers as needed.
3251          * Therefore there's no need to enable the input buffer at this
3252          * stage.
3253          */
3254         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3255         /* Unmute input buffer of pin widget used for Line-in (no equiv
3256          * mixer ctrl)
3257          */
3258         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3259
3260         /* Mute capture amp left and right */
3261         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3262         /* Set ADC connection select to match default mixer setting - line
3263          * in (on mic1 pin)
3264          */
3265         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
3266
3267         /* Do the same for the second ADC: mute capture input amp and
3268          * set ADC connection to line in (on mic1 pin)
3269          */
3270         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3271         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
3272
3273         /* Mute all inputs to mixer widget (even unconnected ones) */
3274         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
3275         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
3276         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
3277         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
3278         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
3279         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
3280         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
3281         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
3282
3283         { }
3284 };
3285
3286 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
3287  * similar laptops (adapted from Fujitsu init verbs).
3288  */
3289 static struct hda_verb alc260_acer_init_verbs[] = {
3290         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
3291          * the headphone jack.  Turn this on and rely on the standard mute
3292          * methods whenever the user wants to turn these outputs off.
3293          */
3294         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
3295         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
3296         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
3297         /* Internal speaker/Headphone jack is connected to Line-out pin */
3298         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3299         /* Internal microphone/Mic jack is connected to Mic1 pin */
3300         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3301         /* Line In jack is connected to Line1 pin */
3302         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3303         /* Ensure all other unused pins are disabled and muted. */
3304         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3305         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3306         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3307         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3308         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3309         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3310         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3311         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3312         /* Disable digital (SPDIF) pins */
3313         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
3314         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
3315
3316         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
3317          * bus when acting as outputs.
3318          */
3319         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
3320         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
3321
3322         /* Start with output sum widgets muted and their output gains at min */
3323         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3324         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3325         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3326         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3327         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3328         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3329         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3330         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3331         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3332
3333         /* Unmute Line-out pin widget amp left and right (no equiv mixer ctrl) */
3334         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3335         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
3336          * inputs. If the pin mode is changed by the user the pin mode control
3337          * will take care of enabling the pin's input/output buffers as needed.
3338          * Therefore there's no need to enable the input buffer at this
3339          * stage.
3340          */
3341         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3342         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3343
3344         /* Mute capture amp left and right */
3345         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3346         /* Set ADC connection select to match default mixer setting - mic
3347          * (on mic1 pin)
3348          */
3349         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
3350
3351         /* Do similar with the second ADC: mute capture input amp and
3352          * set ADC connection to mic to match ALSA's default state.
3353          */
3354         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3355         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
3356
3357         /* Mute all inputs to mixer widget (even unconnected ones) */
3358         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
3359         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
3360         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
3361         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
3362         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
3363         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
3364         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
3365         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
3366
3367         { }
3368 };
3369
3370 /* Test configuration for debugging, modelled after the ALC880 test
3371  * configuration.
3372  */
3373 #ifdef CONFIG_SND_DEBUG
3374 static hda_nid_t alc260_test_dac_nids[1] = {
3375         0x02,
3376 };
3377 static hda_nid_t alc260_test_adc_nids[2] = {
3378         0x04, 0x05,
3379 };
3380 /* For testing the ALC260, each input MUX needs its own definition since
3381  * the signal assignments are different.  This assumes that the first ADC
3382  * is NID 0x04.
3383  */
3384 static struct hda_input_mux alc260_test_capture_sources[2] = {
3385         {
3386                 .num_items = 7,
3387                 .items = {
3388                         { "MIC1 pin", 0x0 },
3389                         { "MIC2 pin", 0x1 },
3390                         { "LINE1 pin", 0x2 },
3391                         { "LINE2 pin", 0x3 },
3392                         { "CD pin", 0x4 },
3393                         { "LINE-OUT pin", 0x5 },
3394                         { "HP-OUT pin", 0x6 },
3395                 },
3396         },
3397         {
3398                 .num_items = 8,
3399                 .items = {
3400                         { "MIC1 pin", 0x0 },
3401                         { "MIC2 pin", 0x1 },
3402                         { "LINE1 pin", 0x2 },
3403                         { "LINE2 pin", 0x3 },
3404                         { "CD pin", 0x4 },
3405                         { "Mixer", 0x5 },
3406                         { "LINE-OUT pin", 0x6 },
3407                         { "HP-OUT pin", 0x7 },
3408                 },
3409         },
3410 };
3411 static struct snd_kcontrol_new alc260_test_mixer[] = {
3412         /* Output driver widgets */
3413         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
3414         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
3415         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
3416         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
3417         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3418         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
3419
3420         /* Modes for retasking pin widgets
3421          * Note: the ALC260 doesn't seem to act on requests to enable mic
3422          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
3423          * mention this restriction.  At this stage it's not clear whether
3424          * this behaviour is intentional or is a hardware bug in chip
3425          * revisions available at least up until early 2006.  Therefore for
3426          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
3427          * choices, but if it turns out that the lack of mic bias for these
3428          * NIDs is intentional we could change their modes from
3429          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
3430          */
3431         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
3432         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
3433         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
3434         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
3435         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
3436         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
3437
3438         /* Loopback mixer controls */
3439         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
3440         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
3441         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
3442         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
3443         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
3444         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
3445         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
3446         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
3447         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
3448         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
3449         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
3450         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
3451         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
3452         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
3453         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
3454         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
3455
3456         /* Controls for GPIO pins, assuming they are configured as outputs */
3457         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
3458         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
3459         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
3460         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
3461
3462         /* Switches to allow the digital IO pins to be enabled.  The datasheet
3463          * is ambigious as to which NID is which; testing on laptops which
3464          * make this output available should provide clarification.
3465          */
3466         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
3467         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
3468
3469         { } /* end */
3470 };
3471 static struct hda_verb alc260_test_init_verbs[] = {
3472         /* Enable all GPIOs as outputs with an initial value of 0 */
3473         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
3474         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
3475         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
3476
3477         /* Enable retasking pins as output, initially without power amp */
3478         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3479         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3480         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3481         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3482         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3483         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3484
3485         /* Disable digital (SPDIF) pins initially, but users can enable
3486          * them via a mixer switch.  In the case of SPDIF-out, this initverb
3487          * payload also sets the generation to 0, output to be in "consumer"
3488          * PCM format, copyright asserted, no pre-emphasis and no validity
3489          * control.
3490          */
3491         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
3492         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
3493
3494         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
3495          * OUT1 sum bus when acting as an output.
3496          */
3497         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
3498         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
3499         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
3500         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
3501
3502         /* Start with output sum widgets muted and their output gains at min */
3503         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3504         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3505         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3506         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3507         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3508         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3509         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3510         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3511         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3512
3513         /* Unmute retasking pin widget output buffers since the default
3514          * state appears to be output.  As the pin mode is changed by the
3515          * user the pin mode control will take care of enabling the pin's
3516          * input/output buffers as needed.
3517          */
3518         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3519         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3520         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3521         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3522         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3523         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3524         /* Also unmute the mono-out pin widget */
3525         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3526
3527         /* Mute capture amp left and right */
3528         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3529         /* Set ADC connection select to match default mixer setting (mic1
3530          * pin)
3531          */
3532         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
3533
3534         /* Do the same for the second ADC: mute capture input amp and
3535          * set ADC connection to mic1 pin
3536          */
3537         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3538         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
3539
3540         /* Mute all inputs to mixer widget (even unconnected ones) */
3541         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
3542         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
3543         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
3544         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
3545         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
3546         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
3547         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
3548         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
3549
3550         { }
3551 };
3552 #endif
3553
3554 static struct hda_pcm_stream alc260_pcm_analog_playback = {
3555         .substreams = 1,
3556         .channels_min = 2,
3557         .channels_max = 2,
3558 };
3559
3560 static struct hda_pcm_stream alc260_pcm_analog_capture = {
3561         .substreams = 1,
3562         .channels_min = 2,
3563         .channels_max = 2,
3564 };
3565
3566 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
3567 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
3568
3569 /*
3570  * for BIOS auto-configuration
3571  */
3572
3573 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
3574                                         const char *pfx)
3575 {
3576         hda_nid_t nid_vol;
3577         unsigned long vol_val, sw_val;
3578         char name[32];
3579         int err;
3580
3581         if (nid >= 0x0f && nid < 0x11) {
3582                 nid_vol = nid - 0x7;
3583                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
3584                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3585         } else if (nid == 0x11) {
3586                 nid_vol = nid - 0x7;
3587                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
3588                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
3589         } else if (nid >= 0x12 && nid <= 0x15) {
3590                 nid_vol = 0x08;
3591                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
3592                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3593         } else
3594                 return 0; /* N/A */
3595
3596         snprintf(name, sizeof(name), "%s Playback Volume", pfx);
3597         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val)) < 0)
3598                 return err;
3599         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
3600         if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val)) < 0)
3601                 return err;
3602         return 1;
3603 }
3604
3605 /* add playback controls from the parsed DAC table */
3606 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
3607                                              const struct auto_pin_cfg *cfg)
3608 {
3609         hda_nid_t nid;
3610         int err;
3611
3612         spec->multiout.num_dacs = 1;
3613         spec->multiout.dac_nids = spec->private_dac_nids;
3614         spec->multiout.dac_nids[0] = 0x02;
3615
3616         nid = cfg->line_out_pins[0];
3617         if (nid) {
3618                 err = alc260_add_playback_controls(spec, nid, "Front");
3619                 if (err < 0)
3620                         return err;
3621         }
3622
3623         nid = cfg->speaker_pins[0];
3624         if (nid) {
3625                 err = alc260_add_playback_controls(spec, nid, "Speaker");
3626                 if (err < 0)
3627                         return err;
3628         }
3629
3630         nid = cfg->hp_pin;
3631         if (nid) {
3632                 err = alc260_add_playback_controls(spec, nid, "Headphone");
3633                 if (err < 0)
3634                         return err;
3635         }
3636         return 0;
3637 }
3638
3639 /* create playback/capture controls for input pins */
3640 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
3641                                                 const struct auto_pin_cfg *cfg)
3642 {
3643         struct hda_input_mux *imux = &spec->private_imux;
3644         int i, err, idx;
3645
3646         for (i = 0; i < AUTO_PIN_LAST; i++) {
3647                 if (cfg->input_pins[i] >= 0x12) {
3648                         idx = cfg->input_pins[i] - 0x12;
3649                         err = new_analog_input(spec, cfg->input_pins[i],
3650                                                auto_pin_cfg_labels[i], idx, 0x07);
3651                         if (err < 0)
3652                                 return err;
3653                         imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3654                         imux->items[imux->num_items].index = idx;
3655                         imux->num_items++;
3656                 }
3657                 if ((cfg->input_pins[i] >= 0x0f) && (cfg->input_pins[i] <= 0x10)){
3658                         idx = cfg->input_pins[i] - 0x09;
3659                         err = new_analog_input(spec, cfg->input_pins[i],
3660                                                auto_pin_cfg_labels[i], idx, 0x07);
3661                         if (err < 0)
3662                                 return err;
3663                         imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3664                         imux->items[imux->num_items].index = idx;
3665                         imux->num_items++;
3666                 }
3667         }
3668         return 0;
3669 }
3670
3671 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
3672                                               hda_nid_t nid, int pin_type,
3673                                               int sel_idx)
3674 {
3675         /* set as output */
3676         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
3677         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
3678         /* need the manual connection? */
3679         if (nid >= 0x12) {
3680                 int idx = nid - 0x12;
3681                 snd_hda_codec_write(codec, idx + 0x0b, 0,
3682                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
3683
3684         }
3685 }
3686
3687 static void alc260_auto_init_multi_out(struct hda_codec *codec)
3688 {
3689         struct alc_spec *spec = codec->spec;
3690         hda_nid_t nid;
3691
3692         nid = spec->autocfg.line_out_pins[0];
3693         if (nid)
3694                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
3695
3696         nid = spec->autocfg.speaker_pins[0];
3697         if (nid)
3698                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
3699
3700         nid = spec->autocfg.hp_pin;
3701         if (nid)
3702                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
3703 }
3704
3705 #define ALC260_PIN_CD_NID               0x16
3706 static void alc260_auto_init_analog_input(struct hda_codec *codec)
3707 {
3708         struct alc_spec *spec = codec->spec;
3709         int i;
3710
3711         for (i = 0; i < AUTO_PIN_LAST; i++) {
3712                 hda_nid_t nid = spec->autocfg.input_pins[i];
3713                 if (nid >= 0x12) {
3714                         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3715                                             i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
3716                         if (nid != ALC260_PIN_CD_NID)
3717                                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3718                                                     AMP_OUT_MUTE);
3719                 }
3720         }
3721 }
3722
3723 /*
3724  * generic initialization of ADC, input mixers and output mixers
3725  */
3726 static struct hda_verb alc260_volume_init_verbs[] = {
3727         /*
3728          * Unmute ADC0-1 and set the default input to mic-in
3729          */
3730         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
3731         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3732         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
3733         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3734
3735         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3736          * mixer widget
3737          * Note: PASD motherboards uses the Line In 2 as the input for front panel
3738          * mic (mic 2)
3739          */
3740         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
3741         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3742         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3743         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
3744         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
3745         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
3746
3747         /*
3748          * Set up output mixers (0x08 - 0x0a)
3749          */
3750         /* set vol=0 to output mixers */
3751         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3752         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3753         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3754         /* set up input amps for analog loopback */
3755         /* Amp Indices: DAC = 0, mixer = 1 */
3756         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3757         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3758         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3759         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3760         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3761         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3762
3763         { }
3764 };
3765
3766 static int alc260_parse_auto_config(struct hda_codec *codec)
3767 {
3768         struct alc_spec *spec = codec->spec;
3769         unsigned int wcap;
3770         int err;
3771         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
3772
3773         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
3774                                                 alc260_ignore)) < 0)
3775                 return err;
3776         if ((err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0)
3777                 return err;
3778         if (! spec->kctl_alloc)
3779                 return 0; /* can't find valid BIOS pin config */
3780         if ((err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
3781                 return err;
3782
3783         spec->multiout.max_channels = 2;
3784
3785         if (spec->autocfg.dig_out_pin)
3786                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
3787         if (spec->kctl_alloc)
3788                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3789
3790         spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs;
3791
3792         spec->num_mux_defs = 1;
3793         spec->input_mux = &spec->private_imux;
3794
3795         /* check whether NID 0x04 is valid */
3796         wcap = get_wcaps(codec, 0x04);
3797         wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
3798         if (wcap != AC_WID_AUD_IN) {
3799                 spec->adc_nids = alc260_adc_nids_alt;
3800                 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
3801                 spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer;
3802         } else {
3803                 spec->adc_nids = alc260_adc_nids;
3804                 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
3805                 spec->mixers[spec->num_mixers] = alc260_capture_mixer;
3806         }
3807         spec->num_mixers++;
3808
3809         return 1;
3810 }
3811
3812 /* additional initialization for auto-configuration model */
3813 static void alc260_auto_init(struct hda_codec *codec)
3814 {
3815         alc260_auto_init_multi_out(codec);
3816         alc260_auto_init_analog_input(codec);
3817 }
3818
3819 /*
3820  * ALC260 configurations
3821  */
3822 static struct hda_board_config alc260_cfg_tbl[] = {
3823         { .modelname = "basic", .config = ALC260_BASIC },
3824         { .pci_subvendor = 0x104d, .pci_subdevice = 0x81bb,
3825           .config = ALC260_BASIC }, /* Sony VAIO */
3826         { .pci_subvendor = 0x104d, .pci_subdevice = 0x81cc,
3827           .config = ALC260_BASIC }, /* Sony VAIO VGN-S3HP */
3828         { .pci_subvendor = 0x104d, .pci_subdevice = 0x81cd,
3829           .config = ALC260_BASIC }, /* Sony VAIO */
3830         { .pci_subvendor = 0x152d, .pci_subdevice = 0x0729,
3831           .config = ALC260_BASIC }, /* CTL Travel Master U553W */
3832         { .modelname = "hp", .config = ALC260_HP },
3833         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3010, .config = ALC260_HP },
3834         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3011, .config = ALC260_HP },
3835         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3012, .config = ALC260_HP },
3836         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3013, .config = ALC260_HP_3013 },
3837         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3014, .config = ALC260_HP },
3838         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3015, .config = ALC260_HP },
3839         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3016, .config = ALC260_HP },
3840         { .modelname = "fujitsu", .config = ALC260_FUJITSU_S702X },
3841         { .pci_subvendor = 0x10cf, .pci_subdevice = 0x1326, .config = ALC260_FUJITSU_S702X },
3842         { .modelname = "acer", .config = ALC260_ACER },
3843         { .pci_subvendor = 0x1025, .pci_subdevice = 0x008f, .config = ALC260_ACER },
3844 #ifdef CONFIG_SND_DEBUG
3845         { .modelname = "test", .config = ALC260_TEST },
3846 #endif
3847         { .modelname = "auto", .config = ALC260_AUTO },
3848         {}
3849 };
3850
3851 static struct alc_config_preset alc260_presets[] = {
3852         [ALC260_BASIC] = {
3853                 .mixers = { alc260_base_output_mixer,
3854                             alc260_input_mixer,
3855                             alc260_pc_beep_mixer,
3856                             alc260_capture_mixer },
3857                 .init_verbs = { alc260_init_verbs },
3858                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
3859                 .dac_nids = alc260_dac_nids,
3860                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
3861                 .adc_nids = alc260_adc_nids,
3862                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
3863                 .channel_mode = alc260_modes,
3864                 .input_mux = &alc260_capture_source,
3865         },
3866         [ALC260_HP] = {
3867                 .mixers = { alc260_base_output_mixer,
3868                             alc260_input_mixer,
3869                             alc260_capture_alt_mixer },
3870                 .init_verbs = { alc260_hp_init_verbs },
3871                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
3872                 .dac_nids = alc260_dac_nids,
3873                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
3874                 .adc_nids = alc260_hp_adc_nids,
3875                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
3876                 .channel_mode = alc260_modes,
3877                 .input_mux = &alc260_capture_source,
3878         },
3879         [ALC260_HP_3013] = {
3880                 .mixers = { alc260_hp_3013_mixer,
3881                             alc260_input_mixer,
3882                             alc260_capture_alt_mixer },
3883                 .init_verbs = { alc260_hp_3013_init_verbs },
3884                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
3885                 .dac_nids = alc260_dac_nids,
3886                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
3887                 .adc_nids = alc260_hp_adc_nids,
3888                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
3889                 .channel_mode = alc260_modes,
3890                 .input_mux = &alc260_capture_source,
3891         },
3892         [ALC260_FUJITSU_S702X] = {
3893                 .mixers = { alc260_fujitsu_mixer,
3894                             alc260_capture_mixer },
3895                 .init_verbs = { alc260_fujitsu_init_verbs },
3896                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
3897                 .dac_nids = alc260_dac_nids,
3898                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
3899                 .adc_nids = alc260_dual_adc_nids,
3900                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
3901                 .channel_mode = alc260_modes,
3902                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
3903                 .input_mux = alc260_fujitsu_capture_sources,
3904         },
3905         [ALC260_ACER] = {
3906                 .mixers = { alc260_acer_mixer,
3907                             alc260_capture_mixer },
3908                 .init_verbs = { alc260_acer_init_verbs },
3909                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
3910                 .dac_nids = alc260_dac_nids,
3911                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
3912                 .adc_nids = alc260_dual_adc_nids,
3913                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
3914                 .channel_mode = alc260_modes,
3915                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
3916                 .input_mux = alc260_acer_capture_sources,
3917         },
3918 #ifdef CONFIG_SND_DEBUG
3919         [ALC260_TEST] = {
3920                 .mixers = { alc260_test_mixer,
3921                             alc260_capture_mixer },
3922                 .init_verbs = { alc260_test_init_verbs },
3923                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
3924                 .dac_nids = alc260_test_dac_nids,
3925                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
3926                 .adc_nids = alc260_test_adc_nids,
3927                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
3928                 .channel_mode = alc260_modes,
3929                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
3930                 .input_mux = alc260_test_capture_sources,
3931         },
3932 #endif
3933 };
3934
3935 static int patch_alc260(struct hda_codec *codec)
3936 {
3937         struct alc_spec *spec;
3938         int err, board_config;
3939
3940         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3941         if (spec == NULL)
3942                 return -ENOMEM;
3943
3944         codec->spec = spec;
3945
3946         board_config = snd_hda_check_board_config(codec, alc260_cfg_tbl);
3947         if (board_config < 0 || board_config >= ALC260_MODEL_LAST) {
3948                 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260\n");
3949                 board_config = ALC260_AUTO;
3950         }
3951
3952         if (board_config == ALC260_AUTO) {
3953                 /* automatic parse from the BIOS config */
3954                 err = alc260_parse_auto_config(codec);
3955                 if (err < 0) {
3956                         alc_free(codec);
3957                         return err;
3958                 } else if (! err) {
3959                         printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using base mode...\n");
3960                         board_config = ALC260_BASIC;
3961                 }
3962         }
3963
3964         if (board_config != ALC260_AUTO)
3965                 setup_preset(spec, &alc260_presets[board_config]);
3966
3967         spec->stream_name_analog = "ALC260 Analog";
3968         spec->stream_analog_playback = &alc260_pcm_analog_playback;
3969         spec->stream_analog_capture = &alc260_pcm_analog_capture;
3970
3971         spec->stream_name_digital = "ALC260 Digital";
3972         spec->stream_digital_playback = &alc260_pcm_digital_playback;
3973         spec->stream_digital_capture = &alc260_pcm_digital_capture;
3974
3975         codec->patch_ops = alc_patch_ops;
3976         if (board_config == ALC260_AUTO)
3977                 spec->init_hook = alc260_auto_init;
3978
3979         return 0;
3980 }
3981
3982
3983 /*
3984  * ALC882 support
3985  *
3986  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
3987  * configuration.  Each pin widget can choose any input DACs and a mixer.
3988  * Each ADC is connected from a mixer of all inputs.  This makes possible
3989  * 6-channel independent captures.
3990  *
3991  * In addition, an independent DAC for the multi-playback (not used in this
3992  * driver yet).
3993  */
3994 #define ALC882_DIGOUT_NID       0x06
3995 #define ALC882_DIGIN_NID        0x0a
3996
3997 static struct hda_channel_mode alc882_ch_modes[1] = {
3998         { 8, NULL }
3999 };
4000
4001 static hda_nid_t alc882_dac_nids[4] = {
4002         /* front, rear, clfe, rear_surr */
4003         0x02, 0x03, 0x04, 0x05
4004 };
4005
4006 /* identical with ALC880 */
4007 #define alc882_adc_nids         alc880_adc_nids
4008 #define alc882_adc_nids_alt     alc880_adc_nids_alt
4009
4010 /* input MUX */
4011 /* FIXME: should be a matrix-type input source selection */
4012
4013 static struct hda_input_mux alc882_capture_source = {
4014         .num_items = 4,
4015         .items = {
4016                 { "Mic", 0x0 },
4017                 { "Front Mic", 0x1 },
4018                 { "Line", 0x2 },
4019                 { "CD", 0x4 },
4020         },
4021 };
4022 #define alc882_mux_enum_info alc_mux_enum_info
4023 #define alc882_mux_enum_get alc_mux_enum_get
4024
4025 static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
4026 {
4027         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4028         struct alc_spec *spec = codec->spec;
4029         const struct hda_input_mux *imux = spec->input_mux;
4030         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
4031         static hda_nid_t capture_mixers[3] = { 0x24, 0x23, 0x22 };
4032         hda_nid_t nid = capture_mixers[adc_idx];
4033         unsigned int *cur_val = &spec->cur_mux[adc_idx];
4034         unsigned int i, idx;
4035
4036         idx = ucontrol->value.enumerated.item[0];
4037         if (idx >= imux->num_items)
4038                 idx = imux->num_items - 1;
4039         if (*cur_val == idx && ! codec->in_resume)
4040                 return 0;
4041         for (i = 0; i < imux->num_items; i++) {
4042                 unsigned int v = (i == idx) ? 0x7000 : 0x7080;
4043                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4044                                     v | (imux->items[i].index << 8));
4045         }
4046         *cur_val = idx;
4047         return 1;
4048 }
4049
4050 /*
4051  * 6ch mode
4052  */
4053 static struct hda_verb alc882_sixstack_ch6_init[] = {
4054         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
4055         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4056         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4057         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4058         { } /* end */
4059 };
4060
4061 /*
4062  * 8ch mode
4063  */
4064 static struct hda_verb alc882_sixstack_ch8_init[] = {
4065         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4066         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4067         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4068         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4069         { } /* end */
4070 };
4071
4072 static struct hda_channel_mode alc882_sixstack_modes[2] = {
4073         { 6, alc882_sixstack_ch6_init },
4074         { 8, alc882_sixstack_ch8_init },
4075 };
4076
4077 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
4078  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
4079  */
4080 static struct snd_kcontrol_new alc882_base_mixer[] = {
4081         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4082         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4083         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4084         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4085         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
4086         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
4087         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
4088         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
4089         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4090         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4091         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
4092         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
4093         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
4094         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
4095         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
4096         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
4097         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
4098         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
4099         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
4100         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
4101         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
4102         { } /* end */
4103 };
4104
4105 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
4106         {
4107                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4108                 .name = "Channel Mode",
4109                 .info = alc_ch_mode_info,
4110                 .get = alc_ch_mode_get,
4111                 .put = alc_ch_mode_put,
4112         },
4113         { } /* end */
4114 };
4115
4116 static struct hda_verb alc882_init_verbs[] = {
4117         /* Front mixer: unmute input/output amp left and right (volume = 0) */
4118         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4119         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4120         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4121         /* Rear mixer */
4122         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4123         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4124         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4125         /* CLFE mixer */
4126         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4127         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4128         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4129         /* Side mixer */
4130         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4131         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4132         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4133
4134         /* Front Pin: output 0 (0x0c) */
4135         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4136         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4137         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
4138         /* Rear Pin: output 1 (0x0d) */
4139         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4140         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4141         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
4142         /* CLFE Pin: output 2 (0x0e) */
4143         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4144         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4145         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
4146         /* Side Pin: output 3 (0x0f) */
4147         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4148         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4149         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
4150         /* Mic (rear) pin: input vref at 80% */
4151         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4152         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4153         /* Front Mic pin: input vref at 80% */
4154         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4155         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4156         /* Line In pin: input */
4157         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4158         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4159         /* Line-2 In: Headphone output (output 0 - 0x0c) */
4160         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4161         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4162         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
4163         /* CD pin widget for input */
4164         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4165
4166         /* FIXME: use matrix-type input source selection */
4167         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
4168         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
4169         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4170         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4171         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4172         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4173         /* Input mixer2 */
4174         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4175         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4176         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4177         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4178         /* Input mixer3 */
4179         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4180         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4181         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4182         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4183         /* ADC1: mute amp left and right */
4184         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4185         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4186         /* ADC2: mute amp left and right */
4187         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4188         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4189         /* ADC3: mute amp left and right */
4190         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4191         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4192
4193         { }
4194 };
4195
4196 /*
4197  * generic initialization of ADC, input mixers and output mixers
4198  */
4199 static struct hda_verb alc882_auto_init_verbs[] = {
4200         /*
4201          * Unmute ADC0-2 and set the default input to mic-in
4202          */
4203         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4204         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4205         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4206         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4207         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4208         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4209
4210         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
4211          * mixer widget
4212          * Note: PASD motherboards uses the Line In 2 as the input for front panel
4213          * mic (mic 2)
4214          */
4215         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
4216         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4217         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4218         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
4219         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
4220         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
4221
4222         /*
4223          * Set up output mixers (0x0c - 0x0f)
4224          */
4225         /* set vol=0 to output mixers */
4226         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4227         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4228         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4229         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4230         /* set up input amps for analog loopback */
4231         /* Amp Indices: DAC = 0, mixer = 1 */
4232         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4233         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4234         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4235         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4236         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4237         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4238         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4239         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4240         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4241         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4242
4243         /* FIXME: use matrix-type input source selection */
4244         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
4245         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
4246         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4247         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4248         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4249         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4250         /* Input mixer2 */
4251         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4252         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4253         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4254         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4255         /* Input mixer3 */
4256         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4257         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4258         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4259         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4260
4261         { }
4262 };
4263
4264 /* capture mixer elements */
4265 static struct snd_kcontrol_new alc882_capture_alt_mixer[] = {
4266         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
4267         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
4268         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
4269         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
4270         {
4271                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4272                 /* The multiple "Capture Source" controls confuse alsamixer
4273                  * So call somewhat different..
4274                  * FIXME: the controls appear in the "playback" view!
4275                  */
4276                 /* .name = "Capture Source", */
4277                 .name = "Input Source",
4278                 .count = 2,
4279                 .info = alc882_mux_enum_info,
4280                 .get = alc882_mux_enum_get,
4281                 .put = alc882_mux_enum_put,
4282         },
4283         { } /* end */
4284 };
4285
4286 static struct snd_kcontrol_new alc882_capture_mixer[] = {
4287         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
4288         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
4289         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
4290         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
4291         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
4292         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
4293         {
4294                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4295                 /* The multiple "Capture Source" controls confuse alsamixer
4296                  * So call somewhat different..
4297                  * FIXME: the controls appear in the "playback" view!
4298                  */
4299                 /* .name = "Capture Source", */
4300                 .name = "Input Source",
4301                 .count = 3,
4302                 .info = alc882_mux_enum_info,
4303                 .get = alc882_mux_enum_get,
4304                 .put = alc882_mux_enum_put,
4305         },
4306         { } /* end */
4307 };
4308
4309 /* pcm configuration: identiacal with ALC880 */
4310 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
4311 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
4312 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
4313 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
4314
4315 /*
4316  * configuration and preset
4317  */
4318 static struct hda_board_config alc882_cfg_tbl[] = {
4319         { .modelname = "3stack-dig", .config = ALC882_3ST_DIG },
4320         { .modelname = "6stack-dig", .config = ALC882_6ST_DIG },
4321         { .pci_subvendor = 0x1462, .pci_subdevice = 0x6668, .config = ALC882_6ST_DIG }, /* MSI  */
4322         { .pci_subvendor = 0x105b, .pci_subdevice = 0x6668, .config = ALC882_6ST_DIG }, /* Foxconn */
4323         { .pci_subvendor = 0x1019, .pci_subdevice = 0x6668, .config = ALC882_6ST_DIG }, /* ECS */
4324         { .modelname = "auto", .config = ALC882_AUTO },
4325         {}
4326 };
4327
4328 static struct alc_config_preset alc882_presets[] = {
4329         [ALC882_3ST_DIG] = {
4330                 .mixers = { alc882_base_mixer },
4331                 .init_verbs = { alc882_init_verbs },
4332                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
4333                 .dac_nids = alc882_dac_nids,
4334                 .dig_out_nid = ALC882_DIGOUT_NID,
4335                 .dig_in_nid = ALC882_DIGIN_NID,
4336                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
4337                 .channel_mode = alc882_ch_modes,
4338                 .input_mux = &alc882_capture_source,
4339         },
4340         [ALC882_6ST_DIG] = {
4341                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
4342                 .init_verbs = { alc882_init_verbs },
4343                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
4344                 .dac_nids = alc882_dac_nids,
4345                 .dig_out_nid = ALC882_DIGOUT_NID,
4346                 .dig_in_nid = ALC882_DIGIN_NID,
4347                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
4348                 .channel_mode = alc882_sixstack_modes,
4349                 .input_mux = &alc882_capture_source,
4350         },
4351 };
4352
4353
4354 /*
4355  * BIOS auto configuration
4356  */
4357 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
4358                                               hda_nid_t nid, int pin_type,
4359                                               int dac_idx)
4360 {
4361         /* set as output */
4362         struct alc_spec *spec = codec->spec;
4363         int idx;
4364
4365         if (spec->multiout.dac_nids[dac_idx] == 0x25)
4366                 idx = 4;
4367         else
4368                 idx = spec->multiout.dac_nids[dac_idx] - 2;
4369
4370         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
4371         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
4372         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
4373
4374 }
4375
4376 static void alc882_auto_init_multi_out(struct hda_codec *codec)
4377 {
4378         struct alc_spec *spec = codec->spec;
4379         int i;
4380
4381         for (i = 0; i <= HDA_SIDE; i++) {
4382                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4383                 if (nid)
4384                         alc882_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
4385         }
4386 }
4387
4388 static void alc882_auto_init_hp_out(struct hda_codec *codec)
4389 {
4390         struct alc_spec *spec = codec->spec;
4391         hda_nid_t pin;
4392
4393         pin = spec->autocfg.hp_pin;
4394         if (pin) /* connect to front */
4395                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); /* use dac 0 */
4396 }
4397
4398 #define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
4399 #define ALC882_PIN_CD_NID               ALC880_PIN_CD_NID
4400
4401 static void alc882_auto_init_analog_input(struct hda_codec *codec)
4402 {
4403         struct alc_spec *spec = codec->spec;
4404         int i;
4405
4406         for (i = 0; i < AUTO_PIN_LAST; i++) {
4407                 hda_nid_t nid = spec->autocfg.input_pins[i];
4408                 if (alc882_is_input_pin(nid)) {
4409                         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4410                                             i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
4411                         if (nid != ALC882_PIN_CD_NID)
4412                                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4413                                                     AMP_OUT_MUTE);
4414                 }
4415         }
4416 }
4417
4418 /* almost identical with ALC880 parser... */
4419 static int alc882_parse_auto_config(struct hda_codec *codec)
4420 {
4421         struct alc_spec *spec = codec->spec;
4422         int err = alc880_parse_auto_config(codec);
4423
4424         if (err < 0)
4425                 return err;
4426         else if (err > 0)
4427                 /* hack - override the init verbs */
4428                 spec->init_verbs[0] = alc882_auto_init_verbs;
4429         return err;
4430 }
4431
4432 /* additional initialization for auto-configuration model */
4433 static void alc882_auto_init(struct hda_codec *codec)
4434 {
4435         alc882_auto_init_multi_out(codec);
4436         alc882_auto_init_hp_out(codec);
4437         alc882_auto_init_analog_input(codec);
4438 }
4439
4440 /*
4441  *  ALC882 Headphone poll in 3.5.1a or 3.5.2
4442  */
4443
4444 static int patch_alc882(struct hda_codec *codec)
4445 {
4446         struct alc_spec *spec;
4447         int err, board_config;
4448
4449         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4450         if (spec == NULL)
4451                 return -ENOMEM;
4452
4453         codec->spec = spec;
4454
4455         board_config = snd_hda_check_board_config(codec, alc882_cfg_tbl);
4456
4457         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
4458                 printk(KERN_INFO "hda_codec: Unknown model for ALC882, trying auto-probe from BIOS...\n");
4459                 board_config = ALC882_AUTO;
4460         }
4461
4462         if (board_config == ALC882_AUTO) {
4463                 /* automatic parse from the BIOS config */
4464                 err = alc882_parse_auto_config(codec);
4465                 if (err < 0) {
4466                         alc_free(codec);
4467                         return err;
4468                 } else if (! err) {
4469                         printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using base mode...\n");
4470                         board_config = ALC882_3ST_DIG;
4471                 }
4472         }
4473
4474         if (board_config != ALC882_AUTO)
4475                 setup_preset(spec, &alc882_presets[board_config]);
4476
4477         spec->stream_name_analog = "ALC882 Analog";
4478         spec->stream_analog_playback = &alc882_pcm_analog_playback;
4479         spec->stream_analog_capture = &alc882_pcm_analog_capture;
4480
4481         spec->stream_name_digital = "ALC882 Digital";
4482         spec->stream_digital_playback = &alc882_pcm_digital_playback;
4483         spec->stream_digital_capture = &alc882_pcm_digital_capture;
4484
4485         if (! spec->adc_nids && spec->input_mux) {
4486                 /* check whether NID 0x07 is valid */
4487                 unsigned int wcap = get_wcaps(codec, 0x07);
4488                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
4489                 if (wcap != AC_WID_AUD_IN) {
4490                         spec->adc_nids = alc882_adc_nids_alt;
4491                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
4492                         spec->mixers[spec->num_mixers] = alc882_capture_alt_mixer;
4493                         spec->num_mixers++;
4494                 } else {
4495                         spec->adc_nids = alc882_adc_nids;
4496                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
4497                         spec->mixers[spec->num_mixers] = alc882_capture_mixer;
4498                         spec->num_mixers++;
4499                 }
4500         }
4501
4502         codec->patch_ops = alc_patch_ops;
4503         if (board_config == ALC882_AUTO)
4504                 spec->init_hook = alc882_auto_init;
4505
4506         return 0;
4507 }
4508
4509 /*
4510  * ALC262 support
4511  */
4512
4513 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
4514 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
4515
4516 #define alc262_dac_nids         alc260_dac_nids
4517 #define alc262_adc_nids         alc882_adc_nids
4518 #define alc262_adc_nids_alt     alc882_adc_nids_alt
4519
4520 #define alc262_modes            alc260_modes
4521 #define alc262_capture_source   alc882_capture_source
4522
4523 static struct snd_kcontrol_new alc262_base_mixer[] = {
4524         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4525         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
4526         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
4527         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
4528         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
4529         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
4530         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
4531         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
4532         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
4533         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
4534         /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
4535            HDA_CODEC_MUTE("PC Beelp Playback Switch", 0x0b, 0x05, HDA_INPUT), */
4536         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
4537         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4538         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
4539         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
4540         { } /* end */
4541 };
4542
4543 #define alc262_capture_mixer            alc882_capture_mixer
4544 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
4545
4546 /*
4547  * generic initialization of ADC, input mixers and output mixers
4548  */
4549 static struct hda_verb alc262_init_verbs[] = {
4550         /*
4551          * Unmute ADC0-2 and set the default input to mic-in
4552          */
4553         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4554         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4555         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4556         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4557         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4558         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4559
4560         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
4561          * mixer widget
4562          * Note: PASD motherboards uses the Line In 2 as the input for front panel
4563          * mic (mic 2)
4564          */
4565         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
4566         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4567         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4568         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
4569         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
4570         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
4571
4572         /*
4573          * Set up output mixers (0x0c - 0x0e)
4574          */
4575         /* set vol=0 to output mixers */
4576         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4577         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4578         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4579         /* set up input amps for analog loopback */
4580         /* Amp Indices: DAC = 0, mixer = 1 */
4581         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4582         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4583         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4584         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4585         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4586         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4587
4588         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4589         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4590         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4591         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4592         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4593         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4594
4595         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4596         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4597         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4598         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4599         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4600
4601         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
4602         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
4603
4604         /* FIXME: use matrix-type input source selection */
4605         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
4606         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
4607         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4608         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4609         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4610         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4611         /* Input mixer2 */
4612         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4613         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4614         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4615         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4616         /* Input mixer3 */
4617         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4618         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4619         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4620         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4621
4622         { }
4623 };
4624
4625 /*
4626  * fujitsu model
4627  *  0x14 = headphone/spdif-out, 0x15 = internal speaker
4628  */
4629
4630 #define ALC_HP_EVENT    0x37
4631
4632 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
4633         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
4634         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4635         {}
4636 };
4637
4638 static struct hda_input_mux alc262_fujitsu_capture_source = {
4639         .num_items = 2,
4640         .items = {
4641                 { "Mic", 0x0 },
4642                 { "CD", 0x4 },
4643         },
4644 };
4645
4646 /* mute/unmute internal speaker according to the hp jack and mute state */
4647 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
4648 {
4649         struct alc_spec *spec = codec->spec;
4650         unsigned int mute;
4651
4652         if (force || ! spec->sense_updated) {
4653                 unsigned int present;
4654                 /* need to execute and sync at first */
4655                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
4656                 present = snd_hda_codec_read(codec, 0x14, 0,
4657                                          AC_VERB_GET_PIN_SENSE, 0);
4658                 spec->jack_present = (present & 0x80000000) != 0;
4659                 spec->sense_updated = 1;
4660         }
4661         if (spec->jack_present) {
4662                 /* mute internal speaker */
4663                 snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
4664                                          0x80, 0x80);
4665                 snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
4666                                          0x80, 0x80);
4667         } else {
4668                 /* unmute internal speaker if necessary */
4669                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
4670                 snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
4671                                          0x80, mute & 0x80);
4672                 mute = snd_hda_codec_amp_read(codec, 0x14, 1, HDA_OUTPUT, 0);
4673                 snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
4674                                          0x80, mute & 0x80);
4675         }
4676 }
4677
4678 /* unsolicited event for HP jack sensing */
4679 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
4680                                        unsigned int res)
4681 {
4682         if ((res >> 26) != ALC_HP_EVENT)
4683                 return;
4684         alc262_fujitsu_automute(codec, 1);
4685 }
4686
4687 /* bind volumes of both NID 0x0c and 0x0d */
4688 static int alc262_fujitsu_master_vol_put(struct snd_kcontrol *kcontrol,
4689                                          struct snd_ctl_elem_value *ucontrol)
4690 {
4691         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4692         long *valp = ucontrol->value.integer.value;
4693         int change;
4694
4695         change = snd_hda_codec_amp_update(codec, 0x0c, 0, HDA_OUTPUT, 0,
4696                                           0x7f, valp[0] & 0x7f);
4697         change |= snd_hda_codec_amp_update(codec, 0x0c, 1, HDA_OUTPUT, 0,
4698                                            0x7f, valp[1] & 0x7f);
4699         snd_hda_codec_amp_update(codec, 0x0d, 0, HDA_OUTPUT, 0,
4700                                  0x7f, valp[0] & 0x7f);
4701         snd_hda_codec_amp_update(codec, 0x0d, 1, HDA_OUTPUT, 0,
4702                                  0x7f, valp[1] & 0x7f);
4703         return change;
4704 }
4705
4706 /* bind hp and internal speaker mute (with plug check) */
4707 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
4708                                          struct snd_ctl_elem_value *ucontrol)
4709 {
4710         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4711         long *valp = ucontrol->value.integer.value;
4712         int change;
4713
4714         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
4715                                           0x80, valp[0] ? 0 : 0x80);
4716         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
4717                                            0x80, valp[1] ? 0 : 0x80);
4718         if (change || codec->in_resume)
4719                 alc262_fujitsu_automute(codec, codec->in_resume);
4720         return change;
4721 }
4722
4723 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
4724         {
4725                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4726                 .name = "Master Playback Volume",
4727                 .info = snd_hda_mixer_amp_volume_info,
4728                 .get = snd_hda_mixer_amp_volume_get,
4729                 .put = alc262_fujitsu_master_vol_put,
4730                 .private_value = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
4731         },
4732         {
4733                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4734                 .name = "Master Playback Switch",
4735                 .info = snd_hda_mixer_amp_switch_info,
4736                 .get = snd_hda_mixer_amp_switch_get,
4737                 .put = alc262_fujitsu_master_sw_put,
4738                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
4739         },
4740         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
4741         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
4742         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
4743         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
4744         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
4745         { } /* end */
4746 };
4747
4748 /* add playback controls from the parsed DAC table */
4749 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
4750 {
4751         hda_nid_t nid;
4752         int err;
4753
4754         spec->multiout.num_dacs = 1;    /* only use one dac */
4755         spec->multiout.dac_nids = spec->private_dac_nids;
4756         spec->multiout.dac_nids[0] = 2;
4757
4758         nid = cfg->line_out_pins[0];
4759         if (nid) {
4760                 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Front Playback Volume",
4761                                        HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT))) < 0)
4762                         return err;
4763                 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Front Playback Switch",
4764                                        HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
4765                         return err;
4766         }
4767
4768         nid = cfg->speaker_pins[0];
4769         if (nid) {
4770                 if (nid == 0x16) {
4771                         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Speaker Playback Volume",
4772                                                HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT))) < 0)
4773                                 return err;
4774                         if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Speaker Playback Switch",
4775                                                HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
4776                                 return err;
4777                 } else {
4778                         if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Speaker Playback Switch",
4779                                                HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
4780                                 return err;
4781                 }
4782         }
4783         nid = cfg->hp_pin;
4784         if (nid) {
4785                 /* spec->multiout.hp_nid = 2; */
4786                 if (nid == 0x16) {
4787                         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Headphone Playback Volume",
4788                                                HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT))) < 0)
4789                                 return err;
4790                         if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
4791                                                HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
4792                                 return err;
4793                 } else {
4794                         if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
4795                                                HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
4796                                 return err;
4797                 }
4798         }
4799         return 0;
4800 }
4801
4802 /* identical with ALC880 */
4803 #define alc262_auto_create_analog_input_ctls alc880_auto_create_analog_input_ctls
4804
4805 /*
4806  * generic initialization of ADC, input mixers and output mixers
4807  */
4808 static struct hda_verb alc262_volume_init_verbs[] = {
4809         /*
4810          * Unmute ADC0-2 and set the default input to mic-in
4811          */
4812         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4813         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4814         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4815         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4816         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4817         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4818
4819         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
4820          * mixer widget
4821          * Note: PASD motherboards uses the Line In 2 as the input for front panel
4822          * mic (mic 2)
4823          */
4824         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
4825         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4826         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4827         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
4828         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
4829         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
4830
4831         /*
4832          * Set up output mixers (0x0c - 0x0f)
4833          */
4834         /* set vol=0 to output mixers */
4835         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4836         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4837         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4838
4839         /* set up input amps for analog loopback */
4840         /* Amp Indices: DAC = 0, mixer = 1 */
4841         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4842         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4843         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4844         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4845         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4846         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4847
4848         /* FIXME: use matrix-type input source selection */
4849         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
4850         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
4851         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4852         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4853         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4854         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4855         /* Input mixer2 */
4856         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4857         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4858         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4859         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4860         /* Input mixer3 */
4861         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4862         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4863         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4864         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4865
4866         { }
4867 };
4868
4869 /* pcm configuration: identiacal with ALC880 */
4870 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
4871 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
4872 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
4873 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
4874
4875 /*
4876  * BIOS auto configuration
4877  */
4878 static int alc262_parse_auto_config(struct hda_codec *codec)
4879 {
4880         struct alc_spec *spec = codec->spec;
4881         int err;
4882         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
4883
4884         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4885                                                 alc262_ignore)) < 0)
4886                 return err;
4887         if (! spec->autocfg.line_outs)
4888                 return 0; /* can't find valid BIOS pin config */
4889         if ((err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
4890             (err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
4891                 return err;
4892
4893         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4894
4895         if (spec->autocfg.dig_out_pin)
4896                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
4897         if (spec->autocfg.dig_in_pin)
4898                 spec->dig_in_nid = ALC262_DIGIN_NID;
4899
4900         if (spec->kctl_alloc)
4901                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
4902
4903         spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
4904         spec->num_mux_defs = 1;
4905         spec->input_mux = &spec->private_imux;
4906
4907         return 1;
4908 }
4909
4910 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
4911 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
4912 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
4913
4914
4915 /* init callback for auto-configuration model -- overriding the default init */
4916 static void alc262_auto_init(struct hda_codec *codec)
4917 {
4918         alc262_auto_init_multi_out(codec);
4919         alc262_auto_init_hp_out(codec);
4920         alc262_auto_init_analog_input(codec);
4921 }
4922
4923 /*
4924  * configuration and preset
4925  */
4926 static struct hda_board_config alc262_cfg_tbl[] = {
4927         { .modelname = "basic", .config = ALC262_BASIC },
4928         { .modelname = "fujitsu", .config = ALC262_FUJITSU },
4929         { .pci_subvendor = 0x10cf, .pci_subdevice = 0x1397, .config = ALC262_FUJITSU },
4930         { .modelname = "auto", .config = ALC262_AUTO },
4931         {}
4932 };
4933
4934 static struct alc_config_preset alc262_presets[] = {
4935         [ALC262_BASIC] = {
4936                 .mixers = { alc262_base_mixer },
4937                 .init_verbs = { alc262_init_verbs },
4938                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
4939                 .dac_nids = alc262_dac_nids,
4940                 .hp_nid = 0x03,
4941                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
4942                 .channel_mode = alc262_modes,
4943                 .input_mux = &alc262_capture_source,
4944         },
4945         [ALC262_FUJITSU] = {
4946                 .mixers = { alc262_fujitsu_mixer },
4947                 .init_verbs = { alc262_init_verbs, alc262_fujitsu_unsol_verbs },
4948                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
4949                 .dac_nids = alc262_dac_nids,
4950                 .hp_nid = 0x03,
4951                 .dig_out_nid = ALC262_DIGOUT_NID,
4952                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
4953                 .channel_mode = alc262_modes,
4954                 .input_mux = &alc262_fujitsu_capture_source,
4955                 .unsol_event = alc262_fujitsu_unsol_event,
4956         },
4957 };
4958
4959 static int patch_alc262(struct hda_codec *codec)
4960 {
4961         struct alc_spec *spec;
4962         int board_config;
4963         int err;
4964
4965         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
4966         if (spec == NULL)
4967                 return -ENOMEM;
4968
4969         codec->spec = spec;
4970 #if 0
4971         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is under-run */
4972         {
4973         int tmp;
4974         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4975         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
4976         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4977         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
4978         }
4979 #endif
4980
4981         board_config = snd_hda_check_board_config(codec, alc262_cfg_tbl);
4982         if (board_config < 0 || board_config >= ALC262_MODEL_LAST) {
4983                 printk(KERN_INFO "hda_codec: Unknown model for ALC262, trying auto-probe from BIOS...\n");
4984                 board_config = ALC262_AUTO;
4985         }
4986
4987         if (board_config == ALC262_AUTO) {
4988                 /* automatic parse from the BIOS config */
4989                 err = alc262_parse_auto_config(codec);
4990                 if (err < 0) {
4991                         alc_free(codec);
4992                         return err;
4993                 } else if (! err) {
4994                         printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using base mode...\n");
4995                         board_config = ALC262_BASIC;
4996                 }
4997         }
4998
4999         if (board_config != ALC262_AUTO)
5000                 setup_preset(spec, &alc262_presets[board_config]);
5001
5002         spec->stream_name_analog = "ALC262 Analog";
5003         spec->stream_analog_playback = &alc262_pcm_analog_playback;
5004         spec->stream_analog_capture = &alc262_pcm_analog_capture;
5005
5006         spec->stream_name_digital = "ALC262 Digital";
5007         spec->stream_digital_playback = &alc262_pcm_digital_playback;
5008         spec->stream_digital_capture = &alc262_pcm_digital_capture;
5009
5010         if (! spec->adc_nids && spec->input_mux) {
5011                 /* check whether NID 0x07 is valid */
5012                 unsigned int wcap = get_wcaps(codec, 0x07);
5013
5014                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
5015                 if (wcap != AC_WID_AUD_IN) {
5016                         spec->adc_nids = alc262_adc_nids_alt;
5017                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
5018                         spec->mixers[spec->num_mixers] = alc262_capture_alt_mixer;
5019                         spec->num_mixers++;
5020                 } else {
5021                         spec->adc_nids = alc262_adc_nids;
5022                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
5023                         spec->mixers[spec->num_mixers] = alc262_capture_mixer;
5024                         spec->num_mixers++;
5025                 }
5026         }
5027
5028         codec->patch_ops = alc_patch_ops;
5029         if (board_config == ALC262_AUTO)
5030                 spec->init_hook = alc262_auto_init;
5031
5032         return 0;
5033 }
5034
5035
5036 /*
5037  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
5038  */
5039
5040 /*
5041  * set the path ways for 2 channel output
5042  * need to set the codec line out and mic 1 pin widgets to inputs
5043  */
5044 static struct hda_verb alc861_threestack_ch2_init[] = {
5045         /* set pin widget 1Ah (line in) for input */
5046         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
5047         /* set pin widget 18h (mic1/2) for input, for mic also enable the vref */
5048         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
5049
5050         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
5051         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, //mic
5052         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, //line in
5053         { } /* end */
5054 };
5055 /*
5056  * 6ch mode
5057  * need to set the codec line out and mic 1 pin widgets to outputs
5058  */
5059 static struct hda_verb alc861_threestack_ch6_init[] = {
5060         /* set pin widget 1Ah (line in) for output (Back Surround)*/
5061         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
5062         /* set pin widget 18h (mic1) for output (CLFE)*/
5063         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
5064
5065         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
5066         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
5067
5068         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
5069         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, //mic
5070         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, //line in
5071         { } /* end */
5072 };
5073
5074 static struct hda_channel_mode alc861_threestack_modes[2] = {
5075         { 2, alc861_threestack_ch2_init },
5076         { 6, alc861_threestack_ch6_init },
5077 };
5078
5079 /* patch-ALC861 */
5080
5081 static struct snd_kcontrol_new alc861_base_mixer[] = {
5082         /* output mixer control */
5083         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
5084         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
5085         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
5086         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
5087         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
5088
5089         /*Input mixer control */
5090         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
5091            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
5092         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
5093         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
5094         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
5095         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
5096         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
5097         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
5098         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
5099         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
5100
5101         /* Capture mixer control */
5102         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5103         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5104         {
5105                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5106                 .name = "Capture Source",
5107                 .count = 1,
5108                 .info = alc_mux_enum_info,
5109                 .get = alc_mux_enum_get,
5110                 .put = alc_mux_enum_put,
5111         },
5112         { } /* end */
5113 };
5114
5115 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
5116         /* output mixer control */
5117         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
5118         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
5119         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
5120         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
5121         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
5122
5123         /* Input mixer control */
5124         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
5125            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
5126         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
5127         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
5128         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
5129         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
5130         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
5131         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
5132         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
5133         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
5134
5135         /* Capture mixer control */
5136         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5137         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5138         {
5139                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5140                 .name = "Capture Source",
5141                 .count = 1,
5142                 .info = alc_mux_enum_info,
5143                 .get = alc_mux_enum_get,
5144                 .put = alc_mux_enum_put,
5145         },
5146         {
5147                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5148                 .name = "Channel Mode",
5149                 .info = alc_ch_mode_info,
5150                 .get = alc_ch_mode_get,
5151                 .put = alc_ch_mode_put,
5152                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
5153         },
5154         { } /* end */
5155 };
5156
5157 /*
5158  * generic initialization of ADC, input mixers and output mixers
5159  */
5160 static struct hda_verb alc861_base_init_verbs[] = {
5161         /*
5162          * Unmute ADC0 and set the default input to mic-in
5163          */
5164         /* port-A for surround (rear panel) */
5165         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
5166         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
5167         /* port-B for mic-in (rear panel) with vref */
5168         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
5169         /* port-C for line-in (rear panel) */
5170         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
5171         /* port-D for Front */
5172         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
5173         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
5174         /* port-E for HP out (front panel) */
5175         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
5176         /* route front PCM to HP */
5177         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x01 },
5178         /* port-F for mic-in (front panel) with vref */
5179         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
5180         /* port-G for CLFE (rear panel) */
5181         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
5182         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
5183         /* port-H for side (rear panel) */
5184         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
5185         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
5186         /* CD-in */
5187         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
5188         /* route front mic to ADC1*/
5189         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5190         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5191
5192         /* Unmute DAC0~3 & spdif out*/
5193         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5194         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5195         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5196         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5197         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5198
5199         /* Unmute Mixer 14 (mic) 1c (Line in)*/
5200         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5201         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5202         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5203         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5204
5205         /* Unmute Stereo Mixer 15 */
5206         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5207         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5208         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5209         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c          }, //Output 0~12 step
5210
5211         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5212         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5213         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5214         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5215         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5216         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5217         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5218         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5219         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
5220         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5221
5222         { }
5223 };
5224
5225 static struct hda_verb alc861_threestack_init_verbs[] = {
5226         /*
5227          * Unmute ADC0 and set the default input to mic-in
5228          */
5229         /* port-A for surround (rear panel) */
5230         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5231         /* port-B for mic-in (rear panel) with vref */
5232         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
5233         /* port-C for line-in (rear panel) */
5234         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
5235         /* port-D for Front */
5236         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
5237         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
5238         /* port-E for HP out (front panel) */
5239         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
5240         /* route front PCM to HP */
5241         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x01 },
5242         /* port-F for mic-in (front panel) with vref */
5243         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
5244         /* port-G for CLFE (rear panel) */
5245         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5246         /* port-H for side (rear panel) */
5247         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5248         /* CD-in */
5249         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
5250         /* route front mic to ADC1*/
5251         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5252         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5253         /* Unmute DAC0~3 & spdif out*/
5254         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5255         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5256         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5257         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5258         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5259
5260         /* Unmute Mixer 14 (mic) 1c (Line in)*/
5261         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5262         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5263         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5264         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5265
5266         /* Unmute Stereo Mixer 15 */
5267         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5268         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5269         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5270         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c          }, //Output 0~12 step
5271
5272         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5273         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5274         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5275         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5276         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5277         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5278         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5279         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5280         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
5281         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5282         { }
5283 };
5284 /*
5285  * generic initialization of ADC, input mixers and output mixers
5286  */
5287 static struct hda_verb alc861_auto_init_verbs[] = {
5288         /*
5289          * Unmute ADC0 and set the default input to mic-in
5290          */
5291 //      {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5292         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5293
5294         /* Unmute DAC0~3 & spdif out*/
5295         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5296         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5297         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5298         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5299         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5300
5301         /* Unmute Mixer 14 (mic) 1c (Line in)*/
5302         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5303         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5304         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5305         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5306
5307         /* Unmute Stereo Mixer 15 */
5308         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5309         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5310         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5311         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
5312
5313         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5314         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5315         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5316         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5317         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5318         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5319         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5320         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5321
5322         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5323         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5324         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5325         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
5326         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5327         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5328         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5329         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
5330
5331         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  // set Mic 1
5332
5333         { }
5334 };
5335
5336 /* pcm configuration: identiacal with ALC880 */
5337 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
5338 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
5339 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
5340 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
5341
5342
5343 #define ALC861_DIGOUT_NID       0x07
5344
5345 static struct hda_channel_mode alc861_8ch_modes[1] = {
5346         { 8, NULL }
5347 };
5348
5349 static hda_nid_t alc861_dac_nids[4] = {
5350         /* front, surround, clfe, side */
5351         0x03, 0x06, 0x05, 0x04
5352 };
5353
5354 static hda_nid_t alc861_adc_nids[1] = {
5355         /* ADC0-2 */
5356         0x08,
5357 };
5358
5359 static struct hda_input_mux alc861_capture_source = {
5360         .num_items = 5,
5361         .items = {
5362                 { "Mic", 0x0 },
5363                 { "Front Mic", 0x3 },
5364                 { "Line", 0x1 },
5365                 { "CD", 0x4 },
5366                 { "Mixer", 0x5 },
5367         },
5368 };
5369
5370 /* fill in the dac_nids table from the parsed pin configuration */
5371 static int alc861_auto_fill_dac_nids(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
5372 {
5373         int i;
5374         hda_nid_t nid;
5375
5376         spec->multiout.dac_nids = spec->private_dac_nids;
5377         for (i = 0; i < cfg->line_outs; i++) {
5378                 nid = cfg->line_out_pins[i];
5379                 if (nid) {
5380                         if (i >= ARRAY_SIZE(alc861_dac_nids))
5381                                 continue;
5382                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
5383                 }
5384         }
5385         spec->multiout.num_dacs = cfg->line_outs;
5386         return 0;
5387 }
5388
5389 /* add playback controls from the parsed DAC table */
5390 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
5391                                              const struct auto_pin_cfg *cfg)
5392 {
5393         char name[32];
5394         static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
5395         hda_nid_t nid;
5396         int i, idx, err;
5397
5398         for (i = 0; i < cfg->line_outs; i++) {
5399                 nid = spec->multiout.dac_nids[i];
5400                 if (! nid)
5401                         continue;
5402                 if (nid == 0x05) {
5403                         /* Center/LFE */
5404                         if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "Center Playback Switch",
5405                                                HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0)
5406                                 return err;
5407                         if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "LFE Playback Switch",
5408                                                HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
5409                                 return err;
5410                 } else {
5411                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1; idx++)
5412                                 if (nid == alc861_dac_nids[idx])
5413                                         break;
5414                         sprintf(name, "%s Playback Switch", chname[idx]);
5415                         if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
5416                                                HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
5417                                 return err;
5418                 }
5419         }
5420         return 0;
5421 }
5422
5423 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
5424 {
5425         int err;
5426         hda_nid_t nid;
5427
5428         if (! pin)
5429                 return 0;
5430
5431         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
5432                 nid = 0x03;
5433                 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
5434                                        HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
5435                         return err;
5436                 spec->multiout.hp_nid = nid;
5437         }
5438         return 0;
5439 }
5440
5441 /* create playback/capture controls for input pins */
5442 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
5443 {
5444         struct hda_input_mux *imux = &spec->private_imux;
5445         int i, err, idx, idx1;
5446
5447         for (i = 0; i < AUTO_PIN_LAST; i++) {
5448                 switch(cfg->input_pins[i]) {
5449                 case 0x0c:
5450                         idx1 = 1;
5451                         idx = 2;        // Line In
5452                         break;
5453                 case 0x0f:
5454                         idx1 = 2;
5455                         idx = 2;        // Line In
5456                         break;
5457                 case 0x0d:
5458                         idx1 = 0;
5459                         idx = 1;        // Mic In
5460                         break;
5461                 case 0x10:
5462                         idx1 = 3;
5463                         idx = 1;        // Mic In
5464                         break;
5465                 case 0x11:
5466                         idx1 = 4;
5467                         idx = 0;        // CD
5468                         break;
5469                 default:
5470                         continue;
5471                 }
5472
5473                 err = new_analog_input(spec, cfg->input_pins[i],
5474                                        auto_pin_cfg_labels[i], idx, 0x15);
5475                 if (err < 0)
5476                         return err;
5477
5478                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
5479                 imux->items[imux->num_items].index = idx1;
5480                 imux->num_items++;
5481         }
5482         return 0;
5483 }
5484
5485 static struct snd_kcontrol_new alc861_capture_mixer[] = {
5486         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5487         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5488
5489         {
5490                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5491                 /* The multiple "Capture Source" controls confuse alsamixer
5492                  * So call somewhat different..
5493                  *FIXME: the controls appear in the "playback" view!
5494                  */
5495                 /* .name = "Capture Source", */
5496                 .name = "Input Source",
5497                 .count = 1,
5498                 .info = alc_mux_enum_info,
5499                 .get = alc_mux_enum_get,
5500                 .put = alc_mux_enum_put,
5501         },
5502         { } /* end */
5503 };
5504
5505 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec, hda_nid_t nid,
5506                                               int pin_type, int dac_idx)
5507 {
5508         /* set as output */
5509
5510         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
5511         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5512
5513 }
5514
5515 static void alc861_auto_init_multi_out(struct hda_codec *codec)
5516 {
5517         struct alc_spec *spec = codec->spec;
5518         int i;
5519
5520         for (i = 0; i < spec->autocfg.line_outs; i++) {
5521                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
5522                 if (nid)
5523                         alc861_auto_set_output_and_unmute(codec, nid, PIN_OUT, spec->multiout.dac_nids[i]);
5524         }
5525 }
5526
5527 static void alc861_auto_init_hp_out(struct hda_codec *codec)
5528 {
5529         struct alc_spec *spec = codec->spec;
5530         hda_nid_t pin;
5531
5532         pin = spec->autocfg.hp_pin;
5533         if (pin) /* connect to front */
5534                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP, spec->multiout.dac_nids[0]);
5535 }
5536
5537 static void alc861_auto_init_analog_input(struct hda_codec *codec)
5538 {
5539         struct alc_spec *spec = codec->spec;
5540         int i;
5541
5542         for (i = 0; i < AUTO_PIN_LAST; i++) {
5543                 hda_nid_t nid = spec->autocfg.input_pins[i];
5544                 if ((nid>=0x0c) && (nid <=0x11)) {
5545                         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5546                                             i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
5547                 }
5548         }
5549 }
5550
5551 /* parse the BIOS configuration and set up the alc_spec */
5552 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
5553 static int alc861_parse_auto_config(struct hda_codec *codec)
5554 {
5555         struct alc_spec *spec = codec->spec;
5556         int err;
5557         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
5558
5559         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5560                                                 alc861_ignore)) < 0)
5561                 return err;
5562         if (! spec->autocfg.line_outs)
5563                 return 0; /* can't find valid BIOS pin config */
5564
5565         if ((err = alc861_auto_fill_dac_nids(spec, &spec->autocfg)) < 0 ||
5566             (err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
5567             (err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pin)) < 0 ||
5568             (err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
5569                 return err;
5570
5571         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5572
5573         if (spec->autocfg.dig_out_pin)
5574                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
5575
5576         if (spec->kctl_alloc)
5577                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
5578
5579         spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
5580
5581         spec->num_mux_defs = 1;
5582         spec->input_mux = &spec->private_imux;
5583
5584         spec->adc_nids = alc861_adc_nids;
5585         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
5586         spec->mixers[spec->num_mixers] = alc861_capture_mixer;
5587         spec->num_mixers++;
5588
5589         return 1;
5590 }
5591
5592 /* additional initialization for auto-configuration model */
5593 static void alc861_auto_init(struct hda_codec *codec)
5594 {
5595         alc861_auto_init_multi_out(codec);
5596         alc861_auto_init_hp_out(codec);
5597         alc861_auto_init_analog_input(codec);
5598 }
5599
5600
5601 /*
5602  * configuration and preset
5603  */
5604 static struct hda_board_config alc861_cfg_tbl[] = {
5605         { .modelname = "3stack", .config = ALC861_3ST },
5606         { .pci_subvendor = 0x8086, .pci_subdevice = 0xd600, .config = ALC861_3ST },
5607         { .modelname = "3stack-dig", .config = ALC861_3ST_DIG },
5608         { .modelname = "6stack-dig", .config = ALC861_6ST_DIG },
5609         { .modelname = "auto", .config = ALC861_AUTO },
5610         {}
5611 };
5612
5613 static struct alc_config_preset alc861_presets[] = {
5614         [ALC861_3ST] = {
5615                 .mixers = { alc861_3ST_mixer },
5616                 .init_verbs = { alc861_threestack_init_verbs },
5617                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
5618                 .dac_nids = alc861_dac_nids,
5619                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
5620                 .channel_mode = alc861_threestack_modes,
5621                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
5622                 .adc_nids = alc861_adc_nids,
5623                 .input_mux = &alc861_capture_source,
5624         },
5625         [ALC861_3ST_DIG] = {
5626                 .mixers = { alc861_base_mixer },
5627                 .init_verbs = { alc861_threestack_init_verbs },
5628                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
5629                 .dac_nids = alc861_dac_nids,
5630                 .dig_out_nid = ALC861_DIGOUT_NID,
5631                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
5632                 .channel_mode = alc861_threestack_modes,
5633                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
5634                 .adc_nids = alc861_adc_nids,
5635                 .input_mux = &alc861_capture_source,
5636         },
5637         [ALC861_6ST_DIG] = {
5638                 .mixers = { alc861_base_mixer },
5639                 .init_verbs = { alc861_base_init_verbs },
5640                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
5641                 .dac_nids = alc861_dac_nids,
5642                 .dig_out_nid = ALC861_DIGOUT_NID,
5643                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
5644                 .channel_mode = alc861_8ch_modes,
5645                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
5646                 .adc_nids = alc861_adc_nids,
5647                 .input_mux = &alc861_capture_source,
5648         },
5649 };
5650
5651
5652 static int patch_alc861(struct hda_codec *codec)
5653 {
5654         struct alc_spec *spec;
5655         int board_config;
5656         int err;
5657
5658         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
5659         if (spec == NULL)
5660                 return -ENOMEM;
5661
5662         codec->spec = spec;
5663
5664         board_config = snd_hda_check_board_config(codec, alc861_cfg_tbl);
5665         if (board_config < 0 || board_config >= ALC861_MODEL_LAST) {
5666                 printk(KERN_INFO "hda_codec: Unknown model for ALC861, trying auto-probe from BIOS...\n");
5667                 board_config = ALC861_AUTO;
5668         }
5669
5670         if (board_config == ALC861_AUTO) {
5671                 /* automatic parse from the BIOS config */
5672                 err = alc861_parse_auto_config(codec);
5673                 if (err < 0) {
5674                         alc_free(codec);
5675                         return err;
5676                 } else if (! err) {
5677                         printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using base mode...\n");
5678                    board_config = ALC861_3ST_DIG;
5679                 }
5680         }
5681
5682         if (board_config != ALC861_AUTO)
5683                 setup_preset(spec, &alc861_presets[board_config]);
5684
5685         spec->stream_name_analog = "ALC861 Analog";
5686         spec->stream_analog_playback = &alc861_pcm_analog_playback;
5687         spec->stream_analog_capture = &alc861_pcm_analog_capture;
5688
5689         spec->stream_name_digital = "ALC861 Digital";
5690         spec->stream_digital_playback = &alc861_pcm_digital_playback;
5691         spec->stream_digital_capture = &alc861_pcm_digital_capture;
5692
5693         codec->patch_ops = alc_patch_ops;
5694         if (board_config == ALC861_AUTO)
5695                 spec->init_hook = alc861_auto_init;
5696
5697         return 0;
5698 }
5699
5700 /*
5701  * patch entries
5702  */
5703 struct hda_codec_preset snd_hda_preset_realtek[] = {
5704         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
5705         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
5706         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
5707         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
5708         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
5709         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
5710         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
5711         {} /* terminator */
5712 };