bc9dd8e6fd86900659cf10852eeefa5ed0075dcc
[muen/linux.git] / sound / pci / hda / patch_analog.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * HD audio interface patch for AD1882, AD1884, AD1981HD, AD1983, AD1984,
4  *   AD1986A, AD1988
5  *
6  * Copyright (c) 2005-2007 Takashi Iwai <tiwai@suse.de>
7  */
8
9 #include <linux/init.h>
10 #include <linux/slab.h>
11 #include <linux/module.h>
12
13 #include <sound/core.h>
14 #include <sound/hda_codec.h>
15 #include "hda_local.h"
16 #include "hda_auto_parser.h"
17 #include "hda_beep.h"
18 #include "hda_jack.h"
19 #include "hda_generic.h"
20
21
22 struct ad198x_spec {
23         struct hda_gen_spec gen;
24
25         /* for auto parser */
26         int smux_paths[4];
27         unsigned int cur_smux;
28         hda_nid_t eapd_nid;
29
30         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
31 };
32
33
34 #ifdef CONFIG_SND_HDA_INPUT_BEEP
35 /* additional beep mixers; the actual parameters are overwritten at build */
36 static const struct snd_kcontrol_new ad_beep_mixer[] = {
37         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_OUTPUT),
38         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_OUTPUT),
39         { } /* end */
40 };
41
42 #define set_beep_amp(spec, nid, idx, dir) \
43         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir)) /* mono */
44 #else
45 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
46 #endif
47
48 #ifdef CONFIG_SND_HDA_INPUT_BEEP
49 static int create_beep_ctls(struct hda_codec *codec)
50 {
51         struct ad198x_spec *spec = codec->spec;
52         const struct snd_kcontrol_new *knew;
53
54         if (!spec->beep_amp)
55                 return 0;
56
57         for (knew = ad_beep_mixer ; knew->name; knew++) {
58                 int err;
59                 struct snd_kcontrol *kctl;
60                 kctl = snd_ctl_new1(knew, codec);
61                 if (!kctl)
62                         return -ENOMEM;
63                 kctl->private_value = spec->beep_amp;
64                 err = snd_hda_ctl_add(codec, 0, kctl);
65                 if (err < 0)
66                         return err;
67         }
68         return 0;
69 }
70 #else
71 #define create_beep_ctls(codec)         0
72 #endif
73
74
75 static void ad198x_power_eapd_write(struct hda_codec *codec, hda_nid_t front,
76                                 hda_nid_t hp)
77 {
78         if (snd_hda_query_pin_caps(codec, front) & AC_PINCAP_EAPD)
79                 snd_hda_codec_write(codec, front, 0, AC_VERB_SET_EAPD_BTLENABLE,
80                             !codec->inv_eapd ? 0x00 : 0x02);
81         if (snd_hda_query_pin_caps(codec, hp) & AC_PINCAP_EAPD)
82                 snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_EAPD_BTLENABLE,
83                             !codec->inv_eapd ? 0x00 : 0x02);
84 }
85
86 static void ad198x_power_eapd(struct hda_codec *codec)
87 {
88         /* We currently only handle front, HP */
89         switch (codec->core.vendor_id) {
90         case 0x11d41882:
91         case 0x11d4882a:
92         case 0x11d41884:
93         case 0x11d41984:
94         case 0x11d41883:
95         case 0x11d4184a:
96         case 0x11d4194a:
97         case 0x11d4194b:
98         case 0x11d41988:
99         case 0x11d4198b:
100         case 0x11d4989a:
101         case 0x11d4989b:
102                 ad198x_power_eapd_write(codec, 0x12, 0x11);
103                 break;
104         case 0x11d41981:
105         case 0x11d41983:
106                 ad198x_power_eapd_write(codec, 0x05, 0x06);
107                 break;
108         case 0x11d41986:
109                 ad198x_power_eapd_write(codec, 0x1b, 0x1a);
110                 break;
111         }
112 }
113
114 static void ad198x_shutup(struct hda_codec *codec)
115 {
116         snd_hda_shutup_pins(codec);
117         ad198x_power_eapd(codec);
118 }
119
120 #ifdef CONFIG_PM
121 static int ad198x_suspend(struct hda_codec *codec)
122 {
123         ad198x_shutup(codec);
124         return 0;
125 }
126 #endif
127
128 /* follow EAPD via vmaster hook */
129 static void ad_vmaster_eapd_hook(void *private_data, int enabled)
130 {
131         struct hda_codec *codec = private_data;
132         struct ad198x_spec *spec = codec->spec;
133
134         if (!spec->eapd_nid)
135                 return;
136         if (codec->inv_eapd)
137                 enabled = !enabled;
138         snd_hda_codec_write_cache(codec, spec->eapd_nid, 0,
139                                    AC_VERB_SET_EAPD_BTLENABLE,
140                                    enabled ? 0x02 : 0x00);
141 }
142
143 /*
144  * Automatic parse of I/O pins from the BIOS configuration
145  */
146
147 static int ad198x_auto_build_controls(struct hda_codec *codec)
148 {
149         int err;
150
151         err = snd_hda_gen_build_controls(codec);
152         if (err < 0)
153                 return err;
154         err = create_beep_ctls(codec);
155         if (err < 0)
156                 return err;
157         return 0;
158 }
159
160 static const struct hda_codec_ops ad198x_auto_patch_ops = {
161         .build_controls = ad198x_auto_build_controls,
162         .build_pcms = snd_hda_gen_build_pcms,
163         .init = snd_hda_gen_init,
164         .free = snd_hda_gen_free,
165         .unsol_event = snd_hda_jack_unsol_event,
166 #ifdef CONFIG_PM
167         .check_power_status = snd_hda_gen_check_power_status,
168         .suspend = ad198x_suspend,
169 #endif
170         .reboot_notify = ad198x_shutup,
171 };
172
173
174 static int ad198x_parse_auto_config(struct hda_codec *codec, bool indep_hp)
175 {
176         struct ad198x_spec *spec = codec->spec;
177         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
178         int err;
179
180         codec->spdif_status_reset = 1;
181         codec->no_trigger_sense = 1;
182         codec->no_sticky_stream = 1;
183
184         spec->gen.indep_hp = indep_hp;
185         if (!spec->gen.add_stereo_mix_input)
186                 spec->gen.add_stereo_mix_input = HDA_HINT_STEREO_MIX_AUTO;
187
188         err = snd_hda_parse_pin_defcfg(codec, cfg, NULL, 0);
189         if (err < 0)
190                 return err;
191         err = snd_hda_gen_parse_auto_config(codec, cfg);
192         if (err < 0)
193                 return err;
194
195         return 0;
196 }
197
198 /*
199  * AD1986A specific
200  */
201
202 static int alloc_ad_spec(struct hda_codec *codec)
203 {
204         struct ad198x_spec *spec;
205
206         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
207         if (!spec)
208                 return -ENOMEM;
209         codec->spec = spec;
210         snd_hda_gen_spec_init(&spec->gen);
211         codec->patch_ops = ad198x_auto_patch_ops;
212         return 0;
213 }
214
215 /*
216  * AD1986A fixup codes
217  */
218
219 /* Lenovo N100 seems to report the reversed bit for HP jack-sensing */
220 static void ad_fixup_inv_jack_detect(struct hda_codec *codec,
221                                      const struct hda_fixup *fix, int action)
222 {
223         struct ad198x_spec *spec = codec->spec;
224
225         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
226                 codec->inv_jack_detect = 1;
227                 spec->gen.keep_eapd_on = 1;
228                 spec->gen.vmaster_mute.hook = ad_vmaster_eapd_hook;
229                 spec->eapd_nid = 0x1b;
230         }
231 }
232
233 /* Toshiba Satellite L40 implements EAPD in a standard way unlike others */
234 static void ad1986a_fixup_eapd(struct hda_codec *codec,
235                                const struct hda_fixup *fix, int action)
236 {
237         struct ad198x_spec *spec = codec->spec;
238
239         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
240                 codec->inv_eapd = 0;
241                 spec->gen.keep_eapd_on = 1;
242                 spec->eapd_nid = 0x1b;
243         }
244 }
245
246 /* enable stereo-mix input for avoiding regression on KDE (bko#88251) */
247 static void ad1986a_fixup_eapd_mix_in(struct hda_codec *codec,
248                                       const struct hda_fixup *fix, int action)
249 {
250         struct ad198x_spec *spec = codec->spec;
251
252         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
253                 ad1986a_fixup_eapd(codec, fix, action);
254                 spec->gen.add_stereo_mix_input = HDA_HINT_STEREO_MIX_ENABLE;
255         }
256 }
257
258 enum {
259         AD1986A_FIXUP_INV_JACK_DETECT,
260         AD1986A_FIXUP_ULTRA,
261         AD1986A_FIXUP_SAMSUNG,
262         AD1986A_FIXUP_3STACK,
263         AD1986A_FIXUP_LAPTOP,
264         AD1986A_FIXUP_LAPTOP_IMIC,
265         AD1986A_FIXUP_EAPD,
266         AD1986A_FIXUP_EAPD_MIX_IN,
267         AD1986A_FIXUP_EASYNOTE,
268 };
269
270 static const struct hda_fixup ad1986a_fixups[] = {
271         [AD1986A_FIXUP_INV_JACK_DETECT] = {
272                 .type = HDA_FIXUP_FUNC,
273                 .v.func = ad_fixup_inv_jack_detect,
274         },
275         [AD1986A_FIXUP_ULTRA] = {
276                 .type = HDA_FIXUP_PINS,
277                 .v.pins = (const struct hda_pintbl[]) {
278                         { 0x1b, 0x90170110 }, /* speaker */
279                         { 0x1d, 0x90a7013e }, /* int mic */
280                         {}
281                 },
282         },
283         [AD1986A_FIXUP_SAMSUNG] = {
284                 .type = HDA_FIXUP_PINS,
285                 .v.pins = (const struct hda_pintbl[]) {
286                         { 0x1b, 0x90170110 }, /* speaker */
287                         { 0x1d, 0x90a7013e }, /* int mic */
288                         { 0x20, 0x411111f0 }, /* N/A */
289                         { 0x24, 0x411111f0 }, /* N/A */
290                         {}
291                 },
292         },
293         [AD1986A_FIXUP_3STACK] = {
294                 .type = HDA_FIXUP_PINS,
295                 .v.pins = (const struct hda_pintbl[]) {
296                         { 0x1a, 0x02214021 }, /* headphone */
297                         { 0x1b, 0x01014011 }, /* front */
298                         { 0x1c, 0x01813030 }, /* line-in */
299                         { 0x1d, 0x01a19020 }, /* rear mic */
300                         { 0x1e, 0x411111f0 }, /* N/A */
301                         { 0x1f, 0x02a190f0 }, /* mic */
302                         { 0x20, 0x411111f0 }, /* N/A */
303                         {}
304                 },
305         },
306         [AD1986A_FIXUP_LAPTOP] = {
307                 .type = HDA_FIXUP_PINS,
308                 .v.pins = (const struct hda_pintbl[]) {
309                         { 0x1a, 0x02214021 }, /* headphone */
310                         { 0x1b, 0x90170110 }, /* speaker */
311                         { 0x1c, 0x411111f0 }, /* N/A */
312                         { 0x1d, 0x411111f0 }, /* N/A */
313                         { 0x1e, 0x411111f0 }, /* N/A */
314                         { 0x1f, 0x02a191f0 }, /* mic */
315                         { 0x20, 0x411111f0 }, /* N/A */
316                         {}
317                 },
318         },
319         [AD1986A_FIXUP_LAPTOP_IMIC] = {
320                 .type = HDA_FIXUP_PINS,
321                 .v.pins = (const struct hda_pintbl[]) {
322                         { 0x1d, 0x90a7013e }, /* int mic */
323                         {}
324                 },
325                 .chained_before = 1,
326                 .chain_id = AD1986A_FIXUP_LAPTOP,
327         },
328         [AD1986A_FIXUP_EAPD] = {
329                 .type = HDA_FIXUP_FUNC,
330                 .v.func = ad1986a_fixup_eapd,
331         },
332         [AD1986A_FIXUP_EAPD_MIX_IN] = {
333                 .type = HDA_FIXUP_FUNC,
334                 .v.func = ad1986a_fixup_eapd_mix_in,
335         },
336         [AD1986A_FIXUP_EASYNOTE] = {
337                 .type = HDA_FIXUP_PINS,
338                 .v.pins = (const struct hda_pintbl[]) {
339                         { 0x1a, 0x0421402f }, /* headphone */
340                         { 0x1b, 0x90170110 }, /* speaker */
341                         { 0x1c, 0x411111f0 }, /* N/A */
342                         { 0x1d, 0x90a70130 }, /* int mic */
343                         { 0x1e, 0x411111f0 }, /* N/A */
344                         { 0x1f, 0x04a19040 }, /* mic */
345                         { 0x20, 0x411111f0 }, /* N/A */
346                         { 0x21, 0x411111f0 }, /* N/A */
347                         { 0x22, 0x411111f0 }, /* N/A */
348                         { 0x23, 0x411111f0 }, /* N/A */
349                         { 0x24, 0x411111f0 }, /* N/A */
350                         { 0x25, 0x411111f0 }, /* N/A */
351                         {}
352                 },
353                 .chained = true,
354                 .chain_id = AD1986A_FIXUP_EAPD_MIX_IN,
355         },
356 };
357
358 static const struct snd_pci_quirk ad1986a_fixup_tbl[] = {
359         SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_FIXUP_LAPTOP_IMIC),
360         SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9V", AD1986A_FIXUP_LAPTOP_IMIC),
361         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS Z99He", AD1986A_FIXUP_EAPD),
362         SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8JN", AD1986A_FIXUP_EAPD),
363         SND_PCI_QUIRK_MASK(0x1043, 0xff00, 0x8100, "ASUS P5", AD1986A_FIXUP_3STACK),
364         SND_PCI_QUIRK_MASK(0x1043, 0xff00, 0x8200, "ASUS M2", AD1986A_FIXUP_3STACK),
365         SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_FIXUP_3STACK),
366         SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba Satellite L40", AD1986A_FIXUP_EAPD),
367         SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_FIXUP_LAPTOP),
368         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc000, "Samsung", AD1986A_FIXUP_SAMSUNG),
369         SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_FIXUP_ULTRA),
370         SND_PCI_QUIRK(0x1631, 0xc022, "PackardBell EasyNote MX65", AD1986A_FIXUP_EASYNOTE),
371         SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_FIXUP_INV_JACK_DETECT),
372         SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_FIXUP_3STACK),
373         SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_FIXUP_3STACK),
374         {}
375 };
376
377 static const struct hda_model_fixup ad1986a_fixup_models[] = {
378         { .id = AD1986A_FIXUP_3STACK, .name = "3stack" },
379         { .id = AD1986A_FIXUP_LAPTOP, .name = "laptop" },
380         { .id = AD1986A_FIXUP_LAPTOP_IMIC, .name = "laptop-imic" },
381         { .id = AD1986A_FIXUP_LAPTOP_IMIC, .name = "laptop-eapd" }, /* alias */
382         { .id = AD1986A_FIXUP_EAPD, .name = "eapd" },
383         {}
384 };
385
386 /*
387  */
388 static int patch_ad1986a(struct hda_codec *codec)
389 {
390         int err;
391         struct ad198x_spec *spec;
392         static hda_nid_t preferred_pairs[] = {
393                 0x1a, 0x03,
394                 0x1b, 0x03,
395                 0x1c, 0x04,
396                 0x1d, 0x05,
397                 0x1e, 0x03,
398                 0
399         };
400
401         err = alloc_ad_spec(codec);
402         if (err < 0)
403                 return err;
404         spec = codec->spec;
405
406         /* AD1986A has the inverted EAPD implementation */
407         codec->inv_eapd = 1;
408
409         spec->gen.mixer_nid = 0x07;
410         spec->gen.beep_nid = 0x19;
411         set_beep_amp(spec, 0x18, 0, HDA_OUTPUT);
412
413         /* AD1986A has a hardware problem that it can't share a stream
414          * with multiple output pins.  The copy of front to surrounds
415          * causes noisy or silent outputs at a certain timing, e.g.
416          * changing the volume.
417          * So, let's disable the shared stream.
418          */
419         spec->gen.multiout.no_share_stream = 1;
420         /* give fixed DAC/pin pairs */
421         spec->gen.preferred_dacs = preferred_pairs;
422
423         /* AD1986A can't manage the dynamic pin on/off smoothly */
424         spec->gen.auto_mute_via_amp = 1;
425
426         snd_hda_pick_fixup(codec, ad1986a_fixup_models, ad1986a_fixup_tbl,
427                            ad1986a_fixups);
428         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
429
430         err = ad198x_parse_auto_config(codec, false);
431         if (err < 0) {
432                 snd_hda_gen_free(codec);
433                 return err;
434         }
435
436         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
437
438         return 0;
439 }
440
441
442 /*
443  * AD1983 specific
444  */
445
446 /*
447  * SPDIF mux control for AD1983 auto-parser
448  */
449 static int ad1983_auto_smux_enum_info(struct snd_kcontrol *kcontrol,
450                                       struct snd_ctl_elem_info *uinfo)
451 {
452         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
453         struct ad198x_spec *spec = codec->spec;
454         static const char * const texts2[] = { "PCM", "ADC" };
455         static const char * const texts3[] = { "PCM", "ADC1", "ADC2" };
456         hda_nid_t dig_out = spec->gen.multiout.dig_out_nid;
457         int num_conns = snd_hda_get_num_conns(codec, dig_out);
458
459         if (num_conns == 2)
460                 return snd_hda_enum_helper_info(kcontrol, uinfo, 2, texts2);
461         else if (num_conns == 3)
462                 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
463         else
464                 return -EINVAL;
465 }
466
467 static int ad1983_auto_smux_enum_get(struct snd_kcontrol *kcontrol,
468                                      struct snd_ctl_elem_value *ucontrol)
469 {
470         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
471         struct ad198x_spec *spec = codec->spec;
472
473         ucontrol->value.enumerated.item[0] = spec->cur_smux;
474         return 0;
475 }
476
477 static int ad1983_auto_smux_enum_put(struct snd_kcontrol *kcontrol,
478                                      struct snd_ctl_elem_value *ucontrol)
479 {
480         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
481         struct ad198x_spec *spec = codec->spec;
482         unsigned int val = ucontrol->value.enumerated.item[0];
483         hda_nid_t dig_out = spec->gen.multiout.dig_out_nid;
484         int num_conns = snd_hda_get_num_conns(codec, dig_out);
485
486         if (val >= num_conns)
487                 return -EINVAL;
488         if (spec->cur_smux == val)
489                 return 0;
490         spec->cur_smux = val;
491         snd_hda_codec_write_cache(codec, dig_out, 0,
492                                   AC_VERB_SET_CONNECT_SEL, val);
493         return 1;
494 }
495
496 static const struct snd_kcontrol_new ad1983_auto_smux_mixer = {
497         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
498         .name = "IEC958 Playback Source",
499         .info = ad1983_auto_smux_enum_info,
500         .get = ad1983_auto_smux_enum_get,
501         .put = ad1983_auto_smux_enum_put,
502 };
503
504 static int ad1983_add_spdif_mux_ctl(struct hda_codec *codec)
505 {
506         struct ad198x_spec *spec = codec->spec;
507         hda_nid_t dig_out = spec->gen.multiout.dig_out_nid;
508         int num_conns;
509
510         if (!dig_out)
511                 return 0;
512         num_conns = snd_hda_get_num_conns(codec, dig_out);
513         if (num_conns != 2 && num_conns != 3)
514                 return 0;
515         if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &ad1983_auto_smux_mixer))
516                 return -ENOMEM;
517         return 0;
518 }
519
520 static int patch_ad1983(struct hda_codec *codec)
521 {
522         struct ad198x_spec *spec;
523         static hda_nid_t conn_0c[] = { 0x08 };
524         static hda_nid_t conn_0d[] = { 0x09 };
525         int err;
526
527         err = alloc_ad_spec(codec);
528         if (err < 0)
529                 return err;
530         spec = codec->spec;
531
532         spec->gen.mixer_nid = 0x0e;
533         spec->gen.beep_nid = 0x10;
534         set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
535
536         /* limit the loopback routes not to confuse the parser */
537         snd_hda_override_conn_list(codec, 0x0c, ARRAY_SIZE(conn_0c), conn_0c);
538         snd_hda_override_conn_list(codec, 0x0d, ARRAY_SIZE(conn_0d), conn_0d);
539
540         err = ad198x_parse_auto_config(codec, false);
541         if (err < 0)
542                 goto error;
543         err = ad1983_add_spdif_mux_ctl(codec);
544         if (err < 0)
545                 goto error;
546         return 0;
547
548  error:
549         snd_hda_gen_free(codec);
550         return err;
551 }
552
553
554 /*
555  * AD1981 HD specific
556  */
557
558 static void ad1981_fixup_hp_eapd(struct hda_codec *codec,
559                                  const struct hda_fixup *fix, int action)
560 {
561         struct ad198x_spec *spec = codec->spec;
562
563         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
564                 spec->gen.vmaster_mute.hook = ad_vmaster_eapd_hook;
565                 spec->eapd_nid = 0x05;
566         }
567 }
568
569 /* set the upper-limit for mixer amp to 0dB for avoiding the possible
570  * damage by overloading
571  */
572 static void ad1981_fixup_amp_override(struct hda_codec *codec,
573                                       const struct hda_fixup *fix, int action)
574 {
575         if (action == HDA_FIXUP_ACT_PRE_PROBE)
576                 snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,
577                                           (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
578                                           (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
579                                           (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
580                                           (1 << AC_AMPCAP_MUTE_SHIFT));
581 }
582
583 enum {
584         AD1981_FIXUP_AMP_OVERRIDE,
585         AD1981_FIXUP_HP_EAPD,
586 };
587
588 static const struct hda_fixup ad1981_fixups[] = {
589         [AD1981_FIXUP_AMP_OVERRIDE] = {
590                 .type = HDA_FIXUP_FUNC,
591                 .v.func = ad1981_fixup_amp_override,
592         },
593         [AD1981_FIXUP_HP_EAPD] = {
594                 .type = HDA_FIXUP_FUNC,
595                 .v.func = ad1981_fixup_hp_eapd,
596                 .chained = true,
597                 .chain_id = AD1981_FIXUP_AMP_OVERRIDE,
598         },
599 };
600
601 static const struct snd_pci_quirk ad1981_fixup_tbl[] = {
602         SND_PCI_QUIRK_VENDOR(0x1014, "Lenovo", AD1981_FIXUP_AMP_OVERRIDE),
603         SND_PCI_QUIRK_VENDOR(0x103c, "HP", AD1981_FIXUP_HP_EAPD),
604         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", AD1981_FIXUP_AMP_OVERRIDE),
605         /* HP nx6320 (reversed SSID, H/W bug) */
606         SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_FIXUP_HP_EAPD),
607         {}
608 };
609
610 static int patch_ad1981(struct hda_codec *codec)
611 {
612         struct ad198x_spec *spec;
613         int err;
614
615         err = alloc_ad_spec(codec);
616         if (err < 0)
617                 return -ENOMEM;
618         spec = codec->spec;
619
620         spec->gen.mixer_nid = 0x0e;
621         spec->gen.beep_nid = 0x10;
622         set_beep_amp(spec, 0x0d, 0, HDA_OUTPUT);
623
624         snd_hda_pick_fixup(codec, NULL, ad1981_fixup_tbl, ad1981_fixups);
625         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
626
627         err = ad198x_parse_auto_config(codec, false);
628         if (err < 0)
629                 goto error;
630         err = ad1983_add_spdif_mux_ctl(codec);
631         if (err < 0)
632                 goto error;
633
634         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
635
636         return 0;
637
638  error:
639         snd_hda_gen_free(codec);
640         return err;
641 }
642
643
644 /*
645  * AD1988
646  *
647  * Output pins and routes
648  *
649  *        Pin               Mix     Sel     DAC (*)
650  * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
651  * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
652  * port-C 0x15 (mute)    <- 0x2c <- 0x31 <- 05/0a
653  * port-D 0x12 (mute/hp) <- 0x29         <- 04
654  * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
655  * port-F 0x16 (mute)    <- 0x2a         <- 06
656  * port-G 0x24 (mute)    <- 0x27         <- 05
657  * port-H 0x25 (mute)    <- 0x28         <- 0a
658  * mono   0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
659  *
660  * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
661  * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.
662  *
663  * Input pins and routes
664  *
665  *        pin     boost   mix input # / adc input #
666  * port-A 0x11 -> 0x38 -> mix 2, ADC 0
667  * port-B 0x14 -> 0x39 -> mix 0, ADC 1
668  * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
669  * port-D 0x12 -> 0x3d -> mix 3, ADC 8
670  * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
671  * port-F 0x16 -> 0x3b -> mix 5, ADC 3
672  * port-G 0x24 -> N/A  -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
673  * port-H 0x25 -> N/A  -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
674  *
675  *
676  * DAC assignment
677  *   6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03
678  *   3stack - front/surr/CLFE/opt DACs - 04/05/0a/03
679  *
680  * Inputs of Analog Mix (0x20)
681  *   0:Port-B (front mic)
682  *   1:Port-C/G/H (line-in)
683  *   2:Port-A
684  *   3:Port-D (line-in/2)
685  *   4:Port-E/G/H (mic-in)
686  *   5:Port-F (mic2-in)
687  *   6:CD
688  *   7:Beep
689  *
690  * ADC selection
691  *   0:Port-A
692  *   1:Port-B (front mic-in)
693  *   2:Port-C (line-in)
694  *   3:Port-F (mic2-in)
695  *   4:Port-E (mic-in)
696  *   5:CD
697  *   6:Port-G
698  *   7:Port-H
699  *   8:Port-D (line-in/2)
700  *   9:Mix
701  *
702  * Proposed pin assignments by the datasheet
703  *
704  * 6-stack
705  * Port-A front headphone
706  *      B front mic-in
707  *      C rear line-in
708  *      D rear front-out
709  *      E rear mic-in
710  *      F rear surround
711  *      G rear CLFE
712  *      H rear side
713  *
714  * 3-stack
715  * Port-A front headphone
716  *      B front mic
717  *      C rear line-in/surround
718  *      D rear front-out
719  *      E rear mic-in/CLFE
720  *
721  * laptop
722  * Port-A headphone
723  *      B mic-in
724  *      C docking station
725  *      D internal speaker (with EAPD)
726  *      E/F quad mic array
727  */
728
729 static int ad1988_auto_smux_enum_info(struct snd_kcontrol *kcontrol,
730                                       struct snd_ctl_elem_info *uinfo)
731 {
732         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
733         static const char * const texts[] = {
734                 "PCM", "ADC1", "ADC2", "ADC3",
735         };
736         int num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1;
737         if (num_conns > 4)
738                 num_conns = 4;
739         return snd_hda_enum_helper_info(kcontrol, uinfo, num_conns, texts);
740 }
741
742 static int ad1988_auto_smux_enum_get(struct snd_kcontrol *kcontrol,
743                                      struct snd_ctl_elem_value *ucontrol)
744 {
745         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
746         struct ad198x_spec *spec = codec->spec;
747
748         ucontrol->value.enumerated.item[0] = spec->cur_smux;
749         return 0;
750 }
751
752 static int ad1988_auto_smux_enum_put(struct snd_kcontrol *kcontrol,
753                                      struct snd_ctl_elem_value *ucontrol)
754 {
755         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
756         struct ad198x_spec *spec = codec->spec;
757         unsigned int val = ucontrol->value.enumerated.item[0];
758         struct nid_path *path;
759         int num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1;
760
761         if (val >= num_conns)
762                 return -EINVAL;
763         if (spec->cur_smux == val)
764                 return 0;
765
766         mutex_lock(&codec->control_mutex);
767         path = snd_hda_get_path_from_idx(codec,
768                                          spec->smux_paths[spec->cur_smux]);
769         if (path)
770                 snd_hda_activate_path(codec, path, false, true);
771         path = snd_hda_get_path_from_idx(codec, spec->smux_paths[val]);
772         if (path)
773                 snd_hda_activate_path(codec, path, true, true);
774         spec->cur_smux = val;
775         mutex_unlock(&codec->control_mutex);
776         return 1;
777 }
778
779 static const struct snd_kcontrol_new ad1988_auto_smux_mixer = {
780         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
781         .name = "IEC958 Playback Source",
782         .info = ad1988_auto_smux_enum_info,
783         .get = ad1988_auto_smux_enum_get,
784         .put = ad1988_auto_smux_enum_put,
785 };
786
787 static int ad1988_auto_init(struct hda_codec *codec)
788 {
789         struct ad198x_spec *spec = codec->spec;
790         int i, err;
791
792         err = snd_hda_gen_init(codec);
793         if (err < 0)
794                 return err;
795         if (!spec->gen.autocfg.dig_outs)
796                 return 0;
797
798         for (i = 0; i < 4; i++) {
799                 struct nid_path *path;
800                 path = snd_hda_get_path_from_idx(codec, spec->smux_paths[i]);
801                 if (path)
802                         snd_hda_activate_path(codec, path, path->active, false);
803         }
804
805         return 0;
806 }
807
808 static int ad1988_add_spdif_mux_ctl(struct hda_codec *codec)
809 {
810         struct ad198x_spec *spec = codec->spec;
811         int i, num_conns;
812         /* we create four static faked paths, since AD codecs have odd
813          * widget connections regarding the SPDIF out source
814          */
815         static struct nid_path fake_paths[4] = {
816                 {
817                         .depth = 3,
818                         .path = { 0x02, 0x1d, 0x1b },
819                         .idx = { 0, 0, 0 },
820                         .multi = { 0, 0, 0 },
821                 },
822                 {
823                         .depth = 4,
824                         .path = { 0x08, 0x0b, 0x1d, 0x1b },
825                         .idx = { 0, 0, 1, 0 },
826                         .multi = { 0, 1, 0, 0 },
827                 },
828                 {
829                         .depth = 4,
830                         .path = { 0x09, 0x0b, 0x1d, 0x1b },
831                         .idx = { 0, 1, 1, 0 },
832                         .multi = { 0, 1, 0, 0 },
833                 },
834                 {
835                         .depth = 4,
836                         .path = { 0x0f, 0x0b, 0x1d, 0x1b },
837                         .idx = { 0, 2, 1, 0 },
838                         .multi = { 0, 1, 0, 0 },
839                 },
840         };
841
842         /* SPDIF source mux appears to be present only on AD1988A */
843         if (!spec->gen.autocfg.dig_outs ||
844             get_wcaps_type(get_wcaps(codec, 0x1d)) != AC_WID_AUD_MIX)
845                 return 0;
846
847         num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1;
848         if (num_conns != 3 && num_conns != 4)
849                 return 0;
850
851         for (i = 0; i < num_conns; i++) {
852                 struct nid_path *path = snd_array_new(&spec->gen.paths);
853                 if (!path)
854                         return -ENOMEM;
855                 *path = fake_paths[i];
856                 if (!i)
857                         path->active = 1;
858                 spec->smux_paths[i] = snd_hda_get_path_idx(codec, path);
859         }
860
861         if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &ad1988_auto_smux_mixer))
862                 return -ENOMEM;
863
864         codec->patch_ops.init = ad1988_auto_init;
865
866         return 0;
867 }
868
869 /*
870  */
871
872 enum {
873         AD1988_FIXUP_6STACK_DIG,
874 };
875
876 static const struct hda_fixup ad1988_fixups[] = {
877         [AD1988_FIXUP_6STACK_DIG] = {
878                 .type = HDA_FIXUP_PINS,
879                 .v.pins = (const struct hda_pintbl[]) {
880                         { 0x11, 0x02214130 }, /* front-hp */
881                         { 0x12, 0x01014010 }, /* line-out */
882                         { 0x14, 0x02a19122 }, /* front-mic */
883                         { 0x15, 0x01813021 }, /* line-in */
884                         { 0x16, 0x01011012 }, /* line-out */
885                         { 0x17, 0x01a19020 }, /* mic */
886                         { 0x1b, 0x0145f1f0 }, /* SPDIF */
887                         { 0x24, 0x01016011 }, /* line-out */
888                         { 0x25, 0x01012013 }, /* line-out */
889                         { }
890                 }
891         },
892 };
893
894 static const struct hda_model_fixup ad1988_fixup_models[] = {
895         { .id = AD1988_FIXUP_6STACK_DIG, .name = "6stack-dig" },
896         {}
897 };
898
899 static int patch_ad1988(struct hda_codec *codec)
900 {
901         struct ad198x_spec *spec;
902         int err;
903
904         err = alloc_ad_spec(codec);
905         if (err < 0)
906                 return err;
907         spec = codec->spec;
908
909         spec->gen.mixer_nid = 0x20;
910         spec->gen.mixer_merge_nid = 0x21;
911         spec->gen.beep_nid = 0x10;
912         set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
913
914         snd_hda_pick_fixup(codec, ad1988_fixup_models, NULL, ad1988_fixups);
915         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
916
917         err = ad198x_parse_auto_config(codec, true);
918         if (err < 0)
919                 goto error;
920         err = ad1988_add_spdif_mux_ctl(codec);
921         if (err < 0)
922                 goto error;
923
924         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
925
926         return 0;
927
928  error:
929         snd_hda_gen_free(codec);
930         return err;
931 }
932
933
934 /*
935  * AD1884 / AD1984
936  *
937  * port-B - front line/mic-in
938  * port-E - aux in/out
939  * port-F - aux in/out
940  * port-C - rear line/mic-in
941  * port-D - rear line/hp-out
942  * port-A - front line/hp-out
943  *
944  * AD1984 = AD1884 + two digital mic-ins
945  *
946  * AD1883 / AD1884A / AD1984A / AD1984B
947  *
948  * port-B (0x14) - front mic-in
949  * port-E (0x1c) - rear mic-in
950  * port-F (0x16) - CD / ext out
951  * port-C (0x15) - rear line-in
952  * port-D (0x12) - rear line-out
953  * port-A (0x11) - front hp-out
954  *
955  * AD1984A = AD1884A + digital-mic
956  * AD1883 = equivalent with AD1984A
957  * AD1984B = AD1984A + extra SPDIF-out
958  */
959
960 /* set the upper-limit for mixer amp to 0dB for avoiding the possible
961  * damage by overloading
962  */
963 static void ad1884_fixup_amp_override(struct hda_codec *codec,
964                                       const struct hda_fixup *fix, int action)
965 {
966         if (action == HDA_FIXUP_ACT_PRE_PROBE)
967                 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
968                                           (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
969                                           (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
970                                           (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
971                                           (1 << AC_AMPCAP_MUTE_SHIFT));
972 }
973
974 /* toggle GPIO1 according to the mute state */
975 static void ad1884_vmaster_hp_gpio_hook(void *private_data, int enabled)
976 {
977         struct hda_codec *codec = private_data;
978         struct ad198x_spec *spec = codec->spec;
979
980         if (spec->eapd_nid)
981                 ad_vmaster_eapd_hook(private_data, enabled);
982         snd_hda_codec_write_cache(codec, 0x01, 0,
983                                    AC_VERB_SET_GPIO_DATA,
984                                    enabled ? 0x00 : 0x02);
985 }
986
987 static void ad1884_fixup_hp_eapd(struct hda_codec *codec,
988                                  const struct hda_fixup *fix, int action)
989 {
990         struct ad198x_spec *spec = codec->spec;
991
992         switch (action) {
993         case HDA_FIXUP_ACT_PRE_PROBE:
994                 spec->gen.vmaster_mute.hook = ad1884_vmaster_hp_gpio_hook;
995                 spec->gen.own_eapd_ctl = 1;
996                 snd_hda_codec_write_cache(codec, 0x01, 0,
997                                           AC_VERB_SET_GPIO_MASK, 0x02);
998                 snd_hda_codec_write_cache(codec, 0x01, 0,
999                                           AC_VERB_SET_GPIO_DIRECTION, 0x02);
1000                 snd_hda_codec_write_cache(codec, 0x01, 0,
1001                                           AC_VERB_SET_GPIO_DATA, 0x02);
1002                 break;
1003         case HDA_FIXUP_ACT_PROBE:
1004                 if (spec->gen.autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1005                         spec->eapd_nid = spec->gen.autocfg.line_out_pins[0];
1006                 else
1007                         spec->eapd_nid = spec->gen.autocfg.speaker_pins[0];
1008                 break;
1009         }
1010 }
1011
1012 static void ad1884_fixup_thinkpad(struct hda_codec *codec,
1013                                   const struct hda_fixup *fix, int action)
1014 {
1015         struct ad198x_spec *spec = codec->spec;
1016
1017         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1018                 spec->gen.keep_eapd_on = 1;
1019                 spec->gen.vmaster_mute.hook = ad_vmaster_eapd_hook;
1020                 spec->eapd_nid = 0x12;
1021                 /* Analog PC Beeper - allow firmware/ACPI beeps */
1022                 spec->beep_amp = HDA_COMPOSE_AMP_VAL(0x20, 3, 3, HDA_INPUT);
1023                 spec->gen.beep_nid = 0; /* no digital beep */
1024         }
1025 }
1026
1027 /* set magic COEFs for dmic */
1028 static const struct hda_verb ad1884_dmic_init_verbs[] = {
1029         {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7},
1030         {0x01, AC_VERB_SET_PROC_COEF, 0x08},
1031         {}
1032 };
1033
1034 enum {
1035         AD1884_FIXUP_AMP_OVERRIDE,
1036         AD1884_FIXUP_HP_EAPD,
1037         AD1884_FIXUP_DMIC_COEF,
1038         AD1884_FIXUP_THINKPAD,
1039         AD1884_FIXUP_HP_TOUCHSMART,
1040 };
1041
1042 static const struct hda_fixup ad1884_fixups[] = {
1043         [AD1884_FIXUP_AMP_OVERRIDE] = {
1044                 .type = HDA_FIXUP_FUNC,
1045                 .v.func = ad1884_fixup_amp_override,
1046         },
1047         [AD1884_FIXUP_HP_EAPD] = {
1048                 .type = HDA_FIXUP_FUNC,
1049                 .v.func = ad1884_fixup_hp_eapd,
1050                 .chained = true,
1051                 .chain_id = AD1884_FIXUP_AMP_OVERRIDE,
1052         },
1053         [AD1884_FIXUP_DMIC_COEF] = {
1054                 .type = HDA_FIXUP_VERBS,
1055                 .v.verbs = ad1884_dmic_init_verbs,
1056         },
1057         [AD1884_FIXUP_THINKPAD] = {
1058                 .type = HDA_FIXUP_FUNC,
1059                 .v.func = ad1884_fixup_thinkpad,
1060                 .chained = true,
1061                 .chain_id = AD1884_FIXUP_DMIC_COEF,
1062         },
1063         [AD1884_FIXUP_HP_TOUCHSMART] = {
1064                 .type = HDA_FIXUP_VERBS,
1065                 .v.verbs = ad1884_dmic_init_verbs,
1066                 .chained = true,
1067                 .chain_id = AD1884_FIXUP_HP_EAPD,
1068         },
1069 };
1070
1071 static const struct snd_pci_quirk ad1884_fixup_tbl[] = {
1072         SND_PCI_QUIRK(0x103c, 0x2a82, "HP Touchsmart", AD1884_FIXUP_HP_TOUCHSMART),
1073         SND_PCI_QUIRK_VENDOR(0x103c, "HP", AD1884_FIXUP_HP_EAPD),
1074         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1884_FIXUP_THINKPAD),
1075         {}
1076 };
1077
1078
1079 static int patch_ad1884(struct hda_codec *codec)
1080 {
1081         struct ad198x_spec *spec;
1082         int err;
1083
1084         err = alloc_ad_spec(codec);
1085         if (err < 0)
1086                 return err;
1087         spec = codec->spec;
1088
1089         spec->gen.mixer_nid = 0x20;
1090         spec->gen.mixer_merge_nid = 0x21;
1091         spec->gen.beep_nid = 0x10;
1092         set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
1093
1094         snd_hda_pick_fixup(codec, NULL, ad1884_fixup_tbl, ad1884_fixups);
1095         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1096
1097         err = ad198x_parse_auto_config(codec, true);
1098         if (err < 0)
1099                 goto error;
1100         err = ad1983_add_spdif_mux_ctl(codec);
1101         if (err < 0)
1102                 goto error;
1103
1104         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1105
1106         return 0;
1107
1108  error:
1109         snd_hda_gen_free(codec);
1110         return err;
1111 }
1112
1113 /*
1114  * AD1882 / AD1882A
1115  *
1116  * port-A - front hp-out
1117  * port-B - front mic-in
1118  * port-C - rear line-in, shared surr-out (3stack)
1119  * port-D - rear line-out
1120  * port-E - rear mic-in, shared clfe-out (3stack)
1121  * port-F - rear surr-out (6stack)
1122  * port-G - rear clfe-out (6stack)
1123  */
1124
1125 static int patch_ad1882(struct hda_codec *codec)
1126 {
1127         struct ad198x_spec *spec;
1128         int err;
1129
1130         err = alloc_ad_spec(codec);
1131         if (err < 0)
1132                 return err;
1133         spec = codec->spec;
1134
1135         spec->gen.mixer_nid = 0x20;
1136         spec->gen.mixer_merge_nid = 0x21;
1137         spec->gen.beep_nid = 0x10;
1138         set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
1139         err = ad198x_parse_auto_config(codec, true);
1140         if (err < 0)
1141                 goto error;
1142         err = ad1988_add_spdif_mux_ctl(codec);
1143         if (err < 0)
1144                 goto error;
1145         return 0;
1146
1147  error:
1148         snd_hda_gen_free(codec);
1149         return err;
1150 }
1151
1152
1153 /*
1154  * patch entries
1155  */
1156 static const struct hda_device_id snd_hda_id_analog[] = {
1157         HDA_CODEC_ENTRY(0x11d4184a, "AD1884A", patch_ad1884),
1158         HDA_CODEC_ENTRY(0x11d41882, "AD1882", patch_ad1882),
1159         HDA_CODEC_ENTRY(0x11d41883, "AD1883", patch_ad1884),
1160         HDA_CODEC_ENTRY(0x11d41884, "AD1884", patch_ad1884),
1161         HDA_CODEC_ENTRY(0x11d4194a, "AD1984A", patch_ad1884),
1162         HDA_CODEC_ENTRY(0x11d4194b, "AD1984B", patch_ad1884),
1163         HDA_CODEC_ENTRY(0x11d41981, "AD1981", patch_ad1981),
1164         HDA_CODEC_ENTRY(0x11d41983, "AD1983", patch_ad1983),
1165         HDA_CODEC_ENTRY(0x11d41984, "AD1984", patch_ad1884),
1166         HDA_CODEC_ENTRY(0x11d41986, "AD1986A", patch_ad1986a),
1167         HDA_CODEC_ENTRY(0x11d41988, "AD1988", patch_ad1988),
1168         HDA_CODEC_ENTRY(0x11d4198b, "AD1988B", patch_ad1988),
1169         HDA_CODEC_ENTRY(0x11d4882a, "AD1882A", patch_ad1882),
1170         HDA_CODEC_ENTRY(0x11d4989a, "AD1989A", patch_ad1988),
1171         HDA_CODEC_ENTRY(0x11d4989b, "AD1989B", patch_ad1988),
1172         {} /* terminator */
1173 };
1174 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_analog);
1175
1176 MODULE_LICENSE("GPL");
1177 MODULE_DESCRIPTION("Analog Devices HD-audio codec");
1178
1179 static struct hda_codec_driver analog_driver = {
1180         .id = snd_hda_id_analog,
1181 };
1182
1183 module_hda_codec_driver(analog_driver);