sound/pci/hda/alc880_quirks.c

   1 /*
   2  * ALC880 quirk models
   3  * included by patch_realtek.c
   4  */
   5
   6 /* ALC880 board config type */
   7 enum {
   8         ALC880_AUTO,
   9         ALC880_3ST,
  10         ALC880_3ST_DIG,
  11         ALC880_5ST,
  12         ALC880_5ST_DIG,
  13         ALC880_W810,
  14         ALC880_Z71V,
  15         ALC880_6ST,
  16         ALC880_6ST_DIG,
  17         ALC880_F1734,
  18         ALC880_ASUS,
  19         ALC880_ASUS_DIG,
  20         ALC880_ASUS_W1V,
  21         ALC880_ASUS_DIG2,
  22         ALC880_FUJITSU,
  23         ALC880_UNIWILL_DIG,
  24         ALC880_UNIWILL,
  25         ALC880_UNIWILL_P53,
  26         ALC880_CLEVO,
  27         ALC880_TCL_S700,
  28         ALC880_LG,
  29         ALC880_LG_LW,
  30         ALC880_MEDION_RIM,
  31 #ifdef CONFIG_SND_DEBUG
  32         ALC880_TEST,
  33 #endif
  34         ALC880_MODEL_LAST /* last tag */
  35 };
  36
  37 /*
  38  * ALC880 3-stack model
  39  *
  40  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
  41  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
  42  *                 F-Mic = 0x1b, HP = 0x19
  43  */
  44
  45 static const hda_nid_t alc880_dac_nids[4] = {
  46         /* front, rear, clfe, rear_surr */
  47         0x02, 0x05, 0x04, 0x03
  48 };
  49
  50 static const hda_nid_t alc880_adc_nids[3] = {
  51         /* ADC0-2 */
  52         0x07, 0x08, 0x09,
  53 };
  54
  55 /* The datasheet says the node 0x07 is connected from inputs,
  56  * but it shows zero connection in the real implementation on some devices.
  57  * Note: this is a 915GAV bug, fixed on 915GLV
  58  */
  59 static const hda_nid_t alc880_adc_nids_alt[2] = {
  60         /* ADC1-2 */
  61         0x08, 0x09,
  62 };
  63
  64 #define ALC880_DIGOUT_NID       0x06
  65 #define ALC880_DIGIN_NID        0x0a
  66 #define ALC880_PIN_CD_NID       0x1c
  67
  68 static const struct hda_input_mux alc880_capture_source = {
  69         .num_items = 4,
  70         .items = {
  71                 { "Mic", 0x0 },
  72                 { "Front Mic", 0x3 },
  73                 { "Line", 0x2 },
  74                 { "CD", 0x4 },
  75         },
  76 };
  77
  78 /* channel source setting (2/6 channel selection for 3-stack) */
  79 /* 2ch mode */
  80 static const struct hda_verb alc880_threestack_ch2_init[] = {
  81         /* set line-in to input, mute it */
  82         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
  83         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
  84         /* set mic-in to input vref 80%, mute it */
  85         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
  86         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
  87         { } /* end */
  88 };
  89
  90 /* 6ch mode */
  91 static const struct hda_verb alc880_threestack_ch6_init[] = {
  92         /* set line-in to output, unmute it */
  93         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
  94         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
  95         /* set mic-in to output, unmute it */
  96         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
  97         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
  98         { } /* end */
  99 };
 100
 101 static const struct hda_channel_mode alc880_threestack_modes[2] = {
 102         { 2, alc880_threestack_ch2_init },
 103         { 6, alc880_threestack_ch6_init },
 104 };
 105
 106 static const struct snd_kcontrol_new alc880_three_stack_mixer[] = {
 107         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 108         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 109         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
 110         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
 111         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 112         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 113         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 114         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 115         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 116         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 117         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 118         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 119         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 120         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 121         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
 122         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
 123         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
 124         {
 125                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 126                 .name = "Channel Mode",
 127                 .info = alc_ch_mode_info,
 128                 .get = alc_ch_mode_get,
 129                 .put = alc_ch_mode_put,
 130         },
 131         { } /* end */
 132 };
 133
 134 /*
 135  * ALC880 5-stack model
 136  *
 137  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
 138  *      Side = 0x02 (0xd)
 139  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
 140  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
 141  */
 142
 143 /* additional mixers to alc880_three_stack_mixer */
 144 static const struct snd_kcontrol_new alc880_five_stack_mixer[] = {
 145         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 146         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
 147         { } /* end */
 148 };
 149
 150 /* channel source setting (6/8 channel selection for 5-stack) */
 151 /* 6ch mode */
 152 static const struct hda_verb alc880_fivestack_ch6_init[] = {
 153         /* set line-in to input, mute it */
 154         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
 155         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
 156         { } /* end */
 157 };
 158
 159 /* 8ch mode */
 160 static const struct hda_verb alc880_fivestack_ch8_init[] = {
 161         /* set line-in to output, unmute it */
 162         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 163         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
 164         { } /* end */
 165 };
 166
 167 static const struct hda_channel_mode alc880_fivestack_modes[2] = {
 168         { 6, alc880_fivestack_ch6_init },
 169         { 8, alc880_fivestack_ch8_init },
 170 };
 171
 172
 173 /*
 174  * ALC880 6-stack model
 175  *
 176  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
 177  *      Side = 0x05 (0x0f)
 178  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
 179  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
 180  */
 181
 182 static const hda_nid_t alc880_6st_dac_nids[4] = {
 183         /* front, rear, clfe, rear_surr */
 184         0x02, 0x03, 0x04, 0x05
 185 };
 186
 187 static const struct hda_input_mux alc880_6stack_capture_source = {
 188         .num_items = 4,
 189         .items = {
 190                 { "Mic", 0x0 },
 191                 { "Front Mic", 0x1 },
 192                 { "Line", 0x2 },
 193                 { "CD", 0x4 },
 194         },
 195 };
 196
 197 /* fixed 8-channels */
 198 static const struct hda_channel_mode alc880_sixstack_modes[1] = {
 199         { 8, NULL },
 200 };
 201
 202 static const struct snd_kcontrol_new alc880_six_stack_mixer[] = {
 203         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 204         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 205         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 206         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
 207         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 208         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 209         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 210         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 211         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
 212         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
 213         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 214         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 215         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 216         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 217         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 218         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 219         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 220         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
 221         {
 222                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 223                 .name = "Channel Mode",
 224                 .info = alc_ch_mode_info,
 225                 .get = alc_ch_mode_get,
 226                 .put = alc_ch_mode_put,
 227         },
 228         { } /* end */
 229 };
 230
 231
 232 /*
 233  * ALC880 W810 model
 234  *
 235  * W810 has rear IO for:
 236  * Front (DAC 02)
 237  * Surround (DAC 03)
 238  * Center/LFE (DAC 04)
 239  * Digital out (06)
 240  *
 241  * The system also has a pair of internal speakers, and a headphone jack.
 242  * These are both connected to Line2 on the codec, hence to DAC 02.
 243  *
 244  * There is a variable resistor to control the speaker or headphone
 245  * volume. This is a hardware-only device without a software API.
 246  *
 247  * Plugging headphones in will disable the internal speakers. This is
 248  * implemented in hardware, not via the driver using jack sense. In
 249  * a similar fashion, plugging into the rear socket marked "front" will
 250  * disable both the speakers and headphones.
 251  *
 252  * For input, there's a microphone jack, and an "audio in" jack.
 253  * These may not do anything useful with this driver yet, because I
 254  * haven't setup any initialization verbs for these yet...
 255  */
 256
 257 static const hda_nid_t alc880_w810_dac_nids[3] = {
 258         /* front, rear/surround, clfe */
 259         0x02, 0x03, 0x04
 260 };
 261
 262 /* fixed 6 channels */
 263 static const struct hda_channel_mode alc880_w810_modes[1] = {
 264         { 6, NULL }
 265 };
 266
 267 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
 268 static const struct snd_kcontrol_new alc880_w810_base_mixer[] = {
 269         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 270         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 271         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 272         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
 273         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 274         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 275         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 276         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 277         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
 278         { } /* end */
 279 };
 280
 281
 282 /*
 283  * Z710V model
 284  *
 285  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
 286  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
 287  *                 Line = 0x1a
 288  */
 289
 290 static const hda_nid_t alc880_z71v_dac_nids[1] = {
 291         0x02
 292 };
 293 #define ALC880_Z71V_HP_DAC      0x03
 294
 295 /* fixed 2 channels */
 296 static const struct hda_channel_mode alc880_2_jack_modes[1] = {
 297         { 2, NULL }
 298 };
 299
 300 static const struct snd_kcontrol_new alc880_z71v_mixer[] = {
 301         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 302         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 303         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 304         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
 305         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 306         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 307         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 308         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 309         { } /* end */
 310 };
 311
 312
 313 /*
 314  * ALC880 F1734 model
 315  *
 316  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
 317  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
 318  */
 319
 320 static const hda_nid_t alc880_f1734_dac_nids[1] = {
 321         0x03
 322 };
 323 #define ALC880_F1734_HP_DAC     0x02
 324
 325 static const struct snd_kcontrol_new alc880_f1734_mixer[] = {
 326         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 327         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
 328         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 329         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
 330         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 331         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 332         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 333         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
 334         { } /* end */
 335 };
 336
 337 static const struct hda_input_mux alc880_f1734_capture_source = {
 338         .num_items = 2,
 339         .items = {
 340                 { "Mic", 0x1 },
 341                 { "CD", 0x4 },
 342         },
 343 };
 344
 345
 346 /*
 347  * ALC880 ASUS model
 348  *
 349  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
 350  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
 351  *  Mic = 0x18, Line = 0x1a
 352  */
 353
 354 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
 355 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
 356
 357 static const struct snd_kcontrol_new alc880_asus_mixer[] = {
 358         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 359         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 360         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 361         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
 362         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 363         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 364         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 365         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 366         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 367         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 368         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 369         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 370         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 371         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 372         {
 373                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 374                 .name = "Channel Mode",
 375                 .info = alc_ch_mode_info,
 376                 .get = alc_ch_mode_get,
 377                 .put = alc_ch_mode_put,
 378         },
 379         { } /* end */
 380 };
 381
 382 /*
 383  * ALC880 ASUS W1V model
 384  *
 385  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
 386  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
 387  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
 388  */
 389
 390 /* additional mixers to alc880_asus_mixer */
 391 static const struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
 392         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
 393         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
 394         { } /* end */
 395 };
 396
 397 /* TCL S700 */
 398 static const struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
 399         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 400         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
 401         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
 402         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
 403         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
 404         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
 405         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
 406         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
 407         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
 408         { } /* end */
 409 };
 410
 411 /* Uniwill */
 412 static const struct snd_kcontrol_new alc880_uniwill_mixer[] = {
 413         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 414         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
 415         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 416         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
 417         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 418         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 419         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 420         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 421         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 422         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 423         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 424         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 425         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 426         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 427         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 428         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
 429         {
 430                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 431                 .name = "Channel Mode",
 432                 .info = alc_ch_mode_info,
 433                 .get = alc_ch_mode_get,
 434                 .put = alc_ch_mode_put,
 435         },
 436         { } /* end */
 437 };
 438
 439 static const struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
 440         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 441         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
 442         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 443         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
 444         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 445         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 446         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 447         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 448         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 449         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
 450         { } /* end */
 451 };
 452
 453 static const struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
 454         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 455         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
 456         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 457         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
 458         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 459         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 460         { } /* end */
 461 };
 462
 463 /*
 464  * initialize the codec volumes, etc
 465  */
 466
 467 /*
 468  * generic initialization of ADC, input mixers and output mixers
 469  */
 470 static const struct hda_verb alc880_volume_init_verbs[] = {
 471         /*
 472          * Unmute ADC0-2 and set the default input to mic-in
 473          */
 474         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 475         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 476         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
 477         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 478         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
 479         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 480
 481         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
 482          * mixer widget
 483          * Note: PASD motherboards uses the Line In 2 as the input for front
 484          * panel mic (mic 2)
 485          */
 486         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
 487         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 488         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 489         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 490         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 491         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 492         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
 493         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
 494
 495         /*
 496          * Set up output mixers (0x0c - 0x0f)
 497          */
 498         /* set vol=0 to output mixers */
 499         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 500         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 501         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 502         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 503         /* set up input amps for analog loopback */
 504         /* Amp Indices: DAC = 0, mixer = 1 */
 505         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 506         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 507         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 508         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 509         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 510         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 511         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 512         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 513
 514         { }
 515 };
 516
 517 /*
 518  * 3-stack pin configuration:
 519  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
 520  */
 521 static const struct hda_verb alc880_pin_3stack_init_verbs[] = {
 522         /*
 523          * preset connection lists of input pins
 524          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
 525          */
 526         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
 527         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 528         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
 529
 530         /*
 531          * Set pin mode and muting
 532          */
 533         /* set front pin widgets 0x14 for output */
 534         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 535         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 536         /* Mic1 (rear panel) pin widget for input and vref at 80% */
 537         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 538         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 539         /* Mic2 (as headphone out) for HP output */
 540         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 541         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 542         /* Line In pin widget for input */
 543         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 544         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 545         /* Line2 (as front mic) pin widget for input and vref at 80% */
 546         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 547         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 548         /* CD pin widget for input */
 549         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 550
 551         { }
 552 };
 553
 554 /*
 555  * 5-stack pin configuration:
 556  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
 557  * line-in/side = 0x1a, f-mic = 0x1b
 558  */
 559 static const struct hda_verb alc880_pin_5stack_init_verbs[] = {
 560         /*
 561          * preset connection lists of input pins
 562          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
 563          */
 564         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 565         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
 566
 567         /*
 568          * Set pin mode and muting
 569          */
 570         /* set pin widgets 0x14-0x17 for output */
 571         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 572         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 573         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 574         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 575         /* unmute pins for output (no gain on this amp) */
 576         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 577         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 578         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 579         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 580
 581         /* Mic1 (rear panel) pin widget for input and vref at 80% */
 582         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 583         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 584         /* Mic2 (as headphone out) for HP output */
 585         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 586         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 587         /* Line In pin widget for input */
 588         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 589         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 590         /* Line2 (as front mic) pin widget for input and vref at 80% */
 591         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 592         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 593         /* CD pin widget for input */
 594         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 595
 596         { }
 597 };
 598
 599 /*
 600  * W810 pin configuration:
 601  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
 602  */
 603 static const struct hda_verb alc880_pin_w810_init_verbs[] = {
 604         /* hphone/speaker input selector: front DAC */
 605         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
 606
 607         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 608         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 609         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 610         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 611         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 612         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 613
 614         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 615         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 616
 617         { }
 618 };
 619
 620 /*
 621  * Z71V pin configuration:
 622  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
 623  */
 624 static const struct hda_verb alc880_pin_z71v_init_verbs[] = {
 625         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 626         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 627         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 628         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 629
 630         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 631         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 632         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 633         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 634
 635         { }
 636 };
 637
 638 /*
 639  * 6-stack pin configuration:
 640  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
 641  * f-mic = 0x19, line = 0x1a, HP = 0x1b
 642  */
 643 static const struct hda_verb alc880_pin_6stack_init_verbs[] = {
 644         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 645
 646         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 647         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 648         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 649         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 650         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 651         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 652         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 653         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 654
 655         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 656         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 657         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 658         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 659         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 660         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 661         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 662         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 663         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 664
 665         { }
 666 };
 667
 668 /*
 669  * Uniwill pin configuration:
 670  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
 671  * line = 0x1a
 672  */
 673 static const struct hda_verb alc880_uniwill_init_verbs[] = {
 674         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 675
 676         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 677         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 678         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 679         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 680         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 681         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 682         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 683         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 684         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 685         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 686         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 687         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 688         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 689         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 690
 691         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 692         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 693         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 694         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 695         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 696         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 697         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
 698         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
 699         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 700
 701         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
 702         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_MIC_EVENT},
 703
 704         { }
 705 };
 706
 707 /*
 708 * Uniwill P53
 709 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
 710  */
 711 static const struct hda_verb alc880_uniwill_p53_init_verbs[] = {
 712         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 713
 714         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 715         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 716         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 717         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 718         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 719         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 720         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 721         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 722         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 723         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 724         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 725         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 726
 727         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 728         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 729         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 730         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 731         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 732         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 733
 734         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
 735         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_DCVOL_EVENT},
 736
 737         { }
 738 };
 739
 740 static const struct hda_verb alc880_beep_init_verbs[] = {
 741         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
 742         { }
 743 };
 744
 745 static void alc880_uniwill_setup(struct hda_codec *codec)
 746 {
 747         struct alc_spec *spec = codec->spec;
 748
 749         spec->autocfg.hp_pins[0] = 0x14;
 750         spec->autocfg.speaker_pins[0] = 0x15;
 751         spec->autocfg.speaker_pins[0] = 0x16;
 752         spec->automute = 1;
 753         spec->automute_mode = ALC_AUTOMUTE_AMP;
 754 }
 755
 756 static void alc880_uniwill_init_hook(struct hda_codec *codec)
 757 {
 758         alc_hp_automute(codec);
 759         alc88x_simple_mic_automute(codec);
 760 }
 761
 762 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
 763                                        unsigned int res)
 764 {
 765         /* Looks like the unsol event is incompatible with the standard
 766          * definition.  4bit tag is placed at 28 bit!
 767          */
 768         switch (res >> 28) {
 769         case ALC_MIC_EVENT:
 770                 alc88x_simple_mic_automute(codec);
 771                 break;
 772         default:
 773                 alc_sku_unsol_event(codec, res);
 774                 break;
 775         }
 776 }
 777
 778 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
 779 {
 780         struct alc_spec *spec = codec->spec;
 781
 782         spec->autocfg.hp_pins[0] = 0x14;
 783         spec->autocfg.speaker_pins[0] = 0x15;
 784         spec->automute = 1;
 785         spec->automute_mode = ALC_AUTOMUTE_AMP;
 786 }
 787
 788 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
 789 {
 790         unsigned int present;
 791
 792         present = snd_hda_codec_read(codec, 0x21, 0,
 793                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
 794         present &= HDA_AMP_VOLMASK;
 795         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
 796                                  HDA_AMP_VOLMASK, present);
 797         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
 798                                  HDA_AMP_VOLMASK, present);
 799 }
 800
 801 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
 802                                            unsigned int res)
 803 {
 804         /* Looks like the unsol event is incompatible with the standard
 805          * definition.  4bit tag is placed at 28 bit!
 806          */
 807         if ((res >> 28) == ALC_DCVOL_EVENT)
 808                 alc880_uniwill_p53_dcvol_automute(codec);
 809         else
 810                 alc_sku_unsol_event(codec, res);
 811 }
 812
 813 /*
 814  * F1734 pin configuration:
 815  * HP = 0x14, speaker-out = 0x15, mic = 0x18
 816  */
 817 static const struct hda_verb alc880_pin_f1734_init_verbs[] = {
 818         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
 819         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
 820         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
 821         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
 822         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
 823
 824         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 825         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 826         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 827         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 828
 829         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 830         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 831         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
 832         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 833         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 834         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 835         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 836         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 837         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 838
 839         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC_HP_EVENT},
 840         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC_DCVOL_EVENT},
 841
 842         { }
 843 };
 844
 845 /*
 846  * ASUS pin configuration:
 847  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
 848  */
 849 static const struct hda_verb alc880_pin_asus_init_verbs[] = {
 850         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
 851         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
 852         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
 853         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
 854
 855         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 856         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 857         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 858         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 859         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 860         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 861         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 862         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 863
 864         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 865         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 866         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 867         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 868         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 869         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 870         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 871         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 872         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 873
 874         { }
 875 };
 876
 877 /* Enable GPIO mask and set output */
 878 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
 879 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
 880 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
 881
 882 /* Clevo m520g init */
 883 static const struct hda_verb alc880_pin_clevo_init_verbs[] = {
 884         /* headphone output */
 885         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
 886         /* line-out */
 887         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 888         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 889         /* Line-in */
 890         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 891         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 892         /* CD */
 893         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 894         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 895         /* Mic1 (rear panel) */
 896         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 897         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 898         /* Mic2 (front panel) */
 899         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 900         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 901         /* headphone */
 902         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 903         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 904         /* change to EAPD mode */
 905         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
 906         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
 907
 908         { }
 909 };
 910
 911 static const struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
 912         /* change to EAPD mode */
 913         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
 914         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
 915
 916         /* Headphone output */
 917         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 918         /* Front output*/
 919         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 920         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
 921
 922         /* Line In pin widget for input */
 923         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 924         /* CD pin widget for input */
 925         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 926         /* Mic1 (rear panel) pin widget for input and vref at 80% */
 927         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 928
 929         /* change to EAPD mode */
 930         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
 931         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
 932
 933         { }
 934 };
 935
 936 /*
 937  * LG m1 express dual
 938  *
 939  * Pin assignment:
 940  *   Rear Line-In/Out (blue): 0x14
 941  *   Build-in Mic-In: 0x15
 942  *   Speaker-out: 0x17
 943  *   HP-Out (green): 0x1b
 944  *   Mic-In/Out (red): 0x19
 945  *   SPDIF-Out: 0x1e
 946  */
 947
 948 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
 949 static const hda_nid_t alc880_lg_dac_nids[3] = {
 950         0x05, 0x02, 0x03
 951 };
 952
 953 /* seems analog CD is not working */
 954 static const struct hda_input_mux alc880_lg_capture_source = {
 955         .num_items = 3,
 956         .items = {
 957                 { "Mic", 0x1 },
 958                 { "Line", 0x5 },
 959                 { "Internal Mic", 0x6 },
 960         },
 961 };
 962
 963 /* 2,4,6 channel modes */
 964 static const struct hda_verb alc880_lg_ch2_init[] = {
 965         /* set line-in and mic-in to input */
 966         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
 967         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
 968         { }
 969 };
 970
 971 static const struct hda_verb alc880_lg_ch4_init[] = {
 972         /* set line-in to out and mic-in to input */
 973         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
 974         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
 975         { }
 976 };
 977
 978 static const struct hda_verb alc880_lg_ch6_init[] = {
 979         /* set line-in and mic-in to output */
 980         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
 981         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
 982         { }
 983 };
 984
 985 static const struct hda_channel_mode alc880_lg_ch_modes[3] = {
 986         { 2, alc880_lg_ch2_init },
 987         { 4, alc880_lg_ch4_init },
 988         { 6, alc880_lg_ch6_init },
 989 };
 990
 991 static const struct snd_kcontrol_new alc880_lg_mixer[] = {
 992         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
 993         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
 994         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 995         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
 996         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
 997         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
 998         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
 999         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
1000         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1001         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1002         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
1003         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
1004         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
1005         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
1006         {
1007                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1008                 .name = "Channel Mode",
1009                 .info = alc_ch_mode_info,
1010                 .get = alc_ch_mode_get,
1011                 .put = alc_ch_mode_put,
1012         },
1013         { } /* end */
1014 };
1015
1016 static const struct hda_verb alc880_lg_init_verbs[] = {
1017         /* set capture source to mic-in */
1018         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1019         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1020         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1021         /* mute all amp mixer inputs */
1022         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
1023         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
1024         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
1025         /* line-in to input */
1026         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1027         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1028         /* built-in mic */
1029         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1030         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1031         /* speaker-out */
1032         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1033         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1034         /* mic-in to input */
1035         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
1036         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1037         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1038         /* HP-out */
1039         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
1040         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1041         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1042         /* jack sense */
1043         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
1044         { }
1045 };
1046
1047 /* toggle speaker-output according to the hp-jack state */
1048 static void alc880_lg_setup(struct hda_codec *codec)
1049 {
1050         struct alc_spec *spec = codec->spec;
1051
1052         spec->autocfg.hp_pins[0] = 0x1b;
1053         spec->autocfg.speaker_pins[0] = 0x17;
1054         spec->automute = 1;
1055         spec->automute_mode = ALC_AUTOMUTE_AMP;
1056 }
1057
1058 /*
1059  * LG LW20
1060  *
1061  * Pin assignment:
1062  *   Speaker-out: 0x14
1063  *   Mic-In: 0x18
1064  *   Built-in Mic-In: 0x19
1065  *   Line-In: 0x1b
1066  *   HP-Out: 0x1a
1067  *   SPDIF-Out: 0x1e
1068  */
1069
1070 static const struct hda_input_mux alc880_lg_lw_capture_source = {
1071         .num_items = 3,
1072         .items = {
1073                 { "Mic", 0x0 },
1074                 { "Internal Mic", 0x1 },
1075                 { "Line In", 0x2 },
1076         },
1077 };
1078
1079 #define alc880_lg_lw_modes alc880_threestack_modes
1080
1081 static const struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
1082         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1083         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1084         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1085         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1086         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1087         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1088         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1089         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1090         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1091         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1092         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1093         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1094         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
1095         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
1096         {
1097                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1098                 .name = "Channel Mode",
1099                 .info = alc_ch_mode_info,
1100                 .get = alc_ch_mode_get,
1101                 .put = alc_ch_mode_put,
1102         },
1103         { } /* end */
1104 };
1105
1106 static const struct hda_verb alc880_lg_lw_init_verbs[] = {
1107         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1108         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
1109         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
1110
1111         /* set capture source to mic-in */
1112         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1113         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1114         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1115         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
1116         /* speaker-out */
1117         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1118         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1119         /* HP-out */
1120         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1121         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1122         /* mic-in to input */
1123         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1124         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1125         /* built-in mic */
1126         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1127         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1128         /* jack sense */
1129         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
1130         { }
1131 };
1132
1133 /* toggle speaker-output according to the hp-jack state */
1134 static void alc880_lg_lw_setup(struct hda_codec *codec)
1135 {
1136         struct alc_spec *spec = codec->spec;
1137
1138         spec->autocfg.hp_pins[0] = 0x1b;
1139         spec->autocfg.speaker_pins[0] = 0x14;
1140         spec->automute = 1;
1141         spec->automute_mode = ALC_AUTOMUTE_AMP;
1142 }
1143
1144 static const struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
1145         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1146         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
1147         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1148         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1149         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1150         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
1151         { } /* end */
1152 };
1153
1154 static const struct hda_input_mux alc880_medion_rim_capture_source = {
1155         .num_items = 2,
1156         .items = {
1157                 { "Mic", 0x0 },
1158                 { "Internal Mic", 0x1 },
1159         },
1160 };
1161
1162 static const struct hda_verb alc880_medion_rim_init_verbs[] = {
1163         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1164
1165         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1166         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1167
1168         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1169         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1170         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1171         /* Mic2 (as headphone out) for HP output */
1172         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1173         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1174         /* Internal Speaker */
1175         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1176         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1177
1178         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
1179         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
1180
1181         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
1182         { }
1183 };
1184
1185 /* toggle speaker-output according to the hp-jack state */
1186 static void alc880_medion_rim_automute(struct hda_codec *codec)
1187 {
1188         struct alc_spec *spec = codec->spec;
1189         alc_hp_automute(codec);
1190         /* toggle EAPD */
1191         if (spec->jack_present)
1192                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
1193         else
1194                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
1195 }
1196
1197 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
1198                                           unsigned int res)
1199 {
1200         /* Looks like the unsol event is incompatible with the standard
1201          * definition.  4bit tag is placed at 28 bit!
1202          */
1203         if ((res >> 28) == ALC_HP_EVENT)
1204                 alc880_medion_rim_automute(codec);
1205 }
1206
1207 static void alc880_medion_rim_setup(struct hda_codec *codec)
1208 {
1209         struct alc_spec *spec = codec->spec;
1210
1211         spec->autocfg.hp_pins[0] = 0x14;
1212         spec->autocfg.speaker_pins[0] = 0x1b;
1213         spec->automute = 1;
1214         spec->automute_mode = ALC_AUTOMUTE_AMP;
1215 }
1216
1217 #ifdef CONFIG_SND_HDA_POWER_SAVE
1218 static const struct hda_amp_list alc880_lg_loopbacks[] = {
1219         { 0x0b, HDA_INPUT, 1 },
1220         { 0x0b, HDA_INPUT, 6 },
1221         { 0x0b, HDA_INPUT, 7 },
1222         { } /* end */
1223 };
1224 #endif
1225
1226 /*
1227  * Test configuration for debugging
1228  *
1229  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
1230  * enum controls.
1231  */
1232 #ifdef CONFIG_SND_DEBUG
1233 static const hda_nid_t alc880_test_dac_nids[4] = {
1234         0x02, 0x03, 0x04, 0x05
1235 };
1236
1237 static const struct hda_input_mux alc880_test_capture_source = {
1238         .num_items = 7,
1239         .items = {
1240                 { "In-1", 0x0 },
1241                 { "In-2", 0x1 },
1242                 { "In-3", 0x2 },
1243                 { "In-4", 0x3 },
1244                 { "CD", 0x4 },
1245                 { "Front", 0x5 },
1246                 { "Surround", 0x6 },
1247         },
1248 };
1249
1250 static const struct hda_channel_mode alc880_test_modes[4] = {
1251         { 2, NULL },
1252         { 4, NULL },
1253         { 6, NULL },
1254         { 8, NULL },
1255 };
1256
1257 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
1258                                  struct snd_ctl_elem_info *uinfo)
1259 {
1260         static const char * const texts[] = {
1261                 "N/A", "Line Out", "HP Out",
1262                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
1263         };
1264         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1265         uinfo->count = 1;
1266         uinfo->value.enumerated.items = 8;
1267         if (uinfo->value.enumerated.item >= 8)
1268                 uinfo->value.enumerated.item = 7;
1269         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1270         return 0;
1271 }
1272
1273 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
1274                                 struct snd_ctl_elem_value *ucontrol)
1275 {
1276         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1277         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
1278         unsigned int pin_ctl, item = 0;
1279
1280         pin_ctl = snd_hda_codec_read(codec, nid, 0,
1281                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
1282         if (pin_ctl & AC_PINCTL_OUT_EN) {
1283                 if (pin_ctl & AC_PINCTL_HP_EN)
1284                         item = 2;
1285                 else
1286                         item = 1;
1287         } else if (pin_ctl & AC_PINCTL_IN_EN) {
1288                 switch (pin_ctl & AC_PINCTL_VREFEN) {
1289                 case AC_PINCTL_VREF_HIZ: item = 3; break;
1290                 case AC_PINCTL_VREF_50:  item = 4; break;
1291                 case AC_PINCTL_VREF_GRD: item = 5; break;
1292                 case AC_PINCTL_VREF_80:  item = 6; break;
1293                 case AC_PINCTL_VREF_100: item = 7; break;
1294                 }
1295         }
1296         ucontrol->value.enumerated.item[0] = item;
1297         return 0;
1298 }
1299
1300 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
1301                                 struct snd_ctl_elem_value *ucontrol)
1302 {
1303         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1304         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
1305         static const unsigned int ctls[] = {
1306                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
1307                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
1308                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
1309                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
1310                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
1311                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
1312         };
1313         unsigned int old_ctl, new_ctl;
1314
1315         old_ctl = snd_hda_codec_read(codec, nid, 0,
1316                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
1317         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
1318         if (old_ctl != new_ctl) {
1319                 int val;
1320                 snd_hda_codec_write_cache(codec, nid, 0,
1321                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
1322                                           new_ctl);
1323                 val = ucontrol->value.enumerated.item[0] >= 3 ?
1324                         HDA_AMP_MUTE : 0;
1325                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1326                                          HDA_AMP_MUTE, val);
1327                 return 1;
1328         }
1329         return 0;
1330 }
1331
1332 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
1333                                  struct snd_ctl_elem_info *uinfo)
1334 {
1335         static const char * const texts[] = {
1336                 "Front", "Surround", "CLFE", "Side"
1337         };
1338         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1339         uinfo->count = 1;
1340         uinfo->value.enumerated.items = 4;
1341         if (uinfo->value.enumerated.item >= 4)
1342                 uinfo->value.enumerated.item = 3;
1343         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1344         return 0;
1345 }
1346
1347 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
1348                                 struct snd_ctl_elem_value *ucontrol)
1349 {
1350         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1351         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
1352         unsigned int sel;
1353
1354         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
1355         ucontrol->value.enumerated.item[0] = sel & 3;
1356         return 0;
1357 }
1358
1359 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
1360                                 struct snd_ctl_elem_value *ucontrol)
1361 {
1362         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1363         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
1364         unsigned int sel;
1365
1366         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
1367         if (ucontrol->value.enumerated.item[0] != sel) {
1368                 sel = ucontrol->value.enumerated.item[0] & 3;
1369                 snd_hda_codec_write_cache(codec, nid, 0,
1370                                           AC_VERB_SET_CONNECT_SEL, sel);
1371                 return 1;
1372         }
1373         return 0;
1374 }
1375
1376 #define PIN_CTL_TEST(xname,nid) {                       \
1377                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
1378                         .name = xname,                 \
1379                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
1380                         .info = alc_test_pin_ctl_info, \
1381                         .get = alc_test_pin_ctl_get,   \
1382                         .put = alc_test_pin_ctl_put,   \
1383                         .private_value = nid           \
1384                         }
1385
1386 #define PIN_SRC_TEST(xname,nid) {                       \
1387                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
1388                         .name = xname,                 \
1389                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
1390                         .info = alc_test_pin_src_info, \
1391                         .get = alc_test_pin_src_get,   \
1392                         .put = alc_test_pin_src_put,   \
1393                         .private_value = nid           \
1394                         }
1395
1396 static const struct snd_kcontrol_new alc880_test_mixer[] = {
1397         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1398         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1399         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
1400         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1401         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1402         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1403         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
1404         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1405         PIN_CTL_TEST("Front Pin Mode", 0x14),
1406         PIN_CTL_TEST("Surround Pin Mode", 0x15),
1407         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
1408         PIN_CTL_TEST("Side Pin Mode", 0x17),
1409         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
1410         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
1411         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
1412         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
1413         PIN_SRC_TEST("In-1 Pin Source", 0x18),
1414         PIN_SRC_TEST("In-2 Pin Source", 0x19),
1415         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
1416         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
1417         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
1418         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
1419         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
1420         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
1421         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
1422         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
1423         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
1424         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
1425         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
1426         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
1427         {
1428                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1429                 .name = "Channel Mode",
1430                 .info = alc_ch_mode_info,
1431                 .get = alc_ch_mode_get,
1432                 .put = alc_ch_mode_put,
1433         },
1434         { } /* end */
1435 };
1436
1437 static const struct hda_verb alc880_test_init_verbs[] = {
1438         /* Unmute inputs of 0x0c - 0x0f */
1439         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1440         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1441         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1442         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1443         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1444         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1445         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1446         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1447         /* Vol output for 0x0c-0x0f */
1448         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1449         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1450         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1451         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1452         /* Set output pins 0x14-0x17 */
1453         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1454         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1455         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1456         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1457         /* Unmute output pins 0x14-0x17 */
1458         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1459         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1460         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1461         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1462         /* Set input pins 0x18-0x1c */
1463         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1464         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1465         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1466         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1467         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1468         /* Mute input pins 0x18-0x1b */
1469         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1470         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1471         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1472         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1473         /* ADC set up */
1474         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1475         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
1476         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1477         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
1478         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1479         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
1480         /* Analog input/passthru */
1481         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1482         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1483         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
1484         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
1485         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
1486         { }
1487 };
1488 #endif
1489
1490 /*
1491  */
1492
1493 static const char * const alc880_models[ALC880_MODEL_LAST] = {
1494         [ALC880_3ST]            = "3stack",
1495         [ALC880_TCL_S700]       = "tcl",
1496         [ALC880_3ST_DIG]        = "3stack-digout",
1497         [ALC880_CLEVO]          = "clevo",
1498         [ALC880_5ST]            = "5stack",
1499         [ALC880_5ST_DIG]        = "5stack-digout",
1500         [ALC880_W810]           = "w810",
1501         [ALC880_Z71V]           = "z71v",
1502         [ALC880_6ST]            = "6stack",
1503         [ALC880_6ST_DIG]        = "6stack-digout",
1504         [ALC880_ASUS]           = "asus",
1505         [ALC880_ASUS_W1V]       = "asus-w1v",
1506         [ALC880_ASUS_DIG]       = "asus-dig",
1507         [ALC880_ASUS_DIG2]      = "asus-dig2",
1508         [ALC880_UNIWILL_DIG]    = "uniwill",
1509         [ALC880_UNIWILL_P53]    = "uniwill-p53",
1510         [ALC880_FUJITSU]        = "fujitsu",
1511         [ALC880_F1734]          = "F1734",
1512         [ALC880_LG]             = "lg",
1513         [ALC880_LG_LW]          = "lg-lw",
1514         [ALC880_MEDION_RIM]     = "medion",
1515 #ifdef CONFIG_SND_DEBUG
1516         [ALC880_TEST]           = "test",
1517 #endif
1518         [ALC880_AUTO]           = "auto",
1519 };
1520
1521 static const struct snd_pci_quirk alc880_cfg_tbl[] = {
1522         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
1523         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
1524         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
1525         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
1526         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
1527         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
1528         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
1529         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
1530         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
1531         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
1532         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
1533         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
1534         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
1535         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
1536         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
1537         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
1538         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
1539         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
1540         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
1541         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
1542         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
1543         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
1544         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
1545         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
1546         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
1547         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
1548         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
1549         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
1550         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
1551         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
1552         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
1553         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
1554         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
1555         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
1556         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
1557         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
1558         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
1559         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
1560         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
1561         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_F1734),
1562         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
1563         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
1564         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
1565         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
1566         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
1567         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
1568         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
1569         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
1570         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
1571         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
1572         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
1573         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
1574         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_LG),
1575         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
1576         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
1577         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
1578         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
1579         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
1580         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
1581         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
1582         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
1583         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
1584         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
1585         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
1586         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
1587         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
1588         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
1589         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
1590         /* default Intel */
1591         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
1592         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
1593         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
1594         {}
1595 };
1596
1597 /*
1598  * ALC880 codec presets
1599  */
1600 static const struct alc_config_preset alc880_presets[] = {
1601         [ALC880_3ST] = {
1602                 .mixers = { alc880_three_stack_mixer },
1603                 .init_verbs = { alc880_volume_init_verbs,
1604                                 alc880_pin_3stack_init_verbs },
1605                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
1606                 .dac_nids = alc880_dac_nids,
1607                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
1608                 .channel_mode = alc880_threestack_modes,
1609                 .need_dac_fix = 1,
1610                 .input_mux = &alc880_capture_source,
1611         },
1612         [ALC880_3ST_DIG] = {
1613                 .mixers = { alc880_three_stack_mixer },
1614                 .init_verbs = { alc880_volume_init_verbs,
1615                                 alc880_pin_3stack_init_verbs },
1616                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
1617                 .dac_nids = alc880_dac_nids,
1618                 .dig_out_nid = ALC880_DIGOUT_NID,
1619                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
1620                 .channel_mode = alc880_threestack_modes,
1621                 .need_dac_fix = 1,
1622                 .input_mux = &alc880_capture_source,
1623         },
1624         [ALC880_TCL_S700] = {
1625                 .mixers = { alc880_tcl_s700_mixer },
1626                 .init_verbs = { alc880_volume_init_verbs,
1627                                 alc880_pin_tcl_S700_init_verbs,
1628                                 alc880_gpio2_init_verbs },
1629                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
1630                 .dac_nids = alc880_dac_nids,
1631                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
1632                 .num_adc_nids = 1, /* single ADC */
1633                 .hp_nid = 0x03,
1634                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
1635                 .channel_mode = alc880_2_jack_modes,
1636                 .input_mux = &alc880_capture_source,
1637         },
1638         [ALC880_5ST] = {
1639                 .mixers = { alc880_three_stack_mixer,
1640                             alc880_five_stack_mixer},
1641                 .init_verbs = { alc880_volume_init_verbs,
1642                                 alc880_pin_5stack_init_verbs },
1643                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
1644                 .dac_nids = alc880_dac_nids,
1645                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
1646                 .channel_mode = alc880_fivestack_modes,
1647                 .input_mux = &alc880_capture_source,
1648         },
1649         [ALC880_5ST_DIG] = {
1650                 .mixers = { alc880_three_stack_mixer,
1651                             alc880_five_stack_mixer },
1652                 .init_verbs = { alc880_volume_init_verbs,
1653                                 alc880_pin_5stack_init_verbs },
1654                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
1655                 .dac_nids = alc880_dac_nids,
1656                 .dig_out_nid = ALC880_DIGOUT_NID,
1657                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
1658                 .channel_mode = alc880_fivestack_modes,
1659                 .input_mux = &alc880_capture_source,
1660         },
1661         [ALC880_6ST] = {
1662                 .mixers = { alc880_six_stack_mixer },
1663                 .init_verbs = { alc880_volume_init_verbs,
1664                                 alc880_pin_6stack_init_verbs },
1665                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
1666                 .dac_nids = alc880_6st_dac_nids,
1667                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
1668                 .channel_mode = alc880_sixstack_modes,
1669                 .input_mux = &alc880_6stack_capture_source,
1670         },
1671         [ALC880_6ST_DIG] = {
1672                 .mixers = { alc880_six_stack_mixer },
1673                 .init_verbs = { alc880_volume_init_verbs,
1674                                 alc880_pin_6stack_init_verbs },
1675                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
1676                 .dac_nids = alc880_6st_dac_nids,
1677                 .dig_out_nid = ALC880_DIGOUT_NID,
1678                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
1679                 .channel_mode = alc880_sixstack_modes,
1680                 .input_mux = &alc880_6stack_capture_source,
1681         },
1682         [ALC880_W810] = {
1683                 .mixers = { alc880_w810_base_mixer },
1684                 .init_verbs = { alc880_volume_init_verbs,
1685                                 alc880_pin_w810_init_verbs,
1686                                 alc880_gpio2_init_verbs },
1687                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
1688                 .dac_nids = alc880_w810_dac_nids,
1689                 .dig_out_nid = ALC880_DIGOUT_NID,
1690                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
1691                 .channel_mode = alc880_w810_modes,
1692                 .input_mux = &alc880_capture_source,
1693         },
1694         [ALC880_Z71V] = {
1695                 .mixers = { alc880_z71v_mixer },
1696                 .init_verbs = { alc880_volume_init_verbs,
1697                                 alc880_pin_z71v_init_verbs },
1698                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
1699                 .dac_nids = alc880_z71v_dac_nids,
1700                 .dig_out_nid = ALC880_DIGOUT_NID,
1701                 .hp_nid = 0x03,
1702                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
1703                 .channel_mode = alc880_2_jack_modes,
1704                 .input_mux = &alc880_capture_source,
1705         },
1706         [ALC880_F1734] = {
1707                 .mixers = { alc880_f1734_mixer },
1708                 .init_verbs = { alc880_volume_init_verbs,
1709                                 alc880_pin_f1734_init_verbs },
1710                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
1711                 .dac_nids = alc880_f1734_dac_nids,
1712                 .hp_nid = 0x02,
1713                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
1714                 .channel_mode = alc880_2_jack_modes,
1715                 .input_mux = &alc880_f1734_capture_source,
1716                 .unsol_event = alc880_uniwill_p53_unsol_event,
1717                 .setup = alc880_uniwill_p53_setup,
1718                 .init_hook = alc_hp_automute,
1719         },
1720         [ALC880_ASUS] = {
1721                 .mixers = { alc880_asus_mixer },
1722                 .init_verbs = { alc880_volume_init_verbs,
1723                                 alc880_pin_asus_init_verbs,
1724                                 alc880_gpio1_init_verbs },
1725                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
1726                 .dac_nids = alc880_asus_dac_nids,
1727                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
1728                 .channel_mode = alc880_asus_modes,
1729                 .need_dac_fix = 1,
1730                 .input_mux = &alc880_capture_source,
1731         },
1732         [ALC880_ASUS_DIG] = {
1733                 .mixers = { alc880_asus_mixer },
1734                 .init_verbs = { alc880_volume_init_verbs,
1735                                 alc880_pin_asus_init_verbs,
1736                                 alc880_gpio1_init_verbs },
1737                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
1738                 .dac_nids = alc880_asus_dac_nids,
1739                 .dig_out_nid = ALC880_DIGOUT_NID,
1740                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
1741                 .channel_mode = alc880_asus_modes,
1742                 .need_dac_fix = 1,
1743                 .input_mux = &alc880_capture_source,
1744         },
1745         [ALC880_ASUS_DIG2] = {
1746                 .mixers = { alc880_asus_mixer },
1747                 .init_verbs = { alc880_volume_init_verbs,
1748                                 alc880_pin_asus_init_verbs,
1749                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
1750                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
1751                 .dac_nids = alc880_asus_dac_nids,
1752                 .dig_out_nid = ALC880_DIGOUT_NID,
1753                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
1754                 .channel_mode = alc880_asus_modes,
1755                 .need_dac_fix = 1,
1756                 .input_mux = &alc880_capture_source,
1757         },
1758         [ALC880_ASUS_W1V] = {
1759                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
1760                 .init_verbs = { alc880_volume_init_verbs,
1761                                 alc880_pin_asus_init_verbs,
1762                                 alc880_gpio1_init_verbs },
1763                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
1764                 .dac_nids = alc880_asus_dac_nids,
1765                 .dig_out_nid = ALC880_DIGOUT_NID,
1766                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
1767                 .channel_mode = alc880_asus_modes,
1768                 .need_dac_fix = 1,
1769                 .input_mux = &alc880_capture_source,
1770         },
1771         [ALC880_UNIWILL_DIG] = {
1772                 .mixers = { alc880_asus_mixer },
1773                 .init_verbs = { alc880_volume_init_verbs,
1774                                 alc880_pin_asus_init_verbs },
1775                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
1776                 .dac_nids = alc880_asus_dac_nids,
1777                 .dig_out_nid = ALC880_DIGOUT_NID,
1778                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
1779                 .channel_mode = alc880_asus_modes,
1780                 .need_dac_fix = 1,
1781                 .input_mux = &alc880_capture_source,
1782         },
1783         [ALC880_UNIWILL] = {
1784                 .mixers = { alc880_uniwill_mixer },
1785                 .init_verbs = { alc880_volume_init_verbs,
1786                                 alc880_uniwill_init_verbs },
1787                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
1788                 .dac_nids = alc880_asus_dac_nids,
1789                 .dig_out_nid = ALC880_DIGOUT_NID,
1790                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
1791                 .channel_mode = alc880_threestack_modes,
1792                 .need_dac_fix = 1,
1793                 .input_mux = &alc880_capture_source,
1794                 .unsol_event = alc880_uniwill_unsol_event,
1795                 .setup = alc880_uniwill_setup,
1796                 .init_hook = alc880_uniwill_init_hook,
1797         },
1798         [ALC880_UNIWILL_P53] = {
1799                 .mixers = { alc880_uniwill_p53_mixer },
1800                 .init_verbs = { alc880_volume_init_verbs,
1801                                 alc880_uniwill_p53_init_verbs },
1802                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
1803                 .dac_nids = alc880_asus_dac_nids,
1804                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
1805                 .channel_mode = alc880_threestack_modes,
1806                 .input_mux = &alc880_capture_source,
1807                 .unsol_event = alc880_uniwill_p53_unsol_event,
1808                 .setup = alc880_uniwill_p53_setup,
1809                 .init_hook = alc_hp_automute,
1810         },
1811         [ALC880_FUJITSU] = {
1812                 .mixers = { alc880_fujitsu_mixer },
1813                 .init_verbs = { alc880_volume_init_verbs,
1814                                 alc880_uniwill_p53_init_verbs,
1815                                 alc880_beep_init_verbs },
1816                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
1817                 .dac_nids = alc880_dac_nids,
1818                 .dig_out_nid = ALC880_DIGOUT_NID,
1819                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
1820                 .channel_mode = alc880_2_jack_modes,
1821                 .input_mux = &alc880_capture_source,
1822                 .unsol_event = alc880_uniwill_p53_unsol_event,
1823                 .setup = alc880_uniwill_p53_setup,
1824                 .init_hook = alc_hp_automute,
1825         },
1826         [ALC880_CLEVO] = {
1827                 .mixers = { alc880_three_stack_mixer },
1828                 .init_verbs = { alc880_volume_init_verbs,
1829                                 alc880_pin_clevo_init_verbs },
1830                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
1831                 .dac_nids = alc880_dac_nids,
1832                 .hp_nid = 0x03,
1833                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
1834                 .channel_mode = alc880_threestack_modes,
1835                 .need_dac_fix = 1,
1836                 .input_mux = &alc880_capture_source,
1837         },
1838         [ALC880_LG] = {
1839                 .mixers = { alc880_lg_mixer },
1840                 .init_verbs = { alc880_volume_init_verbs,
1841                                 alc880_lg_init_verbs },
1842                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
1843                 .dac_nids = alc880_lg_dac_nids,
1844                 .dig_out_nid = ALC880_DIGOUT_NID,
1845                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
1846                 .channel_mode = alc880_lg_ch_modes,
1847                 .need_dac_fix = 1,
1848                 .input_mux = &alc880_lg_capture_source,
1849                 .unsol_event = alc_sku_unsol_event,
1850                 .setup = alc880_lg_setup,
1851                 .init_hook = alc_hp_automute,
1852 #ifdef CONFIG_SND_HDA_POWER_SAVE
1853                 .loopbacks = alc880_lg_loopbacks,
1854 #endif
1855         },
1856         [ALC880_LG_LW] = {
1857                 .mixers = { alc880_lg_lw_mixer },
1858                 .init_verbs = { alc880_volume_init_verbs,
1859                                 alc880_lg_lw_init_verbs },
1860                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
1861                 .dac_nids = alc880_dac_nids,
1862                 .dig_out_nid = ALC880_DIGOUT_NID,
1863                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
1864                 .channel_mode = alc880_lg_lw_modes,
1865                 .input_mux = &alc880_lg_lw_capture_source,
1866                 .unsol_event = alc_sku_unsol_event,
1867                 .setup = alc880_lg_lw_setup,
1868                 .init_hook = alc_hp_automute,
1869         },
1870         [ALC880_MEDION_RIM] = {
1871                 .mixers = { alc880_medion_rim_mixer },
1872                 .init_verbs = { alc880_volume_init_verbs,
1873                                 alc880_medion_rim_init_verbs,
1874                                 alc_gpio2_init_verbs },
1875                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
1876                 .dac_nids = alc880_dac_nids,
1877                 .dig_out_nid = ALC880_DIGOUT_NID,
1878                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
1879                 .channel_mode = alc880_2_jack_modes,
1880                 .input_mux = &alc880_medion_rim_capture_source,
1881                 .unsol_event = alc880_medion_rim_unsol_event,
1882                 .setup = alc880_medion_rim_setup,
1883                 .init_hook = alc880_medion_rim_automute,
1884         },
1885 #ifdef CONFIG_SND_DEBUG
1886         [ALC880_TEST] = {
1887                 .mixers = { alc880_test_mixer },
1888                 .init_verbs = { alc880_test_init_verbs },
1889                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
1890                 .dac_nids = alc880_test_dac_nids,
1891                 .dig_out_nid = ALC880_DIGOUT_NID,
1892                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
1893                 .channel_mode = alc880_test_modes,
1894                 .input_mux = &alc880_test_capture_source,
1895         },
1896 #endif
1897 };
1898