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