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