git.oblomov.eu Git - 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 #if 0 /* should be identical with alc260_init_verbs? */
3110 static struct hda_verb alc260_hp_init_verbs[] = {
3111         /* Headphone and output */
3112         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
3113         /* mono output */
3114         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3115         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3116         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3117         /* Mic2 (front panel) pin widget for input and vref at 80% */
3118         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3119         /* Line In pin widget for input */
3120         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3121         /* Line-2 pin widget for output */
3122         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3123         /* CD pin widget for input */
3124         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3125         /* unmute amp left and right */
3126         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
3127         /* set connection select to line in (default select for this ADC) */
3128         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
3129         /* unmute Line-Out mixer amp left and right (volume = 0) */
3130         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3131         /* mute pin widget amp left and right (no gain on this amp) */
3132         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3133         /* unmute HP mixer amp left and right (volume = 0) */
3134         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3135         /* mute pin widget amp left and right (no gain on this amp) */
3136         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3137         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
3138         /* unmute CD */
3139         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
3140         /* unmute Line In */
3141         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
3142         /* unmute Mic */
3143         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3144         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
3145         /* Unmute Front out path */
3146         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3147         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3148         /* Unmute Headphone out path */
3149         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3150         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3151         /* Unmute Mono out path */
3152         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3153         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3154         { }
3155 };
3156 #endif
3157
3158 static struct hda_verb alc260_hp_3013_init_verbs[] = {
3159         /* Line out and output */
3160         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3161         /* mono output */
3162         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3163         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3164         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3165         /* Mic2 (front panel) pin widget for input and vref at 80% */
3166         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3167         /* Line In pin widget for input */
3168         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3169         /* Headphone pin widget for output */
3170         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
3171         /* CD pin widget for input */
3172         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3173         /* unmute amp left and right */
3174         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
3175         /* set connection select to line in (default select for this ADC) */
3176         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
3177         /* unmute Line-Out mixer amp left and right (volume = 0) */
3178         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3179         /* mute pin widget amp left and right (no gain on this amp) */
3180         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3181         /* unmute HP mixer amp left and right (volume = 0) */
3182         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3183         /* mute pin widget amp left and right (no gain on this amp) */
3184         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3185         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
3186         /* unmute CD */
3187         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
3188         /* unmute Line In */
3189         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
3190         /* unmute Mic */
3191         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3192         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
3193         /* Unmute Front out path */
3194         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3195         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3196         /* Unmute Headphone out path */
3197         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3198         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3199         /* Unmute Mono out path */
3200         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3201         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3202         { }
3203 };
3204
3205 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
3206  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
3207  * audio = 0x16, internal speaker = 0x10.
3208  */
3209 static struct hda_verb alc260_fujitsu_init_verbs[] = {
3210         /* Disable all GPIOs */
3211         {0x01, AC_VERB_SET_GPIO_MASK, 0},
3212         /* Internal speaker is connected to headphone pin */
3213         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3214         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
3215         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3216         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
3217         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3218         /* Ensure all other unused pins are disabled and muted. */
3219         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3220         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3221         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3222         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3223         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3224         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3225         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3226         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3227
3228         /* Disable digital (SPDIF) pins */
3229         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
3230         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
3231
3232         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
3233          * when acting as an output.
3234          */
3235         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
3236
3237         /* Start with output sum widgets muted and their output gains at min */
3238         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3239         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3240         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3241         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3242         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3243         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3244         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3245         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3246         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3247
3248         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
3249         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3250         /* Unmute Line1 pin widget output buffer since it starts as an output.
3251          * If the pin mode is changed by the user the pin mode control will
3252          * take care of enabling the pin's input/output buffers as needed.
3253          * Therefore there's no need to enable the input buffer at this
3254          * stage.
3255          */
3256         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3257         /* Unmute input buffer of pin widget used for Line-in (no equiv
3258          * mixer ctrl)
3259          */
3260         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3261
3262         /* Mute capture amp left and right */
3263         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3264         /* Set ADC connection select to match default mixer setting - line
3265          * in (on mic1 pin)
3266          */
3267         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
3268
3269         /* Do the same for the second ADC: mute capture input amp and
3270          * set ADC connection to line in (on mic1 pin)
3271          */
3272         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3273         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
3274
3275         /* Mute all inputs to mixer widget (even unconnected ones) */
3276         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
3277         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
3278         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
3279         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
3280         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
3281         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
3282         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
3283         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
3284
3285         { }
3286 };
3287
3288 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
3289  * similar laptops (adapted from Fujitsu init verbs).
3290  */
3291 static struct hda_verb alc260_acer_init_verbs[] = {
3292         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
3293          * the headphone jack.  Turn this on and rely on the standard mute
3294          * methods whenever the user wants to turn these outputs off.
3295          */
3296         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
3297         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
3298         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
3299         /* Internal speaker/Headphone jack is connected to Line-out pin */
3300         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3301         /* Internal microphone/Mic jack is connected to Mic1 pin */
3302         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3303         /* Line In jack is connected to Line1 pin */
3304         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3305         /* Ensure all other unused pins are disabled and muted. */
3306         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3307         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3308         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3309         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3310         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3311         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3312         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3313         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3314         /* Disable digital (SPDIF) pins */
3315         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
3316         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
3317
3318         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
3319          * bus when acting as outputs.
3320          */
3321         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
3322         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
3323
3324         /* Start with output sum widgets muted and their output gains at min */
3325         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3326         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3327         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3328         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3329         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3330         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3331         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3332         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3333         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3334
3335         /* Unmute Line-out pin widget amp left and right (no equiv mixer ctrl) */
3336         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3337         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
3338          * inputs. If the pin mode is changed by the user the pin mode control
3339          * will take care of enabling the pin's input/output buffers as needed.
3340          * Therefore there's no need to enable the input buffer at this
3341          * stage.
3342          */
3343         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3344         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3345
3346         /* Mute capture amp left and right */
3347         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3348         /* Set ADC connection select to match default mixer setting - mic
3349          * (on mic1 pin)
3350          */
3351         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
3352
3353         /* Do similar with the second ADC: mute capture input amp and
3354          * set ADC connection to mic to match ALSA's default state.
3355          */
3356         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3357         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
3358
3359         /* Mute all inputs to mixer widget (even unconnected ones) */
3360         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
3361         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
3362         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
3363         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
3364         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
3365         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
3366         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
3367         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
3368
3369         { }
3370 };
3371
3372 /* Test configuration for debugging, modelled after the ALC880 test
3373  * configuration.
3374  */
3375 #ifdef CONFIG_SND_DEBUG
3376 static hda_nid_t alc260_test_dac_nids[1] = {
3377         0x02,
3378 };
3379 static hda_nid_t alc260_test_adc_nids[2] = {
3380         0x04, 0x05,
3381 };
3382 /* For testing the ALC260, each input MUX needs its own definition since
3383  * the signal assignments are different.  This assumes that the first ADC
3384  * is NID 0x04.
3385  */
3386 static struct hda_input_mux alc260_test_capture_sources[2] = {
3387         {
3388                 .num_items = 7,
3389                 .items = {
3390                         { "MIC1 pin", 0x0 },
3391                         { "MIC2 pin", 0x1 },
3392                         { "LINE1 pin", 0x2 },
3393                         { "LINE2 pin", 0x3 },
3394                         { "CD pin", 0x4 },
3395                         { "LINE-OUT pin", 0x5 },
3396                         { "HP-OUT pin", 0x6 },
3397                 },
3398         },
3399         {
3400                 .num_items = 8,
3401                 .items = {
3402                         { "MIC1 pin", 0x0 },
3403                         { "MIC2 pin", 0x1 },
3404                         { "LINE1 pin", 0x2 },
3405                         { "LINE2 pin", 0x3 },
3406                         { "CD pin", 0x4 },
3407                         { "Mixer", 0x5 },
3408                         { "LINE-OUT pin", 0x6 },
3409                         { "HP-OUT pin", 0x7 },
3410                 },
3411         },
3412 };
3413 static struct snd_kcontrol_new alc260_test_mixer[] = {
3414         /* Output driver widgets */
3415         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
3416         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
3417         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
3418         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
3419         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3420         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
3421
3422         /* Modes for retasking pin widgets
3423          * Note: the ALC260 doesn't seem to act on requests to enable mic
3424          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
3425          * mention this restriction.  At this stage it's not clear whether
3426          * this behaviour is intentional or is a hardware bug in chip
3427          * revisions available at least up until early 2006.  Therefore for
3428          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
3429          * choices, but if it turns out that the lack of mic bias for these
3430          * NIDs is intentional we could change their modes from
3431          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
3432          */
3433         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
3434         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
3435         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
3436         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
3437         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
3438         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
3439
3440         /* Loopback mixer controls */
3441         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
3442         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
3443         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
3444         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
3445         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
3446         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
3447         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
3448         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
3449         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
3450         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
3451         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
3452         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
3453         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
3454         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
3455         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
3456         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
3457
3458         /* Controls for GPIO pins, assuming they are configured as outputs */
3459         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
3460         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
3461         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
3462         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
3463
3464         /* Switches to allow the digital IO pins to be enabled.  The datasheet
3465          * is ambigious as to which NID is which; testing on laptops which
3466          * make this output available should provide clarification.
3467          */
3468         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
3469         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
3470
3471         { } /* end */
3472 };
3473 static struct hda_verb alc260_test_init_verbs[] = {
3474         /* Enable all GPIOs as outputs with an initial value of 0 */
3475         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
3476         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
3477         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
3478
3479         /* Enable retasking pins as output, initially without power amp */
3480         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3481         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3482         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3483         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3484         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3485         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3486
3487         /* Disable digital (SPDIF) pins initially, but users can enable
3488          * them via a mixer switch.  In the case of SPDIF-out, this initverb
3489          * payload also sets the generation to 0, output to be in "consumer"
3490          * PCM format, copyright asserted, no pre-emphasis and no validity
3491          * control.
3492          */
3493         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
3494         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
3495
3496         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
3497          * OUT1 sum bus when acting as an output.
3498          */
3499         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
3500         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
3501         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
3502         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
3503
3504         /* Start with output sum widgets muted and their output gains at min */
3505         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3506         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3507         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3508         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3509         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3510         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3511         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3512         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3513         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3514
3515         /* Unmute retasking pin widget output buffers since the default
3516          * state appears to be output.  As the pin mode is changed by the
3517          * user the pin mode control will take care of enabling the pin's
3518          * input/output buffers as needed.
3519          */
3520         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3521         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3522         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3523         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3524         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3525         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3526         /* Also unmute the mono-out pin widget */
3527         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3528
3529         /* Mute capture amp left and right */
3530         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3531         /* Set ADC connection select to match default mixer setting (mic1
3532          * pin)
3533          */
3534         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
3535
3536         /* Do the same for the second ADC: mute capture input amp and
3537          * set ADC connection to mic1 pin
3538          */
3539         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3540         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
3541
3542         /* Mute all inputs to mixer widget (even unconnected ones) */
3543         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
3544         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
3545         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
3546         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
3547         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
3548         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
3549         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
3550         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
3551
3552         { }
3553 };
3554 #endif
3555
3556 static struct hda_pcm_stream alc260_pcm_analog_playback = {
3557         .substreams = 1,
3558         .channels_min = 2,
3559         .channels_max = 2,
3560 };
3561
3562 static struct hda_pcm_stream alc260_pcm_analog_capture = {
3563         .substreams = 1,
3564         .channels_min = 2,
3565         .channels_max = 2,
3566 };
3567
3568 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
3569 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
3570
3571 /*
3572  * for BIOS auto-configuration
3573  */
3574
3575 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
3576                                         const char *pfx)
3577 {
3578         hda_nid_t nid_vol;
3579         unsigned long vol_val, sw_val;
3580         char name[32];
3581         int err;
3582
3583         if (nid >= 0x0f && nid < 0x11) {
3584                 nid_vol = nid - 0x7;
3585                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
3586                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3587         } else if (nid == 0x11) {
3588                 nid_vol = nid - 0x7;
3589                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
3590                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
3591         } else if (nid >= 0x12 && nid <= 0x15) {
3592                 nid_vol = 0x08;
3593                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
3594                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3595         } else
3596                 return 0; /* N/A */
3597
3598         snprintf(name, sizeof(name), "%s Playback Volume", pfx);
3599         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val)) < 0)
3600                 return err;
3601         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
3602         if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val)) < 0)
3603                 return err;
3604         return 1;
3605 }
3606
3607 /* add playback controls from the parsed DAC table */
3608 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
3609                                              const struct auto_pin_cfg *cfg)
3610 {
3611         hda_nid_t nid;
3612         int err;
3613
3614         spec->multiout.num_dacs = 1;
3615         spec->multiout.dac_nids = spec->private_dac_nids;
3616         spec->multiout.dac_nids[0] = 0x02;
3617
3618         nid = cfg->line_out_pins[0];
3619         if (nid) {
3620                 err = alc260_add_playback_controls(spec, nid, "Front");
3621                 if (err < 0)
3622                         return err;
3623         }
3624
3625         nid = cfg->speaker_pins[0];
3626         if (nid) {
3627                 err = alc260_add_playback_controls(spec, nid, "Speaker");
3628                 if (err < 0)
3629                         return err;
3630         }
3631
3632         nid = cfg->hp_pin;
3633         if (nid) {
3634                 err = alc260_add_playback_controls(spec, nid, "Headphone");
3635                 if (err < 0)
3636                         return err;
3637         }
3638         return 0;
3639 }
3640
3641 /* create playback/capture controls for input pins */
3642 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
3643                                                 const struct auto_pin_cfg *cfg)
3644 {
3645         struct hda_input_mux *imux = &spec->private_imux;
3646         int i, err, idx;
3647
3648         for (i = 0; i < AUTO_PIN_LAST; i++) {
3649                 if (cfg->input_pins[i] >= 0x12) {
3650                         idx = cfg->input_pins[i] - 0x12;
3651                         err = new_analog_input(spec, cfg->input_pins[i],
3652                                                auto_pin_cfg_labels[i], idx, 0x07);
3653                         if (err < 0)
3654                                 return err;
3655                         imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3656                         imux->items[imux->num_items].index = idx;
3657                         imux->num_items++;
3658                 }
3659                 if ((cfg->input_pins[i] >= 0x0f) && (cfg->input_pins[i] <= 0x10)){
3660                         idx = cfg->input_pins[i] - 0x09;
3661                         err = new_analog_input(spec, cfg->input_pins[i],
3662                                                auto_pin_cfg_labels[i], idx, 0x07);
3663                         if (err < 0)
3664                                 return err;
3665                         imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3666                         imux->items[imux->num_items].index = idx;
3667                         imux->num_items++;
3668                 }
3669         }
3670         return 0;
3671 }
3672
3673 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
3674                                               hda_nid_t nid, int pin_type,
3675                                               int sel_idx)
3676 {
3677         /* set as output */
3678         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
3679         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
3680         /* need the manual connection? */
3681         if (nid >= 0x12) {
3682                 int idx = nid - 0x12;
3683                 snd_hda_codec_write(codec, idx + 0x0b, 0,
3684                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
3685
3686         }
3687 }
3688
3689 static void alc260_auto_init_multi_out(struct hda_codec *codec)
3690 {
3691         struct alc_spec *spec = codec->spec;
3692         hda_nid_t nid;
3693
3694         nid = spec->autocfg.line_out_pins[0];
3695         if (nid)
3696                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
3697
3698         nid = spec->autocfg.speaker_pins[0];
3699         if (nid)
3700                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
3701
3702         nid = spec->autocfg.hp_pin;
3703         if (nid)
3704                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
3705 }
3706
3707 #define ALC260_PIN_CD_NID               0x16
3708 static void alc260_auto_init_analog_input(struct hda_codec *codec)
3709 {
3710         struct alc_spec *spec = codec->spec;
3711         int i;
3712
3713         for (i = 0; i < AUTO_PIN_LAST; i++) {
3714                 hda_nid_t nid = spec->autocfg.input_pins[i];
3715                 if (nid >= 0x12) {
3716                         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3717                                             i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
3718                         if (nid != ALC260_PIN_CD_NID)
3719                                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3720                                                     AMP_OUT_MUTE);
3721                 }
3722         }
3723 }
3724
3725 /*
3726  * generic initialization of ADC, input mixers and output mixers
3727  */
3728 static struct hda_verb alc260_volume_init_verbs[] = {
3729         /*
3730          * Unmute ADC0-1 and set the default input to mic-in
3731          */
3732         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
3733         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3734         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
3735         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3736
3737         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3738          * mixer widget
3739          * Note: PASD motherboards uses the Line In 2 as the input for front panel
3740          * mic (mic 2)
3741          */
3742         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
3743         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3744         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3745         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
3746         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
3747         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
3748
3749         /*
3750          * Set up output mixers (0x08 - 0x0a)
3751          */
3752         /* set vol=0 to output mixers */
3753         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3754         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3755         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3756         /* set up input amps for analog loopback */
3757         /* Amp Indices: DAC = 0, mixer = 1 */
3758         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3759         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3760         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3761         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3762         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3763         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3764
3765         { }
3766 };
3767
3768 static int alc260_parse_auto_config(struct hda_codec *codec)
3769 {
3770         struct alc_spec *spec = codec->spec;
3771         unsigned int wcap;
3772         int err;
3773         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
3774
3775         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
3776                                                 alc260_ignore)) < 0)
3777                 return err;
3778         if ((err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0)
3779                 return err;
3780         if (! spec->kctl_alloc)
3781                 return 0; /* can't find valid BIOS pin config */
3782         if ((err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
3783                 return err;
3784
3785         spec->multiout.max_channels = 2;
3786
3787         if (spec->autocfg.dig_out_pin)
3788                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
3789         if (spec->kctl_alloc)
3790                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3791
3792         spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs;
3793
3794         spec->num_mux_defs = 1;
3795         spec->input_mux = &spec->private_imux;
3796
3797         /* check whether NID 0x04 is valid */
3798         wcap = get_wcaps(codec, 0x04);
3799         wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
3800         if (wcap != AC_WID_AUD_IN) {
3801                 spec->adc_nids = alc260_adc_nids_alt;
3802                 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
3803                 spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer;
3804         } else {
3805                 spec->adc_nids = alc260_adc_nids;
3806                 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
3807                 spec->mixers[spec->num_mixers] = alc260_capture_mixer;
3808         }
3809         spec->num_mixers++;
3810
3811         return 1;
3812 }
3813
3814 /* additional initialization for auto-configuration model */
3815 static void alc260_auto_init(struct hda_codec *codec)
3816 {
3817         alc260_auto_init_multi_out(codec);
3818         alc260_auto_init_analog_input(codec);
3819 }
3820
3821 /*
3822  * ALC260 configurations
3823  */
3824 static struct hda_board_config alc260_cfg_tbl[] = {
3825         { .modelname = "basic", .config = ALC260_BASIC },
3826         { .pci_subvendor = 0x104d, .pci_subdevice = 0x81bb,
3827           .config = ALC260_BASIC }, /* Sony VAIO */
3828         { .pci_subvendor = 0x104d, .pci_subdevice = 0x81cc,
3829           .config = ALC260_BASIC }, /* Sony VAIO VGN-S3HP */
3830         { .pci_subvendor = 0x104d, .pci_subdevice = 0x81cd,
3831           .config = ALC260_BASIC }, /* Sony VAIO */
3832         { .pci_subvendor = 0x152d, .pci_subdevice = 0x0729,
3833           .config = ALC260_BASIC }, /* CTL Travel Master U553W */
3834         { .modelname = "hp", .config = ALC260_HP },
3835         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3010, .config = ALC260_HP },
3836         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3011, .config = ALC260_HP },
3837         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3012, .config = ALC260_HP },
3838         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3013, .config = ALC260_HP_3013 },
3839         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3014, .config = ALC260_HP },
3840         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3015, .config = ALC260_HP },
3841         { .pci_subvendor = 0x103c, .pci_subdevice = 0x3016, .config = ALC260_HP },
3842         { .modelname = "fujitsu", .config = ALC260_FUJITSU_S702X },
3843         { .pci_subvendor = 0x10cf, .pci_subdevice = 0x1326, .config = ALC260_FUJITSU_S702X },
3844         { .modelname = "acer", .config = ALC260_ACER },
3845         { .pci_subvendor = 0x1025, .pci_subdevice = 0x008f, .config = ALC260_ACER },
3846 #ifdef CONFIG_SND_DEBUG
3847         { .modelname = "test", .config = ALC260_TEST },
3848 #endif
3849         { .modelname = "auto", .config = ALC260_AUTO },
3850         {}
3851 };
3852
3853 static struct alc_config_preset alc260_presets[] = {
3854         [ALC260_BASIC] = {
3855                 .mixers = { alc260_base_output_mixer,
3856                             alc260_input_mixer,
3857                             alc260_pc_beep_mixer,
3858                             alc260_capture_mixer },
3859                 .init_verbs = { alc260_init_verbs },
3860                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
3861                 .dac_nids = alc260_dac_nids,
3862                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
3863                 .adc_nids = alc260_adc_nids,
3864                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
3865                 .channel_mode = alc260_modes,
3866                 .input_mux = &alc260_capture_source,
3867         },
3868         [ALC260_HP] = {
3869                 .mixers = { alc260_base_output_mixer,
3870                             alc260_input_mixer,
3871                             alc260_capture_alt_mixer },
3872                 .init_verbs = { alc260_init_verbs },
3873                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
3874                 .dac_nids = alc260_dac_nids,
3875                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
3876                 .adc_nids = alc260_hp_adc_nids,
3877                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
3878                 .channel_mode = alc260_modes,
3879                 .input_mux = &alc260_capture_source,
3880         },
3881         [ALC260_HP_3013] = {
3882                 .mixers = { alc260_hp_3013_mixer,
3883                             alc260_input_mixer,
3884                             alc260_capture_alt_mixer },
3885                 .init_verbs = { alc260_hp_3013_init_verbs },
3886                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
3887                 .dac_nids = alc260_dac_nids,
3888                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
3889                 .adc_nids = alc260_hp_adc_nids,
3890                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
3891                 .channel_mode = alc260_modes,
3892                 .input_mux = &alc260_capture_source,
3893         },
3894         [ALC260_FUJITSU_S702X] = {
3895                 .mixers = { alc260_fujitsu_mixer,
3896                             alc260_capture_mixer },
3897                 .init_verbs = { alc260_fujitsu_init_verbs },
3898                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
3899                 .dac_nids = alc260_dac_nids,
3900                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
3901                 .adc_nids = alc260_dual_adc_nids,
3902                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
3903                 .channel_mode = alc260_modes,
3904                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
3905                 .input_mux = alc260_fujitsu_capture_sources,
3906         },
3907         [ALC260_ACER] = {
3908                 .mixers = { alc260_acer_mixer,
3909                             alc260_capture_mixer },
3910                 .init_verbs = { alc260_acer_init_verbs },
3911                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
3912                 .dac_nids = alc260_dac_nids,
3913                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
3914                 .adc_nids = alc260_dual_adc_nids,
3915                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
3916                 .channel_mode = alc260_modes,
3917                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
3918                 .input_mux = alc260_acer_capture_sources,
3919         },
3920 #ifdef CONFIG_SND_DEBUG
3921         [ALC260_TEST] = {
3922                 .mixers = { alc260_test_mixer,
3923                             alc260_capture_mixer },
3924                 .init_verbs = { alc260_test_init_verbs },
3925                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
3926                 .dac_nids = alc260_test_dac_nids,
3927                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
3928                 .adc_nids = alc260_test_adc_nids,
3929                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
3930                 .channel_mode = alc260_modes,
3931                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
3932                 .input_mux = alc260_test_capture_sources,
3933         },
3934 #endif
3935 };
3936
3937 static int patch_alc260(struct hda_codec *codec)
3938 {
3939         struct alc_spec *spec;
3940         int err, board_config;
3941
3942         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3943         if (spec == NULL)
3944                 return -ENOMEM;
3945
3946         codec->spec = spec;
3947
3948         board_config = snd_hda_check_board_config(codec, alc260_cfg_tbl);
3949         if (board_config < 0 || board_config >= ALC260_MODEL_LAST) {
3950                 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260\n");
3951                 board_config = ALC260_AUTO;
3952         }
3953
3954         if (board_config == ALC260_AUTO) {
3955                 /* automatic parse from the BIOS config */
3956                 err = alc260_parse_auto_config(codec);
3957                 if (err < 0) {
3958                         alc_free(codec);
3959                         return err;
3960                 } else if (! err) {
3961                         printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using base mode...\n");
3962                         board_config = ALC260_BASIC;
3963                 }
3964         }
3965
3966         if (board_config != ALC260_AUTO)
3967                 setup_preset(spec, &alc260_presets[board_config]);
3968
3969         spec->stream_name_analog = "ALC260 Analog";
3970         spec->stream_analog_playback = &alc260_pcm_analog_playback;
3971         spec->stream_analog_capture = &alc260_pcm_analog_capture;
3972
3973         spec->stream_name_digital = "ALC260 Digital";
3974         spec->stream_digital_playback = &alc260_pcm_digital_playback;
3975         spec->stream_digital_capture = &alc260_pcm_digital_capture;
3976
3977         codec->patch_ops = alc_patch_ops;
3978         if (board_config == ALC260_AUTO)
3979                 spec->init_hook = alc260_auto_init;
3980
3981         return 0;
3982 }
3983
3984
3985 /*
3986  * ALC882 support
3987  *
3988  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
3989  * configuration.  Each pin widget can choose any input DACs and a mixer.
3990  * Each ADC is connected from a mixer of all inputs.  This makes possible
3991  * 6-channel independent captures.
3992  *
3993  * In addition, an independent DAC for the multi-playback (not used in this
3994  * driver yet).
3995  */
3996 #define ALC882_DIGOUT_NID       0x06
3997 #define ALC882_DIGIN_NID        0x0a
3998
3999 static struct hda_channel_mode alc882_ch_modes[1] = {
4000         { 8, NULL }
4001 };
4002
4003 static hda_nid_t alc882_dac_nids[4] = {
4004         /* front, rear, clfe, rear_surr */
4005         0x02, 0x03, 0x04, 0x05
4006 };
4007
4008 /* identical with ALC880 */
4009 #define alc882_adc_nids         alc880_adc_nids
4010 #define alc882_adc_nids_alt     alc880_adc_nids_alt
4011
4012 /* input MUX */
4013 /* FIXME: should be a matrix-type input source selection */
4014
4015 static struct hda_input_mux alc882_capture_source = {
4016         .num_items = 4,
4017         .items = {
4018                 { "Mic", 0x0 },
4019                 { "Front Mic", 0x1 },
4020                 { "Line", 0x2 },
4021                 { "CD", 0x4 },
4022         },
4023 };
4024 #define alc882_mux_enum_info alc_mux_enum_info
4025 #define alc882_mux_enum_get alc_mux_enum_get
4026
4027 static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
4028 {
4029         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4030         struct alc_spec *spec = codec->spec;
4031         const struct hda_input_mux *imux = spec->input_mux;
4032         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
4033         static hda_nid_t capture_mixers[3] = { 0x24, 0x23, 0x22 };
4034         hda_nid_t nid = capture_mixers[adc_idx];
4035         unsigned int *cur_val = &spec->cur_mux[adc_idx];
4036         unsigned int i, idx;
4037
4038         idx = ucontrol->value.enumerated.item[0];
4039         if (idx >= imux->num_items)
4040                 idx = imux->num_items - 1;
4041         if (*cur_val == idx && ! codec->in_resume)
4042                 return 0;
4043         for (i = 0; i < imux->num_items; i++) {
4044                 unsigned int v = (i == idx) ? 0x7000 : 0x7080;
4045                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4046                                     v | (imux->items[i].index << 8));
4047         }
4048         *cur_val = idx;
4049         return 1;
4050 }
4051
4052 /*
4053  * 6ch mode
4054  */
4055 static struct hda_verb alc882_sixstack_ch6_init[] = {
4056         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
4057         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4058         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4059         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4060         { } /* end */
4061 };
4062
4063 /*
4064  * 8ch mode
4065  */
4066 static struct hda_verb alc882_sixstack_ch8_init[] = {
4067         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4068         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4069         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4070         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
4071         { } /* end */
4072 };
4073
4074 static struct hda_channel_mode alc882_sixstack_modes[2] = {
4075         { 6, alc882_sixstack_ch6_init },
4076         { 8, alc882_sixstack_ch8_init },
4077 };
4078
4079 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
4080  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
4081  */
4082 static struct snd_kcontrol_new alc882_base_mixer[] = {
4083         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4084         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4085         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4086         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4087         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
4088         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
4089         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
4090         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
4091         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4092         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4093         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
4094         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
4095         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
4096         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
4097         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
4098         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
4099         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
4100         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
4101         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
4102         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
4103         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
4104         { } /* end */
4105 };
4106
4107 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
4108         {
4109                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4110                 .name = "Channel Mode",
4111                 .info = alc_ch_mode_info,
4112                 .get = alc_ch_mode_get,
4113                 .put = alc_ch_mode_put,
4114         },
4115         { } /* end */
4116 };
4117
4118 static struct hda_verb alc882_init_verbs[] = {
4119         /* Front mixer: unmute input/output amp left and right (volume = 0) */
4120         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4121         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4122         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4123         /* Rear mixer */
4124         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4125         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4126         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4127         /* CLFE mixer */
4128         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4129         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4130         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4131         /* Side mixer */
4132         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4133         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4134         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4135
4136         /* Front Pin: output 0 (0x0c) */
4137         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4138         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4139         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
4140         /* Rear Pin: output 1 (0x0d) */
4141         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4142         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4143         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
4144         /* CLFE Pin: output 2 (0x0e) */
4145         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4146         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4147         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
4148         /* Side Pin: output 3 (0x0f) */
4149         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4150         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4151         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
4152         /* Mic (rear) pin: input vref at 80% */
4153         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4154         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4155         /* Front Mic pin: input vref at 80% */
4156         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4157         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4158         /* Line In pin: input */
4159         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4160         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4161         /* Line-2 In: Headphone output (output 0 - 0x0c) */
4162         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4163         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4164         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
4165         /* CD pin widget for input */
4166         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4167
4168         /* FIXME: use matrix-type input source selection */
4169         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
4170         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
4171         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4172         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4173         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4174         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4175         /* Input mixer2 */
4176         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4177         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4178         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4179         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4180         /* Input mixer3 */
4181         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4182         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4183         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4184         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4185         /* ADC1: mute amp left and right */
4186         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4187         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4188         /* ADC2: mute amp left and right */
4189         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4190         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4191         /* ADC3: mute amp left and right */
4192         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4193         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4194
4195         { }
4196 };
4197
4198 /*
4199  * generic initialization of ADC, input mixers and output mixers
4200  */
4201 static struct hda_verb alc882_auto_init_verbs[] = {
4202         /*
4203          * Unmute ADC0-2 and set the default input to mic-in
4204          */
4205         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4206         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4207         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4208         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4209         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4210         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4211
4212         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
4213          * mixer widget
4214          * Note: PASD motherboards uses the Line In 2 as the input for front panel
4215          * mic (mic 2)
4216          */
4217         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
4218         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4219         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4220         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
4221         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
4222         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
4223
4224         /*
4225          * Set up output mixers (0x0c - 0x0f)
4226          */
4227         /* set vol=0 to output mixers */
4228         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4229         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4230         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4231         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4232         /* set up input amps for analog loopback */
4233         /* Amp Indices: DAC = 0, mixer = 1 */
4234         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4235         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4236         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4237         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4238         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4239         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4240         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4241         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4242         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4243         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4244
4245         /* FIXME: use matrix-type input source selection */
4246         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
4247         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
4248         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4249         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4250         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4251         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4252         /* Input mixer2 */
4253         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4254         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4255         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4256         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4257         /* Input mixer3 */
4258         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4259         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4260         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4261         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4262
4263         { }
4264 };
4265
4266 /* capture mixer elements */
4267 static struct snd_kcontrol_new alc882_capture_alt_mixer[] = {
4268         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
4269         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
4270         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
4271         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
4272         {
4273                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4274                 /* The multiple "Capture Source" controls confuse alsamixer
4275                  * So call somewhat different..
4276                  * FIXME: the controls appear in the "playback" view!
4277                  */
4278                 /* .name = "Capture Source", */
4279                 .name = "Input Source",
4280                 .count = 2,
4281                 .info = alc882_mux_enum_info,
4282                 .get = alc882_mux_enum_get,
4283                 .put = alc882_mux_enum_put,
4284         },
4285         { } /* end */
4286 };
4287
4288 static struct snd_kcontrol_new alc882_capture_mixer[] = {
4289         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
4290         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
4291         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
4292         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
4293         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
4294         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
4295         {
4296                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4297                 /* The multiple "Capture Source" controls confuse alsamixer
4298                  * So call somewhat different..
4299                  * FIXME: the controls appear in the "playback" view!
4300                  */
4301                 /* .name = "Capture Source", */
4302                 .name = "Input Source",
4303                 .count = 3,
4304                 .info = alc882_mux_enum_info,
4305                 .get = alc882_mux_enum_get,
4306                 .put = alc882_mux_enum_put,
4307         },
4308         { } /* end */
4309 };
4310
4311 /* pcm configuration: identiacal with ALC880 */
4312 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
4313 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
4314 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
4315 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
4316
4317 /*
4318  * configuration and preset
4319  */
4320 static struct hda_board_config alc882_cfg_tbl[] = {
4321         { .modelname = "3stack-dig", .config = ALC882_3ST_DIG },
4322         { .modelname = "6stack-dig", .config = ALC882_6ST_DIG },
4323         { .pci_subvendor = 0x1462, .pci_subdevice = 0x6668, .config = ALC882_6ST_DIG }, /* MSI  */
4324         { .pci_subvendor = 0x105b, .pci_subdevice = 0x6668, .config = ALC882_6ST_DIG }, /* Foxconn */
4325         { .pci_subvendor = 0x1019, .pci_subdevice = 0x6668, .config = ALC882_6ST_DIG }, /* ECS */
4326         { .modelname = "auto", .config = ALC882_AUTO },
4327         {}
4328 };
4329
4330 static struct alc_config_preset alc882_presets[] = {
4331         [ALC882_3ST_DIG] = {
4332                 .mixers = { alc882_base_mixer },
4333                 .init_verbs = { alc882_init_verbs },
4334                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
4335                 .dac_nids = alc882_dac_nids,
4336                 .dig_out_nid = ALC882_DIGOUT_NID,
4337                 .dig_in_nid = ALC882_DIGIN_NID,
4338                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
4339                 .channel_mode = alc882_ch_modes,
4340                 .input_mux = &alc882_capture_source,
4341         },
4342         [ALC882_6ST_DIG] = {
4343                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
4344                 .init_verbs = { alc882_init_verbs },
4345                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
4346                 .dac_nids = alc882_dac_nids,
4347                 .dig_out_nid = ALC882_DIGOUT_NID,
4348                 .dig_in_nid = ALC882_DIGIN_NID,
4349                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
4350                 .channel_mode = alc882_sixstack_modes,
4351                 .input_mux = &alc882_capture_source,
4352         },
4353 };
4354
4355
4356 /*
4357  * BIOS auto configuration
4358  */
4359 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
4360                                               hda_nid_t nid, int pin_type,
4361                                               int dac_idx)
4362 {
4363         /* set as output */
4364         struct alc_spec *spec = codec->spec;
4365         int idx;
4366
4367         if (spec->multiout.dac_nids[dac_idx] == 0x25)
4368                 idx = 4;
4369         else
4370                 idx = spec->multiout.dac_nids[dac_idx] - 2;
4371
4372         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
4373         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
4374         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
4375
4376 }
4377
4378 static void alc882_auto_init_multi_out(struct hda_codec *codec)
4379 {
4380         struct alc_spec *spec = codec->spec;
4381         int i;
4382
4383         for (i = 0; i <= HDA_SIDE; i++) {
4384                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4385                 if (nid)
4386                         alc882_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
4387         }
4388 }
4389
4390 static void alc882_auto_init_hp_out(struct hda_codec *codec)
4391 {
4392         struct alc_spec *spec = codec->spec;
4393         hda_nid_t pin;
4394
4395         pin = spec->autocfg.hp_pin;
4396         if (pin) /* connect to front */
4397                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); /* use dac 0 */
4398 }
4399
4400 #define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
4401 #define ALC882_PIN_CD_NID               ALC880_PIN_CD_NID
4402
4403 static void alc882_auto_init_analog_input(struct hda_codec *codec)
4404 {
4405         struct alc_spec *spec = codec->spec;
4406         int i;
4407
4408         for (i = 0; i < AUTO_PIN_LAST; i++) {
4409                 hda_nid_t nid = spec->autocfg.input_pins[i];
4410                 if (alc882_is_input_pin(nid)) {
4411                         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4412                                             i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
4413                         if (nid != ALC882_PIN_CD_NID)
4414                                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4415                                                     AMP_OUT_MUTE);
4416                 }
4417         }
4418 }
4419
4420 /* almost identical with ALC880 parser... */
4421 static int alc882_parse_auto_config(struct hda_codec *codec)
4422 {
4423         struct alc_spec *spec = codec->spec;
4424         int err = alc880_parse_auto_config(codec);
4425
4426         if (err < 0)
4427                 return err;
4428         else if (err > 0)
4429                 /* hack - override the init verbs */
4430                 spec->init_verbs[0] = alc882_auto_init_verbs;
4431         return err;
4432 }
4433
4434 /* additional initialization for auto-configuration model */
4435 static void alc882_auto_init(struct hda_codec *codec)
4436 {
4437         alc882_auto_init_multi_out(codec);
4438         alc882_auto_init_hp_out(codec);
4439         alc882_auto_init_analog_input(codec);
4440 }
4441
4442 /*
4443  *  ALC882 Headphone poll in 3.5.1a or 3.5.2
4444  */
4445
4446 static int patch_alc882(struct hda_codec *codec)
4447 {
4448         struct alc_spec *spec;
4449         int err, board_config;
4450
4451         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4452         if (spec == NULL)
4453                 return -ENOMEM;
4454
4455         codec->spec = spec;
4456
4457         board_config = snd_hda_check_board_config(codec, alc882_cfg_tbl);
4458
4459         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
4460                 printk(KERN_INFO "hda_codec: Unknown model for ALC882, trying auto-probe from BIOS...\n");
4461                 board_config = ALC882_AUTO;
4462         }
4463
4464         if (board_config == ALC882_AUTO) {
4465                 /* automatic parse from the BIOS config */
4466                 err = alc882_parse_auto_config(codec);
4467                 if (err < 0) {
4468                         alc_free(codec);
4469                         return err;
4470                 } else if (! err) {
4471                         printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using base mode...\n");
4472                         board_config = ALC882_3ST_DIG;
4473                 }
4474         }
4475
4476         if (board_config != ALC882_AUTO)
4477                 setup_preset(spec, &alc882_presets[board_config]);
4478
4479         spec->stream_name_analog = "ALC882 Analog";
4480         spec->stream_analog_playback = &alc882_pcm_analog_playback;
4481         spec->stream_analog_capture = &alc882_pcm_analog_capture;
4482
4483         spec->stream_name_digital = "ALC882 Digital";
4484         spec->stream_digital_playback = &alc882_pcm_digital_playback;
4485         spec->stream_digital_capture = &alc882_pcm_digital_capture;
4486
4487         if (! spec->adc_nids && spec->input_mux) {
4488                 /* check whether NID 0x07 is valid */
4489                 unsigned int wcap = get_wcaps(codec, 0x07);
4490                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
4491                 if (wcap != AC_WID_AUD_IN) {
4492                         spec->adc_nids = alc882_adc_nids_alt;
4493                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
4494                         spec->mixers[spec->num_mixers] = alc882_capture_alt_mixer;
4495                         spec->num_mixers++;
4496                 } else {
4497                         spec->adc_nids = alc882_adc_nids;
4498                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
4499                         spec->mixers[spec->num_mixers] = alc882_capture_mixer;
4500                         spec->num_mixers++;
4501                 }
4502         }
4503
4504         codec->patch_ops = alc_patch_ops;
4505         if (board_config == ALC882_AUTO)
4506                 spec->init_hook = alc882_auto_init;
4507
4508         return 0;
4509 }
4510
4511 /*
4512  * ALC262 support
4513  */
4514
4515 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
4516 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
4517
4518 #define alc262_dac_nids         alc260_dac_nids
4519 #define alc262_adc_nids         alc882_adc_nids
4520 #define alc262_adc_nids_alt     alc882_adc_nids_alt
4521
4522 #define alc262_modes            alc260_modes
4523 #define alc262_capture_source   alc882_capture_source
4524
4525 static struct snd_kcontrol_new alc262_base_mixer[] = {
4526         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4527         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
4528         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
4529         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
4530         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
4531         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
4532         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
4533         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
4534         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
4535         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
4536         /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
4537            HDA_CODEC_MUTE("PC Beelp Playback Switch", 0x0b, 0x05, HDA_INPUT), */
4538         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
4539         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4540         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
4541         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
4542         { } /* end */
4543 };
4544
4545 #define alc262_capture_mixer            alc882_capture_mixer
4546 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
4547
4548 /*
4549  * generic initialization of ADC, input mixers and output mixers
4550  */
4551 static struct hda_verb alc262_init_verbs[] = {
4552         /*
4553          * Unmute ADC0-2 and set the default input to mic-in
4554          */
4555         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4556         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4557         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4558         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4559         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4560         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4561
4562         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
4563          * mixer widget
4564          * Note: PASD motherboards uses the Line In 2 as the input for front panel
4565          * mic (mic 2)
4566          */
4567         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
4568         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4569         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4570         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
4571         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
4572         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
4573
4574         /*
4575          * Set up output mixers (0x0c - 0x0e)
4576          */
4577         /* set vol=0 to output mixers */
4578         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4579         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4580         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4581         /* set up input amps for analog loopback */
4582         /* Amp Indices: DAC = 0, mixer = 1 */
4583         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4584         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4585         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4586         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4587         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4588         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4589
4590         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4591         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4592         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4593         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4594         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4595         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4596
4597         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4598         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4599         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4600         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4601         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4602
4603         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
4604         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
4605
4606         /* FIXME: use matrix-type input source selection */
4607         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
4608         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
4609         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4610         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4611         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4612         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4613         /* Input mixer2 */
4614         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4615         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4616         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4617         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4618         /* Input mixer3 */
4619         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4620         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4621         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4622         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4623
4624         { }
4625 };
4626
4627 /*
4628  * fujitsu model
4629  *  0x14 = headphone/spdif-out, 0x15 = internal speaker
4630  */
4631
4632 #define ALC_HP_EVENT    0x37
4633
4634 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
4635         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
4636         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4637         {}
4638 };
4639
4640 static struct hda_input_mux alc262_fujitsu_capture_source = {
4641         .num_items = 2,
4642         .items = {
4643                 { "Mic", 0x0 },
4644                 { "CD", 0x4 },
4645         },
4646 };
4647
4648 /* mute/unmute internal speaker according to the hp jack and mute state */
4649 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
4650 {
4651         struct alc_spec *spec = codec->spec;
4652         unsigned int mute;
4653
4654         if (force || ! spec->sense_updated) {
4655                 unsigned int present;
4656                 /* need to execute and sync at first */
4657                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
4658                 present = snd_hda_codec_read(codec, 0x14, 0,
4659                                          AC_VERB_GET_PIN_SENSE, 0);
4660                 spec->jack_present = (present & 0x80000000) != 0;
4661                 spec->sense_updated = 1;
4662         }
4663         if (spec->jack_present) {
4664                 /* mute internal speaker */
4665                 snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
4666                                          0x80, 0x80);
4667                 snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
4668                                          0x80, 0x80);
4669         } else {
4670                 /* unmute internal speaker if necessary */
4671                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
4672                 snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
4673                                          0x80, mute & 0x80);
4674                 mute = snd_hda_codec_amp_read(codec, 0x14, 1, HDA_OUTPUT, 0);
4675                 snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
4676                                          0x80, mute & 0x80);
4677         }
4678 }
4679
4680 /* unsolicited event for HP jack sensing */
4681 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
4682                                        unsigned int res)
4683 {
4684         if ((res >> 26) != ALC_HP_EVENT)
4685                 return;
4686         alc262_fujitsu_automute(codec, 1);
4687 }
4688
4689 /* bind volumes of both NID 0x0c and 0x0d */
4690 static int alc262_fujitsu_master_vol_put(struct snd_kcontrol *kcontrol,
4691                                          struct snd_ctl_elem_value *ucontrol)
4692 {
4693         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4694         long *valp = ucontrol->value.integer.value;
4695         int change;
4696
4697         change = snd_hda_codec_amp_update(codec, 0x0c, 0, HDA_OUTPUT, 0,
4698                                           0x7f, valp[0] & 0x7f);
4699         change |= snd_hda_codec_amp_update(codec, 0x0c, 1, HDA_OUTPUT, 0,
4700                                            0x7f, valp[1] & 0x7f);
4701         snd_hda_codec_amp_update(codec, 0x0d, 0, HDA_OUTPUT, 0,
4702                                  0x7f, valp[0] & 0x7f);
4703         snd_hda_codec_amp_update(codec, 0x0d, 1, HDA_OUTPUT, 0,
4704                                  0x7f, valp[1] & 0x7f);
4705         return change;
4706 }
4707
4708 /* bind hp and internal speaker mute (with plug check) */
4709 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
4710                                          struct snd_ctl_elem_value *ucontrol)
4711 {
4712         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4713         long *valp = ucontrol->value.integer.value;
4714         int change;
4715
4716         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
4717                                           0x80, valp[0] ? 0 : 0x80);
4718         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
4719                                            0x80, valp[1] ? 0 : 0x80);
4720         if (change || codec->in_resume)
4721                 alc262_fujitsu_automute(codec, codec->in_resume);
4722         return change;
4723 }
4724
4725 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
4726         {
4727                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4728                 .name = "Master Playback Volume",
4729                 .info = snd_hda_mixer_amp_volume_info,
4730                 .get = snd_hda_mixer_amp_volume_get,
4731                 .put = alc262_fujitsu_master_vol_put,
4732                 .private_value = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
4733         },
4734         {
4735                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4736                 .name = "Master Playback Switch",
4737                 .info = snd_hda_mixer_amp_switch_info,
4738                 .get = snd_hda_mixer_amp_switch_get,
4739                 .put = alc262_fujitsu_master_sw_put,
4740                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
4741         },
4742         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
4743         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
4744         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
4745         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
4746         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
4747         { } /* end */
4748 };
4749
4750 /* add playback controls from the parsed DAC table */
4751 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
4752 {
4753         hda_nid_t nid;
4754         int err;
4755
4756         spec->multiout.num_dacs = 1;    /* only use one dac */
4757         spec->multiout.dac_nids = spec->private_dac_nids;
4758         spec->multiout.dac_nids[0] = 2;
4759
4760         nid = cfg->line_out_pins[0];
4761         if (nid) {
4762                 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Front Playback Volume",
4763                                        HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT))) < 0)
4764                         return err;
4765                 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Front Playback Switch",
4766                                        HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
4767                         return err;
4768         }
4769
4770         nid = cfg->speaker_pins[0];
4771         if (nid) {
4772                 if (nid == 0x16) {
4773                         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Speaker Playback Volume",
4774                                                HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT))) < 0)
4775                                 return err;
4776                         if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Speaker Playback Switch",
4777                                                HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
4778                                 return err;
4779                 } else {
4780                         if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Speaker Playback Switch",
4781                                                HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
4782                                 return err;
4783                 }
4784         }
4785         nid = cfg->hp_pin;
4786         if (nid) {
4787                 /* spec->multiout.hp_nid = 2; */
4788                 if (nid == 0x16) {
4789                         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Headphone Playback Volume",
4790                                                HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT))) < 0)
4791                                 return err;
4792                         if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
4793                                                HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
4794                                 return err;
4795                 } else {
4796                         if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
4797                                                HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
4798                                 return err;
4799                 }
4800         }
4801         return 0;
4802 }
4803
4804 /* identical with ALC880 */
4805 #define alc262_auto_create_analog_input_ctls alc880_auto_create_analog_input_ctls
4806
4807 /*
4808  * generic initialization of ADC, input mixers and output mixers
4809  */
4810 static struct hda_verb alc262_volume_init_verbs[] = {
4811         /*
4812          * Unmute ADC0-2 and set the default input to mic-in
4813          */
4814         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4815         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4816         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4817         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4818         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4819         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4820
4821         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
4822          * mixer widget
4823          * Note: PASD motherboards uses the Line In 2 as the input for front panel
4824          * mic (mic 2)
4825          */
4826         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
4827         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4828         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4829         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
4830         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
4831         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
4832
4833         /*
4834          * Set up output mixers (0x0c - 0x0f)
4835          */
4836         /* set vol=0 to output mixers */
4837         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4838         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4839         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4840
4841         /* set up input amps for analog loopback */
4842         /* Amp Indices: DAC = 0, mixer = 1 */
4843         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4844         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4845         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4846         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4847         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4848         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4849
4850         /* FIXME: use matrix-type input source selection */
4851         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
4852         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
4853         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4854         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4855         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4856         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4857         /* Input mixer2 */
4858         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4859         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4860         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4861         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4862         /* Input mixer3 */
4863         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4864         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
4865         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
4866         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
4867
4868         { }
4869 };
4870
4871 /* pcm configuration: identiacal with ALC880 */
4872 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
4873 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
4874 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
4875 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
4876
4877 /*
4878  * BIOS auto configuration
4879  */
4880 static int alc262_parse_auto_config(struct hda_codec *codec)
4881 {
4882         struct alc_spec *spec = codec->spec;
4883         int err;
4884         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
4885
4886         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4887                                                 alc262_ignore)) < 0)
4888                 return err;
4889         if (! spec->autocfg.line_outs)
4890                 return 0; /* can't find valid BIOS pin config */
4891         if ((err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
4892             (err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
4893                 return err;
4894
4895         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4896
4897         if (spec->autocfg.dig_out_pin)
4898                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
4899         if (spec->autocfg.dig_in_pin)
4900                 spec->dig_in_nid = ALC262_DIGIN_NID;
4901
4902         if (spec->kctl_alloc)
4903                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
4904
4905         spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
4906         spec->num_mux_defs = 1;
4907         spec->input_mux = &spec->private_imux;
4908
4909         return 1;
4910 }
4911
4912 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
4913 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
4914 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
4915
4916
4917 /* init callback for auto-configuration model -- overriding the default init */
4918 static void alc262_auto_init(struct hda_codec *codec)
4919 {
4920         alc262_auto_init_multi_out(codec);
4921         alc262_auto_init_hp_out(codec);
4922         alc262_auto_init_analog_input(codec);
4923 }
4924
4925 /*
4926  * configuration and preset
4927  */
4928 static struct hda_board_config alc262_cfg_tbl[] = {
4929         { .modelname = "basic", .config = ALC262_BASIC },
4930         { .modelname = "fujitsu", .config = ALC262_FUJITSU },
4931         { .pci_subvendor = 0x10cf, .pci_subdevice = 0x1397, .config = ALC262_FUJITSU },
4932         { .modelname = "auto", .config = ALC262_AUTO },
4933         {}
4934 };
4935
4936 static struct alc_config_preset alc262_presets[] = {
4937         [ALC262_BASIC] = {
4938                 .mixers = { alc262_base_mixer },
4939                 .init_verbs = { alc262_init_verbs },
4940                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
4941                 .dac_nids = alc262_dac_nids,
4942                 .hp_nid = 0x03,
4943                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
4944                 .channel_mode = alc262_modes,
4945                 .input_mux = &alc262_capture_source,
4946         },
4947         [ALC262_FUJITSU] = {
4948                 .mixers = { alc262_fujitsu_mixer },
4949                 .init_verbs = { alc262_init_verbs, alc262_fujitsu_unsol_verbs },
4950                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
4951                 .dac_nids = alc262_dac_nids,
4952                 .hp_nid = 0x03,
4953                 .dig_out_nid = ALC262_DIGOUT_NID,
4954                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
4955                 .channel_mode = alc262_modes,
4956                 .input_mux = &alc262_fujitsu_capture_source,
4957                 .unsol_event = alc262_fujitsu_unsol_event,
4958         },
4959 };
4960
4961 static int patch_alc262(struct hda_codec *codec)
4962 {
4963         struct alc_spec *spec;
4964         int board_config;
4965         int err;
4966
4967         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
4968         if (spec == NULL)
4969                 return -ENOMEM;
4970
4971         codec->spec = spec;
4972 #if 0
4973         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is under-run */
4974         {
4975         int tmp;
4976         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4977         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
4978         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4979         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
4980         }
4981 #endif
4982
4983         board_config = snd_hda_check_board_config(codec, alc262_cfg_tbl);
4984         if (board_config < 0 || board_config >= ALC262_MODEL_LAST) {
4985                 printk(KERN_INFO "hda_codec: Unknown model for ALC262, trying auto-probe from BIOS...\n");
4986                 board_config = ALC262_AUTO;
4987         }
4988
4989         if (board_config == ALC262_AUTO) {
4990                 /* automatic parse from the BIOS config */
4991                 err = alc262_parse_auto_config(codec);
4992                 if (err < 0) {
4993                         alc_free(codec);
4994                         return err;
4995                 } else if (! err) {
4996                         printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using base mode...\n");
4997                         board_config = ALC262_BASIC;
4998                 }
4999         }
5000
5001         if (board_config != ALC262_AUTO)
5002                 setup_preset(spec, &alc262_presets[board_config]);
5003
5004         spec->stream_name_analog = "ALC262 Analog";
5005         spec->stream_analog_playback = &alc262_pcm_analog_playback;
5006         spec->stream_analog_capture = &alc262_pcm_analog_capture;
5007
5008         spec->stream_name_digital = "ALC262 Digital";
5009         spec->stream_digital_playback = &alc262_pcm_digital_playback;
5010         spec->stream_digital_capture = &alc262_pcm_digital_capture;
5011
5012         if (! spec->adc_nids && spec->input_mux) {
5013                 /* check whether NID 0x07 is valid */
5014                 unsigned int wcap = get_wcaps(codec, 0x07);
5015
5016                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
5017                 if (wcap != AC_WID_AUD_IN) {
5018                         spec->adc_nids = alc262_adc_nids_alt;
5019                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
5020                         spec->mixers[spec->num_mixers] = alc262_capture_alt_mixer;
5021                         spec->num_mixers++;
5022                 } else {
5023                         spec->adc_nids = alc262_adc_nids;
5024                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
5025                         spec->mixers[spec->num_mixers] = alc262_capture_mixer;
5026                         spec->num_mixers++;
5027                 }
5028         }
5029
5030         codec->patch_ops = alc_patch_ops;
5031         if (board_config == ALC262_AUTO)
5032                 spec->init_hook = alc262_auto_init;
5033
5034         return 0;
5035 }
5036
5037
5038 /*
5039  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
5040  */
5041
5042 /*
5043  * set the path ways for 2 channel output
5044  * need to set the codec line out and mic 1 pin widgets to inputs
5045  */
5046 static struct hda_verb alc861_threestack_ch2_init[] = {
5047         /* set pin widget 1Ah (line in) for input */
5048         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
5049         /* set pin widget 18h (mic1/2) for input, for mic also enable the vref */
5050         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
5051
5052         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
5053         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, //mic
5054         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, //line in
5055         { } /* end */
5056 };
5057 /*
5058  * 6ch mode
5059  * need to set the codec line out and mic 1 pin widgets to outputs
5060  */
5061 static struct hda_verb alc861_threestack_ch6_init[] = {
5062         /* set pin widget 1Ah (line in) for output (Back Surround)*/
5063         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
5064         /* set pin widget 18h (mic1) for output (CLFE)*/
5065         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
5066
5067         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
5068         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
5069
5070         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
5071         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, //mic
5072         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, //line in
5073         { } /* end */
5074 };
5075
5076 static struct hda_channel_mode alc861_threestack_modes[2] = {
5077         { 2, alc861_threestack_ch2_init },
5078         { 6, alc861_threestack_ch6_init },
5079 };
5080
5081 /* patch-ALC861 */
5082
5083 static struct snd_kcontrol_new alc861_base_mixer[] = {
5084         /* output mixer control */
5085         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
5086         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
5087         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
5088         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
5089         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
5090
5091         /*Input mixer control */
5092         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
5093            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
5094         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
5095         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
5096         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
5097         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
5098         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
5099         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
5100         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
5101         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
5102
5103         /* Capture mixer control */
5104         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5105         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5106         {
5107                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5108                 .name = "Capture Source",
5109                 .count = 1,
5110                 .info = alc_mux_enum_info,
5111                 .get = alc_mux_enum_get,
5112                 .put = alc_mux_enum_put,
5113         },
5114         { } /* end */
5115 };
5116
5117 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
5118         /* output mixer control */
5119         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
5120         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
5121         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
5122         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
5123         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
5124
5125         /* Input mixer control */
5126         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
5127            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
5128         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
5129         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
5130         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
5131         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
5132         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
5133         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
5134         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
5135         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
5136
5137         /* Capture mixer control */
5138         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5139         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5140         {
5141                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5142                 .name = "Capture Source",
5143                 .count = 1,
5144                 .info = alc_mux_enum_info,
5145                 .get = alc_mux_enum_get,
5146                 .put = alc_mux_enum_put,
5147         },
5148         {
5149                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5150                 .name = "Channel Mode",
5151                 .info = alc_ch_mode_info,
5152                 .get = alc_ch_mode_get,
5153                 .put = alc_ch_mode_put,
5154                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
5155         },
5156         { } /* end */
5157 };
5158
5159 /*
5160  * generic initialization of ADC, input mixers and output mixers
5161  */
5162 static struct hda_verb alc861_base_init_verbs[] = {
5163         /*
5164          * Unmute ADC0 and set the default input to mic-in
5165          */
5166         /* port-A for surround (rear panel) */
5167         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
5168         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
5169         /* port-B for mic-in (rear panel) with vref */
5170         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
5171         /* port-C for line-in (rear panel) */
5172         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
5173         /* port-D for Front */
5174         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
5175         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
5176         /* port-E for HP out (front panel) */
5177         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
5178         /* route front PCM to HP */
5179         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x01 },
5180         /* port-F for mic-in (front panel) with vref */
5181         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
5182         /* port-G for CLFE (rear panel) */
5183         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
5184         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
5185         /* port-H for side (rear panel) */
5186         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
5187         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
5188         /* CD-in */
5189         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
5190         /* route front mic to ADC1*/
5191         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5192         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5193
5194         /* Unmute DAC0~3 & spdif out*/
5195         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5196         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5197         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5198         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5199         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5200
5201         /* Unmute Mixer 14 (mic) 1c (Line in)*/
5202         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5203         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5204         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5205         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5206
5207         /* Unmute Stereo Mixer 15 */
5208         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5209         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5210         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5211         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c          }, //Output 0~12 step
5212
5213         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5214         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5215         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5216         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5217         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5218         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5219         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5220         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5221         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
5222         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5223
5224         { }
5225 };
5226
5227 static struct hda_verb alc861_threestack_init_verbs[] = {
5228         /*
5229          * Unmute ADC0 and set the default input to mic-in
5230          */
5231         /* port-A for surround (rear panel) */
5232         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5233         /* port-B for mic-in (rear panel) with vref */
5234         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
5235         /* port-C for line-in (rear panel) */
5236         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
5237         /* port-D for Front */
5238         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
5239         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
5240         /* port-E for HP out (front panel) */
5241         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
5242         /* route front PCM to HP */
5243         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x01 },
5244         /* port-F for mic-in (front panel) with vref */
5245         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
5246         /* port-G for CLFE (rear panel) */
5247         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5248         /* port-H for side (rear panel) */
5249         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5250         /* CD-in */
5251         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
5252         /* route front mic to ADC1*/
5253         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5254         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5255         /* Unmute DAC0~3 & spdif out*/
5256         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5257         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5258         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5259         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5260         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5261
5262         /* Unmute Mixer 14 (mic) 1c (Line in)*/
5263         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5264         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5265         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5266         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5267
5268         /* Unmute Stereo Mixer 15 */
5269         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5270         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5271         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5272         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c          }, //Output 0~12 step
5273
5274         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5275         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5276         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5277         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5278         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5279         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5280         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5281         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5282         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, // hp used DAC 3 (Front)
5283         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5284         { }
5285 };
5286 /*
5287  * generic initialization of ADC, input mixers and output mixers
5288  */
5289 static struct hda_verb alc861_auto_init_verbs[] = {
5290         /*
5291          * Unmute ADC0 and set the default input to mic-in
5292          */
5293 //      {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5294         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5295
5296         /* Unmute DAC0~3 & spdif out*/
5297         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5298         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5299         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5300         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5301         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5302
5303         /* Unmute Mixer 14 (mic) 1c (Line in)*/
5304         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5305         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5306         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5307         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5308
5309         /* Unmute Stereo Mixer 15 */
5310         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5311         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5312         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5313         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
5314
5315         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5316         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5317         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5318         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5319         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5320         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5321         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5322         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5323
5324         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5325         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5326         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5327         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
5328         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5329         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5330         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
5331         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
5332
5333         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  // set Mic 1
5334
5335         { }
5336 };
5337
5338 /* pcm configuration: identiacal with ALC880 */
5339 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
5340 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
5341 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
5342 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
5343
5344
5345 #define ALC861_DIGOUT_NID       0x07
5346
5347 static struct hda_channel_mode alc861_8ch_modes[1] = {
5348         { 8, NULL }
5349 };
5350
5351 static hda_nid_t alc861_dac_nids[4] = {
5352         /* front, surround, clfe, side */
5353         0x03, 0x06, 0x05, 0x04
5354 };
5355
5356 static hda_nid_t alc861_adc_nids[1] = {
5357         /* ADC0-2 */
5358         0x08,
5359 };
5360
5361 static struct hda_input_mux alc861_capture_source = {
5362         .num_items = 5,
5363         .items = {
5364                 { "Mic", 0x0 },
5365                 { "Front Mic", 0x3 },
5366                 { "Line", 0x1 },
5367                 { "CD", 0x4 },
5368                 { "Mixer", 0x5 },
5369         },
5370 };
5371
5372 /* fill in the dac_nids table from the parsed pin configuration */
5373 static int alc861_auto_fill_dac_nids(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
5374 {
5375         int i;
5376         hda_nid_t nid;
5377
5378         spec->multiout.dac_nids = spec->private_dac_nids;
5379         for (i = 0; i < cfg->line_outs; i++) {
5380                 nid = cfg->line_out_pins[i];
5381                 if (nid) {
5382                         if (i >= ARRAY_SIZE(alc861_dac_nids))
5383                                 continue;
5384                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
5385                 }
5386         }
5387         spec->multiout.num_dacs = cfg->line_outs;
5388         return 0;
5389 }
5390
5391 /* add playback controls from the parsed DAC table */
5392 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
5393                                              const struct auto_pin_cfg *cfg)
5394 {
5395         char name[32];
5396         static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
5397         hda_nid_t nid;
5398         int i, idx, err;
5399
5400         for (i = 0; i < cfg->line_outs; i++) {
5401                 nid = spec->multiout.dac_nids[i];
5402                 if (! nid)
5403                         continue;
5404                 if (nid == 0x05) {
5405                         /* Center/LFE */
5406                         if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "Center Playback Switch",
5407                                                HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0)
5408                                 return err;
5409                         if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "LFE Playback Switch",
5410                                                HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
5411                                 return err;
5412                 } else {
5413                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1; idx++)
5414                                 if (nid == alc861_dac_nids[idx])
5415                                         break;
5416                         sprintf(name, "%s Playback Switch", chname[idx]);
5417                         if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
5418                                                HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
5419                                 return err;
5420                 }
5421         }
5422         return 0;
5423 }
5424
5425 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
5426 {
5427         int err;
5428         hda_nid_t nid;
5429
5430         if (! pin)
5431                 return 0;
5432
5433         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
5434                 nid = 0x03;
5435                 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, "Headphone Playback Switch",
5436                                        HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
5437                         return err;
5438                 spec->multiout.hp_nid = nid;
5439         }
5440         return 0;
5441 }
5442
5443 /* create playback/capture controls for input pins */
5444 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
5445 {
5446         struct hda_input_mux *imux = &spec->private_imux;
5447         int i, err, idx, idx1;
5448
5449         for (i = 0; i < AUTO_PIN_LAST; i++) {
5450                 switch(cfg->input_pins[i]) {
5451                 case 0x0c:
5452                         idx1 = 1;
5453                         idx = 2;        // Line In
5454                         break;
5455                 case 0x0f:
5456                         idx1 = 2;
5457                         idx = 2;        // Line In
5458                         break;
5459                 case 0x0d:
5460                         idx1 = 0;
5461                         idx = 1;        // Mic In
5462                         break;
5463                 case 0x10:
5464                         idx1 = 3;
5465                         idx = 1;        // Mic In
5466                         break;
5467                 case 0x11:
5468                         idx1 = 4;
5469                         idx = 0;        // CD
5470                         break;
5471                 default:
5472                         continue;
5473                 }
5474
5475                 err = new_analog_input(spec, cfg->input_pins[i],
5476                                        auto_pin_cfg_labels[i], idx, 0x15);
5477                 if (err < 0)
5478                         return err;
5479
5480                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
5481                 imux->items[imux->num_items].index = idx1;
5482                 imux->num_items++;
5483         }
5484         return 0;
5485 }
5486
5487 static struct snd_kcontrol_new alc861_capture_mixer[] = {
5488         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5489         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5490
5491         {
5492                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5493                 /* The multiple "Capture Source" controls confuse alsamixer
5494                  * So call somewhat different..
5495                  *FIXME: the controls appear in the "playback" view!
5496                  */
5497                 /* .name = "Capture Source", */
5498                 .name = "Input Source",
5499                 .count = 1,
5500                 .info = alc_mux_enum_info,
5501                 .get = alc_mux_enum_get,
5502                 .put = alc_mux_enum_put,
5503         },
5504         { } /* end */
5505 };
5506
5507 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec, hda_nid_t nid,
5508                                               int pin_type, int dac_idx)
5509 {
5510         /* set as output */
5511
5512         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
5513         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5514
5515 }
5516
5517 static void alc861_auto_init_multi_out(struct hda_codec *codec)
5518 {
5519         struct alc_spec *spec = codec->spec;
5520         int i;
5521
5522         for (i = 0; i < spec->autocfg.line_outs; i++) {
5523                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
5524                 if (nid)
5525                         alc861_auto_set_output_and_unmute(codec, nid, PIN_OUT, spec->multiout.dac_nids[i]);
5526         }
5527 }
5528
5529 static void alc861_auto_init_hp_out(struct hda_codec *codec)
5530 {
5531         struct alc_spec *spec = codec->spec;
5532         hda_nid_t pin;
5533
5534         pin = spec->autocfg.hp_pin;
5535         if (pin) /* connect to front */
5536                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP, spec->multiout.dac_nids[0]);
5537 }
5538
5539 static void alc861_auto_init_analog_input(struct hda_codec *codec)
5540 {
5541         struct alc_spec *spec = codec->spec;
5542         int i;
5543
5544         for (i = 0; i < AUTO_PIN_LAST; i++) {
5545                 hda_nid_t nid = spec->autocfg.input_pins[i];
5546                 if ((nid>=0x0c) && (nid <=0x11)) {
5547                         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5548                                             i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
5549                 }
5550         }
5551 }
5552
5553 /* parse the BIOS configuration and set up the alc_spec */
5554 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
5555 static int alc861_parse_auto_config(struct hda_codec *codec)
5556 {
5557         struct alc_spec *spec = codec->spec;
5558         int err;
5559         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
5560
5561         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5562                                                 alc861_ignore)) < 0)
5563                 return err;
5564         if (! spec->autocfg.line_outs)
5565                 return 0; /* can't find valid BIOS pin config */
5566
5567         if ((err = alc861_auto_fill_dac_nids(spec, &spec->autocfg)) < 0 ||
5568             (err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
5569             (err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pin)) < 0 ||
5570             (err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
5571                 return err;
5572
5573         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5574
5575         if (spec->autocfg.dig_out_pin)
5576                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
5577
5578         if (spec->kctl_alloc)
5579                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
5580
5581         spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
5582
5583         spec->num_mux_defs = 1;
5584         spec->input_mux = &spec->private_imux;
5585
5586         spec->adc_nids = alc861_adc_nids;
5587         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
5588         spec->mixers[spec->num_mixers] = alc861_capture_mixer;
5589         spec->num_mixers++;
5590
5591         return 1;
5592 }
5593
5594 /* additional initialization for auto-configuration model */
5595 static void alc861_auto_init(struct hda_codec *codec)
5596 {
5597         alc861_auto_init_multi_out(codec);
5598         alc861_auto_init_hp_out(codec);
5599         alc861_auto_init_analog_input(codec);
5600 }
5601
5602
5603 /*
5604  * configuration and preset
5605  */
5606 static struct hda_board_config alc861_cfg_tbl[] = {
5607         { .modelname = "3stack", .config = ALC861_3ST },
5608         { .pci_subvendor = 0x8086, .pci_subdevice = 0xd600, .config = ALC861_3ST },
5609         { .modelname = "3stack-dig", .config = ALC861_3ST_DIG },
5610         { .modelname = "6stack-dig", .config = ALC861_6ST_DIG },
5611         { .modelname = "auto", .config = ALC861_AUTO },
5612         {}
5613 };
5614
5615 static struct alc_config_preset alc861_presets[] = {
5616         [ALC861_3ST] = {
5617                 .mixers = { alc861_3ST_mixer },
5618                 .init_verbs = { alc861_threestack_init_verbs },
5619                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
5620                 .dac_nids = alc861_dac_nids,
5621                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
5622                 .channel_mode = alc861_threestack_modes,
5623                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
5624                 .adc_nids = alc861_adc_nids,
5625                 .input_mux = &alc861_capture_source,
5626         },
5627         [ALC861_3ST_DIG] = {
5628                 .mixers = { alc861_base_mixer },
5629                 .init_verbs = { alc861_threestack_init_verbs },
5630                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
5631                 .dac_nids = alc861_dac_nids,
5632                 .dig_out_nid = ALC861_DIGOUT_NID,
5633                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
5634                 .channel_mode = alc861_threestack_modes,
5635                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
5636                 .adc_nids = alc861_adc_nids,
5637                 .input_mux = &alc861_capture_source,
5638         },
5639         [ALC861_6ST_DIG] = {
5640                 .mixers = { alc861_base_mixer },
5641                 .init_verbs = { alc861_base_init_verbs },
5642                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
5643                 .dac_nids = alc861_dac_nids,
5644                 .dig_out_nid = ALC861_DIGOUT_NID,
5645                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
5646                 .channel_mode = alc861_8ch_modes,
5647                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
5648                 .adc_nids = alc861_adc_nids,
5649                 .input_mux = &alc861_capture_source,
5650         },
5651 };
5652
5653
5654 static int patch_alc861(struct hda_codec *codec)
5655 {
5656         struct alc_spec *spec;
5657         int board_config;
5658         int err;
5659
5660         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
5661         if (spec == NULL)
5662                 return -ENOMEM;
5663
5664         codec->spec = spec;
5665
5666         board_config = snd_hda_check_board_config(codec, alc861_cfg_tbl);
5667         if (board_config < 0 || board_config >= ALC861_MODEL_LAST) {
5668                 printk(KERN_INFO "hda_codec: Unknown model for ALC861, trying auto-probe from BIOS...\n");
5669                 board_config = ALC861_AUTO;
5670         }
5671
5672         if (board_config == ALC861_AUTO) {
5673                 /* automatic parse from the BIOS config */
5674                 err = alc861_parse_auto_config(codec);
5675                 if (err < 0) {
5676                         alc_free(codec);
5677                         return err;
5678                 } else if (! err) {
5679                         printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using base mode...\n");
5680                    board_config = ALC861_3ST_DIG;
5681                 }
5682         }
5683
5684         if (board_config != ALC861_AUTO)
5685                 setup_preset(spec, &alc861_presets[board_config]);
5686
5687         spec->stream_name_analog = "ALC861 Analog";
5688         spec->stream_analog_playback = &alc861_pcm_analog_playback;
5689         spec->stream_analog_capture = &alc861_pcm_analog_capture;
5690
5691         spec->stream_name_digital = "ALC861 Digital";
5692         spec->stream_digital_playback = &alc861_pcm_digital_playback;
5693         spec->stream_digital_capture = &alc861_pcm_digital_capture;
5694
5695         codec->patch_ops = alc_patch_ops;
5696         if (board_config == ALC861_AUTO)
5697                 spec->init_hook = alc861_auto_init;
5698
5699         return 0;
5700 }
5701
5702 /*
5703  * patch entries
5704  */
5705 struct hda_codec_preset snd_hda_preset_realtek[] = {
5706         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
5707         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
5708         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
5709         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
5710         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
5711         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
5712         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
5713         {} /* terminator */
5714 };