Merge tag 'sound-4.15-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai...
[muen/linux.git] / sound / pci / hda / patch_realtek.c
1 /*
2  * Universal Interface for Intel High Definition Audio Codec
3  *
4  * HD audio interface patch for Realtek ALC 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@just42.net>
10  *
11  *  This driver is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License as published by
13  *  the Free Software Foundation; either version 2 of the License, or
14  *  (at your option) any later version.
15  *
16  *  This driver is distributed in the hope that it will be useful,
17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  *  GNU General Public License for more details.
20  *
21  *  You should have received a copy of the GNU General Public License
22  *  along with this program; if not, write to the Free Software
23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
24  */
25
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/pci.h>
30 #include <linux/dmi.h>
31 #include <linux/module.h>
32 #include <linux/input.h>
33 #include <sound/core.h>
34 #include <sound/jack.h>
35 #include "hda_codec.h"
36 #include "hda_local.h"
37 #include "hda_auto_parser.h"
38 #include "hda_jack.h"
39 #include "hda_generic.h"
40
41 /* keep halting ALC5505 DSP, for power saving */
42 #define HALT_REALTEK_ALC5505
43
44 /* extra amp-initialization sequence types */
45 enum {
46         ALC_INIT_NONE,
47         ALC_INIT_DEFAULT,
48         ALC_INIT_GPIO1,
49         ALC_INIT_GPIO2,
50         ALC_INIT_GPIO3,
51 };
52
53 enum {
54         ALC_HEADSET_MODE_UNKNOWN,
55         ALC_HEADSET_MODE_UNPLUGGED,
56         ALC_HEADSET_MODE_HEADSET,
57         ALC_HEADSET_MODE_MIC,
58         ALC_HEADSET_MODE_HEADPHONE,
59 };
60
61 enum {
62         ALC_HEADSET_TYPE_UNKNOWN,
63         ALC_HEADSET_TYPE_CTIA,
64         ALC_HEADSET_TYPE_OMTP,
65 };
66
67 enum {
68         ALC_KEY_MICMUTE_INDEX,
69 };
70
71 struct alc_customize_define {
72         unsigned int  sku_cfg;
73         unsigned char port_connectivity;
74         unsigned char check_sum;
75         unsigned char customization;
76         unsigned char external_amp;
77         unsigned int  enable_pcbeep:1;
78         unsigned int  platform_type:1;
79         unsigned int  swap:1;
80         unsigned int  override:1;
81         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
82 };
83
84 struct alc_spec {
85         struct hda_gen_spec gen; /* must be at head */
86
87         /* codec parameterization */
88         const struct snd_kcontrol_new *mixers[5];       /* mixer arrays */
89         unsigned int num_mixers;
90         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
91
92         struct alc_customize_define cdefine;
93         unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
94
95         /* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */
96         int mute_led_polarity;
97         hda_nid_t mute_led_nid;
98         hda_nid_t cap_mute_led_nid;
99
100         unsigned int gpio_led; /* used for alc269_fixup_hp_gpio_led() */
101         unsigned int gpio_mute_led_mask;
102         unsigned int gpio_mic_led_mask;
103
104         hda_nid_t headset_mic_pin;
105         hda_nid_t headphone_mic_pin;
106         int current_headset_mode;
107         int current_headset_type;
108
109         /* hooks */
110         void (*init_hook)(struct hda_codec *codec);
111 #ifdef CONFIG_PM
112         void (*power_hook)(struct hda_codec *codec);
113 #endif
114         void (*shutup)(struct hda_codec *codec);
115         void (*reboot_notify)(struct hda_codec *codec);
116
117         int init_amp;
118         int codec_variant;      /* flag for other variants */
119         unsigned int has_alc5505_dsp:1;
120         unsigned int no_depop_delay:1;
121
122         /* for PLL fix */
123         hda_nid_t pll_nid;
124         unsigned int pll_coef_idx, pll_coef_bit;
125         unsigned int coef0;
126         struct input_dev *kb_dev;
127         u8 alc_mute_keycode_map[1];
128 };
129
130 /*
131  * COEF access helper functions
132  */
133
134 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
135                                unsigned int coef_idx)
136 {
137         unsigned int val;
138
139         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
140         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
141         return val;
142 }
143
144 #define alc_read_coef_idx(codec, coef_idx) \
145         alc_read_coefex_idx(codec, 0x20, coef_idx)
146
147 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
148                                  unsigned int coef_idx, unsigned int coef_val)
149 {
150         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
151         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
152 }
153
154 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
155         alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
156
157 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
158                                   unsigned int coef_idx, unsigned int mask,
159                                   unsigned int bits_set)
160 {
161         unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx);
162
163         if (val != -1)
164                 alc_write_coefex_idx(codec, nid, coef_idx,
165                                      (val & ~mask) | bits_set);
166 }
167
168 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set)    \
169         alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
170
171 /* a special bypass for COEF 0; read the cached value at the second time */
172 static unsigned int alc_get_coef0(struct hda_codec *codec)
173 {
174         struct alc_spec *spec = codec->spec;
175
176         if (!spec->coef0)
177                 spec->coef0 = alc_read_coef_idx(codec, 0);
178         return spec->coef0;
179 }
180
181 /* coef writes/updates batch */
182 struct coef_fw {
183         unsigned char nid;
184         unsigned char idx;
185         unsigned short mask;
186         unsigned short val;
187 };
188
189 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
190         { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
191 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
192 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
193 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
194
195 static void alc_process_coef_fw(struct hda_codec *codec,
196                                 const struct coef_fw *fw)
197 {
198         for (; fw->nid; fw++) {
199                 if (fw->mask == (unsigned short)-1)
200                         alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
201                 else
202                         alc_update_coefex_idx(codec, fw->nid, fw->idx,
203                                               fw->mask, fw->val);
204         }
205 }
206
207 /*
208  * Append the given mixer and verb elements for the later use
209  * The mixer array is referred in build_controls(), and init_verbs are
210  * called in init().
211  */
212 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
213 {
214         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
215                 return;
216         spec->mixers[spec->num_mixers++] = mix;
217 }
218
219 /*
220  * GPIO setup tables, used in initialization
221  */
222 /* Enable GPIO mask and set output */
223 static const struct hda_verb alc_gpio1_init_verbs[] = {
224         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
225         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
226         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
227         { }
228 };
229
230 static const struct hda_verb alc_gpio2_init_verbs[] = {
231         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
232         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
233         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
234         { }
235 };
236
237 static const struct hda_verb alc_gpio3_init_verbs[] = {
238         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
239         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
240         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
241         { }
242 };
243
244 /*
245  * Fix hardware PLL issue
246  * On some codecs, the analog PLL gating control must be off while
247  * the default value is 1.
248  */
249 static void alc_fix_pll(struct hda_codec *codec)
250 {
251         struct alc_spec *spec = codec->spec;
252
253         if (spec->pll_nid)
254                 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
255                                       1 << spec->pll_coef_bit, 0);
256 }
257
258 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
259                              unsigned int coef_idx, unsigned int coef_bit)
260 {
261         struct alc_spec *spec = codec->spec;
262         spec->pll_nid = nid;
263         spec->pll_coef_idx = coef_idx;
264         spec->pll_coef_bit = coef_bit;
265         alc_fix_pll(codec);
266 }
267
268 /* update the master volume per volume-knob's unsol event */
269 static void alc_update_knob_master(struct hda_codec *codec,
270                                    struct hda_jack_callback *jack)
271 {
272         unsigned int val;
273         struct snd_kcontrol *kctl;
274         struct snd_ctl_elem_value *uctl;
275
276         kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
277         if (!kctl)
278                 return;
279         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
280         if (!uctl)
281                 return;
282         val = snd_hda_codec_read(codec, jack->nid, 0,
283                                  AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
284         val &= HDA_AMP_VOLMASK;
285         uctl->value.integer.value[0] = val;
286         uctl->value.integer.value[1] = val;
287         kctl->put(kctl, uctl);
288         kfree(uctl);
289 }
290
291 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
292 {
293         /* For some reason, the res given from ALC880 is broken.
294            Here we adjust it properly. */
295         snd_hda_jack_unsol_event(codec, res >> 2);
296 }
297
298 /* Change EAPD to verb control */
299 static void alc_fill_eapd_coef(struct hda_codec *codec)
300 {
301         int coef;
302
303         coef = alc_get_coef0(codec);
304
305         switch (codec->core.vendor_id) {
306         case 0x10ec0262:
307                 alc_update_coef_idx(codec, 0x7, 0, 1<<5);
308                 break;
309         case 0x10ec0267:
310         case 0x10ec0268:
311                 alc_update_coef_idx(codec, 0x7, 0, 1<<13);
312                 break;
313         case 0x10ec0269:
314                 if ((coef & 0x00f0) == 0x0010)
315                         alc_update_coef_idx(codec, 0xd, 0, 1<<14);
316                 if ((coef & 0x00f0) == 0x0020)
317                         alc_update_coef_idx(codec, 0x4, 1<<15, 0);
318                 if ((coef & 0x00f0) == 0x0030)
319                         alc_update_coef_idx(codec, 0x10, 1<<9, 0);
320                 break;
321         case 0x10ec0280:
322         case 0x10ec0284:
323         case 0x10ec0290:
324         case 0x10ec0292:
325                 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
326                 break;
327         case 0x10ec0215:
328         case 0x10ec0225:
329         case 0x10ec0233:
330         case 0x10ec0236:
331         case 0x10ec0255:
332         case 0x10ec0256:
333         case 0x10ec0257:
334         case 0x10ec0282:
335         case 0x10ec0283:
336         case 0x10ec0286:
337         case 0x10ec0288:
338         case 0x10ec0285:
339         case 0x10ec0295:
340         case 0x10ec0298:
341         case 0x10ec0289:
342         case 0x10ec0299:
343                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
344                 break;
345         case 0x10ec0275:
346                 alc_update_coef_idx(codec, 0xe, 0, 1<<0);
347                 break;
348         case 0x10ec0293:
349                 alc_update_coef_idx(codec, 0xa, 1<<13, 0);
350                 break;
351         case 0x10ec0234:
352         case 0x10ec0274:
353         case 0x10ec0294:
354         case 0x10ec0700:
355         case 0x10ec0701:
356         case 0x10ec0703:
357                 alc_update_coef_idx(codec, 0x10, 1<<15, 0);
358                 break;
359         case 0x10ec0662:
360                 if ((coef & 0x00f0) == 0x0030)
361                         alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
362                 break;
363         case 0x10ec0272:
364         case 0x10ec0273:
365         case 0x10ec0663:
366         case 0x10ec0665:
367         case 0x10ec0670:
368         case 0x10ec0671:
369         case 0x10ec0672:
370                 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
371                 break;
372         case 0x10ec0668:
373                 alc_update_coef_idx(codec, 0x7, 3<<13, 0);
374                 break;
375         case 0x10ec0867:
376                 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
377                 break;
378         case 0x10ec0888:
379                 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
380                         alc_update_coef_idx(codec, 0x7, 1<<5, 0);
381                 break;
382         case 0x10ec0892:
383                 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
384                 break;
385         case 0x10ec0899:
386         case 0x10ec0900:
387         case 0x10ec1168:
388         case 0x10ec1220:
389                 alc_update_coef_idx(codec, 0x7, 1<<1, 0);
390                 break;
391         }
392 }
393
394 /* additional initialization for ALC888 variants */
395 static void alc888_coef_init(struct hda_codec *codec)
396 {
397         switch (alc_get_coef0(codec) & 0x00f0) {
398         /* alc888-VA */
399         case 0x00:
400         /* alc888-VB */
401         case 0x10:
402                 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
403                 break;
404         }
405 }
406
407 /* turn on/off EAPD control (only if available) */
408 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
409 {
410         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
411                 return;
412         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
413                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
414                                     on ? 2 : 0);
415 }
416
417 /* turn on/off EAPD controls of the codec */
418 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
419 {
420         /* We currently only handle front, HP */
421         static hda_nid_t pins[] = {
422                 0x0f, 0x10, 0x14, 0x15, 0x17, 0
423         };
424         hda_nid_t *p;
425         for (p = pins; *p; p++)
426                 set_eapd(codec, *p, on);
427 }
428
429 /* generic shutup callback;
430  * just turning off EAPD and a little pause for avoiding pop-noise
431  */
432 static void alc_eapd_shutup(struct hda_codec *codec)
433 {
434         struct alc_spec *spec = codec->spec;
435
436         alc_auto_setup_eapd(codec, false);
437         if (!spec->no_depop_delay)
438                 msleep(200);
439         snd_hda_shutup_pins(codec);
440 }
441
442 /* generic EAPD initialization */
443 static void alc_auto_init_amp(struct hda_codec *codec, int type)
444 {
445         alc_fill_eapd_coef(codec);
446         alc_auto_setup_eapd(codec, true);
447         switch (type) {
448         case ALC_INIT_GPIO1:
449                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
450                 break;
451         case ALC_INIT_GPIO2:
452                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
453                 break;
454         case ALC_INIT_GPIO3:
455                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
456                 break;
457         case ALC_INIT_DEFAULT:
458                 switch (codec->core.vendor_id) {
459                 case 0x10ec0260:
460                         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
461                         break;
462                 case 0x10ec0880:
463                 case 0x10ec0882:
464                 case 0x10ec0883:
465                 case 0x10ec0885:
466                         alc_update_coef_idx(codec, 7, 0, 0x2030);
467                         break;
468                 case 0x10ec0888:
469                         alc888_coef_init(codec);
470                         break;
471                 }
472                 break;
473         }
474 }
475
476
477 /*
478  * Realtek SSID verification
479  */
480
481 /* Could be any non-zero and even value. When used as fixup, tells
482  * the driver to ignore any present sku defines.
483  */
484 #define ALC_FIXUP_SKU_IGNORE (2)
485
486 static void alc_fixup_sku_ignore(struct hda_codec *codec,
487                                  const struct hda_fixup *fix, int action)
488 {
489         struct alc_spec *spec = codec->spec;
490         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
491                 spec->cdefine.fixup = 1;
492                 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
493         }
494 }
495
496 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
497                                     const struct hda_fixup *fix, int action)
498 {
499         struct alc_spec *spec = codec->spec;
500
501         if (action == HDA_FIXUP_ACT_PROBE) {
502                 spec->no_depop_delay = 1;
503                 codec->depop_delay = 0;
504         }
505 }
506
507 static int alc_auto_parse_customize_define(struct hda_codec *codec)
508 {
509         unsigned int ass, tmp, i;
510         unsigned nid = 0;
511         struct alc_spec *spec = codec->spec;
512
513         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
514
515         if (spec->cdefine.fixup) {
516                 ass = spec->cdefine.sku_cfg;
517                 if (ass == ALC_FIXUP_SKU_IGNORE)
518                         return -1;
519                 goto do_sku;
520         }
521
522         if (!codec->bus->pci)
523                 return -1;
524         ass = codec->core.subsystem_id & 0xffff;
525         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
526                 goto do_sku;
527
528         nid = 0x1d;
529         if (codec->core.vendor_id == 0x10ec0260)
530                 nid = 0x17;
531         ass = snd_hda_codec_get_pincfg(codec, nid);
532
533         if (!(ass & 1)) {
534                 codec_info(codec, "%s: SKU not ready 0x%08x\n",
535                            codec->core.chip_name, ass);
536                 return -1;
537         }
538
539         /* check sum */
540         tmp = 0;
541         for (i = 1; i < 16; i++) {
542                 if ((ass >> i) & 1)
543                         tmp++;
544         }
545         if (((ass >> 16) & 0xf) != tmp)
546                 return -1;
547
548         spec->cdefine.port_connectivity = ass >> 30;
549         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
550         spec->cdefine.check_sum = (ass >> 16) & 0xf;
551         spec->cdefine.customization = ass >> 8;
552 do_sku:
553         spec->cdefine.sku_cfg = ass;
554         spec->cdefine.external_amp = (ass & 0x38) >> 3;
555         spec->cdefine.platform_type = (ass & 0x4) >> 2;
556         spec->cdefine.swap = (ass & 0x2) >> 1;
557         spec->cdefine.override = ass & 0x1;
558
559         codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
560                    nid, spec->cdefine.sku_cfg);
561         codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
562                    spec->cdefine.port_connectivity);
563         codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
564         codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
565         codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
566         codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
567         codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
568         codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
569         codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
570
571         return 0;
572 }
573
574 /* return the position of NID in the list, or -1 if not found */
575 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
576 {
577         int i;
578         for (i = 0; i < nums; i++)
579                 if (list[i] == nid)
580                         return i;
581         return -1;
582 }
583 /* return true if the given NID is found in the list */
584 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
585 {
586         return find_idx_in_nid_list(nid, list, nums) >= 0;
587 }
588
589 /* check subsystem ID and set up device-specific initialization;
590  * return 1 if initialized, 0 if invalid SSID
591  */
592 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
593  *      31 ~ 16 :       Manufacture ID
594  *      15 ~ 8  :       SKU ID
595  *      7  ~ 0  :       Assembly ID
596  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
597  */
598 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
599 {
600         unsigned int ass, tmp, i;
601         unsigned nid;
602         struct alc_spec *spec = codec->spec;
603
604         if (spec->cdefine.fixup) {
605                 ass = spec->cdefine.sku_cfg;
606                 if (ass == ALC_FIXUP_SKU_IGNORE)
607                         return 0;
608                 goto do_sku;
609         }
610
611         ass = codec->core.subsystem_id & 0xffff;
612         if (codec->bus->pci &&
613             ass != codec->bus->pci->subsystem_device && (ass & 1))
614                 goto do_sku;
615
616         /* invalid SSID, check the special NID pin defcfg instead */
617         /*
618          * 31~30        : port connectivity
619          * 29~21        : reserve
620          * 20           : PCBEEP input
621          * 19~16        : Check sum (15:1)
622          * 15~1         : Custom
623          * 0            : override
624         */
625         nid = 0x1d;
626         if (codec->core.vendor_id == 0x10ec0260)
627                 nid = 0x17;
628         ass = snd_hda_codec_get_pincfg(codec, nid);
629         codec_dbg(codec,
630                   "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
631                    ass, nid);
632         if (!(ass & 1))
633                 return 0;
634         if ((ass >> 30) != 1)   /* no physical connection */
635                 return 0;
636
637         /* check sum */
638         tmp = 0;
639         for (i = 1; i < 16; i++) {
640                 if ((ass >> i) & 1)
641                         tmp++;
642         }
643         if (((ass >> 16) & 0xf) != tmp)
644                 return 0;
645 do_sku:
646         codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
647                    ass & 0xffff, codec->core.vendor_id);
648         /*
649          * 0 : override
650          * 1 :  Swap Jack
651          * 2 : 0 --> Desktop, 1 --> Laptop
652          * 3~5 : External Amplifier control
653          * 7~6 : Reserved
654         */
655         tmp = (ass & 0x38) >> 3;        /* external Amp control */
656         switch (tmp) {
657         case 1:
658                 spec->init_amp = ALC_INIT_GPIO1;
659                 break;
660         case 3:
661                 spec->init_amp = ALC_INIT_GPIO2;
662                 break;
663         case 7:
664                 spec->init_amp = ALC_INIT_GPIO3;
665                 break;
666         case 5:
667         default:
668                 spec->init_amp = ALC_INIT_DEFAULT;
669                 break;
670         }
671
672         /* is laptop or Desktop and enable the function "Mute internal speaker
673          * when the external headphone out jack is plugged"
674          */
675         if (!(ass & 0x8000))
676                 return 1;
677         /*
678          * 10~8 : Jack location
679          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
680          * 14~13: Resvered
681          * 15   : 1 --> enable the function "Mute internal speaker
682          *              when the external headphone out jack is plugged"
683          */
684         if (!spec->gen.autocfg.hp_pins[0] &&
685             !(spec->gen.autocfg.line_out_pins[0] &&
686               spec->gen.autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
687                 hda_nid_t nid;
688                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
689                 nid = ports[tmp];
690                 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
691                                       spec->gen.autocfg.line_outs))
692                         return 1;
693                 spec->gen.autocfg.hp_pins[0] = nid;
694         }
695         return 1;
696 }
697
698 /* Check the validity of ALC subsystem-id
699  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
700 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
701 {
702         if (!alc_subsystem_id(codec, ports)) {
703                 struct alc_spec *spec = codec->spec;
704                 codec_dbg(codec,
705                           "realtek: Enable default setup for auto mode as fallback\n");
706                 spec->init_amp = ALC_INIT_DEFAULT;
707         }
708 }
709
710 /*
711  */
712
713 static void alc_fixup_inv_dmic(struct hda_codec *codec,
714                                const struct hda_fixup *fix, int action)
715 {
716         struct alc_spec *spec = codec->spec;
717
718         spec->gen.inv_dmic_split = 1;
719 }
720
721
722 #ifdef CONFIG_SND_HDA_INPUT_BEEP
723 /* additional beep mixers; the actual parameters are overwritten at build */
724 static const struct snd_kcontrol_new alc_beep_mixer[] = {
725         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
726         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
727         { } /* end */
728 };
729 #endif
730
731 static int alc_build_controls(struct hda_codec *codec)
732 {
733         struct alc_spec *spec = codec->spec;
734         int i, err;
735
736         err = snd_hda_gen_build_controls(codec);
737         if (err < 0)
738                 return err;
739
740         for (i = 0; i < spec->num_mixers; i++) {
741                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
742                 if (err < 0)
743                         return err;
744         }
745
746 #ifdef CONFIG_SND_HDA_INPUT_BEEP
747         /* create beep controls if needed */
748         if (spec->beep_amp) {
749                 const struct snd_kcontrol_new *knew;
750                 for (knew = alc_beep_mixer; knew->name; knew++) {
751                         struct snd_kcontrol *kctl;
752                         kctl = snd_ctl_new1(knew, codec);
753                         if (!kctl)
754                                 return -ENOMEM;
755                         kctl->private_value = spec->beep_amp;
756                         err = snd_hda_ctl_add(codec, 0, kctl);
757                         if (err < 0)
758                                 return err;
759                 }
760         }
761 #endif
762
763         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
764         return 0;
765 }
766
767
768 /*
769  * Common callbacks
770  */
771
772 static int alc_init(struct hda_codec *codec)
773 {
774         struct alc_spec *spec = codec->spec;
775
776         if (spec->init_hook)
777                 spec->init_hook(codec);
778
779         alc_fix_pll(codec);
780         alc_auto_init_amp(codec, spec->init_amp);
781
782         snd_hda_gen_init(codec);
783
784         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
785
786         return 0;
787 }
788
789 static inline void alc_shutup(struct hda_codec *codec)
790 {
791         struct alc_spec *spec = codec->spec;
792
793         if (spec && spec->shutup)
794                 spec->shutup(codec);
795         else
796                 snd_hda_shutup_pins(codec);
797 }
798
799 static void alc_reboot_notify(struct hda_codec *codec)
800 {
801         struct alc_spec *spec = codec->spec;
802
803         if (spec && spec->reboot_notify)
804                 spec->reboot_notify(codec);
805         else
806                 alc_shutup(codec);
807 }
808
809 /* power down codec to D3 at reboot/shutdown; set as reboot_notify ops */
810 static void alc_d3_at_reboot(struct hda_codec *codec)
811 {
812         snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3);
813         snd_hda_codec_write(codec, codec->core.afg, 0,
814                             AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
815         msleep(10);
816 }
817
818 #define alc_free        snd_hda_gen_free
819
820 #ifdef CONFIG_PM
821 static void alc_power_eapd(struct hda_codec *codec)
822 {
823         alc_auto_setup_eapd(codec, false);
824 }
825
826 static int alc_suspend(struct hda_codec *codec)
827 {
828         struct alc_spec *spec = codec->spec;
829         alc_shutup(codec);
830         if (spec && spec->power_hook)
831                 spec->power_hook(codec);
832         return 0;
833 }
834 #endif
835
836 #ifdef CONFIG_PM
837 static int alc_resume(struct hda_codec *codec)
838 {
839         struct alc_spec *spec = codec->spec;
840
841         if (!spec->no_depop_delay)
842                 msleep(150); /* to avoid pop noise */
843         codec->patch_ops.init(codec);
844         regcache_sync(codec->core.regmap);
845         hda_call_check_power_status(codec, 0x01);
846         return 0;
847 }
848 #endif
849
850 /*
851  */
852 static const struct hda_codec_ops alc_patch_ops = {
853         .build_controls = alc_build_controls,
854         .build_pcms = snd_hda_gen_build_pcms,
855         .init = alc_init,
856         .free = alc_free,
857         .unsol_event = snd_hda_jack_unsol_event,
858 #ifdef CONFIG_PM
859         .resume = alc_resume,
860         .suspend = alc_suspend,
861         .check_power_status = snd_hda_gen_check_power_status,
862 #endif
863         .reboot_notify = alc_reboot_notify,
864 };
865
866
867 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
868
869 /*
870  * Rename codecs appropriately from COEF value or subvendor id
871  */
872 struct alc_codec_rename_table {
873         unsigned int vendor_id;
874         unsigned short coef_mask;
875         unsigned short coef_bits;
876         const char *name;
877 };
878
879 struct alc_codec_rename_pci_table {
880         unsigned int codec_vendor_id;
881         unsigned short pci_subvendor;
882         unsigned short pci_subdevice;
883         const char *name;
884 };
885
886 static struct alc_codec_rename_table rename_tbl[] = {
887         { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
888         { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
889         { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
890         { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
891         { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
892         { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
893         { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
894         { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
895         { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
896         { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
897         { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
898         { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
899         { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
900         { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
901         { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
902         { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
903         { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
904         { } /* terminator */
905 };
906
907 static struct alc_codec_rename_pci_table rename_pci_tbl[] = {
908         { 0x10ec0280, 0x1028, 0, "ALC3220" },
909         { 0x10ec0282, 0x1028, 0, "ALC3221" },
910         { 0x10ec0283, 0x1028, 0, "ALC3223" },
911         { 0x10ec0288, 0x1028, 0, "ALC3263" },
912         { 0x10ec0292, 0x1028, 0, "ALC3226" },
913         { 0x10ec0293, 0x1028, 0, "ALC3235" },
914         { 0x10ec0255, 0x1028, 0, "ALC3234" },
915         { 0x10ec0668, 0x1028, 0, "ALC3661" },
916         { 0x10ec0275, 0x1028, 0, "ALC3260" },
917         { 0x10ec0899, 0x1028, 0, "ALC3861" },
918         { 0x10ec0298, 0x1028, 0, "ALC3266" },
919         { 0x10ec0236, 0x1028, 0, "ALC3204" },
920         { 0x10ec0256, 0x1028, 0, "ALC3246" },
921         { 0x10ec0225, 0x1028, 0, "ALC3253" },
922         { 0x10ec0295, 0x1028, 0, "ALC3254" },
923         { 0x10ec0299, 0x1028, 0, "ALC3271" },
924         { 0x10ec0670, 0x1025, 0, "ALC669X" },
925         { 0x10ec0676, 0x1025, 0, "ALC679X" },
926         { 0x10ec0282, 0x1043, 0, "ALC3229" },
927         { 0x10ec0233, 0x1043, 0, "ALC3236" },
928         { 0x10ec0280, 0x103c, 0, "ALC3228" },
929         { 0x10ec0282, 0x103c, 0, "ALC3227" },
930         { 0x10ec0286, 0x103c, 0, "ALC3242" },
931         { 0x10ec0290, 0x103c, 0, "ALC3241" },
932         { 0x10ec0668, 0x103c, 0, "ALC3662" },
933         { 0x10ec0283, 0x17aa, 0, "ALC3239" },
934         { 0x10ec0292, 0x17aa, 0, "ALC3232" },
935         { } /* terminator */
936 };
937
938 static int alc_codec_rename_from_preset(struct hda_codec *codec)
939 {
940         const struct alc_codec_rename_table *p;
941         const struct alc_codec_rename_pci_table *q;
942
943         for (p = rename_tbl; p->vendor_id; p++) {
944                 if (p->vendor_id != codec->core.vendor_id)
945                         continue;
946                 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
947                         return alc_codec_rename(codec, p->name);
948         }
949
950         if (!codec->bus->pci)
951                 return 0;
952         for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
953                 if (q->codec_vendor_id != codec->core.vendor_id)
954                         continue;
955                 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
956                         continue;
957                 if (!q->pci_subdevice ||
958                     q->pci_subdevice == codec->bus->pci->subsystem_device)
959                         return alc_codec_rename(codec, q->name);
960         }
961
962         return 0;
963 }
964
965
966 /*
967  * Digital-beep handlers
968  */
969 #ifdef CONFIG_SND_HDA_INPUT_BEEP
970 #define set_beep_amp(spec, nid, idx, dir) \
971         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
972
973 static const struct snd_pci_quirk beep_white_list[] = {
974         SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
975         SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
976         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
977         SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
978         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
979         SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
980         SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
981         SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
982         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
983         {}
984 };
985
986 static inline int has_cdefine_beep(struct hda_codec *codec)
987 {
988         struct alc_spec *spec = codec->spec;
989         const struct snd_pci_quirk *q;
990         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
991         if (q)
992                 return q->value;
993         return spec->cdefine.enable_pcbeep;
994 }
995 #else
996 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
997 #define has_cdefine_beep(codec)         0
998 #endif
999
1000 /* parse the BIOS configuration and set up the alc_spec */
1001 /* return 1 if successful, 0 if the proper config is not found,
1002  * or a negative error code
1003  */
1004 static int alc_parse_auto_config(struct hda_codec *codec,
1005                                  const hda_nid_t *ignore_nids,
1006                                  const hda_nid_t *ssid_nids)
1007 {
1008         struct alc_spec *spec = codec->spec;
1009         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1010         int err;
1011
1012         err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1013                                        spec->parse_flags);
1014         if (err < 0)
1015                 return err;
1016
1017         if (ssid_nids)
1018                 alc_ssid_check(codec, ssid_nids);
1019
1020         err = snd_hda_gen_parse_auto_config(codec, cfg);
1021         if (err < 0)
1022                 return err;
1023
1024         return 1;
1025 }
1026
1027 /* common preparation job for alc_spec */
1028 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1029 {
1030         struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1031         int err;
1032
1033         if (!spec)
1034                 return -ENOMEM;
1035         codec->spec = spec;
1036         snd_hda_gen_spec_init(&spec->gen);
1037         spec->gen.mixer_nid = mixer_nid;
1038         spec->gen.own_eapd_ctl = 1;
1039         codec->single_adc_amp = 1;
1040         /* FIXME: do we need this for all Realtek codec models? */
1041         codec->spdif_status_reset = 1;
1042         codec->patch_ops = alc_patch_ops;
1043
1044         err = alc_codec_rename_from_preset(codec);
1045         if (err < 0) {
1046                 kfree(spec);
1047                 return err;
1048         }
1049         return 0;
1050 }
1051
1052 static int alc880_parse_auto_config(struct hda_codec *codec)
1053 {
1054         static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1055         static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1056         return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1057 }
1058
1059 /*
1060  * ALC880 fix-ups
1061  */
1062 enum {
1063         ALC880_FIXUP_GPIO1,
1064         ALC880_FIXUP_GPIO2,
1065         ALC880_FIXUP_MEDION_RIM,
1066         ALC880_FIXUP_LG,
1067         ALC880_FIXUP_LG_LW25,
1068         ALC880_FIXUP_W810,
1069         ALC880_FIXUP_EAPD_COEF,
1070         ALC880_FIXUP_TCL_S700,
1071         ALC880_FIXUP_VOL_KNOB,
1072         ALC880_FIXUP_FUJITSU,
1073         ALC880_FIXUP_F1734,
1074         ALC880_FIXUP_UNIWILL,
1075         ALC880_FIXUP_UNIWILL_DIG,
1076         ALC880_FIXUP_Z71V,
1077         ALC880_FIXUP_ASUS_W5A,
1078         ALC880_FIXUP_3ST_BASE,
1079         ALC880_FIXUP_3ST,
1080         ALC880_FIXUP_3ST_DIG,
1081         ALC880_FIXUP_5ST_BASE,
1082         ALC880_FIXUP_5ST,
1083         ALC880_FIXUP_5ST_DIG,
1084         ALC880_FIXUP_6ST_BASE,
1085         ALC880_FIXUP_6ST,
1086         ALC880_FIXUP_6ST_DIG,
1087         ALC880_FIXUP_6ST_AUTOMUTE,
1088 };
1089
1090 /* enable the volume-knob widget support on NID 0x21 */
1091 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1092                                   const struct hda_fixup *fix, int action)
1093 {
1094         if (action == HDA_FIXUP_ACT_PROBE)
1095                 snd_hda_jack_detect_enable_callback(codec, 0x21,
1096                                                     alc_update_knob_master);
1097 }
1098
1099 static const struct hda_fixup alc880_fixups[] = {
1100         [ALC880_FIXUP_GPIO1] = {
1101                 .type = HDA_FIXUP_VERBS,
1102                 .v.verbs = alc_gpio1_init_verbs,
1103         },
1104         [ALC880_FIXUP_GPIO2] = {
1105                 .type = HDA_FIXUP_VERBS,
1106                 .v.verbs = alc_gpio2_init_verbs,
1107         },
1108         [ALC880_FIXUP_MEDION_RIM] = {
1109                 .type = HDA_FIXUP_VERBS,
1110                 .v.verbs = (const struct hda_verb[]) {
1111                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1112                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1113                         { }
1114                 },
1115                 .chained = true,
1116                 .chain_id = ALC880_FIXUP_GPIO2,
1117         },
1118         [ALC880_FIXUP_LG] = {
1119                 .type = HDA_FIXUP_PINS,
1120                 .v.pins = (const struct hda_pintbl[]) {
1121                         /* disable bogus unused pins */
1122                         { 0x16, 0x411111f0 },
1123                         { 0x18, 0x411111f0 },
1124                         { 0x1a, 0x411111f0 },
1125                         { }
1126                 }
1127         },
1128         [ALC880_FIXUP_LG_LW25] = {
1129                 .type = HDA_FIXUP_PINS,
1130                 .v.pins = (const struct hda_pintbl[]) {
1131                         { 0x1a, 0x0181344f }, /* line-in */
1132                         { 0x1b, 0x0321403f }, /* headphone */
1133                         { }
1134                 }
1135         },
1136         [ALC880_FIXUP_W810] = {
1137                 .type = HDA_FIXUP_PINS,
1138                 .v.pins = (const struct hda_pintbl[]) {
1139                         /* disable bogus unused pins */
1140                         { 0x17, 0x411111f0 },
1141                         { }
1142                 },
1143                 .chained = true,
1144                 .chain_id = ALC880_FIXUP_GPIO2,
1145         },
1146         [ALC880_FIXUP_EAPD_COEF] = {
1147                 .type = HDA_FIXUP_VERBS,
1148                 .v.verbs = (const struct hda_verb[]) {
1149                         /* change to EAPD mode */
1150                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1151                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1152                         {}
1153                 },
1154         },
1155         [ALC880_FIXUP_TCL_S700] = {
1156                 .type = HDA_FIXUP_VERBS,
1157                 .v.verbs = (const struct hda_verb[]) {
1158                         /* change to EAPD mode */
1159                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1160                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
1161                         {}
1162                 },
1163                 .chained = true,
1164                 .chain_id = ALC880_FIXUP_GPIO2,
1165         },
1166         [ALC880_FIXUP_VOL_KNOB] = {
1167                 .type = HDA_FIXUP_FUNC,
1168                 .v.func = alc880_fixup_vol_knob,
1169         },
1170         [ALC880_FIXUP_FUJITSU] = {
1171                 /* override all pins as BIOS on old Amilo is broken */
1172                 .type = HDA_FIXUP_PINS,
1173                 .v.pins = (const struct hda_pintbl[]) {
1174                         { 0x14, 0x0121401f }, /* HP */
1175                         { 0x15, 0x99030120 }, /* speaker */
1176                         { 0x16, 0x99030130 }, /* bass speaker */
1177                         { 0x17, 0x411111f0 }, /* N/A */
1178                         { 0x18, 0x411111f0 }, /* N/A */
1179                         { 0x19, 0x01a19950 }, /* mic-in */
1180                         { 0x1a, 0x411111f0 }, /* N/A */
1181                         { 0x1b, 0x411111f0 }, /* N/A */
1182                         { 0x1c, 0x411111f0 }, /* N/A */
1183                         { 0x1d, 0x411111f0 }, /* N/A */
1184                         { 0x1e, 0x01454140 }, /* SPDIF out */
1185                         { }
1186                 },
1187                 .chained = true,
1188                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1189         },
1190         [ALC880_FIXUP_F1734] = {
1191                 /* almost compatible with FUJITSU, but no bass and SPDIF */
1192                 .type = HDA_FIXUP_PINS,
1193                 .v.pins = (const struct hda_pintbl[]) {
1194                         { 0x14, 0x0121401f }, /* HP */
1195                         { 0x15, 0x99030120 }, /* speaker */
1196                         { 0x16, 0x411111f0 }, /* N/A */
1197                         { 0x17, 0x411111f0 }, /* N/A */
1198                         { 0x18, 0x411111f0 }, /* N/A */
1199                         { 0x19, 0x01a19950 }, /* mic-in */
1200                         { 0x1a, 0x411111f0 }, /* N/A */
1201                         { 0x1b, 0x411111f0 }, /* N/A */
1202                         { 0x1c, 0x411111f0 }, /* N/A */
1203                         { 0x1d, 0x411111f0 }, /* N/A */
1204                         { 0x1e, 0x411111f0 }, /* N/A */
1205                         { }
1206                 },
1207                 .chained = true,
1208                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1209         },
1210         [ALC880_FIXUP_UNIWILL] = {
1211                 /* need to fix HP and speaker pins to be parsed correctly */
1212                 .type = HDA_FIXUP_PINS,
1213                 .v.pins = (const struct hda_pintbl[]) {
1214                         { 0x14, 0x0121411f }, /* HP */
1215                         { 0x15, 0x99030120 }, /* speaker */
1216                         { 0x16, 0x99030130 }, /* bass speaker */
1217                         { }
1218                 },
1219         },
1220         [ALC880_FIXUP_UNIWILL_DIG] = {
1221                 .type = HDA_FIXUP_PINS,
1222                 .v.pins = (const struct hda_pintbl[]) {
1223                         /* disable bogus unused pins */
1224                         { 0x17, 0x411111f0 },
1225                         { 0x19, 0x411111f0 },
1226                         { 0x1b, 0x411111f0 },
1227                         { 0x1f, 0x411111f0 },
1228                         { }
1229                 }
1230         },
1231         [ALC880_FIXUP_Z71V] = {
1232                 .type = HDA_FIXUP_PINS,
1233                 .v.pins = (const struct hda_pintbl[]) {
1234                         /* set up the whole pins as BIOS is utterly broken */
1235                         { 0x14, 0x99030120 }, /* speaker */
1236                         { 0x15, 0x0121411f }, /* HP */
1237                         { 0x16, 0x411111f0 }, /* N/A */
1238                         { 0x17, 0x411111f0 }, /* N/A */
1239                         { 0x18, 0x01a19950 }, /* mic-in */
1240                         { 0x19, 0x411111f0 }, /* N/A */
1241                         { 0x1a, 0x01813031 }, /* line-in */
1242                         { 0x1b, 0x411111f0 }, /* N/A */
1243                         { 0x1c, 0x411111f0 }, /* N/A */
1244                         { 0x1d, 0x411111f0 }, /* N/A */
1245                         { 0x1e, 0x0144111e }, /* SPDIF */
1246                         { }
1247                 }
1248         },
1249         [ALC880_FIXUP_ASUS_W5A] = {
1250                 .type = HDA_FIXUP_PINS,
1251                 .v.pins = (const struct hda_pintbl[]) {
1252                         /* set up the whole pins as BIOS is utterly broken */
1253                         { 0x14, 0x0121411f }, /* HP */
1254                         { 0x15, 0x411111f0 }, /* N/A */
1255                         { 0x16, 0x411111f0 }, /* N/A */
1256                         { 0x17, 0x411111f0 }, /* N/A */
1257                         { 0x18, 0x90a60160 }, /* mic */
1258                         { 0x19, 0x411111f0 }, /* N/A */
1259                         { 0x1a, 0x411111f0 }, /* N/A */
1260                         { 0x1b, 0x411111f0 }, /* N/A */
1261                         { 0x1c, 0x411111f0 }, /* N/A */
1262                         { 0x1d, 0x411111f0 }, /* N/A */
1263                         { 0x1e, 0xb743111e }, /* SPDIF out */
1264                         { }
1265                 },
1266                 .chained = true,
1267                 .chain_id = ALC880_FIXUP_GPIO1,
1268         },
1269         [ALC880_FIXUP_3ST_BASE] = {
1270                 .type = HDA_FIXUP_PINS,
1271                 .v.pins = (const struct hda_pintbl[]) {
1272                         { 0x14, 0x01014010 }, /* line-out */
1273                         { 0x15, 0x411111f0 }, /* N/A */
1274                         { 0x16, 0x411111f0 }, /* N/A */
1275                         { 0x17, 0x411111f0 }, /* N/A */
1276                         { 0x18, 0x01a19c30 }, /* mic-in */
1277                         { 0x19, 0x0121411f }, /* HP */
1278                         { 0x1a, 0x01813031 }, /* line-in */
1279                         { 0x1b, 0x02a19c40 }, /* front-mic */
1280                         { 0x1c, 0x411111f0 }, /* N/A */
1281                         { 0x1d, 0x411111f0 }, /* N/A */
1282                         /* 0x1e is filled in below */
1283                         { 0x1f, 0x411111f0 }, /* N/A */
1284                         { }
1285                 }
1286         },
1287         [ALC880_FIXUP_3ST] = {
1288                 .type = HDA_FIXUP_PINS,
1289                 .v.pins = (const struct hda_pintbl[]) {
1290                         { 0x1e, 0x411111f0 }, /* N/A */
1291                         { }
1292                 },
1293                 .chained = true,
1294                 .chain_id = ALC880_FIXUP_3ST_BASE,
1295         },
1296         [ALC880_FIXUP_3ST_DIG] = {
1297                 .type = HDA_FIXUP_PINS,
1298                 .v.pins = (const struct hda_pintbl[]) {
1299                         { 0x1e, 0x0144111e }, /* SPDIF */
1300                         { }
1301                 },
1302                 .chained = true,
1303                 .chain_id = ALC880_FIXUP_3ST_BASE,
1304         },
1305         [ALC880_FIXUP_5ST_BASE] = {
1306                 .type = HDA_FIXUP_PINS,
1307                 .v.pins = (const struct hda_pintbl[]) {
1308                         { 0x14, 0x01014010 }, /* front */
1309                         { 0x15, 0x411111f0 }, /* N/A */
1310                         { 0x16, 0x01011411 }, /* CLFE */
1311                         { 0x17, 0x01016412 }, /* surr */
1312                         { 0x18, 0x01a19c30 }, /* mic-in */
1313                         { 0x19, 0x0121411f }, /* HP */
1314                         { 0x1a, 0x01813031 }, /* line-in */
1315                         { 0x1b, 0x02a19c40 }, /* front-mic */
1316                         { 0x1c, 0x411111f0 }, /* N/A */
1317                         { 0x1d, 0x411111f0 }, /* N/A */
1318                         /* 0x1e is filled in below */
1319                         { 0x1f, 0x411111f0 }, /* N/A */
1320                         { }
1321                 }
1322         },
1323         [ALC880_FIXUP_5ST] = {
1324                 .type = HDA_FIXUP_PINS,
1325                 .v.pins = (const struct hda_pintbl[]) {
1326                         { 0x1e, 0x411111f0 }, /* N/A */
1327                         { }
1328                 },
1329                 .chained = true,
1330                 .chain_id = ALC880_FIXUP_5ST_BASE,
1331         },
1332         [ALC880_FIXUP_5ST_DIG] = {
1333                 .type = HDA_FIXUP_PINS,
1334                 .v.pins = (const struct hda_pintbl[]) {
1335                         { 0x1e, 0x0144111e }, /* SPDIF */
1336                         { }
1337                 },
1338                 .chained = true,
1339                 .chain_id = ALC880_FIXUP_5ST_BASE,
1340         },
1341         [ALC880_FIXUP_6ST_BASE] = {
1342                 .type = HDA_FIXUP_PINS,
1343                 .v.pins = (const struct hda_pintbl[]) {
1344                         { 0x14, 0x01014010 }, /* front */
1345                         { 0x15, 0x01016412 }, /* surr */
1346                         { 0x16, 0x01011411 }, /* CLFE */
1347                         { 0x17, 0x01012414 }, /* side */
1348                         { 0x18, 0x01a19c30 }, /* mic-in */
1349                         { 0x19, 0x02a19c40 }, /* front-mic */
1350                         { 0x1a, 0x01813031 }, /* line-in */
1351                         { 0x1b, 0x0121411f }, /* HP */
1352                         { 0x1c, 0x411111f0 }, /* N/A */
1353                         { 0x1d, 0x411111f0 }, /* N/A */
1354                         /* 0x1e is filled in below */
1355                         { 0x1f, 0x411111f0 }, /* N/A */
1356                         { }
1357                 }
1358         },
1359         [ALC880_FIXUP_6ST] = {
1360                 .type = HDA_FIXUP_PINS,
1361                 .v.pins = (const struct hda_pintbl[]) {
1362                         { 0x1e, 0x411111f0 }, /* N/A */
1363                         { }
1364                 },
1365                 .chained = true,
1366                 .chain_id = ALC880_FIXUP_6ST_BASE,
1367         },
1368         [ALC880_FIXUP_6ST_DIG] = {
1369                 .type = HDA_FIXUP_PINS,
1370                 .v.pins = (const struct hda_pintbl[]) {
1371                         { 0x1e, 0x0144111e }, /* SPDIF */
1372                         { }
1373                 },
1374                 .chained = true,
1375                 .chain_id = ALC880_FIXUP_6ST_BASE,
1376         },
1377         [ALC880_FIXUP_6ST_AUTOMUTE] = {
1378                 .type = HDA_FIXUP_PINS,
1379                 .v.pins = (const struct hda_pintbl[]) {
1380                         { 0x1b, 0x0121401f }, /* HP with jack detect */
1381                         { }
1382                 },
1383                 .chained_before = true,
1384                 .chain_id = ALC880_FIXUP_6ST_BASE,
1385         },
1386 };
1387
1388 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1389         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1390         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1391         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1392         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1393         SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1394         SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1395         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1396         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1397         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1398         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1399         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1400         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1401         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1402         SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1403         SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1404         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1405         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1406         SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1407         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1408         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1409         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1410         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1411         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1412
1413         /* Below is the copied entries from alc880_quirks.c.
1414          * It's not quite sure whether BIOS sets the correct pin-config table
1415          * on these machines, thus they are kept to be compatible with
1416          * the old static quirks.  Once when it's confirmed to work without
1417          * these overrides, it'd be better to remove.
1418          */
1419         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1420         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1421         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1422         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1423         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1424         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1425         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1426         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1427         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1428         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1429         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1430         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1431         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1432         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1433         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1434         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1435         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1436         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1437         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1438         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1439         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1440         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1441         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1442         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1443         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1444         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1445         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1446         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1447         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1448         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1449         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1450         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1451         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1452         /* default Intel */
1453         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1454         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1455         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1456         {}
1457 };
1458
1459 static const struct hda_model_fixup alc880_fixup_models[] = {
1460         {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1461         {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1462         {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1463         {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1464         {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1465         {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1466         {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1467         {}
1468 };
1469
1470
1471 /*
1472  * OK, here we have finally the patch for ALC880
1473  */
1474 static int patch_alc880(struct hda_codec *codec)
1475 {
1476         struct alc_spec *spec;
1477         int err;
1478
1479         err = alc_alloc_spec(codec, 0x0b);
1480         if (err < 0)
1481                 return err;
1482
1483         spec = codec->spec;
1484         spec->gen.need_dac_fix = 1;
1485         spec->gen.beep_nid = 0x01;
1486
1487         codec->patch_ops.unsol_event = alc880_unsol_event;
1488
1489         snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1490                        alc880_fixups);
1491         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1492
1493         /* automatic parse from the BIOS config */
1494         err = alc880_parse_auto_config(codec);
1495         if (err < 0)
1496                 goto error;
1497
1498         if (!spec->gen.no_analog)
1499                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1500
1501         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1502
1503         return 0;
1504
1505  error:
1506         alc_free(codec);
1507         return err;
1508 }
1509
1510
1511 /*
1512  * ALC260 support
1513  */
1514 static int alc260_parse_auto_config(struct hda_codec *codec)
1515 {
1516         static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1517         static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1518         return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1519 }
1520
1521 /*
1522  * Pin config fixes
1523  */
1524 enum {
1525         ALC260_FIXUP_HP_DC5750,
1526         ALC260_FIXUP_HP_PIN_0F,
1527         ALC260_FIXUP_COEF,
1528         ALC260_FIXUP_GPIO1,
1529         ALC260_FIXUP_GPIO1_TOGGLE,
1530         ALC260_FIXUP_REPLACER,
1531         ALC260_FIXUP_HP_B1900,
1532         ALC260_FIXUP_KN1,
1533         ALC260_FIXUP_FSC_S7020,
1534         ALC260_FIXUP_FSC_S7020_JWSE,
1535         ALC260_FIXUP_VAIO_PINS,
1536 };
1537
1538 static void alc260_gpio1_automute(struct hda_codec *codec)
1539 {
1540         struct alc_spec *spec = codec->spec;
1541         snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1542                             spec->gen.hp_jack_present);
1543 }
1544
1545 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1546                                       const struct hda_fixup *fix, int action)
1547 {
1548         struct alc_spec *spec = codec->spec;
1549         if (action == HDA_FIXUP_ACT_PROBE) {
1550                 /* although the machine has only one output pin, we need to
1551                  * toggle GPIO1 according to the jack state
1552                  */
1553                 spec->gen.automute_hook = alc260_gpio1_automute;
1554                 spec->gen.detect_hp = 1;
1555                 spec->gen.automute_speaker = 1;
1556                 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1557                 snd_hda_jack_detect_enable_callback(codec, 0x0f,
1558                                                     snd_hda_gen_hp_automute);
1559                 snd_hda_add_verbs(codec, alc_gpio1_init_verbs);
1560         }
1561 }
1562
1563 static void alc260_fixup_kn1(struct hda_codec *codec,
1564                              const struct hda_fixup *fix, int action)
1565 {
1566         struct alc_spec *spec = codec->spec;
1567         static const struct hda_pintbl pincfgs[] = {
1568                 { 0x0f, 0x02214000 }, /* HP/speaker */
1569                 { 0x12, 0x90a60160 }, /* int mic */
1570                 { 0x13, 0x02a19000 }, /* ext mic */
1571                 { 0x18, 0x01446000 }, /* SPDIF out */
1572                 /* disable bogus I/O pins */
1573                 { 0x10, 0x411111f0 },
1574                 { 0x11, 0x411111f0 },
1575                 { 0x14, 0x411111f0 },
1576                 { 0x15, 0x411111f0 },
1577                 { 0x16, 0x411111f0 },
1578                 { 0x17, 0x411111f0 },
1579                 { 0x19, 0x411111f0 },
1580                 { }
1581         };
1582
1583         switch (action) {
1584         case HDA_FIXUP_ACT_PRE_PROBE:
1585                 snd_hda_apply_pincfgs(codec, pincfgs);
1586                 break;
1587         case HDA_FIXUP_ACT_PROBE:
1588                 spec->init_amp = ALC_INIT_NONE;
1589                 break;
1590         }
1591 }
1592
1593 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1594                                    const struct hda_fixup *fix, int action)
1595 {
1596         struct alc_spec *spec = codec->spec;
1597         if (action == HDA_FIXUP_ACT_PROBE)
1598                 spec->init_amp = ALC_INIT_NONE;
1599 }
1600
1601 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1602                                    const struct hda_fixup *fix, int action)
1603 {
1604         struct alc_spec *spec = codec->spec;
1605         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1606                 spec->gen.add_jack_modes = 1;
1607                 spec->gen.hp_mic = 1;
1608         }
1609 }
1610
1611 static const struct hda_fixup alc260_fixups[] = {
1612         [ALC260_FIXUP_HP_DC5750] = {
1613                 .type = HDA_FIXUP_PINS,
1614                 .v.pins = (const struct hda_pintbl[]) {
1615                         { 0x11, 0x90130110 }, /* speaker */
1616                         { }
1617                 }
1618         },
1619         [ALC260_FIXUP_HP_PIN_0F] = {
1620                 .type = HDA_FIXUP_PINS,
1621                 .v.pins = (const struct hda_pintbl[]) {
1622                         { 0x0f, 0x01214000 }, /* HP */
1623                         { }
1624                 }
1625         },
1626         [ALC260_FIXUP_COEF] = {
1627                 .type = HDA_FIXUP_VERBS,
1628                 .v.verbs = (const struct hda_verb[]) {
1629                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1630                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3040 },
1631                         { }
1632                 },
1633         },
1634         [ALC260_FIXUP_GPIO1] = {
1635                 .type = HDA_FIXUP_VERBS,
1636                 .v.verbs = alc_gpio1_init_verbs,
1637         },
1638         [ALC260_FIXUP_GPIO1_TOGGLE] = {
1639                 .type = HDA_FIXUP_FUNC,
1640                 .v.func = alc260_fixup_gpio1_toggle,
1641                 .chained = true,
1642                 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1643         },
1644         [ALC260_FIXUP_REPLACER] = {
1645                 .type = HDA_FIXUP_VERBS,
1646                 .v.verbs = (const struct hda_verb[]) {
1647                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1648                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3050 },
1649                         { }
1650                 },
1651                 .chained = true,
1652                 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1653         },
1654         [ALC260_FIXUP_HP_B1900] = {
1655                 .type = HDA_FIXUP_FUNC,
1656                 .v.func = alc260_fixup_gpio1_toggle,
1657                 .chained = true,
1658                 .chain_id = ALC260_FIXUP_COEF,
1659         },
1660         [ALC260_FIXUP_KN1] = {
1661                 .type = HDA_FIXUP_FUNC,
1662                 .v.func = alc260_fixup_kn1,
1663         },
1664         [ALC260_FIXUP_FSC_S7020] = {
1665                 .type = HDA_FIXUP_FUNC,
1666                 .v.func = alc260_fixup_fsc_s7020,
1667         },
1668         [ALC260_FIXUP_FSC_S7020_JWSE] = {
1669                 .type = HDA_FIXUP_FUNC,
1670                 .v.func = alc260_fixup_fsc_s7020_jwse,
1671                 .chained = true,
1672                 .chain_id = ALC260_FIXUP_FSC_S7020,
1673         },
1674         [ALC260_FIXUP_VAIO_PINS] = {
1675                 .type = HDA_FIXUP_PINS,
1676                 .v.pins = (const struct hda_pintbl[]) {
1677                         /* Pin configs are missing completely on some VAIOs */
1678                         { 0x0f, 0x01211020 },
1679                         { 0x10, 0x0001003f },
1680                         { 0x11, 0x411111f0 },
1681                         { 0x12, 0x01a15930 },
1682                         { 0x13, 0x411111f0 },
1683                         { 0x14, 0x411111f0 },
1684                         { 0x15, 0x411111f0 },
1685                         { 0x16, 0x411111f0 },
1686                         { 0x17, 0x411111f0 },
1687                         { 0x18, 0x411111f0 },
1688                         { 0x19, 0x411111f0 },
1689                         { }
1690                 }
1691         },
1692 };
1693
1694 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1695         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1696         SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1697         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1698         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1699         SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1700         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1701         SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1702         SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1703         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1704         SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1705         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1706         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1707         {}
1708 };
1709
1710 static const struct hda_model_fixup alc260_fixup_models[] = {
1711         {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1712         {.id = ALC260_FIXUP_COEF, .name = "coef"},
1713         {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1714         {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1715         {}
1716 };
1717
1718 /*
1719  */
1720 static int patch_alc260(struct hda_codec *codec)
1721 {
1722         struct alc_spec *spec;
1723         int err;
1724
1725         err = alc_alloc_spec(codec, 0x07);
1726         if (err < 0)
1727                 return err;
1728
1729         spec = codec->spec;
1730         /* as quite a few machines require HP amp for speaker outputs,
1731          * it's easier to enable it unconditionally; even if it's unneeded,
1732          * it's almost harmless.
1733          */
1734         spec->gen.prefer_hp_amp = 1;
1735         spec->gen.beep_nid = 0x01;
1736
1737         spec->shutup = alc_eapd_shutup;
1738
1739         snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1740                            alc260_fixups);
1741         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1742
1743         /* automatic parse from the BIOS config */
1744         err = alc260_parse_auto_config(codec);
1745         if (err < 0)
1746                 goto error;
1747
1748         if (!spec->gen.no_analog)
1749                 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1750
1751         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1752
1753         return 0;
1754
1755  error:
1756         alc_free(codec);
1757         return err;
1758 }
1759
1760
1761 /*
1762  * ALC882/883/885/888/889 support
1763  *
1764  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1765  * configuration.  Each pin widget can choose any input DACs and a mixer.
1766  * Each ADC is connected from a mixer of all inputs.  This makes possible
1767  * 6-channel independent captures.
1768  *
1769  * In addition, an independent DAC for the multi-playback (not used in this
1770  * driver yet).
1771  */
1772
1773 /*
1774  * Pin config fixes
1775  */
1776 enum {
1777         ALC882_FIXUP_ABIT_AW9D_MAX,
1778         ALC882_FIXUP_LENOVO_Y530,
1779         ALC882_FIXUP_PB_M5210,
1780         ALC882_FIXUP_ACER_ASPIRE_7736,
1781         ALC882_FIXUP_ASUS_W90V,
1782         ALC889_FIXUP_CD,
1783         ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1784         ALC889_FIXUP_VAIO_TT,
1785         ALC888_FIXUP_EEE1601,
1786         ALC882_FIXUP_EAPD,
1787         ALC883_FIXUP_EAPD,
1788         ALC883_FIXUP_ACER_EAPD,
1789         ALC882_FIXUP_GPIO1,
1790         ALC882_FIXUP_GPIO2,
1791         ALC882_FIXUP_GPIO3,
1792         ALC889_FIXUP_COEF,
1793         ALC882_FIXUP_ASUS_W2JC,
1794         ALC882_FIXUP_ACER_ASPIRE_4930G,
1795         ALC882_FIXUP_ACER_ASPIRE_8930G,
1796         ALC882_FIXUP_ASPIRE_8930G_VERBS,
1797         ALC885_FIXUP_MACPRO_GPIO,
1798         ALC889_FIXUP_DAC_ROUTE,
1799         ALC889_FIXUP_MBP_VREF,
1800         ALC889_FIXUP_IMAC91_VREF,
1801         ALC889_FIXUP_MBA11_VREF,
1802         ALC889_FIXUP_MBA21_VREF,
1803         ALC889_FIXUP_MP11_VREF,
1804         ALC889_FIXUP_MP41_VREF,
1805         ALC882_FIXUP_INV_DMIC,
1806         ALC882_FIXUP_NO_PRIMARY_HP,
1807         ALC887_FIXUP_ASUS_BASS,
1808         ALC887_FIXUP_BASS_CHMAP,
1809         ALC1220_FIXUP_GB_DUAL_CODECS,
1810         ALC1220_FIXUP_CLEVO_P950,
1811 };
1812
1813 static void alc889_fixup_coef(struct hda_codec *codec,
1814                               const struct hda_fixup *fix, int action)
1815 {
1816         if (action != HDA_FIXUP_ACT_INIT)
1817                 return;
1818         alc_update_coef_idx(codec, 7, 0, 0x2030);
1819 }
1820
1821 /* toggle speaker-output according to the hp-jack state */
1822 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
1823 {
1824         unsigned int gpiostate, gpiomask, gpiodir;
1825
1826         gpiostate = snd_hda_codec_read(codec, codec->core.afg, 0,
1827                                        AC_VERB_GET_GPIO_DATA, 0);
1828
1829         if (!muted)
1830                 gpiostate |= (1 << pin);
1831         else
1832                 gpiostate &= ~(1 << pin);
1833
1834         gpiomask = snd_hda_codec_read(codec, codec->core.afg, 0,
1835                                       AC_VERB_GET_GPIO_MASK, 0);
1836         gpiomask |= (1 << pin);
1837
1838         gpiodir = snd_hda_codec_read(codec, codec->core.afg, 0,
1839                                      AC_VERB_GET_GPIO_DIRECTION, 0);
1840         gpiodir |= (1 << pin);
1841
1842
1843         snd_hda_codec_write(codec, codec->core.afg, 0,
1844                             AC_VERB_SET_GPIO_MASK, gpiomask);
1845         snd_hda_codec_write(codec, codec->core.afg, 0,
1846                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
1847
1848         msleep(1);
1849
1850         snd_hda_codec_write(codec, codec->core.afg, 0,
1851                             AC_VERB_SET_GPIO_DATA, gpiostate);
1852 }
1853
1854 /* set up GPIO at initialization */
1855 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
1856                                      const struct hda_fixup *fix, int action)
1857 {
1858         if (action != HDA_FIXUP_ACT_INIT)
1859                 return;
1860         alc882_gpio_mute(codec, 0, 0);
1861         alc882_gpio_mute(codec, 1, 0);
1862 }
1863
1864 /* Fix the connection of some pins for ALC889:
1865  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
1866  * work correctly (bko#42740)
1867  */
1868 static void alc889_fixup_dac_route(struct hda_codec *codec,
1869                                    const struct hda_fixup *fix, int action)
1870 {
1871         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1872                 /* fake the connections during parsing the tree */
1873                 hda_nid_t conn1[2] = { 0x0c, 0x0d };
1874                 hda_nid_t conn2[2] = { 0x0e, 0x0f };
1875                 snd_hda_override_conn_list(codec, 0x14, 2, conn1);
1876                 snd_hda_override_conn_list(codec, 0x15, 2, conn1);
1877                 snd_hda_override_conn_list(codec, 0x18, 2, conn2);
1878                 snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
1879         } else if (action == HDA_FIXUP_ACT_PROBE) {
1880                 /* restore the connections */
1881                 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
1882                 snd_hda_override_conn_list(codec, 0x14, 5, conn);
1883                 snd_hda_override_conn_list(codec, 0x15, 5, conn);
1884                 snd_hda_override_conn_list(codec, 0x18, 5, conn);
1885                 snd_hda_override_conn_list(codec, 0x1a, 5, conn);
1886         }
1887 }
1888
1889 /* Set VREF on HP pin */
1890 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
1891                                   const struct hda_fixup *fix, int action)
1892 {
1893         struct alc_spec *spec = codec->spec;
1894         static hda_nid_t nids[3] = { 0x14, 0x15, 0x19 };
1895         int i;
1896
1897         if (action != HDA_FIXUP_ACT_INIT)
1898                 return;
1899         for (i = 0; i < ARRAY_SIZE(nids); i++) {
1900                 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
1901                 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
1902                         continue;
1903                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1904                 val |= AC_PINCTL_VREF_80;
1905                 snd_hda_set_pin_ctl(codec, nids[i], val);
1906                 spec->gen.keep_vref_in_automute = 1;
1907                 break;
1908         }
1909 }
1910
1911 static void alc889_fixup_mac_pins(struct hda_codec *codec,
1912                                   const hda_nid_t *nids, int num_nids)
1913 {
1914         struct alc_spec *spec = codec->spec;
1915         int i;
1916
1917         for (i = 0; i < num_nids; i++) {
1918                 unsigned int val;
1919                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1920                 val |= AC_PINCTL_VREF_50;
1921                 snd_hda_set_pin_ctl(codec, nids[i], val);
1922         }
1923         spec->gen.keep_vref_in_automute = 1;
1924 }
1925
1926 /* Set VREF on speaker pins on imac91 */
1927 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
1928                                      const struct hda_fixup *fix, int action)
1929 {
1930         static hda_nid_t nids[2] = { 0x18, 0x1a };
1931
1932         if (action == HDA_FIXUP_ACT_INIT)
1933                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1934 }
1935
1936 /* Set VREF on speaker pins on mba11 */
1937 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
1938                                     const struct hda_fixup *fix, int action)
1939 {
1940         static hda_nid_t nids[1] = { 0x18 };
1941
1942         if (action == HDA_FIXUP_ACT_INIT)
1943                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1944 }
1945
1946 /* Set VREF on speaker pins on mba21 */
1947 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
1948                                     const struct hda_fixup *fix, int action)
1949 {
1950         static hda_nid_t nids[2] = { 0x18, 0x19 };
1951
1952         if (action == HDA_FIXUP_ACT_INIT)
1953                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1954 }
1955
1956 /* Don't take HP output as primary
1957  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
1958  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
1959  */
1960 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
1961                                        const struct hda_fixup *fix, int action)
1962 {
1963         struct alc_spec *spec = codec->spec;
1964         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1965                 spec->gen.no_primary_hp = 1;
1966                 spec->gen.no_multi_io = 1;
1967         }
1968 }
1969
1970 static void alc_fixup_bass_chmap(struct hda_codec *codec,
1971                                  const struct hda_fixup *fix, int action);
1972
1973 /* For dual-codec configuration, we need to disable some features to avoid
1974  * conflicts of kctls and PCM streams
1975  */
1976 static void alc_fixup_dual_codecs(struct hda_codec *codec,
1977                                   const struct hda_fixup *fix, int action)
1978 {
1979         struct alc_spec *spec = codec->spec;
1980
1981         if (action != HDA_FIXUP_ACT_PRE_PROBE)
1982                 return;
1983         /* disable vmaster */
1984         spec->gen.suppress_vmaster = 1;
1985         /* auto-mute and auto-mic switch don't work with multiple codecs */
1986         spec->gen.suppress_auto_mute = 1;
1987         spec->gen.suppress_auto_mic = 1;
1988         /* disable aamix as well */
1989         spec->gen.mixer_nid = 0;
1990         /* add location prefix to avoid conflicts */
1991         codec->force_pin_prefix = 1;
1992 }
1993
1994 static void rename_ctl(struct hda_codec *codec, const char *oldname,
1995                        const char *newname)
1996 {
1997         struct snd_kcontrol *kctl;
1998
1999         kctl = snd_hda_find_mixer_ctl(codec, oldname);
2000         if (kctl)
2001                 strcpy(kctl->id.name, newname);
2002 }
2003
2004 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2005                                          const struct hda_fixup *fix,
2006                                          int action)
2007 {
2008         alc_fixup_dual_codecs(codec, fix, action);
2009         switch (action) {
2010         case HDA_FIXUP_ACT_PRE_PROBE:
2011                 /* override card longname to provide a unique UCM profile */
2012                 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2013                 break;
2014         case HDA_FIXUP_ACT_BUILD:
2015                 /* rename Capture controls depending on the codec */
2016                 rename_ctl(codec, "Capture Volume",
2017                            codec->addr == 0 ?
2018                            "Rear-Panel Capture Volume" :
2019                            "Front-Panel Capture Volume");
2020                 rename_ctl(codec, "Capture Switch",
2021                            codec->addr == 0 ?
2022                            "Rear-Panel Capture Switch" :
2023                            "Front-Panel Capture Switch");
2024                 break;
2025         }
2026 }
2027
2028 static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2029                                      const struct hda_fixup *fix,
2030                                      int action)
2031 {
2032         hda_nid_t conn1[1] = { 0x0c };
2033
2034         if (action != HDA_FIXUP_ACT_PRE_PROBE)
2035                 return;
2036
2037         alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2038         /* We therefore want to make sure 0x14 (front headphone) and
2039          * 0x1b (speakers) use the stereo DAC 0x02
2040          */
2041         snd_hda_override_conn_list(codec, 0x14, 1, conn1);
2042         snd_hda_override_conn_list(codec, 0x1b, 1, conn1);
2043 }
2044
2045 static const struct hda_fixup alc882_fixups[] = {
2046         [ALC882_FIXUP_ABIT_AW9D_MAX] = {
2047                 .type = HDA_FIXUP_PINS,
2048                 .v.pins = (const struct hda_pintbl[]) {
2049                         { 0x15, 0x01080104 }, /* side */
2050                         { 0x16, 0x01011012 }, /* rear */
2051                         { 0x17, 0x01016011 }, /* clfe */
2052                         { }
2053                 }
2054         },
2055         [ALC882_FIXUP_LENOVO_Y530] = {
2056                 .type = HDA_FIXUP_PINS,
2057                 .v.pins = (const struct hda_pintbl[]) {
2058                         { 0x15, 0x99130112 }, /* rear int speakers */
2059                         { 0x16, 0x99130111 }, /* subwoofer */
2060                         { }
2061                 }
2062         },
2063         [ALC882_FIXUP_PB_M5210] = {
2064                 .type = HDA_FIXUP_PINCTLS,
2065                 .v.pins = (const struct hda_pintbl[]) {
2066                         { 0x19, PIN_VREF50 },
2067                         {}
2068                 }
2069         },
2070         [ALC882_FIXUP_ACER_ASPIRE_7736] = {
2071                 .type = HDA_FIXUP_FUNC,
2072                 .v.func = alc_fixup_sku_ignore,
2073         },
2074         [ALC882_FIXUP_ASUS_W90V] = {
2075                 .type = HDA_FIXUP_PINS,
2076                 .v.pins = (const struct hda_pintbl[]) {
2077                         { 0x16, 0x99130110 }, /* fix sequence for CLFE */
2078                         { }
2079                 }
2080         },
2081         [ALC889_FIXUP_CD] = {
2082                 .type = HDA_FIXUP_PINS,
2083                 .v.pins = (const struct hda_pintbl[]) {
2084                         { 0x1c, 0x993301f0 }, /* CD */
2085                         { }
2086                 }
2087         },
2088         [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2089                 .type = HDA_FIXUP_PINS,
2090                 .v.pins = (const struct hda_pintbl[]) {
2091                         { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2092                         { }
2093                 },
2094                 .chained = true,
2095                 .chain_id = ALC889_FIXUP_CD,
2096         },
2097         [ALC889_FIXUP_VAIO_TT] = {
2098                 .type = HDA_FIXUP_PINS,
2099                 .v.pins = (const struct hda_pintbl[]) {
2100                         { 0x17, 0x90170111 }, /* hidden surround speaker */
2101                         { }
2102                 }
2103         },
2104         [ALC888_FIXUP_EEE1601] = {
2105                 .type = HDA_FIXUP_VERBS,
2106                 .v.verbs = (const struct hda_verb[]) {
2107                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2108                         { 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
2109                         { }
2110                 }
2111         },
2112         [ALC882_FIXUP_EAPD] = {
2113                 .type = HDA_FIXUP_VERBS,
2114                 .v.verbs = (const struct hda_verb[]) {
2115                         /* change to EAPD mode */
2116                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2117                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2118                         { }
2119                 }
2120         },
2121         [ALC883_FIXUP_EAPD] = {
2122                 .type = HDA_FIXUP_VERBS,
2123                 .v.verbs = (const struct hda_verb[]) {
2124                         /* change to EAPD mode */
2125                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2126                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2127                         { }
2128                 }
2129         },
2130         [ALC883_FIXUP_ACER_EAPD] = {
2131                 .type = HDA_FIXUP_VERBS,
2132                 .v.verbs = (const struct hda_verb[]) {
2133                         /* eanable EAPD on Acer laptops */
2134                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2135                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2136                         { }
2137                 }
2138         },
2139         [ALC882_FIXUP_GPIO1] = {
2140                 .type = HDA_FIXUP_VERBS,
2141                 .v.verbs = alc_gpio1_init_verbs,
2142         },
2143         [ALC882_FIXUP_GPIO2] = {
2144                 .type = HDA_FIXUP_VERBS,
2145                 .v.verbs = alc_gpio2_init_verbs,
2146         },
2147         [ALC882_FIXUP_GPIO3] = {
2148                 .type = HDA_FIXUP_VERBS,
2149                 .v.verbs = alc_gpio3_init_verbs,
2150         },
2151         [ALC882_FIXUP_ASUS_W2JC] = {
2152                 .type = HDA_FIXUP_VERBS,
2153                 .v.verbs = alc_gpio1_init_verbs,
2154                 .chained = true,
2155                 .chain_id = ALC882_FIXUP_EAPD,
2156         },
2157         [ALC889_FIXUP_COEF] = {
2158                 .type = HDA_FIXUP_FUNC,
2159                 .v.func = alc889_fixup_coef,
2160         },
2161         [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2162                 .type = HDA_FIXUP_PINS,
2163                 .v.pins = (const struct hda_pintbl[]) {
2164                         { 0x16, 0x99130111 }, /* CLFE speaker */
2165                         { 0x17, 0x99130112 }, /* surround speaker */
2166                         { }
2167                 },
2168                 .chained = true,
2169                 .chain_id = ALC882_FIXUP_GPIO1,
2170         },
2171         [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2172                 .type = HDA_FIXUP_PINS,
2173                 .v.pins = (const struct hda_pintbl[]) {
2174                         { 0x16, 0x99130111 }, /* CLFE speaker */
2175                         { 0x1b, 0x99130112 }, /* surround speaker */
2176                         { }
2177                 },
2178                 .chained = true,
2179                 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2180         },
2181         [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2182                 /* additional init verbs for Acer Aspire 8930G */
2183                 .type = HDA_FIXUP_VERBS,
2184                 .v.verbs = (const struct hda_verb[]) {
2185                         /* Enable all DACs */
2186                         /* DAC DISABLE/MUTE 1? */
2187                         /*  setting bits 1-5 disables DAC nids 0x02-0x06
2188                          *  apparently. Init=0x38 */
2189                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2190                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2191                         /* DAC DISABLE/MUTE 2? */
2192                         /*  some bit here disables the other DACs.
2193                          *  Init=0x4900 */
2194                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2195                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2196                         /* DMIC fix
2197                          * This laptop has a stereo digital microphone.
2198                          * The mics are only 1cm apart which makes the stereo
2199                          * useless. However, either the mic or the ALC889
2200                          * makes the signal become a difference/sum signal
2201                          * instead of standard stereo, which is annoying.
2202                          * So instead we flip this bit which makes the
2203                          * codec replicate the sum signal to both channels,
2204                          * turning it into a normal mono mic.
2205                          */
2206                         /* DMIC_CONTROL? Init value = 0x0001 */
2207                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2208                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2209                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2210                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2211                         { }
2212                 },
2213                 .chained = true,
2214                 .chain_id = ALC882_FIXUP_GPIO1,
2215         },
2216         [ALC885_FIXUP_MACPRO_GPIO] = {
2217                 .type = HDA_FIXUP_FUNC,
2218                 .v.func = alc885_fixup_macpro_gpio,
2219         },
2220         [ALC889_FIXUP_DAC_ROUTE] = {
2221                 .type = HDA_FIXUP_FUNC,
2222                 .v.func = alc889_fixup_dac_route,
2223         },
2224         [ALC889_FIXUP_MBP_VREF] = {
2225                 .type = HDA_FIXUP_FUNC,
2226                 .v.func = alc889_fixup_mbp_vref,
2227                 .chained = true,
2228                 .chain_id = ALC882_FIXUP_GPIO1,
2229         },
2230         [ALC889_FIXUP_IMAC91_VREF] = {
2231                 .type = HDA_FIXUP_FUNC,
2232                 .v.func = alc889_fixup_imac91_vref,
2233                 .chained = true,
2234                 .chain_id = ALC882_FIXUP_GPIO1,
2235         },
2236         [ALC889_FIXUP_MBA11_VREF] = {
2237                 .type = HDA_FIXUP_FUNC,
2238                 .v.func = alc889_fixup_mba11_vref,
2239                 .chained = true,
2240                 .chain_id = ALC889_FIXUP_MBP_VREF,
2241         },
2242         [ALC889_FIXUP_MBA21_VREF] = {
2243                 .type = HDA_FIXUP_FUNC,
2244                 .v.func = alc889_fixup_mba21_vref,
2245                 .chained = true,
2246                 .chain_id = ALC889_FIXUP_MBP_VREF,
2247         },
2248         [ALC889_FIXUP_MP11_VREF] = {
2249                 .type = HDA_FIXUP_FUNC,
2250                 .v.func = alc889_fixup_mba11_vref,
2251                 .chained = true,
2252                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2253         },
2254         [ALC889_FIXUP_MP41_VREF] = {
2255                 .type = HDA_FIXUP_FUNC,
2256                 .v.func = alc889_fixup_mbp_vref,
2257                 .chained = true,
2258                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2259         },
2260         [ALC882_FIXUP_INV_DMIC] = {
2261                 .type = HDA_FIXUP_FUNC,
2262                 .v.func = alc_fixup_inv_dmic,
2263         },
2264         [ALC882_FIXUP_NO_PRIMARY_HP] = {
2265                 .type = HDA_FIXUP_FUNC,
2266                 .v.func = alc882_fixup_no_primary_hp,
2267         },
2268         [ALC887_FIXUP_ASUS_BASS] = {
2269                 .type = HDA_FIXUP_PINS,
2270                 .v.pins = (const struct hda_pintbl[]) {
2271                         {0x16, 0x99130130}, /* bass speaker */
2272                         {}
2273                 },
2274                 .chained = true,
2275                 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2276         },
2277         [ALC887_FIXUP_BASS_CHMAP] = {
2278                 .type = HDA_FIXUP_FUNC,
2279                 .v.func = alc_fixup_bass_chmap,
2280         },
2281         [ALC1220_FIXUP_GB_DUAL_CODECS] = {
2282                 .type = HDA_FIXUP_FUNC,
2283                 .v.func = alc1220_fixup_gb_dual_codecs,
2284         },
2285         [ALC1220_FIXUP_CLEVO_P950] = {
2286                 .type = HDA_FIXUP_FUNC,
2287                 .v.func = alc1220_fixup_clevo_p950,
2288         },
2289 };
2290
2291 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2292         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2293         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2294         SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2295         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2296         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2297         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2298         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2299         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2300                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2301         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2302                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2303         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2304                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2305         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2306                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2307         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2308                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2309         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2310                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2311         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2312                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2313         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2314         SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2315                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2316         SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2317         SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2318         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2319         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2320         SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2321         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2322         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2323         SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2324         SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2325         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2326         SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2327         SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2328         SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2329         SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2330
2331         /* All Apple entries are in codec SSIDs */
2332         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2333         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2334         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2335         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2336         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2337         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2338         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2339         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2340         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2341         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2342         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2343         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2344         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2345         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2346         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2347         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2348         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2349         SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2350         SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2351         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2352         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2353         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2354
2355         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2356         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2357         SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2358         SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2359         SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2360         SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2361         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2362         SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2363         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2364         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2365         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2366         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2367         {}
2368 };
2369
2370 static const struct hda_model_fixup alc882_fixup_models[] = {
2371         {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2372         {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2373         {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2374         {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2375         {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2376         {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2377         {}
2378 };
2379
2380 /*
2381  * BIOS auto configuration
2382  */
2383 /* almost identical with ALC880 parser... */
2384 static int alc882_parse_auto_config(struct hda_codec *codec)
2385 {
2386         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2387         static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2388         return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2389 }
2390
2391 /*
2392  */
2393 static int patch_alc882(struct hda_codec *codec)
2394 {
2395         struct alc_spec *spec;
2396         int err;
2397
2398         err = alc_alloc_spec(codec, 0x0b);
2399         if (err < 0)
2400                 return err;
2401
2402         spec = codec->spec;
2403
2404         switch (codec->core.vendor_id) {
2405         case 0x10ec0882:
2406         case 0x10ec0885:
2407         case 0x10ec0900:
2408         case 0x10ec1220:
2409                 break;
2410         default:
2411                 /* ALC883 and variants */
2412                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2413                 break;
2414         }
2415
2416         snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2417                        alc882_fixups);
2418         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2419
2420         alc_auto_parse_customize_define(codec);
2421
2422         if (has_cdefine_beep(codec))
2423                 spec->gen.beep_nid = 0x01;
2424
2425         /* automatic parse from the BIOS config */
2426         err = alc882_parse_auto_config(codec);
2427         if (err < 0)
2428                 goto error;
2429
2430         if (!spec->gen.no_analog && spec->gen.beep_nid)
2431                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2432
2433         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2434
2435         return 0;
2436
2437  error:
2438         alc_free(codec);
2439         return err;
2440 }
2441
2442
2443 /*
2444  * ALC262 support
2445  */
2446 static int alc262_parse_auto_config(struct hda_codec *codec)
2447 {
2448         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2449         static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2450         return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2451 }
2452
2453 /*
2454  * Pin config fixes
2455  */
2456 enum {
2457         ALC262_FIXUP_FSC_H270,
2458         ALC262_FIXUP_FSC_S7110,
2459         ALC262_FIXUP_HP_Z200,
2460         ALC262_FIXUP_TYAN,
2461         ALC262_FIXUP_LENOVO_3000,
2462         ALC262_FIXUP_BENQ,
2463         ALC262_FIXUP_BENQ_T31,
2464         ALC262_FIXUP_INV_DMIC,
2465         ALC262_FIXUP_INTEL_BAYLEYBAY,
2466 };
2467
2468 static const struct hda_fixup alc262_fixups[] = {
2469         [ALC262_FIXUP_FSC_H270] = {
2470                 .type = HDA_FIXUP_PINS,
2471                 .v.pins = (const struct hda_pintbl[]) {
2472                         { 0x14, 0x99130110 }, /* speaker */
2473                         { 0x15, 0x0221142f }, /* front HP */
2474                         { 0x1b, 0x0121141f }, /* rear HP */
2475                         { }
2476                 }
2477         },
2478         [ALC262_FIXUP_FSC_S7110] = {
2479                 .type = HDA_FIXUP_PINS,
2480                 .v.pins = (const struct hda_pintbl[]) {
2481                         { 0x15, 0x90170110 }, /* speaker */
2482                         { }
2483                 },
2484                 .chained = true,
2485                 .chain_id = ALC262_FIXUP_BENQ,
2486         },
2487         [ALC262_FIXUP_HP_Z200] = {
2488                 .type = HDA_FIXUP_PINS,
2489                 .v.pins = (const struct hda_pintbl[]) {
2490                         { 0x16, 0x99130120 }, /* internal speaker */
2491                         { }
2492                 }
2493         },
2494         [ALC262_FIXUP_TYAN] = {
2495                 .type = HDA_FIXUP_PINS,
2496                 .v.pins = (const struct hda_pintbl[]) {
2497                         { 0x14, 0x1993e1f0 }, /* int AUX */
2498                         { }
2499                 }
2500         },
2501         [ALC262_FIXUP_LENOVO_3000] = {
2502                 .type = HDA_FIXUP_PINCTLS,
2503                 .v.pins = (const struct hda_pintbl[]) {
2504                         { 0x19, PIN_VREF50 },
2505                         {}
2506                 },
2507                 .chained = true,
2508                 .chain_id = ALC262_FIXUP_BENQ,
2509         },
2510         [ALC262_FIXUP_BENQ] = {
2511                 .type = HDA_FIXUP_VERBS,
2512                 .v.verbs = (const struct hda_verb[]) {
2513                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2514                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2515                         {}
2516                 }
2517         },
2518         [ALC262_FIXUP_BENQ_T31] = {
2519                 .type = HDA_FIXUP_VERBS,
2520                 .v.verbs = (const struct hda_verb[]) {
2521                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2522                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2523                         {}
2524                 }
2525         },
2526         [ALC262_FIXUP_INV_DMIC] = {
2527                 .type = HDA_FIXUP_FUNC,
2528                 .v.func = alc_fixup_inv_dmic,
2529         },
2530         [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2531                 .type = HDA_FIXUP_FUNC,
2532                 .v.func = alc_fixup_no_depop_delay,
2533         },
2534 };
2535
2536 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2537         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2538         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2539         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2540         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2541         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2542         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2543         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2544         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2545         SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2546         {}
2547 };
2548
2549 static const struct hda_model_fixup alc262_fixup_models[] = {
2550         {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2551         {}
2552 };
2553
2554 /*
2555  */
2556 static int patch_alc262(struct hda_codec *codec)
2557 {
2558         struct alc_spec *spec;
2559         int err;
2560
2561         err = alc_alloc_spec(codec, 0x0b);
2562         if (err < 0)
2563                 return err;
2564
2565         spec = codec->spec;
2566         spec->gen.shared_mic_vref_pin = 0x18;
2567
2568         spec->shutup = alc_eapd_shutup;
2569
2570 #if 0
2571         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2572          * under-run
2573          */
2574         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2575 #endif
2576         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2577
2578         snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2579                        alc262_fixups);
2580         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2581
2582         alc_auto_parse_customize_define(codec);
2583
2584         if (has_cdefine_beep(codec))
2585                 spec->gen.beep_nid = 0x01;
2586
2587         /* automatic parse from the BIOS config */
2588         err = alc262_parse_auto_config(codec);
2589         if (err < 0)
2590                 goto error;
2591
2592         if (!spec->gen.no_analog && spec->gen.beep_nid)
2593                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2594
2595         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2596
2597         return 0;
2598
2599  error:
2600         alc_free(codec);
2601         return err;
2602 }
2603
2604 /*
2605  *  ALC268
2606  */
2607 /* bind Beep switches of both NID 0x0f and 0x10 */
2608 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
2609                                   struct snd_ctl_elem_value *ucontrol)
2610 {
2611         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2612         unsigned long pval;
2613         int err;
2614
2615         mutex_lock(&codec->control_mutex);
2616         pval = kcontrol->private_value;
2617         kcontrol->private_value = (pval & ~0xff) | 0x0f;
2618         err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2619         if (err >= 0) {
2620                 kcontrol->private_value = (pval & ~0xff) | 0x10;
2621                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2622         }
2623         kcontrol->private_value = pval;
2624         mutex_unlock(&codec->control_mutex);
2625         return err;
2626 }
2627
2628 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
2629         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2630         {
2631                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2632                 .name = "Beep Playback Switch",
2633                 .subdevice = HDA_SUBDEV_AMP_FLAG,
2634                 .info = snd_hda_mixer_amp_switch_info,
2635                 .get = snd_hda_mixer_amp_switch_get,
2636                 .put = alc268_beep_switch_put,
2637                 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
2638         },
2639         { }
2640 };
2641
2642 /* set PCBEEP vol = 0, mute connections */
2643 static const struct hda_verb alc268_beep_init_verbs[] = {
2644         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2645         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2646         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2647         { }
2648 };
2649
2650 enum {
2651         ALC268_FIXUP_INV_DMIC,
2652         ALC268_FIXUP_HP_EAPD,
2653         ALC268_FIXUP_SPDIF,
2654 };
2655
2656 static const struct hda_fixup alc268_fixups[] = {
2657         [ALC268_FIXUP_INV_DMIC] = {
2658                 .type = HDA_FIXUP_FUNC,
2659                 .v.func = alc_fixup_inv_dmic,
2660         },
2661         [ALC268_FIXUP_HP_EAPD] = {
2662                 .type = HDA_FIXUP_VERBS,
2663                 .v.verbs = (const struct hda_verb[]) {
2664                         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
2665                         {}
2666                 }
2667         },
2668         [ALC268_FIXUP_SPDIF] = {
2669                 .type = HDA_FIXUP_PINS,
2670                 .v.pins = (const struct hda_pintbl[]) {
2671                         { 0x1e, 0x014b1180 }, /* enable SPDIF out */
2672                         {}
2673                 }
2674         },
2675 };
2676
2677 static const struct hda_model_fixup alc268_fixup_models[] = {
2678         {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
2679         {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
2680         {}
2681 };
2682
2683 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
2684         SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
2685         SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
2686         /* below is codec SSID since multiple Toshiba laptops have the
2687          * same PCI SSID 1179:ff00
2688          */
2689         SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
2690         {}
2691 };
2692
2693 /*
2694  * BIOS auto configuration
2695  */
2696 static int alc268_parse_auto_config(struct hda_codec *codec)
2697 {
2698         static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2699         return alc_parse_auto_config(codec, NULL, alc268_ssids);
2700 }
2701
2702 /*
2703  */
2704 static int patch_alc268(struct hda_codec *codec)
2705 {
2706         struct alc_spec *spec;
2707         int err;
2708
2709         /* ALC268 has no aa-loopback mixer */
2710         err = alc_alloc_spec(codec, 0);
2711         if (err < 0)
2712                 return err;
2713
2714         spec = codec->spec;
2715         spec->gen.beep_nid = 0x01;
2716
2717         spec->shutup = alc_eapd_shutup;
2718
2719         snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
2720         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2721
2722         /* automatic parse from the BIOS config */
2723         err = alc268_parse_auto_config(codec);
2724         if (err < 0)
2725                 goto error;
2726
2727         if (err > 0 && !spec->gen.no_analog &&
2728             spec->gen.autocfg.speaker_pins[0] != 0x1d) {
2729                 add_mixer(spec, alc268_beep_mixer);
2730                 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
2731                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
2732                         /* override the amp caps for beep generator */
2733                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
2734                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
2735                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
2736                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2737                                           (0 << AC_AMPCAP_MUTE_SHIFT));
2738         }
2739
2740         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2741
2742         return 0;
2743
2744  error:
2745         alc_free(codec);
2746         return err;
2747 }
2748
2749 /*
2750  * ALC269
2751  */
2752
2753 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
2754         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2755 };
2756
2757 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
2758         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2759 };
2760
2761 /* different alc269-variants */
2762 enum {
2763         ALC269_TYPE_ALC269VA,
2764         ALC269_TYPE_ALC269VB,
2765         ALC269_TYPE_ALC269VC,
2766         ALC269_TYPE_ALC269VD,
2767         ALC269_TYPE_ALC280,
2768         ALC269_TYPE_ALC282,
2769         ALC269_TYPE_ALC283,
2770         ALC269_TYPE_ALC284,
2771         ALC269_TYPE_ALC293,
2772         ALC269_TYPE_ALC286,
2773         ALC269_TYPE_ALC298,
2774         ALC269_TYPE_ALC255,
2775         ALC269_TYPE_ALC256,
2776         ALC269_TYPE_ALC257,
2777         ALC269_TYPE_ALC215,
2778         ALC269_TYPE_ALC225,
2779         ALC269_TYPE_ALC294,
2780         ALC269_TYPE_ALC700,
2781 };
2782
2783 /*
2784  * BIOS auto configuration
2785  */
2786 static int alc269_parse_auto_config(struct hda_codec *codec)
2787 {
2788         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
2789         static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
2790         static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2791         struct alc_spec *spec = codec->spec;
2792         const hda_nid_t *ssids;
2793
2794         switch (spec->codec_variant) {
2795         case ALC269_TYPE_ALC269VA:
2796         case ALC269_TYPE_ALC269VC:
2797         case ALC269_TYPE_ALC280:
2798         case ALC269_TYPE_ALC284:
2799         case ALC269_TYPE_ALC293:
2800                 ssids = alc269va_ssids;
2801                 break;
2802         case ALC269_TYPE_ALC269VB:
2803         case ALC269_TYPE_ALC269VD:
2804         case ALC269_TYPE_ALC282:
2805         case ALC269_TYPE_ALC283:
2806         case ALC269_TYPE_ALC286:
2807         case ALC269_TYPE_ALC298:
2808         case ALC269_TYPE_ALC255:
2809         case ALC269_TYPE_ALC256:
2810         case ALC269_TYPE_ALC257:
2811         case ALC269_TYPE_ALC215:
2812         case ALC269_TYPE_ALC225:
2813         case ALC269_TYPE_ALC294:
2814         case ALC269_TYPE_ALC700:
2815                 ssids = alc269_ssids;
2816                 break;
2817         default:
2818                 ssids = alc269_ssids;
2819                 break;
2820         }
2821
2822         return alc_parse_auto_config(codec, alc269_ignore, ssids);
2823 }
2824
2825 static int find_ext_mic_pin(struct hda_codec *codec);
2826
2827 static void alc286_shutup(struct hda_codec *codec)
2828 {
2829         int i;
2830         int mic_pin = find_ext_mic_pin(codec);
2831         /* don't shut up pins when unloading the driver; otherwise it breaks
2832          * the default pin setup at the next load of the driver
2833          */
2834         if (codec->bus->shutdown)
2835                 return;
2836         for (i = 0; i < codec->init_pins.used; i++) {
2837                 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
2838                 /* use read here for syncing after issuing each verb */
2839                 if (pin->nid != mic_pin)
2840                         snd_hda_codec_read(codec, pin->nid, 0,
2841                                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
2842         }
2843         codec->pins_shutup = 1;
2844 }
2845
2846 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
2847 {
2848         alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
2849 }
2850
2851 static void alc269_shutup(struct hda_codec *codec)
2852 {
2853         struct alc_spec *spec = codec->spec;
2854
2855         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
2856                 alc269vb_toggle_power_output(codec, 0);
2857         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
2858                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
2859                 msleep(150);
2860         }
2861         snd_hda_shutup_pins(codec);
2862 }
2863
2864 static struct coef_fw alc282_coefs[] = {
2865         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
2866         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
2867         WRITE_COEF(0x07, 0x0200), /* DMIC control */
2868         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
2869         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
2870         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
2871         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
2872         WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
2873         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
2874         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
2875         WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
2876         UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
2877         WRITE_COEF(0x34, 0xa0c0), /* ANC */
2878         UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
2879         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
2880         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
2881         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
2882         WRITE_COEF(0x63, 0x2902), /* PLL */
2883         WRITE_COEF(0x68, 0xa080), /* capless control 2 */
2884         WRITE_COEF(0x69, 0x3400), /* capless control 3 */
2885         WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
2886         WRITE_COEF(0x6b, 0x0), /* capless control 5 */
2887         UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
2888         WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
2889         UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
2890         WRITE_COEF(0x71, 0x0014), /* class D test 6 */
2891         WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
2892         UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
2893         WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
2894         {}
2895 };
2896
2897 static void alc282_restore_default_value(struct hda_codec *codec)
2898 {
2899         alc_process_coef_fw(codec, alc282_coefs);
2900 }
2901
2902 static void alc282_init(struct hda_codec *codec)
2903 {
2904         struct alc_spec *spec = codec->spec;
2905         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2906         bool hp_pin_sense;
2907         int coef78;
2908
2909         alc282_restore_default_value(codec);
2910
2911         if (!hp_pin)
2912                 return;
2913         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2914         coef78 = alc_read_coef_idx(codec, 0x78);
2915
2916         /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
2917         /* Headphone capless set to high power mode */
2918         alc_write_coef_idx(codec, 0x78, 0x9004);
2919
2920         if (hp_pin_sense)
2921                 msleep(2);
2922
2923         snd_hda_codec_write(codec, hp_pin, 0,
2924                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2925
2926         if (hp_pin_sense)
2927                 msleep(85);
2928
2929         snd_hda_codec_write(codec, hp_pin, 0,
2930                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
2931
2932         if (hp_pin_sense)
2933                 msleep(100);
2934
2935         /* Headphone capless set to normal mode */
2936         alc_write_coef_idx(codec, 0x78, coef78);
2937 }
2938
2939 static void alc282_shutup(struct hda_codec *codec)
2940 {
2941         struct alc_spec *spec = codec->spec;
2942         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2943         bool hp_pin_sense;
2944         int coef78;
2945
2946         if (!hp_pin) {
2947                 alc269_shutup(codec);
2948                 return;
2949         }
2950
2951         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2952         coef78 = alc_read_coef_idx(codec, 0x78);
2953         alc_write_coef_idx(codec, 0x78, 0x9004);
2954
2955         if (hp_pin_sense)
2956                 msleep(2);
2957
2958         snd_hda_codec_write(codec, hp_pin, 0,
2959                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2960
2961         if (hp_pin_sense)
2962                 msleep(85);
2963
2964         snd_hda_codec_write(codec, hp_pin, 0,
2965                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
2966
2967         if (hp_pin_sense)
2968                 msleep(100);
2969
2970         alc_auto_setup_eapd(codec, false);
2971         snd_hda_shutup_pins(codec);
2972         alc_write_coef_idx(codec, 0x78, coef78);
2973 }
2974
2975 static struct coef_fw alc283_coefs[] = {
2976         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
2977         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
2978         WRITE_COEF(0x07, 0x0200), /* DMIC control */
2979         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
2980         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
2981         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
2982         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
2983         WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
2984         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
2985         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
2986         WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
2987         UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
2988         WRITE_COEF(0x22, 0xa0c0), /* ANC */
2989         UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
2990         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
2991         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
2992         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
2993         WRITE_COEF(0x2e, 0x2902), /* PLL */
2994         WRITE_COEF(0x33, 0xa080), /* capless control 2 */
2995         WRITE_COEF(0x34, 0x3400), /* capless control 3 */
2996         WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
2997         WRITE_COEF(0x36, 0x0), /* capless control 5 */
2998         UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
2999         WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3000         UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3001         WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3002         WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3003         UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3004         WRITE_COEF(0x49, 0x0), /* test mode */
3005         UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3006         UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3007         WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3008         UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3009         {}
3010 };
3011
3012 static void alc283_restore_default_value(struct hda_codec *codec)
3013 {
3014         alc_process_coef_fw(codec, alc283_coefs);
3015 }
3016
3017 static void alc283_init(struct hda_codec *codec)
3018 {
3019         struct alc_spec *spec = codec->spec;
3020         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
3021         bool hp_pin_sense;
3022
3023         if (!spec->gen.autocfg.hp_outs) {
3024                 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
3025                         hp_pin = spec->gen.autocfg.line_out_pins[0];
3026         }
3027
3028         alc283_restore_default_value(codec);
3029
3030         if (!hp_pin)
3031                 return;
3032
3033         msleep(30);
3034         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3035
3036         /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3037         /* Headphone capless set to high power mode */
3038         alc_write_coef_idx(codec, 0x43, 0x9004);
3039
3040         snd_hda_codec_write(codec, hp_pin, 0,
3041                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3042
3043         if (hp_pin_sense)
3044                 msleep(85);
3045
3046         snd_hda_codec_write(codec, hp_pin, 0,
3047                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3048
3049         if (hp_pin_sense)
3050                 msleep(85);
3051         /* Index 0x46 Combo jack auto switch control 2 */
3052         /* 3k pull low control for Headset jack. */
3053         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3054         /* Headphone capless set to normal mode */
3055         alc_write_coef_idx(codec, 0x43, 0x9614);
3056 }
3057
3058 static void alc283_shutup(struct hda_codec *codec)
3059 {
3060         struct alc_spec *spec = codec->spec;
3061         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
3062         bool hp_pin_sense;
3063
3064         if (!spec->gen.autocfg.hp_outs) {
3065                 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
3066                         hp_pin = spec->gen.autocfg.line_out_pins[0];
3067         }
3068
3069         if (!hp_pin) {
3070                 alc269_shutup(codec);
3071                 return;
3072         }
3073
3074         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3075
3076         alc_write_coef_idx(codec, 0x43, 0x9004);
3077
3078         /*depop hp during suspend*/
3079         alc_write_coef_idx(codec, 0x06, 0x2100);
3080
3081         snd_hda_codec_write(codec, hp_pin, 0,
3082                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3083
3084         if (hp_pin_sense)
3085                 msleep(100);
3086
3087         snd_hda_codec_write(codec, hp_pin, 0,
3088                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3089
3090         alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3091
3092         if (hp_pin_sense)
3093                 msleep(100);
3094         alc_auto_setup_eapd(codec, false);
3095         snd_hda_shutup_pins(codec);
3096         alc_write_coef_idx(codec, 0x43, 0x9614);
3097 }
3098
3099 static void alc256_init(struct hda_codec *codec)
3100 {
3101         struct alc_spec *spec = codec->spec;
3102         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
3103         bool hp_pin_sense;
3104
3105         if (!hp_pin)
3106                 return;
3107
3108         msleep(30);
3109
3110         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3111
3112         if (hp_pin_sense)
3113                 msleep(2);
3114
3115         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3116
3117         snd_hda_codec_write(codec, hp_pin, 0,
3118                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3119
3120         if (hp_pin_sense)
3121                 msleep(85);
3122
3123         snd_hda_codec_write(codec, hp_pin, 0,
3124                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3125
3126         if (hp_pin_sense)
3127                 msleep(100);
3128
3129         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3130         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3131 }
3132
3133 static void alc256_shutup(struct hda_codec *codec)
3134 {
3135         struct alc_spec *spec = codec->spec;
3136         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
3137         bool hp_pin_sense;
3138
3139         if (!hp_pin) {
3140                 alc269_shutup(codec);
3141                 return;
3142         }
3143
3144         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3145
3146         if (hp_pin_sense)
3147                 msleep(2);
3148
3149         snd_hda_codec_write(codec, hp_pin, 0,
3150                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3151
3152         if (hp_pin_sense)
3153                 msleep(85);
3154
3155         snd_hda_codec_write(codec, hp_pin, 0,
3156                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3157
3158         alc_update_coef_idx(codec, 0x46, 0, 3 << 12); /* 3k pull low control for Headset jack. */
3159
3160         if (hp_pin_sense)
3161                 msleep(100);
3162
3163         alc_auto_setup_eapd(codec, false);
3164         snd_hda_shutup_pins(codec);
3165 }
3166
3167 static void alc_default_init(struct hda_codec *codec)
3168 {
3169         struct alc_spec *spec = codec->spec;
3170         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
3171         bool hp_pin_sense;
3172
3173         if (!hp_pin)
3174                 return;
3175
3176         msleep(30);
3177
3178         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3179
3180         if (hp_pin_sense)
3181                 msleep(2);
3182
3183         snd_hda_codec_write(codec, hp_pin, 0,
3184                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3185
3186         if (hp_pin_sense)
3187                 msleep(85);
3188
3189         snd_hda_codec_write(codec, hp_pin, 0,
3190                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3191
3192         if (hp_pin_sense)
3193                 msleep(100);
3194 }
3195
3196 static void alc_default_shutup(struct hda_codec *codec)
3197 {
3198         struct alc_spec *spec = codec->spec;
3199         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
3200         bool hp_pin_sense;
3201
3202         if (!hp_pin) {
3203                 alc269_shutup(codec);
3204                 return;
3205         }
3206
3207         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3208
3209         if (hp_pin_sense)
3210                 msleep(2);
3211
3212         snd_hda_codec_write(codec, hp_pin, 0,
3213                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3214
3215         if (hp_pin_sense)
3216                 msleep(85);
3217
3218         snd_hda_codec_write(codec, hp_pin, 0,
3219                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3220
3221         if (hp_pin_sense)
3222                 msleep(100);
3223
3224         alc_auto_setup_eapd(codec, false);
3225         snd_hda_shutup_pins(codec);
3226 }
3227
3228 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3229                              unsigned int val)
3230 {
3231         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3232         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3233         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3234 }
3235
3236 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3237 {
3238         unsigned int val;
3239
3240         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3241         val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3242                 & 0xffff;
3243         val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3244                 << 16;
3245         return val;
3246 }
3247
3248 static void alc5505_dsp_halt(struct hda_codec *codec)
3249 {
3250         unsigned int val;
3251
3252         alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3253         alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3254         alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3255         alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3256         alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3257         alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3258         alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3259         val = alc5505_coef_get(codec, 0x6220);
3260         alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3261 }
3262
3263 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3264 {
3265         alc5505_coef_set(codec, 0x61b8, 0x04133302);
3266         alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3267         alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3268         alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3269         alc5505_coef_set(codec, 0x6220, 0x2002010f);
3270         alc5505_coef_set(codec, 0x880c, 0x00000004);
3271 }
3272
3273 static void alc5505_dsp_init(struct hda_codec *codec)
3274 {
3275         unsigned int val;
3276
3277         alc5505_dsp_halt(codec);
3278         alc5505_dsp_back_from_halt(codec);
3279         alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
3280         alc5505_coef_set(codec, 0x61b0, 0x5b16);
3281         alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
3282         alc5505_coef_set(codec, 0x61b4, 0x04132b02);
3283         alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
3284         alc5505_coef_set(codec, 0x61b8, 0x041f3302);
3285         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
3286         alc5505_coef_set(codec, 0x61b8, 0x041b3302);
3287         alc5505_coef_set(codec, 0x61b8, 0x04173302);
3288         alc5505_coef_set(codec, 0x61b8, 0x04163302);
3289         alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
3290         alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
3291         alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
3292
3293         val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
3294         if (val <= 3)
3295                 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
3296         else
3297                 alc5505_coef_set(codec, 0x6220, 0x6002018f);
3298
3299         alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
3300         alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
3301         alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
3302         alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
3303         alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
3304         alc5505_coef_set(codec, 0x880c, 0x00000003);
3305         alc5505_coef_set(codec, 0x880c, 0x00000010);
3306
3307 #ifdef HALT_REALTEK_ALC5505
3308         alc5505_dsp_halt(codec);
3309 #endif
3310 }
3311
3312 #ifdef HALT_REALTEK_ALC5505
3313 #define alc5505_dsp_suspend(codec)      /* NOP */
3314 #define alc5505_dsp_resume(codec)       /* NOP */
3315 #else
3316 #define alc5505_dsp_suspend(codec)      alc5505_dsp_halt(codec)
3317 #define alc5505_dsp_resume(codec)       alc5505_dsp_back_from_halt(codec)
3318 #endif
3319
3320 #ifdef CONFIG_PM
3321 static int alc269_suspend(struct hda_codec *codec)
3322 {
3323         struct alc_spec *spec = codec->sp