~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/pci/hda/patch_realtek.c

Version: ~ [ linux-5.9-rc6 ] ~ [ linux-5.8.10 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.66 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.146 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.198 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.236 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.236 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Universal Interface for Intel High Definition Audio Codec
  3  *
  4  * HD audio interface patch for Realtek ALC codecs
  5  *
  6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
  7  *                    PeiSen Hou <pshou@realtek.com.tw>
  8  *                    Takashi Iwai <tiwai@suse.de>
  9  *                    Jonathan Woithe <jwoithe@just42.net>
 10  *
 11  *  This driver is free software; you can redistribute it and/or modify
 12  *  it under the terms of the GNU General Public License as published by
 13  *  the Free Software Foundation; either version 2 of the License, or
 14  *  (at your option) any later version.
 15  *
 16  *  This driver is distributed in the hope that it will be useful,
 17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19  *  GNU General Public License for more details.
 20  *
 21  *  You should have received a copy of the GNU General Public License
 22  *  along with this program; if not, write to the Free Software
 23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 24  */
 25 
 26 #include <linux/init.h>
 27 #include <linux/delay.h>
 28 #include <linux/slab.h>
 29 #include <linux/pci.h>
 30 #include <linux/dmi.h>
 31 #include <linux/module.h>
 32 #include <sound/core.h>
 33 #include <sound/jack.h>
 34 #include "hda_codec.h"
 35 #include "hda_local.h"
 36 #include "hda_auto_parser.h"
 37 #include "hda_jack.h"
 38 #include "hda_generic.h"
 39 
 40 /* keep halting ALC5505 DSP, for power saving */
 41 #define HALT_REALTEK_ALC5505
 42 
 43 /* unsol event tags */
 44 #define ALC_DCVOL_EVENT         0x08
 45 
 46 /* for GPIO Poll */
 47 #define GPIO_MASK       0x03
 48 
 49 /* extra amp-initialization sequence types */
 50 enum {
 51         ALC_INIT_NONE,
 52         ALC_INIT_DEFAULT,
 53         ALC_INIT_GPIO1,
 54         ALC_INIT_GPIO2,
 55         ALC_INIT_GPIO3,
 56 };
 57 
 58 enum {
 59         ALC_HEADSET_MODE_UNKNOWN,
 60         ALC_HEADSET_MODE_UNPLUGGED,
 61         ALC_HEADSET_MODE_HEADSET,
 62         ALC_HEADSET_MODE_MIC,
 63         ALC_HEADSET_MODE_HEADPHONE,
 64 };
 65 
 66 enum {
 67         ALC_HEADSET_TYPE_UNKNOWN,
 68         ALC_HEADSET_TYPE_CTIA,
 69         ALC_HEADSET_TYPE_OMTP,
 70 };
 71 
 72 struct alc_customize_define {
 73         unsigned int  sku_cfg;
 74         unsigned char port_connectivity;
 75         unsigned char check_sum;
 76         unsigned char customization;
 77         unsigned char external_amp;
 78         unsigned int  enable_pcbeep:1;
 79         unsigned int  platform_type:1;
 80         unsigned int  swap:1;
 81         unsigned int  override:1;
 82         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
 83 };
 84 
 85 struct alc_spec {
 86         struct hda_gen_spec gen; /* must be at head */
 87 
 88         /* codec parameterization */
 89         const struct snd_kcontrol_new *mixers[5];       /* mixer arrays */
 90         unsigned int num_mixers;
 91         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 92 
 93         struct alc_customize_define cdefine;
 94         unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
 95 
 96         /* inverted dmic fix */
 97         unsigned int inv_dmic_fixup:1; /* has inverted digital-mic workaround */
 98         unsigned int inv_dmic_muted:1; /* R-ch of inv d-mic is muted? */
 99         hda_nid_t inv_dmic_pin;
100 
101         /* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */
102         int mute_led_polarity;
103         hda_nid_t mute_led_nid;
104 
105         unsigned int gpio_led; /* used for alc269_fixup_hp_gpio_led() */
106 
107         hda_nid_t headset_mic_pin;
108         hda_nid_t headphone_mic_pin;
109         int current_headset_mode;
110         int current_headset_type;
111 
112         /* hooks */
113         void (*init_hook)(struct hda_codec *codec);
114 #ifdef CONFIG_PM
115         void (*power_hook)(struct hda_codec *codec);
116 #endif
117         void (*shutup)(struct hda_codec *codec);
118 
119         int init_amp;
120         int codec_variant;      /* flag for other variants */
121         unsigned int has_alc5505_dsp:1;
122         unsigned int no_depop_delay:1;
123 
124         /* for PLL fix */
125         hda_nid_t pll_nid;
126         unsigned int pll_coef_idx, pll_coef_bit;
127         unsigned int coef0;
128 };
129 
130 /*
131  * Append the given mixer and verb elements for the later use
132  * The mixer array is referred in build_controls(), and init_verbs are
133  * called in init().
134  */
135 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
136 {
137         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
138                 return;
139         spec->mixers[spec->num_mixers++] = mix;
140 }
141 
142 /*
143  * GPIO setup tables, used in initialization
144  */
145 /* Enable GPIO mask and set output */
146 static const struct hda_verb alc_gpio1_init_verbs[] = {
147         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
148         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
149         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
150         { }
151 };
152 
153 static const struct hda_verb alc_gpio2_init_verbs[] = {
154         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
155         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
156         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
157         { }
158 };
159 
160 static const struct hda_verb alc_gpio3_init_verbs[] = {
161         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
162         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
163         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
164         { }
165 };
166 
167 /*
168  * Fix hardware PLL issue
169  * On some codecs, the analog PLL gating control must be off while
170  * the default value is 1.
171  */
172 static void alc_fix_pll(struct hda_codec *codec)
173 {
174         struct alc_spec *spec = codec->spec;
175         unsigned int val;
176 
177         if (!spec->pll_nid)
178                 return;
179         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
180                             spec->pll_coef_idx);
181         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
182                                  AC_VERB_GET_PROC_COEF, 0);
183         if (val == -1)
184                 return;
185         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
186                             spec->pll_coef_idx);
187         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
188                             val & ~(1 << spec->pll_coef_bit));
189 }
190 
191 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
192                              unsigned int coef_idx, unsigned int coef_bit)
193 {
194         struct alc_spec *spec = codec->spec;
195         spec->pll_nid = nid;
196         spec->pll_coef_idx = coef_idx;
197         spec->pll_coef_bit = coef_bit;
198         alc_fix_pll(codec);
199 }
200 
201 /* update the master volume per volume-knob's unsol event */
202 static void alc_update_knob_master(struct hda_codec *codec, struct hda_jack_tbl *jack)
203 {
204         unsigned int val;
205         struct snd_kcontrol *kctl;
206         struct snd_ctl_elem_value *uctl;
207 
208         kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
209         if (!kctl)
210                 return;
211         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
212         if (!uctl)
213                 return;
214         val = snd_hda_codec_read(codec, jack->nid, 0,
215                                  AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
216         val &= HDA_AMP_VOLMASK;
217         uctl->value.integer.value[0] = val;
218         uctl->value.integer.value[1] = val;
219         kctl->put(kctl, uctl);
220         kfree(uctl);
221 }
222 
223 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
224 {
225         /* For some reason, the res given from ALC880 is broken.
226            Here we adjust it properly. */
227         snd_hda_jack_unsol_event(codec, res >> 2);
228 }
229 
230 /* additional initialization for ALC888 variants */
231 static void alc888_coef_init(struct hda_codec *codec)
232 {
233         unsigned int tmp;
234 
235         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
236         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
237         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
238         if ((tmp & 0xf0) == 0x20)
239                 /* alc888S-VC */
240                 snd_hda_codec_read(codec, 0x20, 0,
241                                    AC_VERB_SET_PROC_COEF, 0x830);
242          else
243                  /* alc888-VB */
244                  snd_hda_codec_read(codec, 0x20, 0,
245                                     AC_VERB_SET_PROC_COEF, 0x3030);
246 }
247 
248 /* additional initialization for ALC889 variants */
249 static void alc889_coef_init(struct hda_codec *codec)
250 {
251         unsigned int tmp;
252 
253         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
254         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
255         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
256         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
257 }
258 
259 /* turn on/off EAPD control (only if available) */
260 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
261 {
262         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
263                 return;
264         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
265                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
266                                     on ? 2 : 0);
267 }
268 
269 /* turn on/off EAPD controls of the codec */
270 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
271 {
272         /* We currently only handle front, HP */
273         static hda_nid_t pins[] = {
274                 0x0f, 0x10, 0x14, 0x15, 0x17, 0
275         };
276         hda_nid_t *p;
277         for (p = pins; *p; p++)
278                 set_eapd(codec, *p, on);
279 }
280 
281 /* generic shutup callback;
282  * just turning off EPAD and a little pause for avoiding pop-noise
283  */
284 static void alc_eapd_shutup(struct hda_codec *codec)
285 {
286         struct alc_spec *spec = codec->spec;
287 
288         alc_auto_setup_eapd(codec, false);
289         if (!spec->no_depop_delay)
290                 msleep(200);
291         snd_hda_shutup_pins(codec);
292 }
293 
294 /* generic EAPD initialization */
295 static void alc_auto_init_amp(struct hda_codec *codec, int type)
296 {
297         unsigned int tmp;
298 
299         alc_auto_setup_eapd(codec, true);
300         switch (type) {
301         case ALC_INIT_GPIO1:
302                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
303                 break;
304         case ALC_INIT_GPIO2:
305                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
306                 break;
307         case ALC_INIT_GPIO3:
308                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
309                 break;
310         case ALC_INIT_DEFAULT:
311                 switch (codec->vendor_id) {
312                 case 0x10ec0260:
313                         snd_hda_codec_write(codec, 0x1a, 0,
314                                             AC_VERB_SET_COEF_INDEX, 7);
315                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
316                                                  AC_VERB_GET_PROC_COEF, 0);
317                         snd_hda_codec_write(codec, 0x1a, 0,
318                                             AC_VERB_SET_COEF_INDEX, 7);
319                         snd_hda_codec_write(codec, 0x1a, 0,
320                                             AC_VERB_SET_PROC_COEF,
321                                             tmp | 0x2010);
322                         break;
323                 case 0x10ec0262:
324                 case 0x10ec0880:
325                 case 0x10ec0882:
326                 case 0x10ec0883:
327                 case 0x10ec0885:
328                 case 0x10ec0887:
329                 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
330                 case 0x10ec0900:
331                         alc889_coef_init(codec);
332                         break;
333                 case 0x10ec0888:
334                         alc888_coef_init(codec);
335                         break;
336 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
337                 case 0x10ec0267:
338                 case 0x10ec0268:
339                         snd_hda_codec_write(codec, 0x20, 0,
340                                             AC_VERB_SET_COEF_INDEX, 7);
341                         tmp = snd_hda_codec_read(codec, 0x20, 0,
342                                                  AC_VERB_GET_PROC_COEF, 0);
343                         snd_hda_codec_write(codec, 0x20, 0,
344                                             AC_VERB_SET_COEF_INDEX, 7);
345                         snd_hda_codec_write(codec, 0x20, 0,
346                                             AC_VERB_SET_PROC_COEF,
347                                             tmp | 0x3000);
348                         break;
349 #endif /* XXX */
350                 }
351                 break;
352         }
353 }
354 
355 
356 /*
357  * Realtek SSID verification
358  */
359 
360 /* Could be any non-zero and even value. When used as fixup, tells
361  * the driver to ignore any present sku defines.
362  */
363 #define ALC_FIXUP_SKU_IGNORE (2)
364 
365 static void alc_fixup_sku_ignore(struct hda_codec *codec,
366                                  const struct hda_fixup *fix, int action)
367 {
368         struct alc_spec *spec = codec->spec;
369         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
370                 spec->cdefine.fixup = 1;
371                 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
372         }
373 }
374 
375 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
376                                     const struct hda_fixup *fix, int action)
377 {
378         struct alc_spec *spec = codec->spec;
379 
380         if (action == HDA_FIXUP_ACT_PROBE) {
381                 spec->no_depop_delay = 1;
382                 codec->depop_delay = 0;
383         }
384 }
385 
386 static int alc_auto_parse_customize_define(struct hda_codec *codec)
387 {
388         unsigned int ass, tmp, i;
389         unsigned nid = 0;
390         struct alc_spec *spec = codec->spec;
391 
392         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
393 
394         if (spec->cdefine.fixup) {
395                 ass = spec->cdefine.sku_cfg;
396                 if (ass == ALC_FIXUP_SKU_IGNORE)
397                         return -1;
398                 goto do_sku;
399         }
400 
401         ass = codec->subsystem_id & 0xffff;
402         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
403                 goto do_sku;
404 
405         nid = 0x1d;
406         if (codec->vendor_id == 0x10ec0260)
407                 nid = 0x17;
408         ass = snd_hda_codec_get_pincfg(codec, nid);
409 
410         if (!(ass & 1)) {
411                 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
412                        codec->chip_name, ass);
413                 return -1;
414         }
415 
416         /* check sum */
417         tmp = 0;
418         for (i = 1; i < 16; i++) {
419                 if ((ass >> i) & 1)
420                         tmp++;
421         }
422         if (((ass >> 16) & 0xf) != tmp)
423                 return -1;
424 
425         spec->cdefine.port_connectivity = ass >> 30;
426         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
427         spec->cdefine.check_sum = (ass >> 16) & 0xf;
428         spec->cdefine.customization = ass >> 8;
429 do_sku:
430         spec->cdefine.sku_cfg = ass;
431         spec->cdefine.external_amp = (ass & 0x38) >> 3;
432         spec->cdefine.platform_type = (ass & 0x4) >> 2;
433         spec->cdefine.swap = (ass & 0x2) >> 1;
434         spec->cdefine.override = ass & 0x1;
435 
436         snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
437                    nid, spec->cdefine.sku_cfg);
438         snd_printd("SKU: port_connectivity=0x%x\n",
439                    spec->cdefine.port_connectivity);
440         snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
441         snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
442         snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
443         snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
444         snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
445         snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
446         snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
447 
448         return 0;
449 }
450 
451 /* return the position of NID in the list, or -1 if not found */
452 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
453 {
454         int i;
455         for (i = 0; i < nums; i++)
456                 if (list[i] == nid)
457                         return i;
458         return -1;
459 }
460 /* return true if the given NID is found in the list */
461 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
462 {
463         return find_idx_in_nid_list(nid, list, nums) >= 0;
464 }
465 
466 /* check subsystem ID and set up device-specific initialization;
467  * return 1 if initialized, 0 if invalid SSID
468  */
469 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
470  *      31 ~ 16 :       Manufacture ID
471  *      15 ~ 8  :       SKU ID
472  *      7  ~ 0  :       Assembly ID
473  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
474  */
475 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
476 {
477         unsigned int ass, tmp, i;
478         unsigned nid;
479         struct alc_spec *spec = codec->spec;
480 
481         if (spec->cdefine.fixup) {
482                 ass = spec->cdefine.sku_cfg;
483                 if (ass == ALC_FIXUP_SKU_IGNORE)
484                         return 0;
485                 goto do_sku;
486         }
487 
488         ass = codec->subsystem_id & 0xffff;
489         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
490                 goto do_sku;
491 
492         /* invalid SSID, check the special NID pin defcfg instead */
493         /*
494          * 31~30        : port connectivity
495          * 29~21        : reserve
496          * 20           : PCBEEP input
497          * 19~16        : Check sum (15:1)
498          * 15~1         : Custom
499          * 0            : override
500         */
501         nid = 0x1d;
502         if (codec->vendor_id == 0x10ec0260)
503                 nid = 0x17;
504         ass = snd_hda_codec_get_pincfg(codec, nid);
505         snd_printd("realtek: No valid SSID, "
506                    "checking pincfg 0x%08x for NID 0x%x\n",
507                    ass, nid);
508         if (!(ass & 1))
509                 return 0;
510         if ((ass >> 30) != 1)   /* no physical connection */
511                 return 0;
512 
513         /* check sum */
514         tmp = 0;
515         for (i = 1; i < 16; i++) {
516                 if ((ass >> i) & 1)
517                         tmp++;
518         }
519         if (((ass >> 16) & 0xf) != tmp)
520                 return 0;
521 do_sku:
522         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
523                    ass & 0xffff, codec->vendor_id);
524         /*
525          * 0 : override
526          * 1 :  Swap Jack
527          * 2 : 0 --> Desktop, 1 --> Laptop
528          * 3~5 : External Amplifier control
529          * 7~6 : Reserved
530         */
531         tmp = (ass & 0x38) >> 3;        /* external Amp control */
532         switch (tmp) {
533         case 1:
534                 spec->init_amp = ALC_INIT_GPIO1;
535                 break;
536         case 3:
537                 spec->init_amp = ALC_INIT_GPIO2;
538                 break;
539         case 7:
540                 spec->init_amp = ALC_INIT_GPIO3;
541                 break;
542         case 5:
543         default:
544                 spec->init_amp = ALC_INIT_DEFAULT;
545                 break;
546         }
547 
548         /* is laptop or Desktop and enable the function "Mute internal speaker
549          * when the external headphone out jack is plugged"
550          */
551         if (!(ass & 0x8000))
552                 return 1;
553         /*
554          * 10~8 : Jack location
555          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
556          * 14~13: Resvered
557          * 15   : 1 --> enable the function "Mute internal speaker
558          *              when the external headphone out jack is plugged"
559          */
560         if (!spec->gen.autocfg.hp_pins[0] &&
561             !(spec->gen.autocfg.line_out_pins[0] &&
562               spec->gen.autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
563                 hda_nid_t nid;
564                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
565                 nid = ports[tmp];
566                 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
567                                       spec->gen.autocfg.line_outs))
568                         return 1;
569                 spec->gen.autocfg.hp_pins[0] = nid;
570         }
571         return 1;
572 }
573 
574 /* Check the validity of ALC subsystem-id
575  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
576 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
577 {
578         if (!alc_subsystem_id(codec, ports)) {
579                 struct alc_spec *spec = codec->spec;
580                 snd_printd("realtek: "
581                            "Enable default setup for auto mode as fallback\n");
582                 spec->init_amp = ALC_INIT_DEFAULT;
583         }
584 }
585 
586 /*
587  * COEF access helper functions
588  */
589 
590 static int alc_read_coefex_idx(struct hda_codec *codec,
591                                         hda_nid_t nid,
592                                         unsigned int coef_idx)
593 {
594         unsigned int val;
595         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX,
596                                 coef_idx);
597         val = snd_hda_codec_read(codec, nid, 0,
598                                 AC_VERB_GET_PROC_COEF, 0);
599         return val;
600 }
601 
602 #define alc_read_coef_idx(codec, coef_idx) \
603         alc_read_coefex_idx(codec, 0x20, coef_idx)
604 
605 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
606                                                         unsigned int coef_idx,
607                                                         unsigned int coef_val)
608 {
609         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX,
610                             coef_idx);
611         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF,
612                             coef_val);
613 }
614 
615 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
616         alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
617 
618 /* a special bypass for COEF 0; read the cached value at the second time */
619 static unsigned int alc_get_coef0(struct hda_codec *codec)
620 {
621         struct alc_spec *spec = codec->spec;
622         if (!spec->coef0)
623                 spec->coef0 = alc_read_coef_idx(codec, 0);
624         return spec->coef0;
625 }
626 
627 /*
628  */
629 
630 static hda_nid_t get_adc_nid(struct hda_codec *codec, int adc_idx, int imux_idx)
631 {
632         struct hda_gen_spec *spec = codec->spec;
633         if (spec->dyn_adc_switch)
634                 adc_idx = spec->dyn_adc_idx[imux_idx];
635         return spec->adc_nids[adc_idx];
636 }
637 
638 static void alc_inv_dmic_sync_adc(struct hda_codec *codec, int adc_idx)
639 {
640         struct alc_spec *spec = codec->spec;
641         struct hda_input_mux *imux = &spec->gen.input_mux;
642         struct nid_path *path;
643         hda_nid_t nid;
644         int i, dir, parm;
645         unsigned int val;
646 
647         for (i = 0; i < imux->num_items; i++) {
648                 if (spec->gen.imux_pins[i] == spec->inv_dmic_pin)
649                         break;
650         }
651         if (i >= imux->num_items)
652                 return;
653 
654         path = snd_hda_get_nid_path(codec, spec->inv_dmic_pin,
655                                     get_adc_nid(codec, adc_idx, i));
656         val = path->ctls[NID_PATH_MUTE_CTL];
657         if (!val)
658                 return;
659         nid = get_amp_nid_(val);
660         dir = get_amp_direction_(val);
661         parm = AC_AMP_SET_RIGHT |
662                 (dir == HDA_OUTPUT ? AC_AMP_SET_OUTPUT : AC_AMP_SET_INPUT);
663 
664         /* flush all cached amps at first */
665         snd_hda_codec_flush_cache(codec);
666 
667         /* we care only right channel */
668         val = snd_hda_codec_amp_read(codec, nid, 1, dir, 0);
669         if (val & 0x80) /* if already muted, we don't need to touch */
670                 return;
671         val |= 0x80;
672         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
673                             parm | val);
674 }
675 
676 /*
677  * Inverted digital-mic handling
678  *
679  * First off, it's a bit tricky.  The "Inverted Internal Mic Capture Switch"
680  * gives the additional mute only to the right channel of the digital mic
681  * capture stream.  This is a workaround for avoiding the almost silence
682  * by summing the stereo stream from some (known to be ForteMedia)
683  * digital mic unit.
684  *
685  * The logic is to call alc_inv_dmic_sync() after each action (possibly)
686  * modifying ADC amp.  When the mute flag is set, it mutes the R-channel
687  * without caching so that the cache can still keep the original value.
688  * The cached value is then restored when the flag is set off or any other
689  * than d-mic is used as the current input source.
690  */
691 static void alc_inv_dmic_sync(struct hda_codec *codec, bool force)
692 {
693         struct alc_spec *spec = codec->spec;
694         int src, nums;
695 
696         if (!spec->inv_dmic_fixup)
697                 return;
698         if (!spec->inv_dmic_muted && !force)
699                 return;
700         nums = spec->gen.dyn_adc_switch ? 1 : spec->gen.num_adc_nids;
701         for (src = 0; src < nums; src++) {
702                 bool dmic_fixup = false;
703 
704                 if (spec->inv_dmic_muted &&
705                     spec->gen.imux_pins[spec->gen.cur_mux[src]] == spec->inv_dmic_pin)
706                         dmic_fixup = true;
707                 if (!dmic_fixup && !force)
708                         continue;
709                 alc_inv_dmic_sync_adc(codec, src);
710         }
711 }
712 
713 static void alc_inv_dmic_hook(struct hda_codec *codec,
714                               struct snd_kcontrol *kcontrol,
715                               struct snd_ctl_elem_value *ucontrol)
716 {
717         alc_inv_dmic_sync(codec, false);
718 }
719 
720 static int alc_inv_dmic_sw_get(struct snd_kcontrol *kcontrol,
721                                struct snd_ctl_elem_value *ucontrol)
722 {
723         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
724         struct alc_spec *spec = codec->spec;
725 
726         ucontrol->value.integer.value[0] = !spec->inv_dmic_muted;
727         return 0;
728 }
729 
730 static int alc_inv_dmic_sw_put(struct snd_kcontrol *kcontrol,
731                                struct snd_ctl_elem_value *ucontrol)
732 {
733         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
734         struct alc_spec *spec = codec->spec;
735         unsigned int val = !ucontrol->value.integer.value[0];
736 
737         if (val == spec->inv_dmic_muted)
738                 return 0;
739         spec->inv_dmic_muted = val;
740         alc_inv_dmic_sync(codec, true);
741         return 0;
742 }
743 
744 static const struct snd_kcontrol_new alc_inv_dmic_sw = {
745         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
746         .name = "Inverted Internal Mic Capture Switch",
747         .info = snd_ctl_boolean_mono_info,
748         .get = alc_inv_dmic_sw_get,
749         .put = alc_inv_dmic_sw_put,
750 };
751 
752 static int alc_add_inv_dmic_mixer(struct hda_codec *codec, hda_nid_t nid)
753 {
754         struct alc_spec *spec = codec->spec;
755 
756         if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &alc_inv_dmic_sw))
757                 return -ENOMEM;
758         spec->inv_dmic_fixup = 1;
759         spec->inv_dmic_muted = 0;
760         spec->inv_dmic_pin = nid;
761         spec->gen.cap_sync_hook = alc_inv_dmic_hook;
762         return 0;
763 }
764 
765 /* typically the digital mic is put at node 0x12 */
766 static void alc_fixup_inv_dmic_0x12(struct hda_codec *codec,
767                                     const struct hda_fixup *fix, int action)
768 {
769         if (action == HDA_FIXUP_ACT_PROBE)
770                 alc_add_inv_dmic_mixer(codec, 0x12);
771 }
772 
773 
774 #ifdef CONFIG_SND_HDA_INPUT_BEEP
775 /* additional beep mixers; the actual parameters are overwritten at build */
776 static const struct snd_kcontrol_new alc_beep_mixer[] = {
777         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
778         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
779         { } /* end */
780 };
781 #endif
782 
783 static int alc_build_controls(struct hda_codec *codec)
784 {
785         struct alc_spec *spec = codec->spec;
786         int i, err;
787 
788         err = snd_hda_gen_build_controls(codec);
789         if (err < 0)
790                 return err;
791 
792         for (i = 0; i < spec->num_mixers; i++) {
793                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
794                 if (err < 0)
795                         return err;
796         }
797 
798 #ifdef CONFIG_SND_HDA_INPUT_BEEP
799         /* create beep controls if needed */
800         if (spec->beep_amp) {
801                 const struct snd_kcontrol_new *knew;
802                 for (knew = alc_beep_mixer; knew->name; knew++) {
803                         struct snd_kcontrol *kctl;
804                         kctl = snd_ctl_new1(knew, codec);
805                         if (!kctl)
806                                 return -ENOMEM;
807                         kctl->private_value = spec->beep_amp;
808                         err = snd_hda_ctl_add(codec, 0, kctl);
809                         if (err < 0)
810                                 return err;
811                 }
812         }
813 #endif
814 
815         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
816         return 0;
817 }
818 
819 
820 /*
821  * Common callbacks
822  */
823 
824 static int alc_init(struct hda_codec *codec)
825 {
826         struct alc_spec *spec = codec->spec;
827 
828         if (spec->init_hook)
829                 spec->init_hook(codec);
830 
831         alc_fix_pll(codec);
832         alc_auto_init_amp(codec, spec->init_amp);
833 
834         snd_hda_gen_init(codec);
835 
836         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
837 
838         return 0;
839 }
840 
841 static inline void alc_shutup(struct hda_codec *codec)
842 {
843         struct alc_spec *spec = codec->spec;
844 
845         if (spec && spec->shutup)
846                 spec->shutup(codec);
847         else
848                 snd_hda_shutup_pins(codec);
849 }
850 
851 static void alc_free(struct hda_codec *codec)
852 {
853         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_FREE);
854         snd_hda_gen_free(codec);
855 }
856 
857 #ifdef CONFIG_PM
858 static void alc_power_eapd(struct hda_codec *codec)
859 {
860         alc_auto_setup_eapd(codec, false);
861 }
862 
863 static int alc_suspend(struct hda_codec *codec)
864 {
865         struct alc_spec *spec = codec->spec;
866         alc_shutup(codec);
867         if (spec && spec->power_hook)
868                 spec->power_hook(codec);
869         return 0;
870 }
871 #endif
872 
873 #ifdef CONFIG_PM
874 static int alc_resume(struct hda_codec *codec)
875 {
876         struct alc_spec *spec = codec->spec;
877 
878         if (!spec->no_depop_delay)
879                 msleep(150); /* to avoid pop noise */
880         codec->patch_ops.init(codec);
881         snd_hda_codec_resume_amp(codec);
882         snd_hda_codec_resume_cache(codec);
883         alc_inv_dmic_sync(codec, true);
884         hda_call_check_power_status(codec, 0x01);
885         return 0;
886 }
887 #endif
888 
889 /*
890  */
891 static const struct hda_codec_ops alc_patch_ops = {
892         .build_controls = alc_build_controls,
893         .build_pcms = snd_hda_gen_build_pcms,
894         .init = alc_init,
895         .free = alc_free,
896         .unsol_event = snd_hda_jack_unsol_event,
897 #ifdef CONFIG_PM
898         .resume = alc_resume,
899         .suspend = alc_suspend,
900         .check_power_status = snd_hda_gen_check_power_status,
901 #endif
902         .reboot_notify = alc_shutup,
903 };
904 
905 
906 /* replace the codec chip_name with the given string */
907 static int alc_codec_rename(struct hda_codec *codec, const char *name)
908 {
909         kfree(codec->chip_name);
910         codec->chip_name = kstrdup(name, GFP_KERNEL);
911         if (!codec->chip_name) {
912                 alc_free(codec);
913                 return -ENOMEM;
914         }
915         return 0;
916 }
917 
918 /*
919  * Rename codecs appropriately from COEF value or subvendor id
920  */
921 struct alc_codec_rename_table {
922         unsigned int vendor_id;
923         unsigned short coef_mask;
924         unsigned short coef_bits;
925         const char *name;
926 };
927 
928 struct alc_codec_rename_pci_table {
929         unsigned int codec_vendor_id;
930         unsigned short pci_subvendor;
931         unsigned short pci_subdevice;
932         const char *name;
933 };
934 
935 static struct alc_codec_rename_table rename_tbl[] = {
936         { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
937         { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
938         { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
939         { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
940         { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
941         { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
942         { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
943         { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
944         { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
945         { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
946         { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
947         { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
948         { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
949         { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
950         { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
951         { } /* terminator */
952 };
953 
954 static struct alc_codec_rename_pci_table rename_pci_tbl[] = {
955         { 0x10ec0280, 0x1028, 0, "ALC3220" },
956         { 0x10ec0282, 0x1028, 0, "ALC3221" },
957         { 0x10ec0283, 0x1028, 0, "ALC3223" },
958         { 0x10ec0292, 0x1028, 0, "ALC3226" },
959         { 0x10ec0255, 0x1028, 0, "ALC3234" },
960         { 0x10ec0668, 0x1028, 0, "ALC3661" },
961         { } /* terminator */
962 };
963 
964 static int alc_codec_rename_from_preset(struct hda_codec *codec)
965 {
966         const struct alc_codec_rename_table *p;
967         const struct alc_codec_rename_pci_table *q;
968 
969         for (p = rename_tbl; p->vendor_id; p++) {
970                 if (p->vendor_id != codec->vendor_id)
971                         continue;
972                 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
973                         return alc_codec_rename(codec, p->name);
974         }
975 
976         for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
977                 if (q->codec_vendor_id != codec->vendor_id)
978                         continue;
979                 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
980                         continue;
981                 if (!q->pci_subdevice ||
982                     q->pci_subdevice == codec->bus->pci->subsystem_device)
983                         return alc_codec_rename(codec, q->name);
984         }
985 
986         return 0;
987 }
988 
989 
990 /*
991  * Digital-beep handlers
992  */
993 #ifdef CONFIG_SND_HDA_INPUT_BEEP
994 #define set_beep_amp(spec, nid, idx, dir) \
995         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
996 
997 static const struct snd_pci_quirk beep_white_list[] = {
998         SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
999         SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1000         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1001         SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1002         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1003         SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1004         SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1005         SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1006         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1007         {}
1008 };
1009 
1010 static inline int has_cdefine_beep(struct hda_codec *codec)
1011 {
1012         struct alc_spec *spec = codec->spec;
1013         const struct snd_pci_quirk *q;
1014         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
1015         if (q)
1016                 return q->value;
1017         return spec->cdefine.enable_pcbeep;
1018 }
1019 #else
1020 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
1021 #define has_cdefine_beep(codec)         0
1022 #endif
1023 
1024 /* parse the BIOS configuration and set up the alc_spec */
1025 /* return 1 if successful, 0 if the proper config is not found,
1026  * or a negative error code
1027  */
1028 static int alc_parse_auto_config(struct hda_codec *codec,
1029                                  const hda_nid_t *ignore_nids,
1030                                  const hda_nid_t *ssid_nids)
1031 {
1032         struct alc_spec *spec = codec->spec;
1033         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1034         int err;
1035 
1036         err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1037                                        spec->parse_flags);
1038         if (err < 0)
1039                 return err;
1040 
1041         if (ssid_nids)
1042                 alc_ssid_check(codec, ssid_nids);
1043 
1044         err = snd_hda_gen_parse_auto_config(codec, cfg);
1045         if (err < 0)
1046                 return err;
1047 
1048         return 1;
1049 }
1050 
1051 /* common preparation job for alc_spec */
1052 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1053 {
1054         struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1055         int err;
1056 
1057         if (!spec)
1058                 return -ENOMEM;
1059         codec->spec = spec;
1060         snd_hda_gen_spec_init(&spec->gen);
1061         spec->gen.mixer_nid = mixer_nid;
1062         spec->gen.own_eapd_ctl = 1;
1063         codec->single_adc_amp = 1;
1064         /* FIXME: do we need this for all Realtek codec models? */
1065         codec->spdif_status_reset = 1;
1066 
1067         err = alc_codec_rename_from_preset(codec);
1068         if (err < 0) {
1069                 kfree(spec);
1070                 return err;
1071         }
1072         return 0;
1073 }
1074 
1075 static int alc880_parse_auto_config(struct hda_codec *codec)
1076 {
1077         static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1078         static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1079         return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1080 }
1081 
1082 /*
1083  * ALC880 fix-ups
1084  */
1085 enum {
1086         ALC880_FIXUP_GPIO1,
1087         ALC880_FIXUP_GPIO2,
1088         ALC880_FIXUP_MEDION_RIM,
1089         ALC880_FIXUP_LG,
1090         ALC880_FIXUP_LG_LW25,
1091         ALC880_FIXUP_W810,
1092         ALC880_FIXUP_EAPD_COEF,
1093         ALC880_FIXUP_TCL_S700,
1094         ALC880_FIXUP_VOL_KNOB,
1095         ALC880_FIXUP_FUJITSU,
1096         ALC880_FIXUP_F1734,
1097         ALC880_FIXUP_UNIWILL,
1098         ALC880_FIXUP_UNIWILL_DIG,
1099         ALC880_FIXUP_Z71V,
1100         ALC880_FIXUP_ASUS_W5A,
1101         ALC880_FIXUP_3ST_BASE,
1102         ALC880_FIXUP_3ST,
1103         ALC880_FIXUP_3ST_DIG,
1104         ALC880_FIXUP_5ST_BASE,
1105         ALC880_FIXUP_5ST,
1106         ALC880_FIXUP_5ST_DIG,
1107         ALC880_FIXUP_6ST_BASE,
1108         ALC880_FIXUP_6ST,
1109         ALC880_FIXUP_6ST_DIG,
1110         ALC880_FIXUP_6ST_AUTOMUTE,
1111 };
1112 
1113 /* enable the volume-knob widget support on NID 0x21 */
1114 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1115                                   const struct hda_fixup *fix, int action)
1116 {
1117         if (action == HDA_FIXUP_ACT_PROBE)
1118                 snd_hda_jack_detect_enable_callback(codec, 0x21, ALC_DCVOL_EVENT, alc_update_knob_master);
1119 }
1120 
1121 static const struct hda_fixup alc880_fixups[] = {
1122         [ALC880_FIXUP_GPIO1] = {
1123                 .type = HDA_FIXUP_VERBS,
1124                 .v.verbs = alc_gpio1_init_verbs,
1125         },
1126         [ALC880_FIXUP_GPIO2] = {
1127                 .type = HDA_FIXUP_VERBS,
1128                 .v.verbs = alc_gpio2_init_verbs,
1129         },
1130         [ALC880_FIXUP_MEDION_RIM] = {
1131                 .type = HDA_FIXUP_VERBS,
1132                 .v.verbs = (const struct hda_verb[]) {
1133                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1134                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1135                         { }
1136                 },
1137                 .chained = true,
1138                 .chain_id = ALC880_FIXUP_GPIO2,
1139         },
1140         [ALC880_FIXUP_LG] = {
1141                 .type = HDA_FIXUP_PINS,
1142                 .v.pins = (const struct hda_pintbl[]) {
1143                         /* disable bogus unused pins */
1144                         { 0x16, 0x411111f0 },
1145                         { 0x18, 0x411111f0 },
1146                         { 0x1a, 0x411111f0 },
1147                         { }
1148                 }
1149         },
1150         [ALC880_FIXUP_LG_LW25] = {
1151                 .type = HDA_FIXUP_PINS,
1152                 .v.pins = (const struct hda_pintbl[]) {
1153                         { 0x1a, 0x0181344f }, /* line-in */
1154                         { 0x1b, 0x0321403f }, /* headphone */
1155                         { }
1156                 }
1157         },
1158         [ALC880_FIXUP_W810] = {
1159                 .type = HDA_FIXUP_PINS,
1160                 .v.pins = (const struct hda_pintbl[]) {
1161                         /* disable bogus unused pins */
1162                         { 0x17, 0x411111f0 },
1163                         { }
1164                 },
1165                 .chained = true,
1166                 .chain_id = ALC880_FIXUP_GPIO2,
1167         },
1168         [ALC880_FIXUP_EAPD_COEF] = {
1169                 .type = HDA_FIXUP_VERBS,
1170                 .v.verbs = (const struct hda_verb[]) {
1171                         /* change to EAPD mode */
1172                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1173                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1174                         {}
1175                 },
1176         },
1177         [ALC880_FIXUP_TCL_S700] = {
1178                 .type = HDA_FIXUP_VERBS,
1179                 .v.verbs = (const struct hda_verb[]) {
1180                         /* change to EAPD mode */
1181                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1182                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
1183                         {}
1184                 },
1185                 .chained = true,
1186                 .chain_id = ALC880_FIXUP_GPIO2,
1187         },
1188         [ALC880_FIXUP_VOL_KNOB] = {
1189                 .type = HDA_FIXUP_FUNC,
1190                 .v.func = alc880_fixup_vol_knob,
1191         },
1192         [ALC880_FIXUP_FUJITSU] = {
1193                 /* override all pins as BIOS on old Amilo is broken */
1194                 .type = HDA_FIXUP_PINS,
1195                 .v.pins = (const struct hda_pintbl[]) {
1196                         { 0x14, 0x0121401f }, /* HP */
1197                         { 0x15, 0x99030120 }, /* speaker */
1198                         { 0x16, 0x99030130 }, /* bass speaker */
1199                         { 0x17, 0x411111f0 }, /* N/A */
1200                         { 0x18, 0x411111f0 }, /* N/A */
1201                         { 0x19, 0x01a19950 }, /* mic-in */
1202                         { 0x1a, 0x411111f0 }, /* N/A */
1203                         { 0x1b, 0x411111f0 }, /* N/A */
1204                         { 0x1c, 0x411111f0 }, /* N/A */
1205                         { 0x1d, 0x411111f0 }, /* N/A */
1206                         { 0x1e, 0x01454140 }, /* SPDIF out */
1207                         { }
1208                 },
1209                 .chained = true,
1210                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1211         },
1212         [ALC880_FIXUP_F1734] = {
1213                 /* almost compatible with FUJITSU, but no bass and SPDIF */
1214                 .type = HDA_FIXUP_PINS,
1215                 .v.pins = (const struct hda_pintbl[]) {
1216                         { 0x14, 0x0121401f }, /* HP */
1217                         { 0x15, 0x99030120 }, /* speaker */
1218                         { 0x16, 0x411111f0 }, /* N/A */
1219                         { 0x17, 0x411111f0 }, /* N/A */
1220                         { 0x18, 0x411111f0 }, /* N/A */
1221                         { 0x19, 0x01a19950 }, /* mic-in */
1222                         { 0x1a, 0x411111f0 }, /* N/A */
1223                         { 0x1b, 0x411111f0 }, /* N/A */
1224                         { 0x1c, 0x411111f0 }, /* N/A */
1225                         { 0x1d, 0x411111f0 }, /* N/A */
1226                         { 0x1e, 0x411111f0 }, /* N/A */
1227                         { }
1228                 },
1229                 .chained = true,
1230                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1231         },
1232         [ALC880_FIXUP_UNIWILL] = {
1233                 /* need to fix HP and speaker pins to be parsed correctly */
1234                 .type = HDA_FIXUP_PINS,
1235                 .v.pins = (const struct hda_pintbl[]) {
1236                         { 0x14, 0x0121411f }, /* HP */
1237                         { 0x15, 0x99030120 }, /* speaker */
1238                         { 0x16, 0x99030130 }, /* bass speaker */
1239                         { }
1240                 },
1241         },
1242         [ALC880_FIXUP_UNIWILL_DIG] = {
1243                 .type = HDA_FIXUP_PINS,
1244                 .v.pins = (const struct hda_pintbl[]) {
1245                         /* disable bogus unused pins */
1246                         { 0x17, 0x411111f0 },
1247                         { 0x19, 0x411111f0 },
1248                         { 0x1b, 0x411111f0 },
1249                         { 0x1f, 0x411111f0 },
1250                         { }
1251                 }
1252         },
1253         [ALC880_FIXUP_Z71V] = {
1254                 .type = HDA_FIXUP_PINS,
1255                 .v.pins = (const struct hda_pintbl[]) {
1256                         /* set up the whole pins as BIOS is utterly broken */
1257                         { 0x14, 0x99030120 }, /* speaker */
1258                         { 0x15, 0x0121411f }, /* HP */
1259                         { 0x16, 0x411111f0 }, /* N/A */
1260                         { 0x17, 0x411111f0 }, /* N/A */
1261                         { 0x18, 0x01a19950 }, /* mic-in */
1262                         { 0x19, 0x411111f0 }, /* N/A */
1263                         { 0x1a, 0x01813031 }, /* line-in */
1264                         { 0x1b, 0x411111f0 }, /* N/A */
1265                         { 0x1c, 0x411111f0 }, /* N/A */
1266                         { 0x1d, 0x411111f0 }, /* N/A */
1267                         { 0x1e, 0x0144111e }, /* SPDIF */
1268                         { }
1269                 }
1270         },
1271         [ALC880_FIXUP_ASUS_W5A] = {
1272                 .type = HDA_FIXUP_PINS,
1273                 .v.pins = (const struct hda_pintbl[]) {
1274                         /* set up the whole pins as BIOS is utterly broken */
1275                         { 0x14, 0x0121411f }, /* HP */
1276                         { 0x15, 0x411111f0 }, /* N/A */
1277                         { 0x16, 0x411111f0 }, /* N/A */
1278                         { 0x17, 0x411111f0 }, /* N/A */
1279                         { 0x18, 0x90a60160 }, /* mic */
1280                         { 0x19, 0x411111f0 }, /* N/A */
1281                         { 0x1a, 0x411111f0 }, /* N/A */
1282                         { 0x1b, 0x411111f0 }, /* N/A */
1283                         { 0x1c, 0x411111f0 }, /* N/A */
1284                         { 0x1d, 0x411111f0 }, /* N/A */
1285                         { 0x1e, 0xb743111e }, /* SPDIF out */
1286                         { }
1287                 },
1288                 .chained = true,
1289                 .chain_id = ALC880_FIXUP_GPIO1,
1290         },
1291         [ALC880_FIXUP_3ST_BASE] = {
1292                 .type = HDA_FIXUP_PINS,
1293                 .v.pins = (const struct hda_pintbl[]) {
1294                         { 0x14, 0x01014010 }, /* line-out */
1295                         { 0x15, 0x411111f0 }, /* N/A */
1296                         { 0x16, 0x411111f0 }, /* N/A */
1297                         { 0x17, 0x411111f0 }, /* N/A */
1298                         { 0x18, 0x01a19c30 }, /* mic-in */
1299                         { 0x19, 0x0121411f }, /* HP */
1300                         { 0x1a, 0x01813031 }, /* line-in */
1301                         { 0x1b, 0x02a19c40 }, /* front-mic */
1302                         { 0x1c, 0x411111f0 }, /* N/A */
1303                         { 0x1d, 0x411111f0 }, /* N/A */
1304                         /* 0x1e is filled in below */
1305                         { 0x1f, 0x411111f0 }, /* N/A */
1306                         { }
1307                 }
1308         },
1309         [ALC880_FIXUP_3ST] = {
1310                 .type = HDA_FIXUP_PINS,
1311                 .v.pins = (const struct hda_pintbl[]) {
1312                         { 0x1e, 0x411111f0 }, /* N/A */
1313                         { }
1314                 },
1315                 .chained = true,
1316                 .chain_id = ALC880_FIXUP_3ST_BASE,
1317         },
1318         [ALC880_FIXUP_3ST_DIG] = {
1319                 .type = HDA_FIXUP_PINS,
1320                 .v.pins = (const struct hda_pintbl[]) {
1321                         { 0x1e, 0x0144111e }, /* SPDIF */
1322                         { }
1323                 },
1324                 .chained = true,
1325                 .chain_id = ALC880_FIXUP_3ST_BASE,
1326         },
1327         [ALC880_FIXUP_5ST_BASE] = {
1328                 .type = HDA_FIXUP_PINS,
1329                 .v.pins = (const struct hda_pintbl[]) {
1330                         { 0x14, 0x01014010 }, /* front */
1331                         { 0x15, 0x411111f0 }, /* N/A */
1332                         { 0x16, 0x01011411 }, /* CLFE */
1333                         { 0x17, 0x01016412 }, /* surr */
1334                         { 0x18, 0x01a19c30 }, /* mic-in */
1335                         { 0x19, 0x0121411f }, /* HP */
1336                         { 0x1a, 0x01813031 }, /* line-in */
1337                         { 0x1b, 0x02a19c40 }, /* front-mic */
1338                         { 0x1c, 0x411111f0 }, /* N/A */
1339                         { 0x1d, 0x411111f0 }, /* N/A */
1340                         /* 0x1e is filled in below */
1341                         { 0x1f, 0x411111f0 }, /* N/A */
1342                         { }
1343                 }
1344         },
1345         [ALC880_FIXUP_5ST] = {
1346                 .type = HDA_FIXUP_PINS,
1347                 .v.pins = (const struct hda_pintbl[]) {
1348                         { 0x1e, 0x411111f0 }, /* N/A */
1349                         { }
1350                 },
1351                 .chained = true,
1352                 .chain_id = ALC880_FIXUP_5ST_BASE,
1353         },
1354         [ALC880_FIXUP_5ST_DIG] = {
1355                 .type = HDA_FIXUP_PINS,
1356                 .v.pins = (const struct hda_pintbl[]) {
1357                         { 0x1e, 0x0144111e }, /* SPDIF */
1358                         { }
1359                 },
1360                 .chained = true,
1361                 .chain_id = ALC880_FIXUP_5ST_BASE,
1362         },
1363         [ALC880_FIXUP_6ST_BASE] = {
1364                 .type = HDA_FIXUP_PINS,
1365                 .v.pins = (const struct hda_pintbl[]) {
1366                         { 0x14, 0x01014010 }, /* front */
1367                         { 0x15, 0x01016412 }, /* surr */
1368                         { 0x16, 0x01011411 }, /* CLFE */
1369                         { 0x17, 0x01012414 }, /* side */
1370                         { 0x18, 0x01a19c30 }, /* mic-in */
1371                         { 0x19, 0x02a19c40 }, /* front-mic */
1372                         { 0x1a, 0x01813031 }, /* line-in */
1373                         { 0x1b, 0x0121411f }, /* HP */
1374                         { 0x1c, 0x411111f0 }, /* N/A */
1375                         { 0x1d, 0x411111f0 }, /* N/A */
1376                         /* 0x1e is filled in below */
1377                         { 0x1f, 0x411111f0 }, /* N/A */
1378                         { }
1379                 }
1380         },
1381         [ALC880_FIXUP_6ST] = {
1382                 .type = HDA_FIXUP_PINS,
1383                 .v.pins = (const struct hda_pintbl[]) {
1384                         { 0x1e, 0x411111f0 }, /* N/A */
1385                         { }
1386                 },
1387                 .chained = true,
1388                 .chain_id = ALC880_FIXUP_6ST_BASE,
1389         },
1390         [ALC880_FIXUP_6ST_DIG] = {
1391                 .type = HDA_FIXUP_PINS,
1392                 .v.pins = (const struct hda_pintbl[]) {
1393                         { 0x1e, 0x0144111e }, /* SPDIF */
1394                         { }
1395                 },
1396                 .chained = true,
1397                 .chain_id = ALC880_FIXUP_6ST_BASE,
1398         },
1399         [ALC880_FIXUP_6ST_AUTOMUTE] = {
1400                 .type = HDA_FIXUP_PINS,
1401                 .v.pins = (const struct hda_pintbl[]) {
1402                         { 0x1b, 0x0121401f }, /* HP with jack detect */
1403                         { }
1404                 },
1405                 .chained_before = true,
1406                 .chain_id = ALC880_FIXUP_6ST_BASE,
1407         },
1408 };
1409 
1410 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1411         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1412         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1413         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1414         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1415         SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1416         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1417         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1418         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1419         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1420         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1421         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1422         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1423         SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1424         SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1425         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1426         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1427         SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1428         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1429         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1430         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1431         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1432         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1433 
1434         /* Below is the copied entries from alc880_quirks.c.
1435          * It's not quite sure whether BIOS sets the correct pin-config table
1436          * on these machines, thus they are kept to be compatible with
1437          * the old static quirks.  Once when it's confirmed to work without
1438          * these overrides, it'd be better to remove.
1439          */
1440         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1441         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1442         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1443         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1444         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1445         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1446         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1447         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1448         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1449         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1450         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1451         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1452         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1453         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1454         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1455         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1456         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1457         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1458         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1459         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1460         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1461         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1462         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1463         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1464         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1465         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1466         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1467         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1468         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1469         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1470         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1471         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1472         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1473         /* default Intel */
1474         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1475         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1476         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1477         {}
1478 };
1479 
1480 static const struct hda_model_fixup alc880_fixup_models[] = {
1481         {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1482         {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1483         {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1484         {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1485         {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1486         {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1487         {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1488         {}
1489 };
1490 
1491 
1492 /*
1493  * OK, here we have finally the patch for ALC880
1494  */
1495 static int patch_alc880(struct hda_codec *codec)
1496 {
1497         struct alc_spec *spec;
1498         int err;
1499 
1500         err = alc_alloc_spec(codec, 0x0b);
1501         if (err < 0)
1502                 return err;
1503 
1504         spec = codec->spec;
1505         spec->gen.need_dac_fix = 1;
1506         spec->gen.beep_nid = 0x01;
1507 
1508         snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1509                        alc880_fixups);
1510         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1511 
1512         /* automatic parse from the BIOS config */
1513         err = alc880_parse_auto_config(codec);
1514         if (err < 0)
1515                 goto error;
1516 
1517         if (!spec->gen.no_analog)
1518                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1519 
1520         codec->patch_ops = alc_patch_ops;
1521         codec->patch_ops.unsol_event = alc880_unsol_event;
1522 
1523 
1524         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1525 
1526         return 0;
1527 
1528  error:
1529         alc_free(codec);
1530         return err;
1531 }
1532 
1533 
1534 /*
1535  * ALC260 support
1536  */
1537 static int alc260_parse_auto_config(struct hda_codec *codec)
1538 {
1539         static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1540         static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1541         return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1542 }
1543 
1544 /*
1545  * Pin config fixes
1546  */
1547 enum {
1548         ALC260_FIXUP_HP_DC5750,
1549         ALC260_FIXUP_HP_PIN_0F,
1550         ALC260_FIXUP_COEF,
1551         ALC260_FIXUP_GPIO1,
1552         ALC260_FIXUP_GPIO1_TOGGLE,
1553         ALC260_FIXUP_REPLACER,
1554         ALC260_FIXUP_HP_B1900,
1555         ALC260_FIXUP_KN1,
1556         ALC260_FIXUP_FSC_S7020,
1557         ALC260_FIXUP_FSC_S7020_JWSE,
1558         ALC260_FIXUP_VAIO_PINS,
1559 };
1560 
1561 static void alc260_gpio1_automute(struct hda_codec *codec)
1562 {
1563         struct alc_spec *spec = codec->spec;
1564         snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1565                             spec->gen.hp_jack_present);
1566 }
1567 
1568 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1569                                       const struct hda_fixup *fix, int action)
1570 {
1571         struct alc_spec *spec = codec->spec;
1572         if (action == HDA_FIXUP_ACT_PROBE) {
1573                 /* although the machine has only one output pin, we need to
1574                  * toggle GPIO1 according to the jack state
1575                  */
1576                 spec->gen.automute_hook = alc260_gpio1_automute;
1577                 spec->gen.detect_hp = 1;
1578                 spec->gen.automute_speaker = 1;
1579                 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1580                 snd_hda_jack_detect_enable_callback(codec, 0x0f, HDA_GEN_HP_EVENT,
1581                                                     snd_hda_gen_hp_automute);
1582                 snd_hda_add_verbs(codec, alc_gpio1_init_verbs);
1583         }
1584 }
1585 
1586 static void alc260_fixup_kn1(struct hda_codec *codec,
1587                              const struct hda_fixup *fix, int action)
1588 {
1589         struct alc_spec *spec = codec->spec;
1590         static const struct hda_pintbl pincfgs[] = {
1591                 { 0x0f, 0x02214000 }, /* HP/speaker */
1592                 { 0x12, 0x90a60160 }, /* int mic */
1593                 { 0x13, 0x02a19000 }, /* ext mic */
1594                 { 0x18, 0x01446000 }, /* SPDIF out */
1595                 /* disable bogus I/O pins */
1596                 { 0x10, 0x411111f0 },
1597                 { 0x11, 0x411111f0 },
1598                 { 0x14, 0x411111f0 },
1599                 { 0x15, 0x411111f0 },
1600                 { 0x16, 0x411111f0 },
1601                 { 0x17, 0x411111f0 },
1602                 { 0x19, 0x411111f0 },
1603                 { }
1604         };
1605 
1606         switch (action) {
1607         case HDA_FIXUP_ACT_PRE_PROBE:
1608                 snd_hda_apply_pincfgs(codec, pincfgs);
1609                 break;
1610         case HDA_FIXUP_ACT_PROBE:
1611                 spec->init_amp = ALC_INIT_NONE;
1612                 break;
1613         }
1614 }
1615 
1616 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1617                                    const struct hda_fixup *fix, int action)
1618 {
1619         struct alc_spec *spec = codec->spec;
1620         if (action == HDA_FIXUP_ACT_PROBE)
1621                 spec->init_amp = ALC_INIT_NONE;
1622 }
1623 
1624 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1625                                    const struct hda_fixup *fix, int action)
1626 {
1627         struct alc_spec *spec = codec->spec;
1628         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1629                 spec->gen.add_jack_modes = 1;
1630                 spec->gen.hp_mic = 1;
1631         }
1632 }
1633 
1634 static const struct hda_fixup alc260_fixups[] = {
1635         [ALC260_FIXUP_HP_DC5750] = {
1636                 .type = HDA_FIXUP_PINS,
1637                 .v.pins = (const struct hda_pintbl[]) {
1638                         { 0x11, 0x90130110 }, /* speaker */
1639                         { }
1640                 }
1641         },
1642         [ALC260_FIXUP_HP_PIN_0F] = {
1643                 .type = HDA_FIXUP_PINS,
1644                 .v.pins = (const struct hda_pintbl[]) {
1645                         { 0x0f, 0x01214000 }, /* HP */
1646                         { }
1647                 }
1648         },
1649         [ALC260_FIXUP_COEF] = {
1650                 .type = HDA_FIXUP_VERBS,
1651                 .v.verbs = (const struct hda_verb[]) {
1652                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1653                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3040 },
1654                         { }
1655                 },
1656         },
1657         [ALC260_FIXUP_GPIO1] = {
1658                 .type = HDA_FIXUP_VERBS,
1659                 .v.verbs = alc_gpio1_init_verbs,
1660         },
1661         [ALC260_FIXUP_GPIO1_TOGGLE] = {
1662                 .type = HDA_FIXUP_FUNC,
1663                 .v.func = alc260_fixup_gpio1_toggle,
1664                 .chained = true,
1665                 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1666         },
1667         [ALC260_FIXUP_REPLACER] = {
1668                 .type = HDA_FIXUP_VERBS,
1669                 .v.verbs = (const struct hda_verb[]) {
1670                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1671                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3050 },
1672                         { }
1673                 },
1674                 .chained = true,
1675                 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1676         },
1677         [ALC260_FIXUP_HP_B1900] = {
1678                 .type = HDA_FIXUP_FUNC,
1679                 .v.func = alc260_fixup_gpio1_toggle,
1680                 .chained = true,
1681                 .chain_id = ALC260_FIXUP_COEF,
1682         },
1683         [ALC260_FIXUP_KN1] = {
1684                 .type = HDA_FIXUP_FUNC,
1685                 .v.func = alc260_fixup_kn1,
1686         },
1687         [ALC260_FIXUP_FSC_S7020] = {
1688                 .type = HDA_FIXUP_FUNC,
1689                 .v.func = alc260_fixup_fsc_s7020,
1690         },
1691         [ALC260_FIXUP_FSC_S7020_JWSE] = {
1692                 .type = HDA_FIXUP_FUNC,
1693                 .v.func = alc260_fixup_fsc_s7020_jwse,
1694                 .chained = true,
1695                 .chain_id = ALC260_FIXUP_FSC_S7020,
1696         },
1697         [ALC260_FIXUP_VAIO_PINS] = {
1698                 .type = HDA_FIXUP_PINS,
1699                 .v.pins = (const struct hda_pintbl[]) {
1700                         /* Pin configs are missing completely on some VAIOs */
1701                         { 0x0f, 0x01211020 },
1702                         { 0x10, 0x0001003f },
1703                         { 0x11, 0x411111f0 },
1704                         { 0x12, 0x01a15930 },
1705                         { 0x13, 0x411111f0 },
1706                         { 0x14, 0x411111f0 },
1707                         { 0x15, 0x411111f0 },
1708                         { 0x16, 0x411111f0 },
1709                         { 0x17, 0x411111f0 },
1710                         { 0x18, 0x411111f0 },
1711                         { 0x19, 0x411111f0 },
1712                         { }
1713                 }
1714         },
1715 };
1716 
1717 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1718         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1719         SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1720         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1721         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1722         SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1723         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1724         SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1725         SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1726         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1727         SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1728         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1729         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1730         {}
1731 };
1732 
1733 static const struct hda_model_fixup alc260_fixup_models[] = {
1734         {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1735         {.id = ALC260_FIXUP_COEF, .name = "coef"},
1736         {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1737         {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1738         {}
1739 };
1740 
1741 /*
1742  */
1743 static int patch_alc260(struct hda_codec *codec)
1744 {
1745         struct alc_spec *spec;
1746         int err;
1747 
1748         err = alc_alloc_spec(codec, 0x07);
1749         if (err < 0)
1750                 return err;
1751 
1752         spec = codec->spec;
1753         /* as quite a few machines require HP amp for speaker outputs,
1754          * it's easier to enable it unconditionally; even if it's unneeded,
1755          * it's almost harmless.
1756          */
1757         spec->gen.prefer_hp_amp = 1;
1758         spec->gen.beep_nid = 0x01;
1759 
1760         snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1761                            alc260_fixups);
1762         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1763 
1764         /* automatic parse from the BIOS config */
1765         err = alc260_parse_auto_config(codec);
1766         if (err < 0)
1767                 goto error;
1768 
1769         if (!spec->gen.no_analog)
1770                 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1771 
1772         codec->patch_ops = alc_patch_ops;
1773         spec->shutup = alc_eapd_shutup;
1774 
1775         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1776 
1777         return 0;
1778 
1779  error:
1780         alc_free(codec);
1781         return err;
1782 }
1783 
1784 
1785 /*
1786  * ALC882/883/885/888/889 support
1787  *
1788  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1789  * configuration.  Each pin widget can choose any input DACs and a mixer.
1790  * Each ADC is connected from a mixer of all inputs.  This makes possible
1791  * 6-channel independent captures.
1792  *
1793  * In addition, an independent DAC for the multi-playback (not used in this
1794  * driver yet).
1795  */
1796 
1797 /*
1798  * Pin config fixes
1799  */
1800 enum {
1801         ALC882_FIXUP_ABIT_AW9D_MAX,
1802         ALC882_FIXUP_LENOVO_Y530,
1803         ALC882_FIXUP_PB_M5210,
1804         ALC882_FIXUP_ACER_ASPIRE_7736,
1805         ALC882_FIXUP_ASUS_W90V,
1806         ALC889_FIXUP_CD,
1807         ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1808         ALC889_FIXUP_VAIO_TT,
1809         ALC888_FIXUP_EEE1601,
1810         ALC882_FIXUP_EAPD,
1811         ALC883_FIXUP_EAPD,
1812         ALC883_FIXUP_ACER_EAPD,
1813         ALC882_FIXUP_GPIO1,
1814         ALC882_FIXUP_GPIO2,
1815         ALC882_FIXUP_GPIO3,
1816         ALC889_FIXUP_COEF,
1817         ALC882_FIXUP_ASUS_W2JC,
1818         ALC882_FIXUP_ACER_ASPIRE_4930G,
1819         ALC882_FIXUP_ACER_ASPIRE_8930G,
1820         ALC882_FIXUP_ASPIRE_8930G_VERBS,
1821         ALC885_FIXUP_MACPRO_GPIO,
1822         ALC889_FIXUP_DAC_ROUTE,
1823         ALC889_FIXUP_MBP_VREF,
1824         ALC889_FIXUP_IMAC91_VREF,
1825         ALC889_FIXUP_MBA11_VREF,
1826         ALC889_FIXUP_MBA21_VREF,
1827         ALC889_FIXUP_MP11_VREF,
1828         ALC889_FIXUP_MP41_VREF,
1829         ALC882_FIXUP_INV_DMIC,
1830         ALC882_FIXUP_NO_PRIMARY_HP,
1831         ALC887_FIXUP_ASUS_BASS,
1832         ALC887_FIXUP_BASS_CHMAP,
1833 };
1834 
1835 static void alc889_fixup_coef(struct hda_codec *codec,
1836                               const struct hda_fixup *fix, int action)
1837 {
1838         if (action != HDA_FIXUP_ACT_INIT)
1839                 return;
1840         alc889_coef_init(codec);
1841 }
1842 
1843 /* toggle speaker-output according to the hp-jack state */
1844 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
1845 {
1846         unsigned int gpiostate, gpiomask, gpiodir;
1847 
1848         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
1849                                        AC_VERB_GET_GPIO_DATA, 0);
1850 
1851         if (!muted)
1852                 gpiostate |= (1 << pin);
1853         else
1854                 gpiostate &= ~(1 << pin);
1855 
1856         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
1857                                       AC_VERB_GET_GPIO_MASK, 0);
1858         gpiomask |= (1 << pin);
1859 
1860         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
1861                                      AC_VERB_GET_GPIO_DIRECTION, 0);
1862         gpiodir |= (1 << pin);
1863 
1864 
1865         snd_hda_codec_write(codec, codec->afg, 0,
1866                             AC_VERB_SET_GPIO_MASK, gpiomask);
1867         snd_hda_codec_write(codec, codec->afg, 0,
1868                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
1869 
1870         msleep(1);
1871 
1872         snd_hda_codec_write(codec, codec->afg, 0,
1873                             AC_VERB_SET_GPIO_DATA, gpiostate);
1874 }
1875 
1876 /* set up GPIO at initialization */
1877 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
1878                                      const struct hda_fixup *fix, int action)
1879 {
1880         if (action != HDA_FIXUP_ACT_INIT)
1881                 return;
1882         alc882_gpio_mute(codec, 0, 0);
1883         alc882_gpio_mute(codec, 1, 0);
1884 }
1885 
1886 /* Fix the connection of some pins for ALC889:
1887  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
1888  * work correctly (bko#42740)
1889  */
1890 static void alc889_fixup_dac_route(struct hda_codec *codec,
1891                                    const struct hda_fixup *fix, int action)
1892 {
1893         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1894                 /* fake the connections during parsing the tree */
1895                 hda_nid_t conn1[2] = { 0x0c, 0x0d };
1896                 hda_nid_t conn2[2] = { 0x0e, 0x0f };
1897                 snd_hda_override_conn_list(codec, 0x14, 2, conn1);
1898                 snd_hda_override_conn_list(codec, 0x15, 2, conn1);
1899                 snd_hda_override_conn_list(codec, 0x18, 2, conn2);
1900                 snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
1901         } else if (action == HDA_FIXUP_ACT_PROBE) {
1902                 /* restore the connections */
1903                 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
1904                 snd_hda_override_conn_list(codec, 0x14, 5, conn);
1905                 snd_hda_override_conn_list(codec, 0x15, 5, conn);
1906                 snd_hda_override_conn_list(codec, 0x18, 5, conn);
1907                 snd_hda_override_conn_list(codec, 0x1a, 5, conn);
1908         }
1909 }
1910 
1911 /* Set VREF on HP pin */
1912 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
1913                                   const struct hda_fixup *fix, int action)
1914 {
1915         struct alc_spec *spec = codec->spec;
1916         static hda_nid_t nids[3] = { 0x14, 0x15, 0x19 };
1917         int i;
1918 
1919         if (action != HDA_FIXUP_ACT_INIT)
1920                 return;
1921         for (i = 0; i < ARRAY_SIZE(nids); i++) {
1922                 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
1923                 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
1924                         continue;
1925                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1926                 val |= AC_PINCTL_VREF_80;
1927                 snd_hda_set_pin_ctl(codec, nids[i], val);
1928                 spec->gen.keep_vref_in_automute = 1;
1929                 break;
1930         }
1931 }
1932 
1933 static void alc889_fixup_mac_pins(struct hda_codec *codec,
1934                                   const hda_nid_t *nids, int num_nids)
1935 {
1936         struct alc_spec *spec = codec->spec;
1937         int i;
1938 
1939         for (i = 0; i < num_nids; i++) {
1940                 unsigned int val;
1941                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1942                 val |= AC_PINCTL_VREF_50;
1943                 snd_hda_set_pin_ctl(codec, nids[i], val);
1944         }
1945         spec->gen.keep_vref_in_automute = 1;
1946 }
1947 
1948 /* Set VREF on speaker pins on imac91 */
1949 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
1950                                      const struct hda_fixup *fix, int action)
1951 {
1952         static hda_nid_t nids[2] = { 0x18, 0x1a };
1953 
1954         if (action == HDA_FIXUP_ACT_INIT)
1955                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1956 }
1957 
1958 /* Set VREF on speaker pins on mba11 */
1959 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
1960                                     const struct hda_fixup *fix, int action)
1961 {
1962         static hda_nid_t nids[1] = { 0x18 };
1963 
1964         if (action == HDA_FIXUP_ACT_INIT)
1965                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1966 }
1967 
1968 /* Set VREF on speaker pins on mba21 */
1969 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
1970                                     const struct hda_fixup *fix, int action)
1971 {
1972         static hda_nid_t nids[2] = { 0x18, 0x19 };
1973 
1974         if (action == HDA_FIXUP_ACT_INIT)
1975                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1976 }
1977 
1978 /* Don't take HP output as primary
1979  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
1980  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
1981  */
1982 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
1983                                        const struct hda_fixup *fix, int action)
1984 {
1985         struct alc_spec *spec = codec->spec;
1986         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1987                 spec->gen.no_primary_hp = 1;
1988                 spec->gen.no_multi_io = 1;
1989         }
1990 }
1991 
1992 static void alc_fixup_bass_chmap(struct hda_codec *codec,
1993                                  const struct hda_fixup *fix, int action);
1994 
1995 static const struct hda_fixup alc882_fixups[] = {
1996         [ALC882_FIXUP_ABIT_AW9D_MAX] = {
1997                 .type = HDA_FIXUP_PINS,
1998                 .v.pins = (const struct hda_pintbl[]) {
1999                         { 0x15, 0x01080104 }, /* side */
2000                         { 0x16, 0x01011012 }, /* rear */
2001                         { 0x17, 0x01016011 }, /* clfe */
2002                         { }
2003                 }
2004         },
2005         [ALC882_FIXUP_LENOVO_Y530] = {
2006                 .type = HDA_FIXUP_PINS,
2007                 .v.pins = (const struct hda_pintbl[]) {
2008                         { 0x15, 0x99130112 }, /* rear int speakers */
2009                         { 0x16, 0x99130111 }, /* subwoofer */
2010                         { }
2011                 }
2012         },
2013         [ALC882_FIXUP_PB_M5210] = {
2014                 .type = HDA_FIXUP_PINCTLS,
2015                 .v.pins = (const struct hda_pintbl[]) {
2016                         { 0x19, PIN_VREF50 },
2017                         {}
2018                 }
2019         },
2020         [ALC882_FIXUP_ACER_ASPIRE_7736] = {
2021                 .type = HDA_FIXUP_FUNC,
2022                 .v.func = alc_fixup_sku_ignore,
2023         },
2024         [ALC882_FIXUP_ASUS_W90V] = {
2025                 .type = HDA_FIXUP_PINS,
2026                 .v.pins = (const struct hda_pintbl[]) {
2027                         { 0x16, 0x99130110 }, /* fix sequence for CLFE */
2028                         { }
2029                 }
2030         },
2031         [ALC889_FIXUP_CD] = {
2032                 .type = HDA_FIXUP_PINS,
2033                 .v.pins = (const struct hda_pintbl[]) {
2034                         { 0x1c, 0x993301f0 }, /* CD */
2035                         { }
2036                 }
2037         },
2038         [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2039                 .type = HDA_FIXUP_PINS,
2040                 .v.pins = (const struct hda_pintbl[]) {
2041                         { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2042                         { }
2043                 },
2044                 .chained = true,
2045                 .chain_id = ALC889_FIXUP_CD,
2046         },
2047         [ALC889_FIXUP_VAIO_TT] = {
2048                 .type = HDA_FIXUP_PINS,
2049                 .v.pins = (const struct hda_pintbl[]) {
2050                         { 0x17, 0x90170111 }, /* hidden surround speaker */
2051                         { }
2052                 }
2053         },
2054         [ALC888_FIXUP_EEE1601] = {
2055                 .type = HDA_FIXUP_VERBS,
2056                 .v.verbs = (const struct hda_verb[]) {
2057                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2058                         { 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
2059                         { }
2060                 }
2061         },
2062         [ALC882_FIXUP_EAPD] = {
2063                 .type = HDA_FIXUP_VERBS,
2064                 .v.verbs = (const struct hda_verb[]) {
2065                         /* change to EAPD mode */
2066                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2067                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2068                         { }
2069                 }
2070         },
2071         [ALC883_FIXUP_EAPD] = {
2072                 .type = HDA_FIXUP_VERBS,
2073                 .v.verbs = (const struct hda_verb[]) {
2074                         /* change to EAPD mode */
2075                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2076                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2077                         { }
2078                 }
2079         },
2080         [ALC883_FIXUP_ACER_EAPD] = {
2081                 .type = HDA_FIXUP_VERBS,
2082                 .v.verbs = (const struct hda_verb[]) {
2083                         /* eanable EAPD on Acer laptops */
2084                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2085                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2086                         { }
2087                 }
2088         },
2089         [ALC882_FIXUP_GPIO1] = {
2090                 .type = HDA_FIXUP_VERBS,
2091                 .v.verbs = alc_gpio1_init_verbs,
2092         },
2093         [ALC882_FIXUP_GPIO2] = {
2094                 .type = HDA_FIXUP_VERBS,
2095                 .v.verbs = alc_gpio2_init_verbs,
2096         },
2097         [ALC882_FIXUP_GPIO3] = {
2098                 .type = HDA_FIXUP_VERBS,
2099                 .v.verbs = alc_gpio3_init_verbs,
2100         },
2101         [ALC882_FIXUP_ASUS_W2JC] = {
2102                 .type = HDA_FIXUP_VERBS,
2103                 .v.verbs = alc_gpio1_init_verbs,
2104                 .chained = true,
2105                 .chain_id = ALC882_FIXUP_EAPD,
2106         },
2107         [ALC889_FIXUP_COEF] = {
2108                 .type = HDA_FIXUP_FUNC,
2109                 .v.func = alc889_fixup_coef,
2110         },
2111         [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2112                 .type = HDA_FIXUP_PINS,
2113                 .v.pins = (const struct hda_pintbl[]) {
2114                         { 0x16, 0x99130111 }, /* CLFE speaker */
2115                         { 0x17, 0x99130112 }, /* surround speaker */
2116                         { }
2117                 },
2118                 .chained = true,
2119                 .chain_id = ALC882_FIXUP_GPIO1,
2120         },
2121         [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2122                 .type = HDA_FIXUP_PINS,
2123                 .v.pins = (const struct hda_pintbl[]) {
2124                         { 0x16, 0x99130111 }, /* CLFE speaker */
2125                         { 0x1b, 0x99130112 }, /* surround speaker */
2126                         { }
2127                 },
2128                 .chained = true,
2129                 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2130         },
2131         [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2132                 /* additional init verbs for Acer Aspire 8930G */
2133                 .type = HDA_FIXUP_VERBS,
2134                 .v.verbs = (const struct hda_verb[]) {
2135                         /* Enable all DACs */
2136                         /* DAC DISABLE/MUTE 1? */
2137                         /*  setting bits 1-5 disables DAC nids 0x02-0x06
2138                          *  apparently. Init=0x38 */
2139                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2140                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2141                         /* DAC DISABLE/MUTE 2? */
2142                         /*  some bit here disables the other DACs.
2143                          *  Init=0x4900 */
2144                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2145                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2146                         /* DMIC fix
2147                          * This laptop has a stereo digital microphone.
2148                          * The mics are only 1cm apart which makes the stereo
2149                          * useless. However, either the mic or the ALC889
2150                          * makes the signal become a difference/sum signal
2151                          * instead of standard stereo, which is annoying.
2152                          * So instead we flip this bit which makes the
2153                          * codec replicate the sum signal to both channels,
2154                          * turning it into a normal mono mic.
2155                          */
2156                         /* DMIC_CONTROL? Init value = 0x0001 */
2157                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2158                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2159                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2160                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2161                         { }
2162                 },
2163                 .chained = true,
2164                 .chain_id = ALC882_FIXUP_GPIO1,
2165         },
2166         [ALC885_FIXUP_MACPRO_GPIO] = {
2167                 .type = HDA_FIXUP_FUNC,
2168                 .v.func = alc885_fixup_macpro_gpio,
2169         },
2170         [ALC889_FIXUP_DAC_ROUTE] = {
2171                 .type = HDA_FIXUP_FUNC,
2172                 .v.func = alc889_fixup_dac_route,
2173         },
2174         [ALC889_FIXUP_MBP_VREF] = {
2175                 .type = HDA_FIXUP_FUNC,
2176                 .v.func = alc889_fixup_mbp_vref,
2177                 .chained = true,
2178                 .chain_id = ALC882_FIXUP_GPIO1,
2179         },
2180         [ALC889_FIXUP_IMAC91_VREF] = {
2181                 .type = HDA_FIXUP_FUNC,
2182                 .v.func = alc889_fixup_imac91_vref,
2183                 .chained = true,
2184                 .chain_id = ALC882_FIXUP_GPIO1,
2185         },
2186         [ALC889_FIXUP_MBA11_VREF] = {
2187                 .type = HDA_FIXUP_FUNC,
2188                 .v.func = alc889_fixup_mba11_vref,
2189                 .chained = true,
2190                 .chain_id = ALC889_FIXUP_MBP_VREF,
2191         },
2192         [ALC889_FIXUP_MBA21_VREF] = {
2193                 .type = HDA_FIXUP_FUNC,
2194                 .v.func = alc889_fixup_mba21_vref,
2195                 .chained = true,
2196                 .chain_id = ALC889_FIXUP_MBP_VREF,
2197         },
2198         [ALC889_FIXUP_MP11_VREF] = {
2199                 .type = HDA_FIXUP_FUNC,
2200                 .v.func = alc889_fixup_mba11_vref,
2201                 .chained = true,
2202                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2203         },
2204         [ALC889_FIXUP_MP41_VREF] = {
2205                 .type = HDA_FIXUP_FUNC,
2206                 .v.func = alc889_fixup_mbp_vref,
2207                 .chained = true,
2208                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2209         },
2210         [ALC882_FIXUP_INV_DMIC] = {
2211                 .type = HDA_FIXUP_FUNC,
2212                 .v.func = alc_fixup_inv_dmic_0x12,
2213         },
2214         [ALC882_FIXUP_NO_PRIMARY_HP] = {
2215                 .type = HDA_FIXUP_FUNC,
2216                 .v.func = alc882_fixup_no_primary_hp,
2217         },
2218         [ALC887_FIXUP_ASUS_BASS] = {
2219                 .type = HDA_FIXUP_PINS,
2220                 .v.pins = (const struct hda_pintbl[]) {
2221                         {0x16, 0x99130130}, /* bass speaker */
2222                         {}
2223                 },
2224                 .chained = true,
2225                 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2226         },
2227         [ALC887_FIXUP_BASS_CHMAP] = {
2228                 .type = HDA_FIXUP_FUNC,
2229                 .v.func = alc_fixup_bass_chmap,
2230         },
2231 };
2232 
2233 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2234         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2235         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2236         SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2237         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2238         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2239         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2240         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2241         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2242                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2243         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2244                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2245         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2246                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2247         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2248                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2249         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2250                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2251         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2252                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2253         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2254                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2255         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2256         SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2257                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2258         SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2259         SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2260         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2261         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2262         SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2263         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2264         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2265         SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2266         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2267         SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2268         SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2269         SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2270 
2271         /* All Apple entries are in codec SSIDs */
2272         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2273         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2274         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2275         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2276         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2277         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2278         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2279         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2280         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2281         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2282         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2283         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2284         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2285         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2286         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2287         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2288         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2289         SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2290         SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2291         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2292         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2293         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2294 
2295         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2296         SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2297         SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2298         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2299         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2300         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2301         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2302         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2303         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2304         {}
2305 };
2306 
2307 static const struct hda_model_fixup alc882_fixup_models[] = {
2308         {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2309         {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2310         {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2311         {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2312         {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2313         {}
2314 };
2315 
2316 /*
2317  * BIOS auto configuration
2318  */
2319 /* almost identical with ALC880 parser... */
2320 static int alc882_parse_auto_config(struct hda_codec *codec)
2321 {
2322         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2323         static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2324         return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2325 }
2326 
2327 /*
2328  */
2329 static int patch_alc882(struct hda_codec *codec)
2330 {
2331         struct alc_spec *spec;
2332         int err;
2333 
2334         err = alc_alloc_spec(codec, 0x0b);
2335         if (err < 0)
2336                 return err;
2337 
2338         spec = codec->spec;
2339 
2340         switch (codec->vendor_id) {
2341         case 0x10ec0882:
2342         case 0x10ec0885:
2343         case 0x10ec0900:
2344                 break;
2345         default:
2346                 /* ALC883 and variants */
2347                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2348                 break;
2349         }
2350 
2351         snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2352                        alc882_fixups);
2353         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2354 
2355         alc_auto_parse_customize_define(codec);
2356 
2357         if (has_cdefine_beep(codec))
2358                 spec->gen.beep_nid = 0x01;
2359 
2360         /* automatic parse from the BIOS config */
2361         err = alc882_parse_auto_config(codec);
2362         if (err < 0)
2363                 goto error;
2364 
2365         if (!spec->gen.no_analog && spec->gen.beep_nid)
2366                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2367 
2368         codec->patch_ops = alc_patch_ops;
2369 
2370         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2371 
2372         return 0;
2373 
2374  error:
2375         alc_free(codec);
2376         return err;
2377 }
2378 
2379 
2380 /*
2381  * ALC262 support
2382  */
2383 static int alc262_parse_auto_config(struct hda_codec *codec)
2384 {
2385         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2386         static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2387         return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2388 }
2389 
2390 /*
2391  * Pin config fixes
2392  */
2393 enum {
2394         ALC262_FIXUP_FSC_H270,
2395         ALC262_FIXUP_FSC_S7110,
2396         ALC262_FIXUP_HP_Z200,
2397         ALC262_FIXUP_TYAN,
2398         ALC262_FIXUP_LENOVO_3000,
2399         ALC262_FIXUP_BENQ,
2400         ALC262_FIXUP_BENQ_T31,
2401         ALC262_FIXUP_INV_DMIC,
2402         ALC262_FIXUP_INTEL_BAYLEYBAY,
2403 };
2404 
2405 static const struct hda_fixup alc262_fixups[] = {
2406         [ALC262_FIXUP_FSC_H270] = {
2407                 .type = HDA_FIXUP_PINS,
2408                 .v.pins = (const struct hda_pintbl[]) {
2409                         { 0x14, 0x99130110 }, /* speaker */
2410                         { 0x15, 0x0221142f }, /* front HP */
2411                         { 0x1b, 0x0121141f }, /* rear HP */
2412                         { }
2413                 }
2414         },
2415         [ALC262_FIXUP_FSC_S7110] = {
2416                 .type = HDA_FIXUP_PINS,
2417                 .v.pins = (const struct hda_pintbl[]) {
2418                         { 0x15, 0x90170110 }, /* speaker */
2419                         { }
2420                 },
2421                 .chained = true,
2422                 .chain_id = ALC262_FIXUP_BENQ,
2423         },
2424         [ALC262_FIXUP_HP_Z200] = {
2425                 .type = HDA_FIXUP_PINS,
2426                 .v.pins = (const struct hda_pintbl[]) {
2427                         { 0x16, 0x99130120 }, /* internal speaker */
2428                         { }
2429                 }
2430         },
2431         [ALC262_FIXUP_TYAN] = {
2432                 .type = HDA_FIXUP_PINS,
2433                 .v.pins = (const struct hda_pintbl[]) {
2434                         { 0x14, 0x1993e1f0 }, /* int AUX */
2435                         { }
2436                 }
2437         },
2438         [ALC262_FIXUP_LENOVO_3000] = {
2439                 .type = HDA_FIXUP_PINCTLS,
2440                 .v.pins = (const struct hda_pintbl[]) {
2441                         { 0x19, PIN_VREF50 },
2442                         {}
2443                 },
2444                 .chained = true,
2445                 .chain_id = ALC262_FIXUP_BENQ,
2446         },
2447         [ALC262_FIXUP_BENQ] = {
2448                 .type = HDA_FIXUP_VERBS,
2449                 .v.verbs = (const struct hda_verb[]) {
2450                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2451                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2452                         {}
2453                 }
2454         },
2455         [ALC262_FIXUP_BENQ_T31] = {
2456                 .type = HDA_FIXUP_VERBS,
2457                 .v.verbs = (const struct hda_verb[]) {
2458                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2459                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2460                         {}
2461                 }
2462         },
2463         [ALC262_FIXUP_INV_DMIC] = {
2464                 .type = HDA_FIXUP_FUNC,
2465                 .v.func = alc_fixup_inv_dmic_0x12,
2466         },
2467         [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2468                 .type = HDA_FIXUP_FUNC,
2469                 .v.func = alc_fixup_no_depop_delay,
2470         },
2471 };
2472 
2473 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2474         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2475         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2476         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2477         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2478         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2479         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2480         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2481         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2482         SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2483         {}
2484 };
2485 
2486 static const struct hda_model_fixup alc262_fixup_models[] = {
2487         {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2488         {}
2489 };
2490 
2491 /*
2492  */
2493 static int patch_alc262(struct hda_codec *codec)
2494 {
2495         struct alc_spec *spec;
2496         int err;
2497 
2498         err = alc_alloc_spec(codec, 0x0b);
2499         if (err < 0)
2500                 return err;
2501 
2502         spec = codec->spec;
2503         spec->gen.shared_mic_vref_pin = 0x18;
2504 
2505 #if 0
2506         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2507          * under-run
2508          */
2509         {
2510         int tmp;
2511         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
2512         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
2513         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
2514         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
2515         }
2516 #endif
2517         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2518 
2519         snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2520                        alc262_fixups);
2521         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2522 
2523         alc_auto_parse_customize_define(codec);
2524 
2525         if (has_cdefine_beep(codec))
2526                 spec->gen.beep_nid = 0x01;
2527 
2528         /* automatic parse from the BIOS config */
2529         err = alc262_parse_auto_config(codec);
2530         if (err < 0)
2531                 goto error;
2532 
2533         if (!spec->gen.no_analog && spec->gen.beep_nid)
2534                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2535 
2536         codec->patch_ops = alc_patch_ops;
2537         spec->shutup = alc_eapd_shutup;
2538 
2539         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2540 
2541         return 0;
2542 
2543  error:
2544         alc_free(codec);
2545         return err;
2546 }
2547 
2548 /*
2549  *  ALC268
2550  */
2551 /* bind Beep switches of both NID 0x0f and 0x10 */
2552 static const struct hda_bind_ctls alc268_bind_beep_sw = {
2553         .ops = &snd_hda_bind_sw,
2554         .values = {
2555                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
2556                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
2557                 0
2558         },
2559 };
2560 
2561 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
2562         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2563         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
2564         { }
2565 };
2566 
2567 /* set PCBEEP vol = 0, mute connections */
2568 static const struct hda_verb alc268_beep_init_verbs[] = {
2569         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2570         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2571         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2572         { }
2573 };
2574 
2575 enum {
2576         ALC268_FIXUP_INV_DMIC,
2577         ALC268_FIXUP_HP_EAPD,
2578         ALC268_FIXUP_SPDIF,
2579 };
2580 
2581 static const struct hda_fixup alc268_fixups[] = {
2582         [ALC268_FIXUP_INV_DMIC] = {
2583                 .type = HDA_FIXUP_FUNC,
2584                 .v.func = alc_fixup_inv_dmic_0x12,
2585         },
2586         [ALC268_FIXUP_HP_EAPD] = {
2587                 .type = HDA_FIXUP_VERBS,
2588                 .v.verbs = (const struct hda_verb[]) {
2589                         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
2590                         {}
2591                 }
2592         },
2593         [ALC268_FIXUP_SPDIF] = {
2594                 .type = HDA_FIXUP_PINS,
2595                 .v.pins = (const struct hda_pintbl[]) {
2596                         { 0x1e, 0x014b1180 }, /* enable SPDIF out */
2597                         {}
2598                 }
2599         },
2600 };
2601 
2602 static const struct hda_model_fixup alc268_fixup_models[] = {
2603         {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
2604         {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
2605         {}
2606 };
2607 
2608 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
2609         SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
2610         SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
2611         /* below is codec SSID since multiple Toshiba laptops have the
2612          * same PCI SSID 1179:ff00
2613          */
2614         SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
2615         {}
2616 };
2617 
2618 /*
2619  * BIOS auto configuration
2620  */
2621 static int alc268_parse_auto_config(struct hda_codec *codec)
2622 {
2623         static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2624         return alc_parse_auto_config(codec, NULL, alc268_ssids);
2625 }
2626 
2627 /*
2628  */
2629 static int patch_alc268(struct hda_codec *codec)
2630 {
2631         struct alc_spec *spec;
2632         int err;
2633 
2634         /* ALC268 has no aa-loopback mixer */
2635         err = alc_alloc_spec(codec, 0);
2636         if (err < 0)
2637                 return err;
2638 
2639         spec = codec->spec;
2640         spec->gen.beep_nid = 0x01;
2641 
2642         snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
2643         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2644 
2645         /* automatic parse from the BIOS config */
2646         err = alc268_parse_auto_config(codec);
2647         if (err < 0)
2648                 goto error;
2649 
2650         if (err > 0 && !spec->gen.no_analog &&
2651             spec->gen.autocfg.speaker_pins[0] != 0x1d) {
2652                 add_mixer(spec, alc268_beep_mixer);
2653                 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
2654                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
2655                         /* override the amp caps for beep generator */
2656                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
2657                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
2658                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
2659                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2660                                           (0 << AC_AMPCAP_MUTE_SHIFT));
2661         }
2662 
2663         codec->patch_ops = alc_patch_ops;
2664         spec->shutup = alc_eapd_shutup;
2665 
2666         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2667 
2668         return 0;
2669 
2670  error:
2671         alc_free(codec);
2672         return err;
2673 }
2674 
2675 /*
2676  * ALC269
2677  */
2678 
2679 static int playback_pcm_open(struct hda_pcm_stream *hinfo,
2680                              struct hda_codec *codec,
2681                              struct snd_pcm_substream *substream)
2682 {
2683         struct hda_gen_spec *spec = codec->spec;
2684         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2685                                              hinfo);
2686 }
2687 
2688 static int playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2689                                 struct hda_codec *codec,
2690                                 unsigned int stream_tag,
2691                                 unsigned int format,
2692                                 struct snd_pcm_substream *substream)
2693 {
2694         struct hda_gen_spec *spec = codec->spec;
2695         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2696                                                 stream_tag, format, substream);
2697 }
2698 
2699 static int playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2700                                 struct hda_codec *codec,
2701                                 struct snd_pcm_substream *substream)
2702 {
2703         struct hda_gen_spec *spec = codec->spec;
2704         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2705 }
2706 
2707 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
2708         .substreams = 1,
2709         .channels_min = 2,
2710         .channels_max = 8,
2711         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2712         /* NID is set in alc_build_pcms */
2713         .ops = {
2714                 .open = playback_pcm_open,
2715                 .prepare = playback_pcm_prepare,
2716                 .cleanup = playback_pcm_cleanup
2717         },
2718 };
2719 
2720 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
2721         .substreams = 1,
2722         .channels_min = 2,
2723         .channels_max = 2,
2724         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2725         /* NID is set in alc_build_pcms */
2726 };
2727 
2728 /* different alc269-variants */
2729 enum {
2730         ALC269_TYPE_ALC269VA,
2731         ALC269_TYPE_ALC269VB,
2732         ALC269_TYPE_ALC269VC,
2733         ALC269_TYPE_ALC269VD,
2734         ALC269_TYPE_ALC280,
2735         ALC269_TYPE_ALC282,
2736         ALC269_TYPE_ALC283,
2737         ALC269_TYPE_ALC284,
2738         ALC269_TYPE_ALC285,
2739         ALC269_TYPE_ALC286,
2740         ALC269_TYPE_ALC255,
2741 };
2742 
2743 /*
2744  * BIOS auto configuration
2745  */
2746 static int alc269_parse_auto_config(struct hda_codec *codec)
2747 {
2748         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
2749         static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
2750         static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2751         struct alc_spec *spec = codec->spec;
2752         const hda_nid_t *ssids;
2753 
2754         switch (spec->codec_variant) {
2755         case ALC269_TYPE_ALC269VA:
2756         case ALC269_TYPE_ALC269VC:
2757         case ALC269_TYPE_ALC280:
2758         case ALC269_TYPE_ALC284:
2759         case ALC269_TYPE_ALC285:
2760                 ssids = alc269va_ssids;
2761                 break;
2762         case ALC269_TYPE_ALC269VB:
2763         case ALC269_TYPE_ALC269VD:
2764         case ALC269_TYPE_ALC282:
2765         case ALC269_TYPE_ALC283:
2766         case ALC269_TYPE_ALC286:
2767         case ALC269_TYPE_ALC255:
2768                 ssids = alc269_ssids;
2769                 break;
2770         default:
2771                 ssids = alc269_ssids;
2772                 break;
2773         }
2774 
2775         return alc_parse_auto_config(codec, alc269_ignore, ssids);
2776 }
2777 
2778 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
2779 {
2780         int val = alc_read_coef_idx(codec, 0x04);
2781         if (val == -1)
2782                 return;
2783         if (power_up)
2784                 val |= 1 << 11;
2785         else
2786                 val &= ~(1 << 11);
2787         alc_write_coef_idx(codec, 0x04, val);
2788 }
2789 
2790 static void alc269_shutup(struct hda_codec *codec)
2791 {
2792         struct alc_spec *spec = codec->spec;
2793 
2794         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
2795                 alc269vb_toggle_power_output(codec, 0);
2796         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
2797                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
2798                 msleep(150);
2799         }
2800         snd_hda_shutup_pins(codec);
2801 }
2802 
2803 static void alc283_restore_default_value(struct hda_codec *codec)
2804 {
2805         int val;
2806 
2807         /* Power Down Control */
2808         alc_write_coef_idx(codec, 0x03, 0x0002);
2809         /* FIFO and filter clock */
2810         alc_write_coef_idx(codec, 0x05, 0x0700);
2811         /* DMIC control */
2812         alc_write_coef_idx(codec, 0x07, 0x0200);
2813         /* Analog clock */
2814         val = alc_read_coef_idx(codec, 0x06);
2815         alc_write_coef_idx(codec, 0x06, (val & ~0x00f0) | 0x0);
2816         /* JD */
2817         val = alc_read_coef_idx(codec, 0x08);
2818         alc_write_coef_idx(codec, 0x08, (val & ~0xfffc) | 0x0c2c);
2819         /* JD offset1 */
2820         alc_write_coef_idx(codec, 0x0a, 0xcccc);
2821         /* JD offset2 */
2822         alc_write_coef_idx(codec, 0x0b, 0xcccc);
2823         /* LDO1/2/3, DAC/ADC */
2824         alc_write_coef_idx(codec, 0x0e, 0x6fc0);
2825         /* JD */
2826         val = alc_read_coef_idx(codec, 0x0f);
2827         alc_write_coef_idx(codec, 0x0f, (val & ~0xf800) | 0x1000);
2828         /* Capless */
2829         val = alc_read_coef_idx(codec, 0x10);
2830         alc_write_coef_idx(codec, 0x10, (val & ~0xfc00) | 0x0c00);
2831         /* Class D test 4 */
2832         alc_write_coef_idx(codec, 0x3a, 0x0);
2833         /* IO power down directly */
2834         val = alc_read_coef_idx(codec, 0x0c);
2835         alc_write_coef_idx(codec, 0x0c, (val & ~0xfe00) | 0x0);
2836         /* ANC */
2837         alc_write_coef_idx(codec, 0x22, 0xa0c0);
2838         /* AGC MUX */
2839         val = alc_read_coefex_idx(codec, 0x53, 0x01);
2840         alc_write_coefex_idx(codec, 0x53, 0x01, (val & ~0x000f) | 0x0008);
2841         /* DAC simple content protection */
2842         val = alc_read_coef_idx(codec, 0x1d);
2843         alc_write_coef_idx(codec, 0x1d, (val & ~0x00e0) | 0x0);
2844         /* ADC simple content protection */
2845         val = alc_read_coef_idx(codec, 0x1f);
2846         alc_write_coef_idx(codec, 0x1f, (val & ~0x00e0) | 0x0);
2847         /* DAC ADC Zero Detection */
2848         alc_write_coef_idx(codec, 0x21, 0x8804);
2849         /* PLL */
2850         alc_write_coef_idx(codec, 0x2e, 0x2902);
2851         /* capless control 2 */
2852         alc_write_coef_idx(codec, 0x33, 0xa080);
2853         /* capless control 3 */
2854         alc_write_coef_idx(codec, 0x34, 0x3400);
2855         /* capless control 4 */
2856         alc_write_coef_idx(codec, 0x35, 0x2f3e);
2857         /* capless control 5 */
2858         alc_write_coef_idx(codec, 0x36, 0x0);
2859         /* class D test 2 */
2860         val = alc_read_coef_idx(codec, 0x38);
2861         alc_write_coef_idx(codec, 0x38, (val & ~0x0fff) | 0x0900);
2862         /* class D test 3 */
2863         alc_write_coef_idx(codec, 0x39, 0x110a);
2864         /* class D test 5 */
2865         val = alc_read_coef_idx(codec, 0x3b);
2866         alc_write_coef_idx(codec, 0x3b, (val & ~0x00f8) | 0x00d8);
2867         /* class D test 6 */
2868         alc_write_coef_idx(codec, 0x3c, 0x0014);
2869         /* classD OCP */
2870         alc_write_coef_idx(codec, 0x3d, 0xc2ba);
2871         /* classD pure DC test */
2872         val = alc_read_coef_idx(codec, 0x42);
2873         alc_write_coef_idx(codec, 0x42, (val & ~0x0f80) | 0x0);
2874         /* test mode */
2875         alc_write_coef_idx(codec, 0x49, 0x0);
2876         /* Class D DC enable */
2877         val = alc_read_coef_idx(codec, 0x40);
2878         alc_write_coef_idx(codec, 0x40, (val & ~0xf800) | 0x9800);
2879         /* DC offset */
2880         val = alc_read_coef_idx(codec, 0x42);
2881         alc_write_coef_idx(codec, 0x42, (val & ~0xf000) | 0x2000);
2882         /* Class D amp control */
2883         alc_write_coef_idx(codec, 0x37, 0xfc06);
2884 }
2885 
2886 static void alc283_init(struct hda_codec *codec)
2887 {
2888         struct alc_spec *spec = codec->spec;
2889         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2890         bool hp_pin_sense;
2891         int val;
2892 
2893         alc283_restore_default_value(codec);
2894 
2895         if (!hp_pin)
2896                 return;
2897 
2898         msleep(30);
2899         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2900 
2901         /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
2902         /* Headphone capless set to high power mode */
2903         alc_write_coef_idx(codec, 0x43, 0x9004);
2904 
2905         snd_hda_codec_write(codec, hp_pin, 0,
2906                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2907 
2908         if (hp_pin_sense)
2909                 msleep(85);
2910 
2911         snd_hda_codec_write(codec, hp_pin, 0,
2912                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
2913 
2914         if (hp_pin_sense)
2915                 msleep(85);
2916         /* Index 0x46 Combo jack auto switch control 2 */
2917         /* 3k pull low control for Headset jack. */
2918         val = alc_read_coef_idx(codec, 0x46);
2919         alc_write_coef_idx(codec, 0x46, val & ~(3 << 12));
2920         /* Headphone capless set to normal mode */
2921         alc_write_coef_idx(codec, 0x43, 0x9614);
2922 }
2923 
2924 static void alc283_shutup(struct hda_codec *codec)
2925 {
2926         struct alc_spec *spec = codec->spec;
2927         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2928         bool hp_pin_sense;
2929         int val;
2930 
2931         if (!hp_pin) {
2932                 alc269_shutup(codec);
2933                 return;
2934         }
2935 
2936         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2937 
2938         alc_write_coef_idx(codec, 0x43, 0x9004);
2939 
2940         /*depop hp during suspend*/
2941         alc_write_coef_idx(codec, 0x06, 0x2100);
2942 
2943         snd_hda_codec_write(codec, hp_pin, 0,
2944                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2945 
2946         if (hp_pin_sense)
2947                 msleep(100);
2948 
2949         snd_hda_codec_write(codec, hp_pin, 0,
2950                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
2951 
2952         val = alc_read_coef_idx(codec, 0x46);
2953         alc_write_coef_idx(codec, 0x46, val | (3 << 12));
2954 
2955         if (hp_pin_sense)
2956                 msleep(100);
2957         snd_hda_shutup_pins(codec);
2958         alc_write_coef_idx(codec, 0x43, 0x9614);
2959 }
2960 
2961 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
2962                              unsigned int val)
2963 {
2964         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
2965         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
2966         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
2967 }
2968 
2969 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
2970 {
2971         unsigned int val;
2972 
2973         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
2974         val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
2975                 & 0xffff;
2976         val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
2977                 << 16;
2978         return val;
2979 }
2980 
2981 static void alc5505_dsp_halt(struct hda_codec *codec)
2982 {
2983         unsigned int val;
2984 
2985         alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
2986         alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
2987         alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
2988         alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
2989         alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
2990         alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
2991         alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
2992         val = alc5505_coef_get(codec, 0x6220);
2993         alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
2994 }
2995 
2996 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
2997 {
2998         alc5505_coef_set(codec, 0x61b8, 0x04133302);
2999         alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3000         alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3001         alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3002         alc5505_coef_set(codec, 0x6220, 0x2002010f);
3003         alc5505_coef_set(codec, 0x880c, 0x00000004);
3004 }
3005 
3006 static void alc5505_dsp_init(struct hda_codec *codec)
3007 {
3008         unsigned int val;
3009 
3010         alc5505_dsp_halt(codec);
3011         alc5505_dsp_back_from_halt(codec);
3012         alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
3013         alc5505_coef_set(codec, 0x61b0, 0x5b16);
3014         alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
3015         alc5505_coef_set(codec, 0x61b4, 0x04132b02);
3016         alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
3017         alc5505_coef_set(codec, 0x61b8, 0x041f3302);
3018         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
3019         alc5505_coef_set(codec, 0x61b8, 0x041b3302);
3020         alc5505_coef_set(codec, 0x61b8, 0x04173302);
3021         alc5505_coef_set(codec, 0x61b8, 0x04163302);
3022         alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
3023         alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
3024         alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
3025 
3026         val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
3027         if (val <= 3)
3028                 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
3029         else
3030                 alc5505_coef_set(codec, 0x6220, 0x6002018f);
3031 
3032         alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
3033         alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
3034         alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
3035         alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
3036         alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
3037         alc5505_coef_set(codec, 0x880c, 0x00000003);
3038         alc5505_coef_set(codec, 0x880c, 0x00000010);
3039 
3040 #ifdef HALT_REALTEK_ALC5505
3041         alc5505_dsp_halt(codec);
3042 #endif
3043 }
3044 
3045 #ifdef HALT_REALTEK_ALC5505
3046 #define alc5505_dsp_suspend(codec)      /* NOP */
3047 #define alc5505_dsp_resume(codec)       /* NOP */
3048 #else
3049 #define alc5505_dsp_suspend(codec)      alc5505_dsp_halt(codec)
3050 #define alc5505_dsp_resume(codec)       alc5505_dsp_back_from_halt(codec)
3051 #endif
3052 
3053 #ifdef CONFIG_PM
3054 static int alc269_suspend(struct hda_codec *codec)
3055 {
3056         struct alc_spec *spec = codec->spec;
3057 
3058         if (spec->has_alc5505_dsp)
3059                 alc5505_dsp_suspend(codec);
3060         return alc_suspend(codec);
3061 }
3062 
3063 static int alc269_resume(struct hda_codec *codec)
3064 {
3065         struct alc_spec *spec = codec->spec;
3066 
3067         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3068                 alc269vb_toggle_power_output(codec, 0);
3069         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3070                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3071                 msleep(150);
3072         }
3073 
3074         codec->patch_ops.init(codec);
3075 
3076         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3077                 alc269vb_toggle_power_output(codec, 1);
3078         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3079                         (alc_get_coef0(codec) & 0x00ff) == 0x017) {
3080                 msleep(200);
3081         }
3082 
3083         snd_hda_codec_resume_amp(codec);
3084         snd_hda_codec_resume_cache(codec);
3085         alc_inv_dmic_sync(codec, true);
3086         hda_call_check_power_status(codec, 0x01);
3087 
3088         /* on some machine, the BIOS will clear the codec gpio data when enter
3089          * suspend, and won't restore the data after resume, so we restore it
3090          * in the driver.
3091          */
3092         if (spec->gpio_led)
3093                 snd_hda_codec_write(codec, codec->afg, 0, AC_VERB_SET_GPIO_DATA,
3094                             spec->gpio_led);
3095 
3096         if (spec->has_alc5505_dsp)
3097                 alc5505_dsp_resume(codec);
3098 
3099         return 0;
3100 }
3101 #endif /* CONFIG_PM */
3102 
3103 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
3104                                                  const struct hda_fixup *fix, int action)
3105 {
3106         struct alc_spec *spec = codec->spec;
3107 
3108         if (action == HDA_FIXUP_ACT_PRE_PROBE)
3109                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
3110 }
3111 
3112 static void alc269_fixup_hweq(struct hda_codec *codec,
3113                                const struct hda_fixup *fix, int action)
3114 {
3115         int coef;
3116 
3117         if (action != HDA_FIXUP_ACT_INIT)
3118                 return;
3119         coef = alc_read_coef_idx(codec, 0x1e);
3120         alc_write_coef_idx(codec, 0x1e, coef | 0x80);
3121 }
3122 
3123 static void alc269_fixup_headset_mic(struct hda_codec *codec,
3124                                        const struct hda_fixup *fix, int action)
3125 {
3126         struct alc_spec *spec = codec->spec;
3127 
3128         if (action == HDA_FIXUP_ACT_PRE_PROBE)
3129                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3130 }
3131 
3132 static void alc271_fixup_dmic(struct hda_codec *codec,
3133                               const struct hda_fixup *fix, int action)
3134 {
3135         static const struct hda_verb verbs[] = {
3136                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
3137                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
3138                 {}
3139         };
3140         unsigned int cfg;
3141 
3142         if (strcmp(codec->chip_name, "ALC271X") &&
3143             strcmp(codec->chip_name, "ALC269VB"))
3144                 return;
3145         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
3146         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
3147                 snd_hda_sequence_write(codec, verbs);
3148 }
3149 
3150 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
3151                                  const struct hda_fixup *fix, int action)
3152 {
3153         struct alc_spec *spec = codec->spec;
3154 
3155         if (action != HDA_FIXUP_ACT_PROBE)
3156                 return;
3157 
3158         /* Due to a hardware problem on Lenovo Ideadpad, we need to
3159          * fix the sample rate of analog I/O to 44.1kHz
3160          */
3161         spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
3162         spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
3163 }
3164 
3165 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
3166                                      const struct hda_fixup *fix, int action)
3167 {
3168         int coef;
3169 
3170         if (action != HDA_FIXUP_ACT_INIT)
3171                 return;
3172         /* The digital-mic unit sends PDM (differential signal) instead of
3173          * the standard PCM, thus you can't record a valid mono stream as is.
3174          * Below is a workaround specific to ALC269 to control the dmic
3175          * signal source as mono.
3176          */
3177         coef = alc_read_coef_idx(codec, 0x07);
3178         alc_write_coef_idx(codec, 0x07, coef | 0x80);
3179 }
3180 
3181 static void alc269_quanta_automute(struct hda_codec *codec)
3182 {
3183         snd_hda_gen_update_outputs(codec);
3184 
3185         snd_hda_codec_write(codec, 0x20, 0,
3186                         AC_VERB_SET_COEF_INDEX, 0x0c);
3187         snd_hda_codec_write(codec, 0x20, 0,
3188                         AC_VERB_SET_PROC_COEF, 0x680);
3189 
3190         snd_hda_codec_write(codec, 0x20, 0,
3191                         AC_VERB_SET_COEF_INDEX, 0x0c);
3192         snd_hda_codec_write(codec, 0x20, 0,
3193                         AC_VERB_SET_PROC_COEF, 0x480);
3194 }
3195 
3196 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
3197                                      const struct hda_fixup *fix, int action)
3198 {
3199         struct alc_spec *spec = codec->spec;
3200         if (action != HDA_FIXUP_ACT_PROBE)
3201                 return;
3202         spec->gen.automute_hook = alc269_quanta_automute;
3203 }
3204 
3205 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
3206                                          struct hda_jack_tbl *jack)
3207 {
3208         struct alc_spec *spec = codec->spec;
3209         int vref;
3210         msleep(200);
3211         snd_hda_gen_hp_automute(codec, jack);
3212 
3213         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
3214         msleep(100);
3215         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3216                             vref);
3217         msleep(500);
3218         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3219                             vref);
3220 }
3221 
3222 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
3223                                      const struct hda_fixup *fix, int action)
3224 {
3225         struct alc_spec *spec = codec->spec;
3226         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3227                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3228                 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
3229         }
3230 }
3231 
3232 
3233 /* update mute-LED according to the speaker mute state via mic VREF pin */
3234 static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)
3235 {
3236         struct hda_codec *codec = private_data;
3237         struct alc_spec *spec = codec->spec;
3238         unsigned int pinval;
3239 
3240         if (spec->mute_led_polarity)
3241                 enabled = !enabled;
3242         pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);
3243         pinval &= ~AC_PINCTL_VREFEN;
3244         pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;
3245         if (spec->mute_led_nid)
3246                 snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);
3247 }
3248 
3249 /* Make sure the led works even in runtime suspend */
3250 static unsigned int led_power_filter(struct hda_codec *codec,
3251                                                   hda_nid_t nid,
3252                                                   unsigned int power_state)
3253 {
3254         struct alc_spec *spec = codec->spec;
3255 
3256         if (power_state != AC_PWRST_D3 || nid != spec->mute_led_nid)
3257                 return power_state;
3258 
3259         /* Set pin ctl again, it might have just been set to 0 */
3260         snd_hda_set_pin_ctl(codec, nid,
3261                             snd_hda_codec_get_pin_target(codec, nid));
3262 
3263         return AC_PWRST_D0;
3264 }
3265 
3266 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
3267                                      const struct hda_fixup *fix, int action)
3268 {
3269         struct alc_spec *spec = codec->spec;
3270         const struct dmi_device *dev = NULL;
3271 
3272         if (action != HDA_FIXUP_ACT_PRE_PROBE)
3273                 return;
3274 
3275         while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
3276                 int pol, pin;
3277                 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
3278                         continue;
3279                 if (pin < 0x0a || pin >= 0x10)
3280                         break;
3281                 spec->mute_led_polarity = pol;
3282                 spec->mute_led_nid = pin - 0x0a + 0x18;
3283                 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3284                 spec->gen.vmaster_mute_enum = 1;
3285                 codec->power_filter = led_power_filter;
3286                 snd_printd("Detected mute LED for %x:%d\n", spec->mute_led_nid,
3287                            spec->mute_led_polarity);
3288                 break;
3289         }
3290 }
3291 
3292 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
3293                                 const struct hda_fixup *fix, int action)
3294 {
3295         struct alc_spec *spec = codec->spec;
3296         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3297                 spec->mute_led_polarity = 0;
3298                 spec->mute_led_nid = 0x18;
3299                 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3300                 spec->gen.vmaster_mute_enum = 1;
3301                 codec->power_filter = led_power_filter;
3302         }
3303 }
3304 
3305 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
3306                                 const struct hda_fixup *fix, int action)
3307 {
3308         struct alc_spec *spec = codec->spec;
3309         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3310                 spec->mute_led_polarity = 0;
3311                 spec->mute_led_nid = 0x19;
3312                 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3313                 spec->gen.vmaster_mute_enum = 1;
3314                 codec->power_filter = led_power_filter;
3315         }
3316 }
3317 
3318 /* turn on/off mute LED per vmaster hook */
3319 static void alc269_fixup_hp_gpio_mute_hook(void *private_data, int enabled)
3320 {
3321         struct hda_codec *codec = private_data;
3322         struct alc_spec *spec = codec->spec;
3323         unsigned int oldval = spec->gpio_led;
3324 
3325         if (enabled)
3326                 spec->gpio_led &= ~0x08;
3327         else
3328                 spec->gpio_led |= 0x08;
3329         if (spec->gpio_led != oldval)
3330                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
3331                                     spec->gpio_led);
3332 }
3333 
3334 /* turn on/off mic-mute LED per capture hook */
3335 static void alc269_fixup_hp_gpio_mic_mute_hook(struct hda_codec *codec,
3336                                                struct snd_kcontrol *kcontrol,
3337                                                struct snd_ctl_elem_value *ucontrol)
3338 {
3339         struct alc_spec *spec = codec->spec;
3340         unsigned int oldval = spec->gpio_led;
3341 
3342         if (!ucontrol)
3343                 return;
3344 
3345         if (ucontrol->value.integer.value[0] ||
3346             ucontrol->value.integer.value[1])
3347                 spec->gpio_led &= ~0x10;
3348         else
3349                 spec->gpio_led |= 0x10;
3350         if (spec->gpio_led != oldval)
3351                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
3352                                     spec->gpio_led);
3353 }
3354 
3355 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
3356                                 const struct hda_fixup *fix, int action)
3357 {
3358         struct alc_spec *spec = codec->spec;
3359         static const struct hda_verb gpio_init[] = {
3360                 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
3361                 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
3362                 {}
3363         };
3364 
3365         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3366                 spec->gen.vmaster_mute.hook = alc269_fixup_hp_gpio_mute_hook;
3367                 spec->gen.cap_sync_hook = alc269_fixup_hp_gpio_mic_mute_hook;
3368                 spec->gpio_led = 0;
3369                 snd_hda_add_verbs(codec, gpio_init);
3370         }
3371 }
3372 
3373 static void alc_headset_mode_unplugged(struct hda_codec *codec)
3374 {
3375         int val;
3376 
3377         switch (codec->vendor_id) {
3378         case 0x10ec0255:
3379                 /* LDO and MISC control */
3380                 alc_write_coef_idx(codec, 0x1b, 0x0c0b);
3381                 /* UAJ function set to menual mode */
3382                 alc_write_coef_idx(codec, 0x45, 0xd089);
3383                 /* Direct Drive HP Amp control(Set to verb control)*/
3384                 val = alc_read_coefex_idx(codec, 0x57, 0x05);
3385                 alc_write_coefex_idx(codec, 0x57, 0x05, val & ~(1<<14));
3386                 /* Set MIC2 Vref gate with HP */
3387                 alc_write_coef_idx(codec, 0x06, 0x6104);
3388                 /* Direct Drive HP Amp control */
3389                 alc_write_coefex_idx(codec, 0x57, 0x03, 0x8aa6);
3390                 break;
3391         case 0x10ec0283:
3392                 alc_write_coef_idx(codec, 0x1b, 0x0c0b);
3393                 alc_write_coef_idx(codec, 0x45, 0xc429);
3394                 val = alc_read_coef_idx(codec, 0x35);
3395                 alc_write_coef_idx(codec, 0x35, val & 0xbfff);
3396                 alc_write_coef_idx(codec, 0x06, 0x2104);
3397                 alc_write_coef_idx(codec, 0x1a, 0x0001);
3398                 alc_write_coef_idx(codec, 0x26, 0x0004);
3399                 alc_write_coef_idx(codec, 0x32, 0x42a3);
3400                 break;
3401         case 0x10ec0292:
3402                 alc_write_coef_idx(codec, 0x76, 0x000e);
3403                 alc_write_coef_idx(codec, 0x6c, 0x2400);
3404                 alc_write_coef_idx(codec, 0x18, 0x7308);
3405                 alc_write_coef_idx(codec, 0x6b, 0xc429);
3406                 break;
3407         case 0x10ec0668:
3408                 alc_write_coef_idx(codec, 0x15, 0x0d40);
3409                 alc_write_coef_idx(codec, 0xb7, 0x802b);
3410                 break;
3411         }
3412         snd_printdd("Headset jack set to unplugged mode.\n");
3413 }
3414 
3415 
3416 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
3417                                     hda_nid_t mic_pin)
3418 {
3419         int val;
3420 
3421         switch (codec->vendor_id) {
3422         case 0x10ec0255:
3423                 alc_write_coef_idx(codec, 0x45, 0xc489);
3424                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3425                 alc_write_coefex_idx(codec, 0x57, 0x03, 0x8aa6);
3426                 /* Set MIC2 Vref gate to normal */
3427                 alc_write_coef_idx(codec, 0x06, 0x6100);
3428                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3429                 break;
3430         case 0x10ec0283:
3431                 alc_write_coef_idx(codec, 0x45, 0xc429);
3432                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3433                 val = alc_read_coef_idx(codec, 0x35);
3434                 alc_write_coef_idx(codec, 0x35, val | 1<<14);
3435                 alc_write_coef_idx(codec, 0x06, 0x2100);
3436                 alc_write_coef_idx(codec, 0x1a, 0x0021);
3437                 alc_write_coef_idx(codec, 0x26, 0x008c);
3438                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3439                 break;
3440         case 0x10ec0292:
3441                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3442                 alc_write_coef_idx(codec, 0x19, 0xa208);
3443                 alc_write_coef_idx(codec, 0x2e, 0xacf0);
3444                 break;
3445         case 0x10ec0668:
3446                 alc_write_coef_idx(codec, 0x11, 0x0001);
3447                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3448                 alc_write_coef_idx(codec, 0xb7, 0x802b);
3449                 alc_write_coef_idx(codec, 0xb5, 0x1040);
3450                 val = alc_read_coef_idx(codec, 0xc3);
3451                 alc_write_coef_idx(codec, 0xc3, val | 1<<12);
3452                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3453                 break;
3454         }
3455         snd_printdd("Headset jack set to mic-in mode.\n");
3456 }
3457 
3458 static void alc_headset_mode_default(struct hda_codec *codec)
3459 {
3460         switch (codec->vendor_id) {
3461         case 0x10ec0255:
3462                 alc_write_coef_idx(codec, 0x45, 0xc089);
3463                 alc_write_coef_idx(codec, 0x45, 0xc489);
3464                 alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);
3465                 alc_write_coef_idx(codec, 0x49, 0x0049);
3466                 break;
3467         case 0x10ec0283:
3468                 alc_write_coef_idx(codec, 0x06, 0x2100);
3469                 alc_write_coef_idx(codec, 0x32, 0x4ea3);
3470                 break;
3471         case 0x10ec0292:
3472                 alc_write_coef_idx(codec, 0x76, 0x000e);
3473                 alc_write_coef_idx(codec, 0x6c, 0x2400);
3474                 alc_write_coef_idx(codec, 0x6b, 0xc429);
3475                 alc_write_coef_idx(codec, 0x18, 0x7308);
3476                 break;
3477         case 0x10ec0668:
3478                 alc_write_coef_idx(codec, 0x11, 0x0041);
3479                 alc_write_coef_idx(codec, 0x15, 0x0d40);
3480                 alc_write_coef_idx(codec, 0xb7, 0x802b);
3481                 break;
3482         }
3483         snd_printdd("Headset jack set to headphone (default) mode.\n");
3484 }
3485 
3486 /* Iphone type */
3487 static void alc_headset_mode_ctia(struct hda_codec *codec)
3488 {
3489         switch (codec->vendor_id) {
3490         case 0x10ec0255:
3491                 /* Set to CTIA type */
3492                 alc_write_coef_idx(codec, 0x45, 0xd489);
3493                 alc_write_coef_idx(codec, 0x1b, 0x0c2b);
3494                 alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);
3495                 break;
3496         case 0x10ec0283:
3497                 alc_write_coef_idx(codec, 0x45, 0xd429);
3498                 alc_write_coef_idx(codec, 0x1b, 0x0c2b);
3499                 alc_write_coef_idx(codec, 0x32, 0x4ea3);
3500                 break;
3501         case 0x10ec0292:
3502                 alc_write_coef_idx(codec, 0x6b, 0xd429);
3503                 alc_write_coef_idx(codec, 0x76, 0x0008);
3504                 alc_write_coef_idx(codec, 0x18, 0x7388);
3505                 break;
3506         case 0x10ec0668:
3507                 alc_write_coef_idx(codec, 0x11, 0x0001);
3508                 alc_write_coef_idx(codec, 0x15, 0x0d60);
3509                 alc_write_coef_idx(codec, 0xc3, 0x0000);
3510                 break;
3511         }
3512         snd_printdd("Headset jack set to iPhone-style headset mode.\n");
3513 }
3514 
3515 /* Nokia type */
3516 static void alc_headset_mode_omtp(struct hda_codec *codec)
3517 {
3518         switch (codec->vendor_id) {
3519         case 0x10ec0255:
3520                 /* Set to OMTP Type */
3521                 alc_write_coef_idx(codec, 0x45, 0xe489);
3522                 alc_write_coef_idx(codec, 0x1b, 0x0c2b);
3523                 alc_write_coefex_idx(codec, 0x57, 0x03, 0x8ea6);
3524                 break;
3525         case 0x10ec0283:
3526                 alc_write_coef_idx(codec, 0x45, 0xe429);
3527                 alc_write_coef_idx(codec, 0x1b, 0x0c2b);
3528                 alc_write_coef_idx(codec, 0x32, 0x4ea3);
3529                 break;
3530         case 0x10ec0292:
3531                 alc_write_coef_idx(codec, 0x6b, 0xe429);
3532                 alc_write_coef_idx(codec, 0x76, 0x0008);
3533                 alc_write_coef_idx(codec, 0x18, 0x7388);
3534                 break;
3535         case 0x10ec0668:
3536                 alc_write_coef_idx(codec, 0x11, 0x0001);
3537                 alc_write_coef_idx(codec, 0x15, 0x0d50);
3538                 alc_write_coef_idx(codec, 0xc3, 0x0000);
3539                 break;
3540         }
3541         snd_printdd("Headset jack set to Nokia-style headset mode.\n");
3542 }
3543 
3544 static void alc_determine_headset_type(struct hda_codec *codec)
3545 {
3546         int val;
3547         bool is_ctia = false;
3548         struct alc_spec *spec = codec->spec;
3549 
3550         switch (codec->vendor_id) {
3551         case 0x10ec0255:
3552                 /* combo jack auto switch control(Check type)*/
3553                 alc_write_coef_idx(codec, 0x45, 0xd089);
3554                 /* combo jack auto switch control(Vref conteol) */
3555                 alc_write_coef_idx(codec, 0x49, 0x0149);
3556                 msleep(300);
3557                 val = alc_read_coef_idx(codec, 0x46);
3558                 is_ctia = (val & 0x0070) == 0x0070;
3559                 break;
3560         case 0x10ec0283:
3561                 alc_write_coef_idx(codec, 0x45, 0xd029);
3562                 msleep(300);
3563                 val = alc_read_coef_idx(codec, 0x46);
3564                 is_ctia = (val & 0x0070) == 0x0070;
3565                 break;
3566         case 0x10ec0292:
3567                 alc_write_coef_idx(codec, 0x6b, 0xd429);
3568                 msleep(300);
3569                 val = alc_read_coef_idx(codec, 0x6c);
3570                 is_ctia = (val & 0x001c) == 0x001c;
3571                 break;
3572         case 0x10ec0668:
3573                 alc_write_coef_idx(codec, 0x11, 0x0001);
3574                 alc_write_coef_idx(codec, 0xb7, 0x802b);
3575                 alc_write_coef_idx(codec, 0x15, 0x0d60);
3576                 alc_write_coef_idx(codec, 0xc3, 0x0c00);
3577                 msleep(300);
3578                 val = alc_read_coef_idx(codec, 0xbe);
3579                 is_ctia = (val & 0x1c02) == 0x1c02;
3580                 break;
3581         }
3582 
3583         snd_printdd("Headset jack detected iPhone-style headset: %s\n",
3584                     is_ctia ? "yes" : "no");
3585         spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
3586 }
3587 
3588 static void alc_update_headset_mode(struct hda_codec *codec)
3589 {
3590         struct alc_spec *spec = codec->spec;
3591 
3592         hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
3593         hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
3594 
3595         int new_headset_mode;
3596 
3597         if (!snd_hda_jack_detect(codec, hp_pin))
3598                 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
3599         else if (mux_pin == spec->headset_mic_pin)
3600                 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
3601         else if (mux_pin == spec->headphone_mic_pin)
3602                 new_headset_mode = ALC_HEADSET_MODE_MIC;
3603         else
3604                 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
3605 
3606         if (new_headset_mode == spec->current_headset_mode) {
3607                 snd_hda_gen_update_outputs(codec);
3608                 return;
3609         }
3610 
3611         switch (new_headset_mode) {
3612         case ALC_HEADSET_MODE_UNPLUGGED:
3613                 alc_headset_mode_unplugged(codec);
3614                 spec->gen.hp_jack_present = false;
3615                 break;
3616         case ALC_HEADSET_MODE_HEADSET:
3617                 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
3618                         alc_determine_headset_type(codec);
3619                 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
3620                         alc_headset_mode_ctia(codec);
3621                 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
3622                         alc_headset_mode_omtp(codec);
3623                 spec->gen.hp_jack_present = true;
3624                 break;
3625         case ALC_HEADSET_MODE_MIC:
3626                 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
3627                 spec->gen.hp_jack_present = false;
3628                 break;
3629         case ALC_HEADSET_MODE_HEADPHONE:
3630                 alc_headset_mode_default(codec);
3631                 spec->gen.hp_jack_present = true;
3632                 break;
3633         }
3634         if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
3635                 snd_hda_set_pin_ctl_cache(codec, hp_pin,
3636                                           AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3637                 if (spec->headphone_mic_pin)
3638                         snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
3639                                                   PIN_VREFHIZ);
3640         }
3641         spec->current_headset_mode = new_headset_mode;
3642 
3643         snd_hda_gen_update_outputs(codec);
3644 }
3645 
3646 static void alc_update_headset_mode_hook(struct hda_codec *codec,
3647                                          struct snd_kcontrol *kcontrol,
3648                                          struct snd_ctl_elem_value *ucontrol)
3649 {
3650         alc_update_headset_mode(codec);
3651 }
3652 
3653 static void alc_update_headset_jack_cb(struct hda_codec *codec, struct hda_jack_tbl *jack)
3654 {
3655         struct alc_spec *spec = codec->spec;
3656         spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
3657         snd_hda_gen_hp_automute(codec, jack);
3658 }
3659 
3660 static void alc_probe_headset_mode(struct hda_codec *codec)
3661 {
3662         int i;
3663         struct alc_spec *spec = codec->spec;
3664         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
3665 
3666         /* Find mic pins */
3667         for (i = 0; i < cfg->num_inputs; i++) {
3668                 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
3669                         spec->headset_mic_pin = cfg->inputs[i].pin;
3670                 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
3671                         spec->headphone_mic_pin = cfg->inputs[i].pin;
3672         }
3673 
3674         spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
3675         spec->gen.automute_hook = alc_update_headset_mode;
3676         spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
3677 }
3678 
3679 static void alc_fixup_headset_mode(struct hda_codec *codec,
3680                                 const struct hda_fixup *fix, int action)
3681 {
3682         struct alc_spec *spec = codec->spec;
3683 
3684         switch (action) {
3685         case HDA_FIXUP_ACT_PRE_PROBE:
3686                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
3687                 break;
3688         case HDA_FIXUP_ACT_PROBE:
3689                 alc_probe_headset_mode(codec);
3690                 break;
3691         case HDA_FIXUP_ACT_INIT:
3692                 spec->current_headset_mode = 0;
3693                 alc_update_headset_mode(codec);
3694                 break;
3695         }
3696 }
3697 
3698 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
3699                                 const struct hda_fixup *fix, int action)
3700 {
3701         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3702                 struct alc_spec *spec = codec->spec;
3703                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3704         }
3705         else
3706                 alc_fixup_headset_mode(codec, fix, action);
3707 }
3708 
3709 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
3710                                 const struct hda_fixup *fix, int action)
3711 {
3712         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3713                 /* Set to iphone type */
3714                 alc_write_coef_idx(codec, 0x1b, 0x880b);
3715                 alc_write_coef_idx(codec, 0x45, 0xd089);
3716                 alc_write_coef_idx(codec, 0x1b, 0x080b);
3717                 alc_write_coef_idx(codec, 0x46, 0x0004);
3718                 alc_write_coef_idx(codec, 0x1b, 0x0c0b);
3719                 msleep(30);
3720         }
3721         alc_fixup_headset_mode(codec, fix, action);
3722 }
3723 
3724 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
3725                                         const struct hda_fixup *fix, int action)
3726 {
3727         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3728                 struct alc_spec *spec = codec->spec;
3729                 spec->gen.auto_mute_via_amp = 1;
3730         }
3731 }
3732 
3733 static void alc_no_shutup(struct hda_codec *codec)
3734 {
3735 }
3736 
3737 static void alc_fixup_no_shutup(struct hda_codec *codec,
3738                                 const struct hda_fixup *fix, int action)
3739 {
3740         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3741                 struct alc_spec *spec = codec->spec;
3742                 spec->shutup = alc_no_shutup;
3743         }
3744 }
3745 
3746 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
3747                                 const struct hda_fixup *fix, int action)
3748 {
3749         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3750                 int val;
3751                 alc_write_coef_idx(codec, 0xc4, 0x8000);
3752                 val = alc_read_coef_idx(codec, 0xc2);
3753                 alc_write_coef_idx(codec, 0xc2, val & 0xfe);
3754                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
3755         }
3756         alc_fixup_headset_mode(codec, fix, action);
3757 }
3758 
3759 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
3760 static int find_ext_mic_pin(struct hda_codec *codec)
3761 {
3762         struct alc_spec *spec = codec->spec;
3763         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
3764         hda_nid_t nid;
3765         unsigned int defcfg;
3766         int i;
3767 
3768         for (i = 0; i < cfg->num_inputs; i++) {
3769                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3770                         continue;
3771                 nid = cfg->inputs[i].pin;
3772                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
3773                 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
3774                         continue;
3775                 return nid;
3776         }
3777 
3778         return 0;
3779 }
3780 
3781 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
3782                                     const struct hda_fixup *fix,
3783                                     int action)
3784 {
3785         struct alc_spec *spec = codec->spec;
3786 
3787         if (action == HDA_FIXUP_ACT_PROBE) {
3788                 int mic_pin = find_ext_mic_pin(codec);
3789                 int hp_pin = spec->gen.autocfg.hp_pins[0];
3790 
3791                 if (snd_BUG_ON(!mic_pin || !hp_pin))
3792                         return;
3793                 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
3794         }
3795 }
3796 
3797 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
3798                                              const struct hda_fixup *fix,
3799                                              int action)
3800 {
3801         struct alc_spec *spec = codec->spec;
3802         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
3803         int i;
3804 
3805         /* The mic boosts on level 2 and 3 are too noisy
3806            on the internal mic input.
3807            Therefore limit the boost to 0 or 1. */
3808 
3809         if (action != HDA_FIXUP_ACT_PROBE)
3810                 return;
3811 
3812         for (i = 0; i < cfg->num_inputs; i++) {
3813                 hda_nid_t nid = cfg->inputs[i].pin;
3814                 unsigned int defcfg;
3815                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
3816                         continue;
3817                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
3818                 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
3819                         continue;
3820 
3821                 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
3822                                           (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
3823                                           (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3824                                           (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
3825                                           (0 << AC_AMPCAP_MUTE_SHIFT));
3826         }
3827 }
3828 
3829 static void alc283_hp_automute_hook(struct hda_codec *codec,
3830                                     struct hda_jack_tbl *jack)
3831 {
3832         struct alc_spec *spec = codec->spec;
3833         int vref;
3834 
3835         msleep(200);
3836         snd_hda_gen_hp_automute(codec, jack);
3837 
3838         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
3839 
3840         msleep(600);
3841         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3842                             vref);
3843 }
3844 
3845 static void alc283_fixup_chromebook(struct hda_codec *codec,
3846                                     const struct hda_fixup *fix, int action)
3847 {
3848         struct alc_spec *spec = codec->spec;
3849         int val;
3850 
3851         switch (action) {
3852         case HDA_FIXUP_ACT_PRE_PROBE:
3853                 snd_hda_override_wcaps(codec, 0x03, 0);
3854                 /* Disable AA-loopback as it causes white noise */
3855                 spec->gen.mixer_nid = 0;
3856                 break;
3857         case HDA_FIXUP_ACT_INIT:
3858                 /* Enable Line1 input control by verb */
3859                 val = alc_read_coef_idx(codec, 0x1a);
3860                 alc_write_coef_idx(codec, 0x1a, val | (1 << 4));
3861                 break;
3862         }
3863 }
3864 
3865 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
3866                                     const struct hda_fixup *fix, int action)
3867 {
3868         struct alc_spec *spec = codec->spec;
3869         int val;
3870 
3871         switch (action) {
3872         case HDA_FIXUP_ACT_PRE_PROBE:
3873                 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
3874                 break;
3875         case HDA_FIXUP_ACT_INIT:
3876                 /* MIC2-VREF control */
3877                 /* Set to manual mode */
3878                 val = alc_read_coef_idx(codec, 0x06);
3879                 alc_write_coef_idx(codec, 0x06, val & ~0x000c);
3880                 break;
3881         }
3882 }
3883 
3884 /* mute tablet speaker pin (0x14) via dock plugging in addition */
3885 static void asus_tx300_automute(struct hda_codec *codec)
3886 {
3887         struct alc_spec *spec = codec->spec;
3888         snd_hda_gen_update_outputs(codec);
3889         if (snd_hda_jack_detect(codec, 0x1b))
3890                 spec->gen.mute_bits |= (1ULL << 0x14);
3891 }
3892 
3893 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
3894                                     const struct hda_fixup *fix, int action)
3895 {
3896         struct alc_spec *spec = codec->spec;
3897         /* TX300 needs to set up GPIO2 for the speaker amp */
3898         static const struct hda_verb gpio2_verbs[] = {
3899                 { 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },
3900                 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },
3901                 { 0x01, AC_VERB_SET_GPIO_DATA, 0x04 },
3902                 {}
3903         };
3904         static const struct hda_pintbl dock_pins[] = {
3905                 { 0x1b, 0x21114000 }, /* dock speaker pin */
3906                 {}
3907         };
3908         struct snd_kcontrol *kctl;
3909 
3910         switch (action) {
3911         case HDA_FIXUP_ACT_PRE_PROBE:
3912                 snd_hda_add_verbs(codec, gpio2_verbs);
3913                 snd_hda_apply_pincfgs(codec, dock_pins);
3914                 spec->gen.auto_mute_via_amp = 1;
3915                 spec->gen.automute_hook = asus_tx300_automute;
3916                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
3917                                                     HDA_GEN_HP_EVENT,
3918                                                     snd_hda_gen_hp_automute);
3919                 break;
3920         case HDA_FIXUP_ACT_BUILD:
3921                 /* this is a bit tricky; give more sane names for the main
3922                  * (tablet) speaker and the dock speaker, respectively
3923                  */
3924                 kctl = snd_hda_find_mixer_ctl(codec, "Speaker Playback Switch");
3925                 if (kctl)
3926                         strcpy(kctl->id.name, "Dock Speaker Playback Switch");
3927                 kctl = snd_hda_find_mixer_ctl(codec, "Bass Speaker Playback Switch");
3928                 if (kctl)
3929                         strcpy(kctl->id.name, "Speaker Playback Switch");
3930                 break;
3931         }
3932 }
3933 
3934 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
3935                                        const struct hda_fixup *fix, int action)
3936 {
3937         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3938                 /* DAC node 0x03 is giving mono output. We therefore want to
3939                    make sure 0x14 (front speaker) and 0x15 (headphones) use the
3940                    stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
3941                 hda_nid_t conn1[2] = { 0x0c };
3942                 snd_hda_override_conn_list(codec, 0x14, 1, conn1);
3943                 snd_hda_override_conn_list(codec, 0x15, 1, conn1);
3944         }
3945 }
3946 
3947 /* for hda_fixup_thinkpad_acpi() */
3948 #include "thinkpad_helper.c"
3949 
3950 enum {
3951         ALC269_FIXUP_SONY_VAIO,
3952         ALC275_FIXUP_SONY_VAIO_GPIO2,
3953         ALC269_FIXUP_DELL_M101Z,
3954         ALC269_FIXUP_SKU_IGNORE,
3955         ALC269_FIXUP_ASUS_G73JW,
3956         ALC269_FIXUP_LENOVO_EAPD,
3957         ALC275_FIXUP_SONY_HWEQ,
3958         ALC271_FIXUP_DMIC,
3959         ALC269_FIXUP_PCM_44K,
3960         ALC269_FIXUP_STEREO_DMIC,
3961         ALC269_FIXUP_HEADSET_MIC,
3962         ALC269_FIXUP_QUANTA_MUTE,
3963         ALC269_FIXUP_LIFEBOOK,
3964         ALC269_FIXUP_LIFEBOOK_EXTMIC,
3965         ALC269_FIXUP_LIFEBOOK_HP_PIN,
3966         ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
3967         ALC269_FIXUP_AMIC,
3968         ALC269_FIXUP_DMIC,
3969         ALC269VB_FIXUP_AMIC,
3970         ALC269VB_FIXUP_DMIC,
3971         ALC269_FIXUP_HP_MUTE_LED,
3972         ALC269_FIXUP_HP_MUTE_LED_MIC1,
3973         ALC269_FIXUP_HP_MUTE_LED_MIC2,
3974         ALC269_FIXUP_HP_GPIO_LED,
3975         ALC269_FIXUP_INV_DMIC,
3976         ALC269_FIXUP_LENOVO_DOCK,
3977         ALC269_FIXUP_NO_SHUTUP,
3978         ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
3979         ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
3980         ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
3981         ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
3982         ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
3983         ALC269_FIXUP_HEADSET_MODE,
3984         ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
3985         ALC269_FIXUP_ASPIRE_HEADSET_MIC,
3986         ALC269_FIXUP_ASUS_X101_FUNC,
3987         ALC269_FIXUP_ASUS_X101_VERB,
3988         ALC269_FIXUP_ASUS_X101,
3989         ALC271_FIXUP_AMIC_MIC2,
3990         ALC271_FIXUP_HP_GATE_MIC_JACK,
3991         ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
3992         ALC269_FIXUP_ACER_AC700,
3993         ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
3994         ALC269VB_FIXUP_ASUS_ZENBOOK,
3995         ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
3996         ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
3997         ALC269VB_FIXUP_ORDISSIMO_EVE2,
3998         ALC283_FIXUP_CHROME_BOOK,
3999         ALC283_FIXUP_SENSE_COMBO_JACK,
4000         ALC282_FIXUP_ASUS_TX300,
4001         ALC283_FIXUP_INT_MIC,
4002         ALC290_FIXUP_MONO_SPEAKERS,
4003         ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
4004         ALC290_FIXUP_SUBWOOFER,
4005         ALC290_FIXUP_SUBWOOFER_HSJACK,
4006         ALC269_FIXUP_THINKPAD_ACPI,
4007         ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
4008         ALC255_FIXUP_HEADSET_MODE,
4009 };
4010 
4011 static const struct hda_fixup alc269_fixups[] = {
4012         [ALC269_FIXUP_SONY_VAIO] = {
4013                 .type = HDA_FIXUP_PINCTLS,
4014                 .v.pins = (const struct hda_pintbl[]) {
4015                         {0x19, PIN_VREFGRD},
4016                         {}
4017                 }
4018         },
4019         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
4020                 .type = HDA_FIXUP_VERBS,
4021                 .v.verbs = (const struct hda_verb[]) {
4022                         {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
4023                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
4024                         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4025                         { }
4026                 },
4027                 .chained = true,
4028                 .chain_id = ALC269_FIXUP_SONY_VAIO
4029         },
4030         [ALC269_FIXUP_DELL_M101Z] = {
4031                 .type = HDA_FIXUP_VERBS,
4032                 .v.verbs = (const struct hda_verb[]) {
4033                         /* Enables internal speaker */
4034                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
4035                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
4036                         {}
4037                 }
4038         },
4039         [ALC269_FIXUP_SKU_IGNORE] = {
4040                 .type = HDA_FIXUP_FUNC,
4041                 .v.func = alc_fixup_sku_ignore,
4042         },
4043         [ALC269_FIXUP_ASUS_G73JW] = {
4044                 .type = HDA_FIXUP_PINS,
4045                 .v.pins = (const struct hda_pintbl[]) {
4046                         { 0x17, 0x99130111 }, /* subwoofer */
4047                         { }
4048                 }
4049         },
4050         [ALC269_FIXUP_LENOVO_EAPD] = {
4051                 .type = HDA_FIXUP_VERBS,
4052                 .v.verbs = (const struct hda_verb[]) {
4053                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
4054                         {}
4055                 }
4056         },
4057         [ALC275_FIXUP_SONY_HWEQ] = {
4058                 .type = HDA_FIXUP_FUNC,
4059                 .v.func = alc269_fixup_hweq,
4060                 .chained = true,
4061                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
4062         },
4063         [ALC271_FIXUP_DMIC] = {
4064                 .type = HDA_FIXUP_FUNC,
4065                 .v.func = alc271_fixup_dmic,
4066         },
4067         [ALC269_FIXUP_PCM_44K] = {
4068                 .type = HDA_FIXUP_FUNC,
4069                 .v.func = alc269_fixup_pcm_44k,
4070                 .chained = true,
4071                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
4072         },
4073         [ALC269_FIXUP_STEREO_DMIC] = {
4074                 .type = HDA_FIXUP_FUNC,
4075                 .v.func = alc269_fixup_stereo_dmic,
4076         },
4077         [ALC269_FIXUP_HEADSET_MIC] = {
4078                 .type = HDA_FIXUP_FUNC,
4079                 .v.func = alc269_fixup_headset_mic,
4080         },
4081         [ALC269_FIXUP_QUANTA_MUTE] = {
4082                 .type = HDA_FIXUP_FUNC,
4083                 .v.func = alc269_fixup_quanta_mute,
4084         },
4085         [ALC269_FIXUP_LIFEBOOK] = {
4086                 .type = HDA_FIXUP_PINS,
4087                 .v.pins = (const struct hda_pintbl[]) {
4088                         { 0x1a, 0x2101103f }, /* dock line-out */
4089                         { 0x1b, 0x23a11040 }, /* dock mic-in */
4090                         { }
4091                 },
4092                 .chained = true,
4093                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
4094         },
4095         [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
4096                 .type = HDA_FIXUP_PINS,
4097                 .v.pins = (const struct hda_pintbl[]) {
4098                         { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
4099                         { }
4100                 },
4101         },
4102         [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
4103                 .type = HDA_FIXUP_PINS,
4104                 .v.pins = (const struct hda_pintbl[]) {
4105                         { 0x21, 0x0221102f }, /* HP out */
4106                         { }
4107                 },
4108         },
4109         [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
4110                 .type = HDA_FIXUP_FUNC,
4111                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
4112         },
4113         [ALC269_FIXUP_AMIC] = {
4114                 .type = HDA_FIXUP_PINS,
4115                 .v.pins = (const struct hda_pintbl[]) {
4116                         { 0x14, 0x99130110 }, /* speaker */
4117                         { 0x15, 0x0121401f }, /* HP out */
4118                         { 0x18, 0x01a19c20 }, /* mic */
4119                         { 0x19, 0x99a3092f }, /* int-mic */
4120                         { }
4121                 },
4122         },
4123         [ALC269_FIXUP_DMIC] = {
4124                 .type = HDA_FIXUP_PINS,
4125                 .v.pins = (const struct hda_pintbl[]) {
4126                         { 0x12, 0x99a3092f }, /* int-mic */
4127                         { 0x14, 0x99130110 }, /* speaker */
4128                         { 0x15, 0x0121401f }, /* HP out */
4129                         { 0x18, 0x01a19c20 }, /* mic */
4130                         { }
4131                 },
4132         },
4133         [ALC269VB_FIXUP_AMIC] = {
4134                 .type = HDA_FIXUP_PINS,
4135                 .v.pins = (const struct hda_pintbl[]) {
4136                         { 0x14, 0x99130110 }, /* speaker */
4137                         { 0x18, 0x01a19c20 }, /* mic */
4138                         { 0x19, 0x99a3092f }, /* int-mic */
4139                         { 0x21, 0x0121401f }, /* HP out */
4140                         { }
4141                 },
4142         },
4143         [ALC269VB_FIXUP_DMIC] = {
4144                 .type = HDA_FIXUP_PINS,
4145                 .v.pins = (const struct hda_pintbl[]) {
4146                         { 0x12, 0x99a3092f }, /* int-mic */
4147                         { 0x14, 0x99130110 }, /* speaker */
4148                         { 0x18, 0x01a19c20 }, /* mic */
4149                         { 0x21, 0x0121401f }, /* HP out */
4150                         { }
4151                 },
4152         },
4153         [ALC269_FIXUP_HP_MUTE_LED] = {
4154                 .type = HDA_FIXUP_FUNC,
4155                 .v.func = alc269_fixup_hp_mute_led,
4156         },
4157         [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
4158                 .type = HDA_FIXUP_FUNC,
4159                 .v.func = alc269_fixup_hp_mute_led_mic1,
4160         },
4161         [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
4162                 .type = HDA_FIXUP_FUNC,
4163                 .v.func = alc269_fixup_hp_mute_led_mic2,
4164         },
4165         [ALC269_FIXUP_HP_GPIO_LED] = {
4166                 .type = HDA_FIXUP_FUNC,
4167                 .v.func = alc269_fixup_hp_gpio_led,
4168         },
4169         [ALC269_FIXUP_INV_DMIC] = {
4170                 .type = HDA_FIXUP_FUNC,
4171                 .v.func = alc_fixup_inv_dmic_0x12,
4172         },
4173         [ALC269_FIXUP_NO_SHUTUP] = {
4174                 .type = HDA_FIXUP_FUNC,
4175                 .v.func = alc_fixup_no_shutup,
4176         },
4177         [ALC269_FIXUP_LENOVO_DOCK] = {
4178                 .type = HDA_FIXUP_PINS,
4179                 .v.pins = (const struct hda_pintbl[]) {
4180                         { 0x19, 0x23a11040 }, /* dock mic */
4181                         { 0x1b, 0x2121103f }, /* dock headphone */
4182                         { }
4183                 },
4184                 .chained = true,
4185                 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
4186         },
4187         [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
4188                 .type = HDA_FIXUP_FUNC,
4189                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
4190                 .chained = true,
4191                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
4192         },
4193         [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
4194                 .type = HDA_FIXUP_PINS,
4195                 .v.pins = (const struct hda_pintbl[]) {
4196                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4197                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
4198                         { }
4199                 },
4200                 .chained = true,
4201                 .chain_id = ALC269_FIXUP_HEADSET_MODE
4202         },
4203         [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
4204                 .type = HDA_FIXUP_PINS,
4205                 .v.pins = (const struct hda_pintbl[]) {
4206                         { 0x16, 0x21014020 }, /* dock line out */
4207                         { 0x19, 0x21a19030 }, /* dock mic */
4208                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4209                         { }
4210                 },
4211                 .chained = true,
4212                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
4213         },
4214         [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
4215                 .type = HDA_FIXUP_PINS,
4216                 .v.pins = (const struct hda_pintbl[]) {
4217                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4218                         { }
4219                 },
4220                 .chained = true,
4221                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
4222         },
4223         [ALC269_FIXUP_HEADSET_MODE] = {
4224                 .type = HDA_FIXUP_FUNC,
4225                 .v.func = alc_fixup_headset_mode,
4226         },
4227         [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
4228                 .type = HDA_FIXUP_FUNC,
4229                 .v.func = alc_fixup_headset_mode_no_hp_mic,
4230         },
4231         [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
4232                 .type = HDA_FIXUP_PINS,
4233                 .v.pins = (const struct hda_pintbl[]) {
4234                         { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
4235                         { }
4236                 },
4237                 .chained = true,
4238                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
4239         },
4240         [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
4241                 .type = HDA_FIXUP_PINS,
4242                 .v.pins = (const struct hda_pintbl[]) {
4243                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4244                         { }
4245                 },
4246                 .chained = true,
4247                 .chain_id = ALC269_FIXUP_HEADSET_MIC
4248         },
4249         [ALC269_FIXUP_ASUS_X101_FUNC] = {
4250                 .type = HDA_FIXUP_FUNC,
4251                 .v.func = alc269_fixup_x101_headset_mic,
4252         },
4253         [ALC269_FIXUP_ASUS_X101_VERB] = {
4254                 .type = HDA_FIXUP_VERBS,
4255                 .v.verbs = (const struct hda_verb[]) {
4256                         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4257                         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
4258                         {0x20, AC_VERB_SET_PROC_COEF,  0x0310},
4259                         { }
4260                 },
4261                 .chained = true,
4262                 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
4263         },
4264         [ALC269_FIXUP_ASUS_X101] = {
4265                 .type = HDA_FIXUP_PINS,
4266                 .v.pins = (const struct hda_pintbl[]) {
4267                         { 0x18, 0x04a1182c }, /* Headset mic */
4268                         { }
4269                 },
4270                 .chained = true,
4271                 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
4272         },
4273         [ALC271_FIXUP_AMIC_MIC2] = {
4274                 .type = HDA_FIXUP_PINS,
4275                 .v.pins = (const struct hda_pintbl[]) {
4276                         { 0x14, 0x99130110 }, /* speaker */
4277                         { 0x19, 0x01a19c20 }, /* mic */
4278                         { 0x1b, 0x99a7012f }, /* int-mic */
4279                         { 0x21, 0x0121401f }, /* HP out */
4280                         { }
4281                 },
4282         },
4283         [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
4284                 .type = HDA_FIXUP_FUNC,
4285                 .v.func = alc271_hp_gate_mic_jack,
4286                 .chained = true,
4287                 .chain_id = ALC271_FIXUP_AMIC_MIC2,
4288         },
4289         [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
4290                 .type = HDA_FIXUP_FUNC,
4291                 .v.func = alc269_fixup_limit_int_mic_boost,
4292                 .chained = true,
4293                 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
4294         },
4295         [ALC269_FIXUP_ACER_AC700] = {
4296                 .type = HDA_FIXUP_PINS,
4297                 .v.pins = (const struct hda_pintbl[]) {
4298                         { 0x12, 0x99a3092f }, /* int-mic */
4299                         { 0x14, 0x99130110 }, /* speaker */
4300                         { 0x18, 0x03a11c20 }, /* mic */
4301                         { 0x1e, 0x0346101e }, /* SPDIF1 */
4302                         { 0x21, 0x0321101f }, /* HP out */
4303                         { }
4304                 },
4305                 .chained = true,
4306                 .chain_id = ALC271_FIXUP_DMIC,
4307         },
4308         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
4309                 .type = HDA_FIXUP_FUNC,
4310                 .v.func = alc269_fixup_limit_int_mic_boost,
4311                 .chained = true,
4312                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
4313         },
4314         [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
4315                 .type = HDA_FIXUP_FUNC,
4316                 .v.func = alc269_fixup_limit_int_mic_boost,
4317                 .chained = true,
4318                 .chain_id = ALC269VB_FIXUP_DMIC,
4319         },
4320         [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
4321                 .type = HDA_FIXUP_VERBS,
4322                 .v.verbs = (const struct hda_verb[]) {
4323                         /* class-D output amp +5dB */
4324                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
4325                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
4326                         {}
4327                 },
4328                 .chained = true,
4329                 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
4330         },
4331         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
4332                 .type = HDA_FIXUP_FUNC,
4333                 .v.func = alc269_fixup_limit_int_mic_boost,
4334                 .chained = true,
4335                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
4336         },
4337         [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
4338                 .type = HDA_FIXUP_PINS,
4339                 .v.pins = (const struct hda_pintbl[]) {
4340                         { 0x12, 0x99a3092f }, /* int-mic */
4341                         { 0x18, 0x03a11d20 }, /* mic */
4342                         { 0x19, 0x411111f0 }, /* Unused bogus pin */
4343                         { }
4344                 },
4345         },
4346         [ALC283_FIXUP_CHROME_BOOK] = {
4347                 .type = HDA_FIXUP_FUNC,
4348                 .v.func = alc283_fixup_chromebook,
4349         },
4350         [ALC283_FIXUP_SENSE_COMBO_JACK] = {
4351                 .type = HDA_FIXUP_FUNC,
4352                 .v.func = alc283_fixup_sense_combo_jack,
4353                 .chained = true,
4354                 .chain_id = ALC283_FIXUP_CHROME_BOOK,
4355         },
4356         [ALC282_FIXUP_ASUS_TX300] = {
4357                 .type = HDA_FIXUP_FUNC,
4358                 .v.func = alc282_fixup_asus_tx300,
4359         },
4360         [ALC283_FIXUP_INT_MIC] = {
4361                 .type = HDA_FIXUP_VERBS,
4362                 .v.verbs = (const struct hda_verb[]) {
4363                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
4364                         {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
4365                         { }
4366                 },
4367                 .chained = true,
4368                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
4369         },
4370         [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
4371                 .type = HDA_FIXUP_PINS,
4372                 .v.pins = (const struct hda_pintbl[]) {
4373                         { 0x17, 0x90170112 }, /* subwoofer */
4374                         { }
4375                 },
4376                 .chained = true,
4377                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
4378         },
4379         [ALC290_FIXUP_SUBWOOFER] = {
4380                 .type = HDA_FIXUP_PINS,
4381                 .v.pins = (const struct hda_pintbl[]) {
4382                         { 0x17, 0x90170112 }, /* subwoofer */
4383                         { }
4384                 },
4385                 .chained = true,
4386                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
4387         },
4388         [ALC290_FIXUP_MONO_SPEAKERS] = {
4389                 .type = HDA_FIXUP_FUNC,
4390                 .v.func = alc290_fixup_mono_speakers,
4391         },
4392         [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
4393                 .type = HDA_FIXUP_FUNC,
4394                 .v.func = alc290_fixup_mono_speakers,
4395                 .chained = true,
4396                 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
4397         },
4398         [ALC269_FIXUP_THINKPAD_ACPI] = {
4399                 .type = HDA_FIXUP_FUNC,
4400                 .v.func = hda_fixup_thinkpad_acpi,
4401         },
4402         [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
4403                 .type = HDA_FIXUP_PINS,
4404                 .v.pins = (const struct hda_pintbl[]) {
4405                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4406                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
4407                         { }
4408                 },
4409                 .chained = true,
4410                 .chain_id = ALC255_FIXUP_HEADSET_MODE
4411         },
4412         [ALC255_FIXUP_HEADSET_MODE] = {
4413                 .type = HDA_FIXUP_FUNC,
4414                 .v.func = alc_fixup_headset_mode_alc255,
4415         },
4416 };
4417 
4418 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
4419         SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
4420         SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
4421         SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
4422         SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
4423         SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
4424         SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
4425         SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
4426         SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
4427         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
4428         SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
4429         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
4430         SND_PCI_QUIRK(0x1028, 0x05bd, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4431         SND_PCI_QUIRK(0x1028, 0x05be, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4432         SND_PCI_QUIRK(0x1028, 0x05c4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4433         SND_PCI_QUIRK(0x1028, 0x05c5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4434         SND_PCI_QUIRK(0x1028, 0x05c6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4435         SND_PCI_QUIRK(0x1028, 0x05c7, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4436         SND_PCI_QUIRK(0x1028, 0x05c8, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4437         SND_PCI_QUIRK(0x1028, 0x05c9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4438         SND_PCI_QUIRK(0x1028, 0x05ca, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4439         SND_PCI_QUIRK(0x1028, 0x05cb, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4440         SND_PCI_QUIRK(0x1028, 0x05cc, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4441         SND_PCI_QUIRK(0x1028, 0x05cd, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4442         SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
4443         SND_PCI_QUIRK(0x1028, 0x05de, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4444         SND_PCI_QUIRK(0x1028, 0x05e0, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4445         SND_PCI_QUIRK(0x1028, 0x05e9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4446         SND_PCI_QUIRK(0x1028, 0x05ea, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4447         SND_PCI_QUIRK(0x1028, 0x05eb, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4448         SND_PCI_QUIRK(0x1028, 0x05ec, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4449         SND_PCI_QUIRK(0x1028, 0x05ed, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4450         SND_PCI_QUIRK(0x1028, 0x05ee, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4451         SND_PCI_QUIRK(0x1028, 0x05f3, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4452         SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4453         SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4454         SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4455         SND_PCI_QUIRK(0x1028, 0x05f8, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4456         SND_PCI_QUIRK(0x1028, 0x05f9, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4457         SND_PCI_QUIRK(0x1028, 0x05fb, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4458         SND_PCI_QUIRK(0x1028, 0x0606, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4459         SND_PCI_QUIRK(0x1028, 0x0608, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4460         SND_PCI_QUIRK(0x1028, 0x0609, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4461         SND_PCI_QUIRK(0x1028, 0x060f, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE),
4462         SND_PCI_QUIRK(0x1028, 0x0610, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE),
4463         SND_PCI_QUIRK(0x1028, 0x0613, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4464         SND_PCI_QUIRK(0x1028, 0x0614, "Dell Inspiron 3135", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4465         SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
4466         SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
4467         SND_PCI_QUIRK(0x1028, 0x061f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4468         SND_PCI_QUIRK(0x1028, 0x0629, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4469         SND_PCI_QUIRK(0x1028, 0x062c, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4470         SND_PCI_QUIRK(0x1028, 0x062e, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4471         SND_PCI_QUIRK(0x1028, 0x0632, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4472         SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
4473         SND_PCI_QUIRK(0x1028, 0x063e, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4474         SND_PCI_QUIRK(0x1028, 0x063f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4475         SND_PCI_QUIRK(0x1028, 0x0640, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4476         SND_PCI_QUIRK(0x1028, 0x064d, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4477         SND_PCI_QUIRK(0x1028, 0x0651, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4478         SND_PCI_QUIRK(0x1028, 0x0652, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4479         SND_PCI_QUIRK(0x1028, 0x0653, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4480         SND_PCI_QUIRK(0x1028, 0x0657, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4481         SND_PCI_QUIRK(0x1028, 0x0658, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
4482         SND_PCI_QUIRK(0x1028, 0x065f, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4483         SND_PCI_QUIRK(0x1028, 0x0662, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
4484         SND_PCI_QUIRK(0x1028, 0x15cc, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4485         SND_PCI_QUIRK(0x1028, 0x15cd, "Dell X5 Precision", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE),
4486         SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
4487         SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
4488         SND_PCI_QUIRK(0x103c, 0x1973, "HP Pavilion", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4489         SND_PCI_QUIRK(0x103c, 0x1983, "HP Pavilion", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4490         SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
4491         /* ALC282 */
4492         SND_PCI_QUIRK(0x103c, 0x2191, "HP Touchsmart 14", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4493         SND_PCI_QUIRK(0x103c, 0x2192, "HP Touchsmart 15", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4494         SND_PCI_QUIRK(0x103c, 0x220d, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4495         SND_PCI_QUIRK(0x103c, 0x220e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4496         SND_PCI_QUIRK(0x103c, 0x220f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4497         SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4498         SND_PCI_QUIRK(0x103c, 0x2211, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4499         SND_PCI_QUIRK(0x103c, 0x2212, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4500         SND_PCI_QUIRK(0x103c, 0x2213, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4501         SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4502         SND_PCI_QUIRK(0x103c, 0x2266, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4503         SND_PCI_QUIRK(0x103c, 0x2267, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4504         SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4505         SND_PCI_QUIRK(0x103c, 0x2269, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4506         SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4507         SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4508         SND_PCI_QUIRK(0x103c, 0x226c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4509         SND_PCI_QUIRK(0x103c, 0x226d, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4510         SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4511         SND_PCI_QUIRK(0x103c, 0x226f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4512         SND_PCI_QUIRK(0x103c, 0x227a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4513         SND_PCI_QUIRK(0x103c, 0x227b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4514         SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4515         SND_PCI_QUIRK(0x103c, 0x22a0, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4516         SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4517         SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4518         SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4519         SND_PCI_QUIRK(0x103c, 0x22c0, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4520         SND_PCI_QUIRK(0x103c, 0x22c1, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4521         SND_PCI_QUIRK(0x103c, 0x22c2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4522         SND_PCI_QUIRK(0x103c, 0x22cd, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4523         SND_PCI_QUIRK(0x103c, 0x22ce, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4524         SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4525         SND_PCI_QUIRK(0x103c, 0x22d0, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4526         /* ALC290 */
4527         SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4528         SND_PCI_QUIRK(0x103c, 0x2261, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4529         SND_PCI_QUIRK(0x103c, 0x2262, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4530         SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4531         SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4532         SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4533         SND_PCI_QUIRK(0x103c, 0x227d, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4534         SND_PCI_QUIRK(0x103c, 0x227e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4535         SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4536         SND_PCI_QUIRK(0x103c, 0x2280, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4537         SND_PCI_QUIRK(0x103c, 0x2281, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4538         SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4539         SND_PCI_QUIRK(0x103c, 0x2289, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4540         SND_PCI_QUIRK(0x103c, 0x228a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4541         SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4542         SND_PCI_QUIRK(0x103c, 0x228c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4543         SND_PCI_QUIRK(0x103c, 0x228d, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4544         SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4545         SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4546         SND_PCI_QUIRK(0x103c, 0x22c6, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4547         SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4548         SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4549         SND_PCI_QUIRK(0x103c, 0x22c3, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4550         SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4551         SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4552         SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4553         SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4554         SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
4555         SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
4556         SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
4557         SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4558         SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4559         SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
4560         SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
4561         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
4562         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
4563         SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
4564         SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4565         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
4566         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
4567         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
4568         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
4569         SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
4570         SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
4571         SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
4572         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
4573         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
4574         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
4575         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
4576         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
4577         SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
4578         SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
4579         SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
4580         SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
4581         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
4582         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
4583         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
4584         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
4585         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
4586         SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),
4587         SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
4588         SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
4589         SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
4590         SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
4591         SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
4592         SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4593         SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4594         SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4595         SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4596         SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
4597         SND_PCI_QUIRK(0x17aa, 0x3978, "IdeaPad Y410P", ALC269_FIXUP_NO_SHUTUP),
4598         SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4599         SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
4600         SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4601         SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
4602         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
4603         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
4604         SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
4605         SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
4606 
4607 #if 0
4608         /* Below is a quirk table taken from the old code.
4609          * Basically the device should work as is without the fixup table.
4610          * If BIOS doesn't give a proper info, enable the corresponding
4611          * fixup entry.
4612          */
4613         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
4614                       ALC269_FIXUP_AMIC),
4615         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
4616         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
4617         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
4618         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
4619         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
4620         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
4621         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
4622         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
4623         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
4624         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
4625         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
4626         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
4627         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
4628         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
4629         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
4630         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
4631         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
4632         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
4633         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
4634         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
4635         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
4636         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
4637         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
4638         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
4639         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
4640         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
4641         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
4642         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
4643         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
4644         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
4645         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
4646         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
4647         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
4648         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
4649         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
4650         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
4651         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
4652         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
4653         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
4654 #endif
4655         {}
4656 };
4657 
4658 static const struct hda_model_fixup alc269_fixup_models[] = {
4659         {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
4660         {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
4661         {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
4662         {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
4663         {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
4664         {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
4665         {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
4666         {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
4667         {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
4668         {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
4669         {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-chrome"},
4670         {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
4671         {}
4672 };
4673 
4674 
4675 static void alc269_fill_coef(struct hda_codec *codec)
4676 {
4677         struct alc_spec *spec = codec->spec;
4678         int val;
4679 
4680         if (spec->codec_variant != ALC269_TYPE_ALC269VB)
4681                 return;
4682 
4683         if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
4684                 alc_write_coef_idx(codec, 0xf, 0x960b);
4685                 alc_write_coef_idx(codec, 0xe, 0x8817);
4686         }
4687 
4688         if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
4689                 alc_write_coef_idx(codec, 0xf, 0x960b);
4690                 alc_write_coef_idx(codec, 0xe, 0x8814);
4691         }
4692 
4693         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
4694                 val = alc_read_coef_idx(codec, 0x04);
4695                 /* Power up output pin */
4696                 if (val != -1)
4697                         alc_write_coef_idx(codec, 0x04, val | (1<<11));
4698         }
4699 
4700         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
4701                 val = alc_read_coef_idx(codec, 0xd);
4702                 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
4703                         /* Capless ramp up clock control */
4704                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
4705                 }
4706                 val = alc_read_coef_idx(codec, 0x17);
4707                 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
4708                         /* Class D power on reset */
4709                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
4710                 }
4711         }
4712 
4713         val = alc_read_coef_idx(codec, 0xd); /* Class D */
4714         if (val != -1)
4715                 alc_write_coef_idx(codec, 0xd, val | (1<<14));
4716 
4717         val = alc_read_coef_idx(codec, 0x4); /* HP */
4718         if (val != -1)
4719                 alc_write_coef_idx(codec, 0x4, val | (1<<11));
4720 }
4721 
4722 /*
4723  */
4724 static int patch_alc269(struct hda_codec *codec)
4725 {
4726         struct alc_spec *spec;
4727         int err;
4728 
4729         err = alc_alloc_spec(codec, 0x0b);
4730         if (err < 0)
4731                 return err;
4732 
4733         spec = codec->spec;
4734         spec->gen.shared_mic_vref_pin = 0x18;
4735 
4736         snd_hda_pick_fixup(codec, alc269_fixup_models,
4737                        alc269_fixup_tbl, alc269_fixups);
4738         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4739 
4740         alc_auto_parse_customize_define(codec);
4741 
4742         if (has_cdefine_beep(codec))
4743                 spec->gen.beep_nid = 0x01;
4744 
4745         switch (codec->vendor_id) {
4746         case 0x10ec0269:
4747                 spec->codec_variant = ALC269_TYPE_ALC269VA;
4748                 switch (alc_get_coef0(codec) & 0x00f0) {
4749                 case 0x0010:
4750                         if (codec->bus->pci->subsystem_vendor == 0x1025 &&
4751                             spec->cdefine.platform_type == 1)
4752                                 err = alc_codec_rename(codec, "ALC271X");
4753                         spec->codec_variant = ALC269_TYPE_ALC269VB;
4754                         break;
4755                 case 0x0020:
4756                         if (codec->bus->pci->subsystem_vendor == 0x17aa &&
4757                             codec->bus->pci->subsystem_device == 0x21f3)
4758                                 err = alc_codec_rename(codec, "ALC3202");
4759                         spec->codec_variant = ALC269_TYPE_ALC269VC;
4760                         break;
4761                 case 0x0030:
4762                         spec->codec_variant = ALC269_TYPE_ALC269VD;
4763                         break;
4764                 default:
4765                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
4766                 }
4767                 if (err < 0)
4768                         goto error;
4769                 spec->init_hook = alc269_fill_coef;
4770                 alc269_fill_coef(codec);
4771                 break;
4772 
4773         case 0x10ec0280:
4774         case 0x10ec0290:
4775                 spec->codec_variant = ALC269_TYPE_ALC280;
4776                 break;
4777         case 0x10ec0282:
4778                 spec->codec_variant = ALC269_TYPE_ALC282;
4779                 break;
4780         case 0x10ec0233:
4781         case 0x10ec0283:
4782                 spec->codec_variant = ALC269_TYPE_ALC283;
4783                 spec->shutup = alc283_shutup;
4784                 spec->init_hook = alc283_init;
4785                 break;
4786         case 0x10ec0284:
4787         case 0x10ec0292:
4788                 spec->codec_variant = ALC269_TYPE_ALC284;
4789                 break;
4790         case 0x10ec0285:
4791         case 0x10ec0293:
4792                 spec->codec_variant = ALC269_TYPE_ALC285;
4793                 break;
4794         case 0x10ec0286:
4795         case 0x10ec0288:
4796                 spec->codec_variant = ALC269_TYPE_ALC286;
4797                 break;
4798         case 0x10ec0255:
4799                 spec->codec_variant = ALC269_TYPE_ALC255;
4800                 break;
4801         }
4802 
4803         if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
4804                 spec->has_alc5505_dsp = 1;
4805                 spec->init_hook = alc5505_dsp_init;
4806         }
4807 
4808         /* automatic parse from the BIOS config */
4809         err = alc269_parse_auto_config(codec);
4810         if (err < 0)
4811                 goto error;
4812 
4813         if (!spec->gen.no_analog && spec->gen.beep_nid)
4814                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
4815 
4816         codec->patch_ops = alc_patch_ops;
4817 #ifdef CONFIG_PM
4818         codec->patch_ops.suspend = alc269_suspend;
4819         codec->patch_ops.resume = alc269_resume;
4820 #endif
4821         if (!spec->shutup)
4822                 spec->shutup = alc269_shutup;
4823 
4824         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4825 
4826         return 0;
4827 
4828  error:
4829         alc_free(codec);
4830         return err;
4831 }
4832 
4833 /*
4834  * ALC861
4835  */
4836 
4837 static int alc861_parse_auto_config(struct hda_codec *codec)
4838 {
4839         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
4840         static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
4841         return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
4842 }
4843 
4844 /* Pin config fixes */
4845 enum {
4846         ALC861_FIXUP_FSC_AMILO_PI1505,
4847         ALC861_FIXUP_AMP_VREF_0F,
4848         ALC861_FIXUP_NO_JACK_DETECT,
4849         ALC861_FIXUP_ASUS_A6RP,
4850         ALC660_FIXUP_ASUS_W7J,
4851 };
4852 
4853 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
4854 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
4855                         const struct hda_fixup *fix, int action)
4856 {
4857         struct alc_spec *spec = codec->spec;
4858         unsigned int val;
4859 
4860         if (action != HDA_FIXUP_ACT_INIT)
4861                 return;
4862         val = snd_hda_codec_get_pin_target(codec, 0x0f);
4863         if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
4864                 val |= AC_PINCTL_IN_EN;
4865         val |= AC_PINCTL_VREF_50;
4866         snd_hda_set_pin_ctl(codec, 0x0f, val);
4867         spec->gen.keep_vref_in_automute = 1;
4868 }
4869 
4870 /* suppress the jack-detection */
4871 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
4872                                      const struct hda_fixup *fix, int action)
4873 {
4874         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4875                 codec->no_jack_detect = 1;
4876 }
4877 
4878 static const struct hda_fixup alc861_fixups[] = {
4879         [ALC861_FIXUP_FSC_AMILO_PI1505] = {
4880                 .type = HDA_FIXUP_PINS,
4881                 .v.pins = (const struct hda_pintbl[]) {
4882                         { 0x0b, 0x0221101f }, /* HP */
4883                         { 0x0f, 0x90170310 }, /* speaker */
4884                         { }
4885                 }
4886         },
4887         [ALC861_FIXUP_AMP_VREF_0F] = {
4888                 .type = HDA_FIXUP_FUNC,
4889                 .v.func = alc861_fixup_asus_amp_vref_0f,
4890         },
4891         [ALC861_FIXUP_NO_JACK_DETECT] = {
4892                 .type = HDA_FIXUP_FUNC,
4893                 .v.func = alc_fixup_no_jack_detect,
4894         },
4895         [ALC861_FIXUP_ASUS_A6RP] = {
4896                 .type = HDA_FIXUP_FUNC,
4897                 .v.func = alc861_fixup_asus_amp_vref_0f,
4898                 .chained = true,
4899                 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
4900         },
4901         [ALC660_FIXUP_ASUS_W7J] = {
4902                 .type = HDA_FIXUP_VERBS,
4903                 .v.verbs = (const struct hda_verb[]) {
4904                         /* ASUS W7J needs a magic pin setup on unused NID 0x10
4905                          * for enabling outputs
4906                          */
4907                         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4908                         { }
4909                 },
4910         }
4911 };
4912 
4913 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
4914         SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
4915         SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
4916         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
4917         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
4918         SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
4919         SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
4920         SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
4921         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
4922         {}
4923 };
4924 
4925 /*
4926  */
4927 static int patch_alc861(struct hda_codec *codec)
4928 {
4929         struct alc_spec *spec;
4930         int err;
4931 
4932         err = alc_alloc_spec(codec, 0x15);
4933         if (err < 0)
4934                 return err;
4935 
4936         spec = codec->spec;
4937         spec->gen.beep_nid = 0x23;
4938 
4939         snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
4940         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4941 
4942         /* automatic parse from the BIOS config */
4943         err = alc861_parse_auto_config(codec);
4944         if (err < 0)
4945                 goto error;
4946 
4947         if (!spec->gen.no_analog)
4948                 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
4949 
4950         codec->patch_ops = alc_patch_ops;
4951 #ifdef CONFIG_PM
4952         spec->power_hook = alc_power_eapd;
4953 #endif
4954 
4955         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4956 
4957         return 0;
4958 
4959  error:
4960         alc_free(codec);
4961         return err;
4962 }
4963 
4964 /*
4965  * ALC861-VD support
4966  *
4967  * Based on ALC882
4968  *
4969  * In addition, an independent DAC
4970  */
4971 static int alc861vd_parse_auto_config(struct hda_codec *codec)
4972 {
4973         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
4974         static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4975         return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
4976 }
4977 
4978 enum {
4979         ALC660VD_FIX_ASUS_GPIO1,
4980         ALC861VD_FIX_DALLAS,
4981 };
4982 
4983 /* exclude VREF80 */
4984 static void alc861vd_fixup_dallas(struct hda_codec *codec,
4985                                   const struct hda_fixup *fix, int action)
4986 {
4987         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4988                 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
4989                 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
4990         }
4991 }
4992 
4993 static const struct hda_fixup alc861vd_fixups[] = {
4994         [ALC660VD_FIX_ASUS_GPIO1] = {
4995                 .type = HDA_FIXUP_VERBS,
4996                 .v.verbs = (const struct hda_verb[]) {
4997                         /* reset GPIO1 */
4998                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
4999                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5000                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5001                         { }
5002                 }
5003         },
5004         [ALC861VD_FIX_DALLAS] = {
5005                 .type = HDA_FIXUP_FUNC,
5006                 .v.func = alc861vd_fixup_dallas,
5007         },
5008 };
5009 
5010 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
5011         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
5012         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
5013         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
5014         {}
5015 };
5016 
5017 /*
5018  */
5019 static int patch_alc861vd(struct hda_codec *codec)
5020 {
5021         struct alc_spec *spec;
5022         int err;
5023 
5024         err = alc_alloc_spec(codec, 0x0b);
5025         if (err < 0)
5026                 return err;
5027 
5028         spec = codec->spec;
5029         spec->gen.beep_nid = 0x23;
5030 
5031         snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
5032         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
5033 
5034         /* automatic parse from the BIOS config */
5035         err = alc861vd_parse_auto_config(codec);
5036         if (err < 0)
5037                 goto error;
5038 
5039         if (!spec->gen.no_analog)
5040                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5041 
5042         codec->patch_ops = alc_patch_ops;
5043 
5044         spec->shutup = alc_eapd_shutup;
5045 
5046         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
5047 
5048         return 0;
5049 
5050  error:
5051         alc_free(codec);
5052         return err;
5053 }
5054 
5055 /*
5056  * ALC662 support
5057  *
5058  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5059  * configuration.  Each pin widget can choose any input DACs and a mixer.
5060  * Each ADC is connected from a mixer of all inputs.  This makes possible
5061  * 6-channel independent captures.
5062  *
5063  * In addition, an independent DAC for the multi-playback (not used in this
5064  * driver yet).
5065  */
5066 
5067 /*
5068  * BIOS auto configuration
5069  */
5070 
5071 static int alc662_parse_auto_config(struct hda_codec *codec)
5072 {
5073         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
5074         static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
5075         static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5076         const hda_nid_t *ssids;
5077 
5078         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
5079             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670 ||
5080             codec->vendor_id == 0x10ec0671)
5081                 ssids = alc663_ssids;
5082         else
5083                 ssids = alc662_ssids;
5084         return alc_parse_auto_config(codec, alc662_ignore, ssids);
5085 }
5086 
5087 static void alc272_fixup_mario(struct hda_codec *codec,
5088                                const struct hda_fixup *fix, int action)
5089 {
5090         if (action != HDA_FIXUP_ACT_PRE_PROBE)
5091                 return;
5092         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
5093                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
5094                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
5095                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5096                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
5097                 printk(KERN_WARNING
5098                        "hda_codec: failed to override amp caps for NID 0x2\n");
5099 }
5100 
5101 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
5102         { .channels = 2,
5103           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
5104         { .channels = 4,
5105           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
5106                    SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
5107         { }
5108 };
5109 
5110 /* override the 2.1 chmap */
5111 static void alc_fixup_bass_chmap(struct hda_codec *codec,
5112                                     const struct hda_fixup *fix, int action)
5113 {
5114         if (action == HDA_FIXUP_ACT_BUILD) {
5115                 struct alc_spec *spec = codec->spec;
5116                 spec->gen.pcm_rec[0].stream[0].chmap = asus_pcm_2_1_chmaps;
5117         }
5118 }
5119 
5120 enum {
5121         ALC662_FIXUP_ASPIRE,
5122         ALC662_FIXUP_IDEAPAD,
5123         ALC272_FIXUP_MARIO,
5124         ALC662_FIXUP_CZC_P10T,
5125         ALC662_FIXUP_SKU_IGNORE,
5126         ALC662_FIXUP_HP_RP5800,
5127         ALC662_FIXUP_ASUS_MODE1,
5128         ALC662_FIXUP_ASUS_MODE2,
5129         ALC662_FIXUP_ASUS_MODE3,
5130         ALC662_FIXUP_ASUS_MODE4,
5131         ALC662_FIXUP_ASUS_MODE5,
5132         ALC662_FIXUP_ASUS_MODE6,
5133         ALC662_FIXUP_ASUS_MODE7,
5134         ALC662_FIXUP_ASUS_MODE8,
5135         ALC662_FIXUP_NO_JACK_DETECT,
5136         ALC662_FIXUP_ZOTAC_Z68,
5137         ALC662_FIXUP_INV_DMIC,
5138         ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
5139         ALC668_FIXUP_HEADSET_MODE,
5140         ALC662_FIXUP_BASS_CHMAP,
5141         ALC662_FIXUP_BASS_1A,
5142         ALC662_FIXUP_BASS_1A_CHMAP,
5143         ALC668_FIXUP_AUTO_MUTE,
5144 };
5145 
5146 static const struct hda_fixup alc662_fixups[] = {
5147         [ALC662_FIXUP_ASPIRE] = {
5148                 .type = HDA_FIXUP_PINS,
5149                 .v.pins = (const struct hda_pintbl[]) {
5150                         { 0x15, 0x99130112 }, /* subwoofer */
5151                         { }
5152                 }
5153         },
5154         [ALC662_FIXUP_IDEAPAD] = {
5155                 .type = HDA_FIXUP_PINS,
5156                 .v.pins = (const struct hda_pintbl[]) {
5157                         { 0x17, 0x99130112 }, /* subwoofer */
5158                         { }
5159                 }
5160         },
5161         [ALC272_FIXUP_MARIO] = {
5162                 .type = HDA_FIXUP_FUNC,
5163                 .v.func = alc272_fixup_mario,
5164         },
5165         [ALC662_FIXUP_CZC_P10T] = {
5166                 .type = HDA_FIXUP_VERBS,
5167                 .v.verbs = (const struct hda_verb[]) {
5168                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5169                         {}
5170                 }
5171         },
5172         [ALC662_FIXUP_SKU_IGNORE] = {
5173                 .type = HDA_FIXUP_FUNC,
5174                 .v.func = alc_fixup_sku_ignore,
5175         },
5176         [ALC662_FIXUP_HP_RP5800] = {
5177                 .type = HDA_FIXUP_PINS,
5178                 .v.pins = (const struct hda_pintbl[]) {
5179                         { 0x14, 0x0221201f }, /* HP out */
5180                         { }
5181                 },
5182                 .chained = true,
5183                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5184         },
5185         [ALC662_FIXUP_ASUS_MODE1] = {
5186                 .type = HDA_FIXUP_PINS,
5187                 .v.pins = (const struct hda_pintbl[]) {
5188                         { 0x14, 0x99130110 }, /* speaker */
5189                         { 0x18, 0x01a19c20 }, /* mic */
5190                         { 0x19, 0x99a3092f }, /* int-mic */
5191                         { 0x21, 0x0121401f }, /* HP out */
5192                         { }
5193                 },
5194                 .chained = true,
5195                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5196         },
5197         [ALC662_FIXUP_ASUS_MODE2] = {
5198                 .type = HDA_FIXUP_PINS,
5199                 .v.pins = (const struct hda_pintbl[]) {
5200                         { 0x14, 0x99130110 }, /* speaker */
5201                         { 0x18, 0x01a19820 }, /* mic */
5202                         { 0x19, 0x99a3092f }, /* int-mic */
5203                         { 0x1b, 0x0121401f }, /* HP out */
5204                         { }
5205                 },
5206                 .chained = true,
5207                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5208         },
5209         [ALC662_FIXUP_ASUS_MODE3] = {
5210                 .type = HDA_FIXUP_PINS,
5211                 .v.pins = (const struct hda_pintbl[]) {
5212                         { 0x14, 0x99130110 }, /* speaker */
5213                         { 0x15, 0x0121441f }, /* HP */
5214                         { 0x18, 0x01a19840 }, /* mic */
5215                         { 0x19, 0x99a3094f }, /* int-mic */
5216                         { 0x21, 0x01211420 }, /* HP2 */
5217                         { }
5218                 },
5219                 .chained = true,
5220                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5221         },
5222         [ALC662_FIXUP_ASUS_MODE4] = {
5223                 .type = HDA_FIXUP_PINS,
5224                 .v.pins = (const struct hda_pintbl[]) {
5225                         { 0x14, 0x99130110 }, /* speaker */
5226                         { 0x16, 0x99130111 }, /* speaker */
5227                         { 0x18, 0x01a19840 }, /* mic */
5228                         { 0x19, 0x99a3094f }, /* int-mic */
5229                         { 0x21, 0x0121441f }, /* HP */
5230                         { }
5231                 },
5232                 .chained = true,
5233                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5234         },
5235         [ALC662_FIXUP_ASUS_MODE5] = {
5236                 .type = HDA_FIXUP_PINS,
5237                 .v.pins = (const struct hda_pintbl[]) {
5238                         { 0x14, 0x99130110 }, /* speaker */
5239                         { 0x15, 0x0121441f }, /* HP */
5240                         { 0x16, 0x99130111 }, /* speaker */
5241                         { 0x18, 0x01a19840 }, /* mic */
5242                         { 0x19, 0x99a3094f }, /* int-mic */
5243                         { }
5244                 },
5245                 .chained = true,
5246                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5247         },
5248         [ALC662_FIXUP_ASUS_MODE6] = {
5249                 .type = HDA_FIXUP_PINS,
5250                 .v.pins = (const struct hda_pintbl[]) {
5251                         { 0x14, 0x99130110 }, /* speaker */
5252                         { 0x15, 0x01211420 }, /* HP2 */
5253                         { 0x18, 0x01a19840 }, /* mic */
5254                         { 0x19, 0x99a3094f }, /* int-mic */
5255                         { 0x1b, 0x0121441f }, /* HP */
5256                         { }
5257                 },
5258                 .chained = true,
5259                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5260         },
5261         [ALC662_FIXUP_ASUS_MODE7] = {
5262                 .type = HDA_FIXUP_PINS,
5263                 .v.pins = (const struct hda_pintbl[]) {
5264                         { 0x14, 0x99130110 }, /* speaker */
5265                         { 0x17, 0x99130111 }, /* speaker */
5266                         { 0x18, 0x01a19840 }, /* mic */
5267                         { 0x19, 0x99a3094f }, /* int-mic */
5268                         { 0x1b, 0x01214020 }, /* HP */
5269                         { 0x21, 0x0121401f }, /* HP */
5270                         { }
5271                 },
5272                 .chained = true,
5273                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5274         },
5275         [ALC662_FIXUP_ASUS_MODE8] = {
5276                 .type = HDA_FIXUP_PINS,
5277                 .v.pins = (const struct hda_pintbl[]) {
5278                         { 0x14, 0x99130110 }, /* speaker */
5279                         { 0x12, 0x99a30970 }, /* int-mic */
5280                         { 0x15, 0x01214020 }, /* HP */
5281                         { 0x17, 0x99130111 }, /* speaker */
5282                         { 0x18, 0x01a19840 }, /* mic */
5283                         { 0x21, 0x0121401f }, /* HP */
5284                         { }
5285                 },
5286                 .chained = true,
5287                 .chain_id = ALC662_FIXUP_SKU_IGNORE
5288         },
5289         [ALC662_FIXUP_NO_JACK_DETECT] = {
5290                 .type = HDA_FIXUP_FUNC,
5291                 .v.func = alc_fixup_no_jack_detect,
5292         },
5293         [ALC662_FIXUP_ZOTAC_Z68] = {
5294                 .type = HDA_FIXUP_PINS,
5295                 .v.pins = (const struct hda_pintbl[]) {
5296                         { 0x1b, 0x02214020 }, /* Front HP */
5297                         { }
5298                 }
5299         },
5300         [ALC662_FIXUP_INV_DMIC] = {
5301                 .type = HDA_FIXUP_FUNC,
5302                 .v.func = alc_fixup_inv_dmic_0x12,
5303         },
5304         [ALC668_FIXUP_AUTO_MUTE] = {
5305                 .type = HDA_FIXUP_FUNC,
5306                 .v.func = alc_fixup_auto_mute_via_amp,
5307                 .chained = true,
5308                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
5309         },
5310         [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
5311                 .type = HDA_FIXUP_PINS,
5312                 .v.pins = (const struct hda_pintbl[]) {
5313                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
5314                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
5315                         { }
5316                 },
5317                 .chained = true,
5318                 .chain_id = ALC668_FIXUP_HEADSET_MODE
5319         },
5320         [ALC668_FIXUP_HEADSET_MODE] = {
5321                 .type = HDA_FIXUP_FUNC,
5322                 .v.func = alc_fixup_headset_mode_alc668,
5323         },
5324         [ALC662_FIXUP_BASS_CHMAP] = {
5325                 .type = HDA_FIXUP_FUNC,
5326                 .v.func = alc_fixup_bass_chmap,
5327                 .chained = true,
5328                 .chain_id = ALC662_FIXUP_ASUS_MODE4
5329         },
5330         [ALC662_FIXUP_BASS_1A] = {
5331                 .type = HDA_FIXUP_PINS,
5332                 .v.pins = (const struct hda_pintbl[]) {
5333                         {0x1a, 0x80106111}, /* bass speaker */
5334                         {}
5335                 },
5336         },
5337         [ALC662_FIXUP_BASS_1A_CHMAP] = {
5338                 .type = HDA_FIXUP_FUNC,
5339                 .v.func = alc_fixup_bass_chmap,
5340                 .chained = true,
5341                 .chain_id = ALC662_FIXUP_BASS_1A,
5342         },
5343 };
5344 
5345 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
5346         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
5347         SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
5348         SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
5349         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
5350         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
5351         SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
5352         SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
5353         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
5354         SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
5355         SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
5356         SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
5357         SND_PCI_QUIRK(0x1028, 0x0623, "Dell", ALC668_FIXUP_AUTO_MUTE),
5358         SND_PCI_QUIRK(0x1028, 0x0624, "Dell", ALC668_FIXUP_AUTO_MUTE),
5359         SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
5360         SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
5361         SND_PCI_QUIRK(0x1028, 0x0628, "Dell", ALC668_FIXUP_AUTO_MUTE),
5362         SND_PCI_QUIRK(0x1028, 0x064e, "Dell", ALC668_FIXUP_AUTO_MUTE),
5363         SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
5364         SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
5365         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
5366         SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_BASS_1A_CHMAP),
5367         SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_CHMAP),
5368         SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_CHMAP),
5369         SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
5370         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
5371         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
5372         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
5373         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
5374         SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
5375         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
5376 
5377 #if 0
5378         /* Below is a quirk table taken from the old code.
5379          * Basically the device should work as is without the fixup table.
5380          * If BIOS doesn't give a proper info, enable the corresponding
5381          * fixup entry.
5382          */
5383         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
5384         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
5385         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
5386         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
5387         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5388         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5389         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5390         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
5391         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
5392         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5393         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
5394         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
5395         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
5396         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
5397         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
5398         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5399         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
5400         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
5401         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5402         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5403         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5404         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5405         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
5406         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
5407         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
5408         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5409         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
5410         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5411         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5412         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
5413         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5414         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5415         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
5416         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
5417         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
5418         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
5419         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
5420         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
5421         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
5422         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5423         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
5424         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
5425         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5426         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
5427         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
5428         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
5429         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
5430         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
5431         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5432         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
5433 #endif
5434         {}
5435 };
5436 
5437 static const struct hda_model_fixup alc662_fixup_models[] = {
5438         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
5439         {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
5440         {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
5441         {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
5442         {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
5443         {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
5444         {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
5445         {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
5446         {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
5447         {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
5448         {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
5449         {}
5450 };
5451 
5452 static void alc662_fill_coef(struct hda_codec *codec)
5453 {
5454         int val, coef;
5455 
5456         coef = alc_get_coef0(codec);
5457 
5458         switch (codec->vendor_id) {
5459         case 0x10ec0662:
5460                 if ((coef & 0x00f0) == 0x0030) {
5461                         val = alc_read_coef_idx(codec, 0x4); /* EAPD Ctrl */
5462                         alc_write_coef_idx(codec, 0x4, val & ~(1<<10));
5463                 }
5464                 break;
5465         case 0x10ec0272:
5466         case 0x10ec0273:
5467         case 0x10ec0663:
5468         case 0x10ec0665:
5469         case 0x10ec0670:
5470         case 0x10ec0671:
5471         case 0x10ec0672:
5472                 val = alc_read_coef_idx(codec, 0xd); /* EAPD Ctrl */
5473                 alc_write_coef_idx(codec, 0xd, val | (1<<14));
5474                 break;
5475         }
5476 }
5477 
5478 /*
5479  */
5480 static int patch_alc662(struct hda_codec *codec)
5481 {
5482         struct alc_spec *spec;
5483         int err;
5484 
5485         err = alc_alloc_spec(codec, 0x0b);
5486         if (err < 0)
5487                 return err;
5488 
5489         spec = codec->spec;
5490 
5491         /* handle multiple HPs as is */
5492         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5493 
5494         alc_fix_pll_init(codec, 0x20, 0x04, 15);
5495 
5496         spec->init_hook = alc662_fill_coef;
5497         alc662_fill_coef(codec);
5498 
5499         snd_hda_pick_fixup(codec, alc662_fixup_models,
5500                        alc662_fixup_tbl, alc662_fixups);
5501         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
5502 
5503         alc_auto_parse_customize_define(codec);
5504 
5505         if (has_cdefine_beep(codec))
5506                 spec->gen.beep_nid = 0x01;
5507 
5508         if ((alc_get_coef0(codec) & (1 << 14)) &&
5509             codec->bus->pci->subsystem_vendor == 0x1025 &&
5510             spec->cdefine.platform_type == 1) {
5511                 err = alc_codec_rename(codec, "ALC272X");
5512                 if (err < 0)
5513                         goto error;
5514         }
5515 
5516         /* automatic parse from the BIOS config */
5517         err = alc662_parse_auto_config(codec);
5518         if (err < 0)
5519                 goto error;
5520 
5521         if (!spec->gen.no_analog && spec->gen.beep_nid) {
5522                 switch (codec->vendor_id) {
5523                 case 0x10ec0662:
5524                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5525                         break;
5526                 case 0x10ec0272:
5527                 case 0x10ec0663:
5528                 case 0x10ec0665:
5529                 case 0x10ec0668:
5530                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5531                         break;
5532                 case 0x10ec0273:
5533                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
5534                         break;
5535                 }
5536         }
5537 
5538         codec->patch_ops = alc_patch_ops;
5539         spec->shutup = alc_eapd_shutup;
5540 
5541         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
5542 
5543         return 0;
5544 
5545  error:
5546         alc_free(codec);
5547         return err;
5548 }
5549 
5550 /*
5551  * ALC680 support
5552  */
5553 
5554 static int alc680_parse_auto_config(struct hda_codec *codec)
5555 {
5556         return alc_parse_auto_config(codec, NULL, NULL);
5557 }
5558 
5559 /*
5560  */
5561 static int patch_alc680(struct hda_codec *codec)
5562 {
5563         int err;
5564 
5565         /* ALC680 has no aa-loopback mixer */
5566         err = alc_alloc_spec(codec, 0);
5567         if (err < 0)
5568                 return err;
5569 
5570         /* automatic parse from the BIOS config */
5571         err = alc680_parse_auto_config(codec);
5572         if (err < 0) {
5573                 alc_free(codec);
5574                 return err;
5575         }
5576 
5577         codec->patch_ops = alc_patch_ops;
5578 
5579         return 0;
5580 }
5581 
5582 /*
5583  * patch entries
5584  */
5585 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
5586         { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
5587         { .id = 0x10ec0231, .name = "ALC231", .patch = patch_alc269 },
5588         { .id = 0x10ec0233, .name = "ALC233", .patch = patch_alc269 },
5589         { .id = 0x10ec0255, .name = "ALC255", .patch = patch_alc269 },
5590         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
5591         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
5592         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
5593         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
5594         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
5595         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
5596         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
5597         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
5598         { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
5599         { .id = 0x10ec0280, .name = "ALC280", .patch = patch_alc269 },
5600         { .id = 0x10ec0282, .name = "ALC282", .patch = patch_alc269 },
5601         { .id = 0x10ec0283, .name = "ALC283", .patch = patch_alc269 },
5602         { .id = 0x10ec0284, .name = "ALC284", .patch = patch_alc269 },
5603         { .id = 0x10ec0285, .name = "ALC285", .patch = patch_alc269 },
5604         { .id = 0x10ec0286, .name = "ALC286", .patch = patch_alc269 },
5605         { .id = 0x10ec0288, .name = "ALC288", .patch = patch_alc269 },
5606         { .id = 0x10ec0290, .name = "ALC290", .patch = patch_alc269 },
5607         { .id = 0x10ec0292, .name = "ALC292", .patch = patch_alc269 },
5608         { .id = 0x10ec0293, .name = "ALC293", .patch = patch_alc269 },
5609         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
5610           .patch = patch_alc861 },
5611         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
5612         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
5613         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
5614         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
5615           .patch = patch_alc882 },
5616         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
5617           .patch = patch_alc662 },
5618         { .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",
5619           .patch = patch_alc662 },
5620         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
5621         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
5622         { .id = 0x10ec0668, .name = "ALC668", .patch = patch_alc662 },
5623         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
5624         { .id = 0x10ec0671, .name = "ALC671", .patch = patch_alc662 },
5625         { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
5626         { .id = 0x10ec0867, .name = "ALC891", .patch = patch_alc882 },
5627         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
5628         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
5629         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
5630         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
5631           .patch = patch_alc882 },
5632         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
5633           .patch = patch_alc882 },
5634         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
5635         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
5636         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
5637           .patch = patch_alc882 },
5638         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
5639         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
5640         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
5641         { .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },
5642         { .id = 0x10ec0900, .name = "ALC1150", .patch = patch_alc882 },
5643         {} /* terminator */
5644 };
5645 
5646 MODULE_ALIAS("snd-hda-codec-id:10ec*");
5647 
5648 MODULE_LICENSE("GPL");
5649 MODULE_DESCRIPTION("Realtek HD-audio codec");
5650 
5651 static struct hda_codec_preset_list realtek_list = {
5652         .preset = snd_hda_preset_realtek,
5653         .owner = THIS_MODULE,
5654 };
5655 
5656 static int __init patch_realtek_init(void)
5657 {
5658         return snd_hda_add_codec_preset(&realtek_list);
5659 }
5660 
5661 static void __exit patch_realtek_exit(void)
5662 {
5663         snd_hda_delete_codec_preset(&realtek_list);
5664 }
5665 
5666 module_init(patch_realtek_init)
5667 module_exit(patch_realtek_exit)
5668 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp