projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: hda - Rearrange for dropping static quirk codes in AD codec driver
[deliverable/linux.git] / sound / pci / hda / patch_analog.c
CommitLineData
1da177e4 1/*
0ac8551e
TI		 2 * HD audio interface patch for AD1882, AD1884, AD1981HD, AD1983, AD1984,
3 * AD1986A, AD1988
1da177e4 4 *
2bac647c 5 * Copyright (c) 2005-2007 Takashi Iwai <tiwai@suse.de>
1da177e4
LT		 6 *
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This driver is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
1da177e4 22#include <linux/init.h>
1da177e4
LT		 23#include <linux/slab.h>
24#include <linux/pci.h>
da155d5b 25#include <linux/module.h>
62932df8 26
1da177e4
LT		 27#include <sound/core.h>
28#include "hda_codec.h"
29#include "hda_local.h"
128bc4ba 30#include "hda_auto_parser.h"
c5a4bcd0 31#include "hda_beep.h"
1835a0f9 32#include "hda_jack.h"
78bb3cb0 33#include "hda_generic.h"
1da177e4 34
9ff4bc8f
TI		 35#define ENABLE_AD_STATIC_QUIRKS
36
4a3fdf3d 37struct ad198x_spec {
78bb3cb0
TI		 38 struct hda_gen_spec gen;
39
272f3ea3
TI		 40 /* for auto parser */
41 int smux_paths[4];
42 unsigned int cur_smux;
43
c5a4bcd0 44 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */
78bb3cb0 45 hda_nid_t beep_dev_nid;
9ff4bc8f
TI		 46
47#ifdef ENABLE_AD_STATIC_QUIRKS
48 const struct snd_kcontrol_new *mixers[6];
49 int num_mixers;
28220846 50 const struct hda_verb *init_verbs[6]; /* initialization verbs
985be54b
TI		 51 * don't forget NULL termination!
52 */
53 unsigned int num_init_verbs;
54
55 /* playback */
56 struct hda_multi_out multiout; /* playback set-up
57 * max_channels, dacs must be set
58 * dig_out_nid and hp_nid are optional
59 */
fd66e0d0 60 unsigned int cur_eapd;
2125cad2 61 unsigned int need_dac_fix;
985be54b
TI		 62
63 /* capture */
64 unsigned int num_adc_nids;
498f5b17 65 const hda_nid_t *adc_nids;
985be54b
TI		 66 hda_nid_t dig_in_nid; /* digital-in NID; optional */
67
68 /* capture source */
4a3fdf3d 69 const struct hda_input_mux *input_mux;
498f5b17 70 const hda_nid_t *capsrc_nids;
985be54b
TI		 71 unsigned int cur_mux[3];
72
73 /* channel model */
d2a6d7dc 74 const struct hda_channel_mode *channel_mode;
985be54b
TI		 75 int num_channel_mode;
76
77 /* PCM information */
2bac647c 78 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */
985be54b 79
4a3fdf3d 80 unsigned int spdif_route;
d32410b1 81
0bf0e5a6
JK		 82 unsigned int jack_present: 1;
83 unsigned int inv_jack_detect: 1;/* inverted jack-detection */
0bf0e5a6 84 unsigned int analog_beep: 1; /* analog beep input present */
18478e8b 85 unsigned int avoid_init_slave_vol:1;
8ab78c74 86
83012a7c 87#ifdef CONFIG_PM
cb53c626
TI		 88 struct hda_loopback_check loopback;
89#endif
2134ea4f
TI		 90 /* for virtual master */
91 hda_nid_t vmaster_nid;
ea734963
TI		 92 const char * const *slave_vols;
93 const char * const *slave_sws;
9ff4bc8f 94#endif /* ENABLE_AD_STATIC_QUIRKS */
1da177e4
LT		 95};
96
9ff4bc8f 97#ifdef ENABLE_AD_STATIC_QUIRKS
4a3fdf3d
TI		 98/*
99 * input MUX handling (common part)
100 */
c8b6bf9b 101static int ad198x_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
4a3fdf3d
TI		 102{
103 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
104 struct ad198x_spec *spec = codec->spec;
105
106 return snd_hda_input_mux_info(spec->input_mux, uinfo);
107}
108
c8b6bf9b 109static int ad198x_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
4a3fdf3d
TI		 110{
111 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
112 struct ad198x_spec *spec = codec->spec;
985be54b 113 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
4a3fdf3d 114
985be54b 115 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
4a3fdf3d
TI		 116 return 0;
117}
118
c8b6bf9b 119static int ad198x_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
4a3fdf3d
TI		 120{
121 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
122 struct ad198x_spec *spec = codec->spec;
985be54b 123 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
4a3fdf3d
TI		 124
125 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
2e5b9567
TI		 126 spec->capsrc_nids[adc_idx],
127 &spec->cur_mux[adc_idx]);
4a3fdf3d
TI		 128}
129
130/*
131 * initialization (common callbacks)
132 */
133static int ad198x_init(struct hda_codec *codec)
134{
135 struct ad198x_spec *spec = codec->spec;
985be54b
TI		 136 int i;
137
138 for (i = 0; i < spec->num_init_verbs; i++)
139 snd_hda_sequence_write(codec, spec->init_verbs[i]);
4a3fdf3d
TI		 140 return 0;
141}
142
9322ca54
TI		 143static const char * const ad_slave_pfxs[] = {
144 "Front", "Surround", "Center", "LFE", "Side",
145 "Headphone", "Mono", "Speaker", "IEC958",
2134ea4f
TI		 146 NULL
147};
148
9322ca54
TI		 149static const char * const ad1988_6stack_fp_slave_pfxs[] = {
150 "Front", "Surround", "Center", "LFE", "Side", "IEC958",
2134ea4f
TI		 151 NULL
152};
9ff4bc8f 153#endif /* ENABLE_AD_STATIC_QUIRKS */
2134ea4f 154
67d634c0 155#ifdef CONFIG_SND_HDA_INPUT_BEEP
c5a4bcd0 156/* additional beep mixers; the actual parameters are overwritten at build */
498f5b17 157static const struct snd_kcontrol_new ad_beep_mixer[] = {
c5a4bcd0 158 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_OUTPUT),
123c07ae 159 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_OUTPUT),
c5a4bcd0
TI		 160 { } /* end */
161};
162
498f5b17 163static const struct snd_kcontrol_new ad_beep2_mixer[] = {
0bf0e5a6
JK		 164 HDA_CODEC_VOLUME("Digital Beep Playback Volume", 0, 0, HDA_OUTPUT),
165 HDA_CODEC_MUTE_BEEP("Digital Beep Playback Switch", 0, 0, HDA_OUTPUT),
166 { } /* end */
167};
168
c5a4bcd0
TI		 169#define set_beep_amp(spec, nid, idx, dir) \
170 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir)) /* mono */
67d634c0
TI		 171#else
172#define set_beep_amp(spec, nid, idx, dir) /* NOP */
173#endif
c5a4bcd0 174
78bb3cb0
TI		 175#ifdef CONFIG_SND_HDA_INPUT_BEEP
176static int create_beep_ctls(struct hda_codec *codec)
177{
178 struct ad198x_spec *spec = codec->spec;
179 const struct snd_kcontrol_new *knew;
180
181 if (!spec->beep_amp)
182 return 0;
183
184 knew = spec->analog_beep ? ad_beep2_mixer : ad_beep_mixer;
185 for ( ; knew->name; knew++) {
186 int err;
187 struct snd_kcontrol *kctl;
188 kctl = snd_ctl_new1(knew, codec);
189 if (!kctl)
190 return -ENOMEM;
191 kctl->private_value = spec->beep_amp;
192 err = snd_hda_ctl_add(codec, 0, kctl);
193 if (err < 0)
194 return err;
195 }
196 return 0;
197}
198#else
199#define create_beep_ctls(codec) 0
200#endif
201
9ff4bc8f 202#ifdef ENABLE_AD_STATIC_QUIRKS
4a3fdf3d
TI		 203static int ad198x_build_controls(struct hda_codec *codec)
204{
205 struct ad198x_spec *spec = codec->spec;
5b0cb1d8 206 struct snd_kcontrol *kctl;
985be54b 207 unsigned int i;
4a3fdf3d
TI		 208 int err;
209
985be54b
TI		 210 for (i = 0; i < spec->num_mixers; i++) {
211 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
212 if (err < 0)
213 return err;
214 }
215 if (spec->multiout.dig_out_nid) {
74b654c9
SW		 216 err = snd_hda_create_spdif_out_ctls(codec,
217 spec->multiout.dig_out_nid,
218 spec->multiout.dig_out_nid);
985be54b
TI		 219 if (err < 0)
220 return err;
9a08160b
TI		 221 err = snd_hda_create_spdif_share_sw(codec,
222 &spec->multiout);
223 if (err < 0)
224 return err;
225 spec->multiout.share_spdif = 1;
985be54b
TI		 226 }
227 if (spec->dig_in_nid) {
228 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
229 if (err < 0)
230 return err;
231 }
2134ea4f 232
c5a4bcd0 233 /* create beep controls if needed */
78bb3cb0
TI		 234 err = create_beep_ctls(codec);
235 if (err < 0)
236 return err;
c5a4bcd0 237
2134ea4f
TI		 238 /* if we have no master control, let's create it */
239 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1c82ed1b 240 unsigned int vmaster_tlv[4];
2134ea4f 241 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1c82ed1b 242 HDA_OUTPUT, vmaster_tlv);
18478e8b 243 err = __snd_hda_add_vmaster(codec, "Master Playback Volume",
1c82ed1b 244 vmaster_tlv,
2134ea4f 245 (spec->slave_vols ?
9322ca54 246 spec->slave_vols : ad_slave_pfxs),
18478e8b 247 "Playback Volume",
29e5853d 248 !spec->avoid_init_slave_vol, NULL);
2134ea4f
TI		 249 if (err < 0)
250 return err;
251 }
252 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
253 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
254 NULL,
255 (spec->slave_sws ?
9322ca54
TI		 256 spec->slave_sws : ad_slave_pfxs),
257 "Playback Switch");
2134ea4f
TI		 258 if (err < 0)
259 return err;
260 }
261
5b0cb1d8
JK		 262 /* assign Capture Source enums to NID */
263 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
264 if (!kctl)
265 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
266 for (i = 0; kctl && i < kctl->count; i++) {
21949f00 267 err = snd_hda_add_nid(codec, kctl, i, spec->capsrc_nids[i]);
5b0cb1d8
JK		 268 if (err < 0)
269 return err;
270 }
271
272 /* assign IEC958 enums to NID */
273 kctl = snd_hda_find_mixer_ctl(codec,
274 SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source");
275 if (kctl) {
276 err = snd_hda_add_nid(codec, kctl, 0,
277 spec->multiout.dig_out_nid);
278 if (err < 0)
279 return err;
280 }
281
4a3fdf3d
TI		 282 return 0;
283}
284
83012a7c 285#ifdef CONFIG_PM
cb53c626
TI		 286static int ad198x_check_power_status(struct hda_codec *codec, hda_nid_t nid)
287{
288 struct ad198x_spec *spec = codec->spec;
289 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
290}
291#endif
292
4a3fdf3d
TI		 293/*
294 * Analog playback callbacks
295 */
296static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo,
297 struct hda_codec *codec,
c8b6bf9b 298 struct snd_pcm_substream *substream)
4a3fdf3d
TI		 299{
300 struct ad198x_spec *spec = codec->spec;
78bb3cb0 301 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
9a08160b 302 hinfo);
4a3fdf3d
TI		 303}
304
305static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
306 struct hda_codec *codec,
307 unsigned int stream_tag,
308 unsigned int format,
c8b6bf9b 309 struct snd_pcm_substream *substream)
4a3fdf3d
TI		 310{
311 struct ad198x_spec *spec = codec->spec;
312 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
313 format, substream);
314}
315
316static int ad198x_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
317 struct hda_codec *codec,
c8b6bf9b 318 struct snd_pcm_substream *substream)
4a3fdf3d
TI		 319{
320 struct ad198x_spec *spec = codec->spec;
321 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
322}
323
324/*
325 * Digital out
326 */
327static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
328 struct hda_codec *codec,
c8b6bf9b 329 struct snd_pcm_substream *substream)
4a3fdf3d
TI		 330{
331 struct ad198x_spec *spec = codec->spec;
332 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
333}
334
335static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
336 struct hda_codec *codec,
c8b6bf9b 337 struct snd_pcm_substream *substream)
4a3fdf3d
TI		 338{
339 struct ad198x_spec *spec = codec->spec;
340 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
341}
342
6b97eb45
TI		 343static int ad198x_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
344 struct hda_codec *codec,
345 unsigned int stream_tag,
346 unsigned int format,
347 struct snd_pcm_substream *substream)
348{
349 struct ad198x_spec *spec = codec->spec;
350 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
351 format, substream);
352}
353
9411e21c
TI		 354static int ad198x_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
355 struct hda_codec *codec,
356 struct snd_pcm_substream *substream)
357{
358 struct ad198x_spec *spec = codec->spec;
359 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
360}
361
4a3fdf3d
TI		 362/*
363 * Analog capture
364 */
365static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
366 struct hda_codec *codec,
367 unsigned int stream_tag,
368 unsigned int format,
c8b6bf9b 369 struct snd_pcm_substream *substream)
4a3fdf3d
TI		 370{
371 struct ad198x_spec *spec = codec->spec;
985be54b
TI		 372 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
373 stream_tag, 0, format);
4a3fdf3d
TI		 374 return 0;
375}
376
377static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
378 struct hda_codec *codec,
c8b6bf9b 379 struct snd_pcm_substream *substream)
4a3fdf3d
TI		 380{
381 struct ad198x_spec *spec = codec->spec;
888afa15 382 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
4a3fdf3d
TI		 383 return 0;
384}
385
4a3fdf3d
TI		 386/*
387 */
498f5b17 388static const struct hda_pcm_stream ad198x_pcm_analog_playback = {
4a3fdf3d
TI		 389 .substreams = 1,
390 .channels_min = 2,
985be54b 391 .channels_max = 6, /* changed later */
4a3fdf3d
TI		 392 .nid = 0, /* fill later */
393 .ops = {
394 .open = ad198x_playback_pcm_open,
395 .prepare = ad198x_playback_pcm_prepare,
34588709 396 .cleanup = ad198x_playback_pcm_cleanup,
4a3fdf3d
TI		 397 },
398};
399
498f5b17 400static const struct hda_pcm_stream ad198x_pcm_analog_capture = {
985be54b 401 .substreams = 1,
4a3fdf3d
TI		 402 .channels_min = 2,
403 .channels_max = 2,
404 .nid = 0, /* fill later */
405 .ops = {
406 .prepare = ad198x_capture_pcm_prepare,
407 .cleanup = ad198x_capture_pcm_cleanup
408 },
409};
410
498f5b17 411static const struct hda_pcm_stream ad198x_pcm_digital_playback = {
4a3fdf3d
TI		 412 .substreams = 1,
413 .channels_min = 2,
414 .channels_max = 2,
415 .nid = 0, /* fill later */
416 .ops = {
417 .open = ad198x_dig_playback_pcm_open,
6b97eb45 418 .close = ad198x_dig_playback_pcm_close,
9411e21c
TI		 419 .prepare = ad198x_dig_playback_pcm_prepare,
420 .cleanup = ad198x_dig_playback_pcm_cleanup
4a3fdf3d
TI		 421 },
422};
423
498f5b17 424static const struct hda_pcm_stream ad198x_pcm_digital_capture = {
985be54b
TI		 425 .substreams = 1,
426 .channels_min = 2,
427 .channels_max = 2,
428 /* NID is set in alc_build_pcms */
429};
430
4a3fdf3d
TI		 431static int ad198x_build_pcms(struct hda_codec *codec)
432{
433 struct ad198x_spec *spec = codec->spec;
434 struct hda_pcm *info = spec->pcm_rec;
435
436 codec->num_pcms = 1;
437 codec->pcm_info = info;
438
439 info->name = "AD198x Analog";
440 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_analog_playback;
441 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels;
442 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
443 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture;
985be54b
TI		 444 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
445 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4a3fdf3d
TI		 446
447 if (spec->multiout.dig_out_nid) {
448 info++;
449 codec->num_pcms++;
ae24c319 450 codec->spdif_status_reset = 1;
4a3fdf3d 451 info->name = "AD198x Digital";
7ba72ba1 452 info->pcm_type = HDA_PCM_TYPE_SPDIF;
4a3fdf3d
TI		 453 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback;
454 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
985be54b
TI		 455 if (spec->dig_in_nid) {
456 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture;
457 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
458 }
4a3fdf3d
TI		 459 }
460
461 return 0;
462}
9ff4bc8f 463#endif /* ENABLE_AD_STATIC_QUIRKS */
4a3fdf3d 464
ea52bf26
DC		 465static void ad198x_power_eapd_write(struct hda_codec *codec, hda_nid_t front,
466 hda_nid_t hp)
467{
a01ef051
RY		 468 if (snd_hda_query_pin_caps(codec, front) & AC_PINCAP_EAPD)
469 snd_hda_codec_write(codec, front, 0, AC_VERB_SET_EAPD_BTLENABLE,
78bb3cb0 470 !codec->inv_eapd ? 0x00 : 0x02);
a01ef051
RY		 471 if (snd_hda_query_pin_caps(codec, hp) & AC_PINCAP_EAPD)
472 snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_EAPD_BTLENABLE,
78bb3cb0 473 !codec->inv_eapd ? 0x00 : 0x02);
ea52bf26
DC		 474}
475
476static void ad198x_power_eapd(struct hda_codec *codec)
477{
478 /* We currently only handle front, HP */
479 switch (codec->vendor_id) {
480 case 0x11d41882:
481 case 0x11d4882a:
482 case 0x11d41884:
483 case 0x11d41984:
484 case 0x11d41883:
485 case 0x11d4184a:
486 case 0x11d4194a:
487 case 0x11d4194b:
4dffbe03
TI		 488 case 0x11d41988:
489 case 0x11d4198b:
490 case 0x11d4989a:
491 case 0x11d4989b:
ea52bf26
DC		 492 ad198x_power_eapd_write(codec, 0x12, 0x11);
493 break;
494 case 0x11d41981:
495 case 0x11d41983:
496 ad198x_power_eapd_write(codec, 0x05, 0x06);
497 break;
498 case 0x11d41986:
499 ad198x_power_eapd_write(codec, 0x1b, 0x1a);
500 break;
ea52bf26
DC		 501 }
502}
503
0da26922
TI		 504static void ad198x_shutup(struct hda_codec *codec)
505{
506 snd_hda_shutup_pins(codec);
507 ad198x_power_eapd(codec);
508}
509
603c4019
TI		 510static void ad198x_free(struct hda_codec *codec)
511{
512 struct ad198x_spec *spec = codec->spec;
513
514 if (!spec)
515 return;
516
78bb3cb0 517 snd_hda_gen_spec_free(&spec->gen);
c5a4bcd0
TI		 518 kfree(spec);
519 snd_hda_detach_beep_device(codec);
4a3fdf3d
TI		 520}
521
2a43952a 522#ifdef CONFIG_PM
68cb2b55 523static int ad198x_suspend(struct hda_codec *codec)
ea52bf26
DC		 524{
525 ad198x_shutup(codec);
ea52bf26
DC		 526 return 0;
527}
ea52bf26
DC		 528#endif
529
9ff4bc8f 530#ifdef ENABLE_AD_STATIC_QUIRKS
498f5b17 531static const struct hda_codec_ops ad198x_patch_ops = {
4a3fdf3d
TI		 532 .build_controls = ad198x_build_controls,
533 .build_pcms = ad198x_build_pcms,
534 .init = ad198x_init,
535 .free = ad198x_free,
2a43952a 536#ifdef CONFIG_PM
83012a7c 537 .check_power_status = ad198x_check_power_status,
ea52bf26 538 .suspend = ad198x_suspend,
ea52bf26
DC		 539#endif
540 .reboot_notify = ad198x_shutup,
4a3fdf3d
TI		 541};
542
543
18a815d7
TI		 544/*
545 * EAPD control
ee6e365e 546 * the private value = nid
18a815d7 547 */
a5ce8890 548#define ad198x_eapd_info snd_ctl_boolean_mono_info
18a815d7
TI		 549
550static int ad198x_eapd_get(struct snd_kcontrol *kcontrol,
551 struct snd_ctl_elem_value *ucontrol)
552{
553 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
554 struct ad198x_spec *spec = codec->spec;
78bb3cb0 555 if (codec->inv_eapd)
18a815d7
TI		 556 ucontrol->value.integer.value[0] = ! spec->cur_eapd;
557 else
558 ucontrol->value.integer.value[0] = spec->cur_eapd;
559 return 0;
560}
561
562static int ad198x_eapd_put(struct snd_kcontrol *kcontrol,
563 struct snd_ctl_elem_value *ucontrol)
564{
565 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
566 struct ad198x_spec *spec = codec->spec;
18a815d7
TI		 567 hda_nid_t nid = kcontrol->private_value & 0xff;
568 unsigned int eapd;
68ea7b2f 569 eapd = !!ucontrol->value.integer.value[0];
78bb3cb0 570 if (codec->inv_eapd)
18a815d7 571 eapd = !eapd;
82beb8fd 572 if (eapd == spec->cur_eapd)
18a815d7
TI		 573 return 0;
574 spec->cur_eapd = eapd;
82beb8fd
TI		 575 snd_hda_codec_write_cache(codec, nid,
576 0, AC_VERB_SET_EAPD_BTLENABLE,
577 eapd ? 0x02 : 0x00);
18a815d7
TI		 578 return 1;
579}
580
9230d214
TI		 581static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
582 struct snd_ctl_elem_info *uinfo);
583static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
584 struct snd_ctl_elem_value *ucontrol);
585static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
586 struct snd_ctl_elem_value *ucontrol);
9ff4bc8f 587#endif /* ENABLE_AD_STATIC_QUIRKS */
9230d214
TI		 588
589
78bb3cb0
TI		 590/*
591 * Automatic parse of I/O pins from the BIOS configuration
592 */
593
594static int ad198x_auto_build_controls(struct hda_codec *codec)
595{
596 int err;
597
598 err = snd_hda_gen_build_controls(codec);
599 if (err < 0)
600 return err;
601 err = create_beep_ctls(codec);
602 if (err < 0)
603 return err;
604 return 0;
605}
606
607static const struct hda_codec_ops ad198x_auto_patch_ops = {
608 .build_controls = ad198x_auto_build_controls,
609 .build_pcms = snd_hda_gen_build_pcms,
610 .init = snd_hda_gen_init,
611 .free = ad198x_free,
8a6c21ae 612 .unsol_event = snd_hda_jack_unsol_event,
78bb3cb0
TI		 613#ifdef CONFIG_PM
614 .check_power_status = snd_hda_gen_check_power_status,
615 .suspend = ad198x_suspend,
616#endif
617 .reboot_notify = ad198x_shutup,
618};
619
620
621static int ad198x_parse_auto_config(struct hda_codec *codec)
622{
623 struct ad198x_spec *spec = codec->spec;
624 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
625 int err;
626
627 codec->spdif_status_reset = 1;
628 codec->no_trigger_sense = 1;
629 codec->no_sticky_stream = 1;
630
631 spec->gen.indep_hp = 1;
632
633 err = snd_hda_parse_pin_defcfg(codec, cfg, NULL, 0);
634 if (err < 0)
635 return err;
636 err = snd_hda_gen_parse_auto_config(codec, cfg);
637 if (err < 0)
638 return err;
639
640 if (spec->beep_dev_nid) {
641 err = snd_hda_attach_beep_device(codec, spec->beep_dev_nid);
642 if (err < 0)
643 return err;
644 }
645
646 codec->patch_ops = ad198x_auto_patch_ops;
647
648 return 0;
649}
650
4a3fdf3d
TI		 651/*
652 * AD1986A specific
653 */
654
9ff4bc8f 655#ifdef ENABLE_AD_STATIC_QUIRKS
1da177e4
LT		 656#define AD1986A_SPDIF_OUT 0x02
657#define AD1986A_FRONT_DAC 0x03
658#define AD1986A_SURR_DAC 0x04
659#define AD1986A_CLFE_DAC 0x05
660#define AD1986A_ADC 0x06
661
498f5b17 662static const hda_nid_t ad1986a_dac_nids[3] = {
1da177e4
LT		 663 AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC
664};
498f5b17
TI		 665static const hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC };
666static const hda_nid_t ad1986a_capsrc_nids[1] = { 0x12 };
1da177e4 667
498f5b17 668static const struct hda_input_mux ad1986a_capture_source = {
1da177e4
LT		 669 .num_items = 7,
670 .items = {
671 { "Mic", 0x0 },
672 { "CD", 0x1 },
673 { "Aux", 0x3 },
674 { "Line", 0x4 },
675 { "Mix", 0x5 },
676 { "Mono", 0x6 },
677 { "Phone", 0x7 },
678 },
679};
680
1da177e4 681
498f5b17 682static const struct hda_bind_ctls ad1986a_bind_pcm_vol = {
532d5381
TI		 683 .ops = &snd_hda_bind_vol,
684 .values = {
685 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
686 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
687 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
688 0
689 },
690};
1da177e4 691
498f5b17 692static const struct hda_bind_ctls ad1986a_bind_pcm_sw = {
532d5381
TI		 693 .ops = &snd_hda_bind_sw,
694 .values = {
695 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
696 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
697 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
698 0
699 },
700};
1da177e4 701
1da177e4
LT		 702/*
703 * mixers
704 */
498f5b17 705static const struct snd_kcontrol_new ad1986a_mixers[] = {
532d5381
TI		 706 /*
707 * bind volumes/mutes of 3 DACs as a single PCM control for simplicity
708 */
709 HDA_BIND_VOL("PCM Playback Volume", &ad1986a_bind_pcm_vol),
710 HDA_BIND_SW("PCM Playback Switch", &ad1986a_bind_pcm_sw),
1da177e4
LT		 711 HDA_CODEC_VOLUME("Front Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
712 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
713 HDA_CODEC_VOLUME("Surround Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
714 HDA_CODEC_MUTE("Surround Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
715 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x1d, 1, 0x0, HDA_OUTPUT),
716 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x1d, 2, 0x0, HDA_OUTPUT),
717 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x1d, 1, 0x0, HDA_OUTPUT),
718 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x1d, 2, 0x0, HDA_OUTPUT),
719 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
720 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
721 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
722 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
723 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
724 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
725 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
726 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
727 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
728 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
5f99f86a 729 HDA_CODEC_VOLUME("Mic Boost Volume", 0x0f, 0x0, HDA_OUTPUT),
1da177e4
LT		 730 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
731 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT),
732 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
733 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
734 {
735 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
736 .name = "Capture Source",
4a3fdf3d
TI		 737 .info = ad198x_mux_enum_info,
738 .get = ad198x_mux_enum_get,
739 .put = ad198x_mux_enum_put,
1da177e4
LT		 740 },
741 HDA_CODEC_MUTE("Stereo Downmix Switch", 0x09, 0x0, HDA_OUTPUT),
742 { } /* end */
743};
744
9230d214 745/* additional mixers for 3stack mode */
498f5b17 746static const struct snd_kcontrol_new ad1986a_3st_mixers[] = {
9230d214
TI		 747 {
748 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
749 .name = "Channel Mode",
750 .info = ad198x_ch_mode_info,
751 .get = ad198x_ch_mode_get,
752 .put = ad198x_ch_mode_put,
753 },
754 { } /* end */
755};
756
757/* laptop model - 2ch only */
498f5b17 758static const hda_nid_t ad1986a_laptop_dac_nids[1] = { AD1986A_FRONT_DAC };
9230d214 759
20a45e86 760/* master controls both pins 0x1a and 0x1b */
498f5b17 761static const struct hda_bind_ctls ad1986a_laptop_master_vol = {
20a45e86
TI		 762 .ops = &snd_hda_bind_vol,
763 .values = {
764 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
765 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
766 0,
767 },
768};
769
498f5b17 770static const struct hda_bind_ctls ad1986a_laptop_master_sw = {
20a45e86
TI		 771 .ops = &snd_hda_bind_sw,
772 .values = {
773 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
774 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
775 0,
776 },
777};
778
498f5b17 779static const struct snd_kcontrol_new ad1986a_laptop_mixers[] = {
9230d214
TI		 780 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
781 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
20a45e86
TI		 782 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
783 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
9230d214
TI		 784 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
785 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
786 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
787 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
788 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
789 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
790 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
791 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
5f99f86a 792 HDA_CODEC_VOLUME("Mic Boost Volume", 0x0f, 0x0, HDA_OUTPUT),
c5a4bcd0 793 /*
9230d214
TI		 794 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
795 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
796 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
797 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
798 {
799 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
800 .name = "Capture Source",
801 .info = ad198x_mux_enum_info,
802 .get = ad198x_mux_enum_get,
803 .put = ad198x_mux_enum_put,
804 },
805 { } /* end */
806};
807
825aa972
TI		 808/* laptop-eapd model - 2ch only */
809
498f5b17 810static const struct hda_input_mux ad1986a_laptop_eapd_capture_source = {
825aa972
TI		 811 .num_items = 3,
812 .items = {
813 { "Mic", 0x0 },
814 { "Internal Mic", 0x4 },
815 { "Mix", 0x5 },
816 },
817};
818
498f5b17 819static const struct hda_input_mux ad1986a_automic_capture_source = {
5d5d5f43
TI		 820 .num_items = 2,
821 .items = {
822 { "Mic", 0x0 },
823 { "Mix", 0x5 },
824 },
825};
826
498f5b17 827static const struct snd_kcontrol_new ad1986a_laptop_master_mixers[] = {
1725b82a
TI		 828 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
829 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
1725b82a
TI		 830 { } /* end */
831};
832
498f5b17 833static const struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
825aa972
TI		 834 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
835 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
825aa972
TI		 836 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
837 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
5f99f86a 838 HDA_CODEC_VOLUME("Mic Boost Volume", 0x0f, 0x0, HDA_OUTPUT),
825aa972
TI		 839 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
840 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
841 {
842 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
843 .name = "Capture Source",
844 .info = ad198x_mux_enum_info,
845 .get = ad198x_mux_enum_get,
846 .put = ad198x_mux_enum_put,
847 },
848 {
849 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
850 .name = "External Amplifier",
5b0cb1d8 851 .subdevice = HDA_SUBDEV_NID_FLAG | 0x1b,
825aa972
TI		 852 .info = ad198x_eapd_info,
853 .get = ad198x_eapd_get,
854 .put = ad198x_eapd_put,
ee6e365e 855 .private_value = 0x1b, /* port-D */
825aa972
TI		 856 },
857 { } /* end */
858};
859
498f5b17 860static const struct snd_kcontrol_new ad1986a_laptop_intmic_mixers[] = {
16d11a82
TI		 861 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0, HDA_OUTPUT),
862 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0, HDA_OUTPUT),
863 { } /* end */
864};
865
5d5d5f43
TI		 866/* re-connect the mic boost input according to the jack sensing */
867static void ad1986a_automic(struct hda_codec *codec)
868{
869 unsigned int present;
d56757ab 870 present = snd_hda_jack_detect(codec, 0x1f);
5d5d5f43
TI		 871 /* 0 = 0x1f, 2 = 0x1d, 4 = mixed */
872 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_CONNECT_SEL,
d56757ab 873 present ? 0 : 2);
5d5d5f43
TI		 874}
875
876#define AD1986A_MIC_EVENT 0x36
877
878static void ad1986a_automic_unsol_event(struct hda_codec *codec,
879 unsigned int res)
880{
881 if ((res >> 26) != AD1986A_MIC_EVENT)
882 return;
883 ad1986a_automic(codec);
884}
885
886static int ad1986a_automic_init(struct hda_codec *codec)
887{
888 ad198x_init(codec);
889 ad1986a_automic(codec);
890 return 0;
891}
892
8ab78c74
TI		 893/* laptop-automute - 2ch only */
894
895static void ad1986a_update_hp(struct hda_codec *codec)
896{
897 struct ad198x_spec *spec = codec->spec;
898 unsigned int mute;
899
900 if (spec->jack_present)
901 mute = HDA_AMP_MUTE; /* mute internal speaker */
902 else
903 /* unmute internal speaker if necessary */
904 mute = snd_hda_codec_amp_read(codec, 0x1a, 0, HDA_OUTPUT, 0);
905 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
906 HDA_AMP_MUTE, mute);
907}
908
909static void ad1986a_hp_automute(struct hda_codec *codec)
910{
911 struct ad198x_spec *spec = codec->spec;
8ab78c74 912
d56757ab 913 spec->jack_present = snd_hda_jack_detect(codec, 0x1a);
03c405ad
TI		 914 if (spec->inv_jack_detect)
915 spec->jack_present = !spec->jack_present;
8ab78c74
TI		 916 ad1986a_update_hp(codec);
917}
918
919#define AD1986A_HP_EVENT 0x37
920
921static void ad1986a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
922{
923 if ((res >> 26) != AD1986A_HP_EVENT)
924 return;
925 ad1986a_hp_automute(codec);
926}
927
928static int ad1986a_hp_init(struct hda_codec *codec)
929{
930 ad198x_init(codec);
931 ad1986a_hp_automute(codec);
932 return 0;
933}
934
935/* bind hp and internal speaker mute (with plug check) */
936static int ad1986a_hp_master_sw_put(struct snd_kcontrol *kcontrol,
937 struct snd_ctl_elem_value *ucontrol)
938{
939 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8092e606 940 int change = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
8ab78c74
TI		 941 if (change)
942 ad1986a_update_hp(codec);
943 return change;
944}
945
498f5b17 946static const struct snd_kcontrol_new ad1986a_automute_master_mixers[] = {
8ab78c74
TI		 947 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
948 {
949 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
950 .name = "Master Playback Switch",
5e26dfd0 951 .subdevice = HDA_SUBDEV_AMP_FLAG,
8ab78c74
TI		 952 .info = snd_hda_mixer_amp_switch_info,
953 .get = snd_hda_mixer_amp_switch_get,
954 .put = ad1986a_hp_master_sw_put,
955 .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
956 },
8ab78c74
TI		 957 { } /* end */
958};
959
16d11a82 960
1da177e4
LT		 961/*
962 * initialization verbs
963 */
498f5b17 964static const struct hda_verb ad1986a_init_verbs[] = {
1da177e4
LT		 965 /* Front, Surround, CLFE DAC; mute as default */
966 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
967 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
968 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
969 /* Downmix - off */
970 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
971 /* HP, Line-Out, Surround, CLFE selectors */
972 {0x0a, AC_VERB_SET_CONNECT_SEL, 0x0},
973 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0},
974 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
975 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
976 /* Mono selector */
977 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x0},
978 /* Mic selector: Mic 1/2 pin */
979 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
980 /* Line-in selector: Line-in */
981 {0x10, AC_VERB_SET_CONNECT_SEL, 0x0},
982 /* Mic 1/2 swap */
983 {0x11, AC_VERB_SET_CONNECT_SEL, 0x0},
984 /* Record selector: mic */
985 {0x12, AC_VERB_SET_CONNECT_SEL, 0x0},
986 /* Mic, Phone, CD, Aux, Line-In amp; mute as default */
987 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
988 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
989 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
990 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
991 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
992 /* PC beep */
993 {0x18, AC_VERB_SET_CONNECT_SEL, 0x0},
994 /* HP, Line-Out, Surround, CLFE, Mono pins; mute as default */
995 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
996 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
997 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
998 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
999 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
4a3fdf3d
TI		 1000 /* HP Pin */
1001 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1002 /* Front, Surround, CLFE Pins */
1003 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1004 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1005 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1006 /* Mono Pin */
1007 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1008 /* Mic Pin */
1009 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1010 /* Line, Aux, CD, Beep-In Pin */
1011 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1012 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1013 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1014 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1015 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1da177e4
LT		 1016 { } /* end */
1017};
1018
498f5b17 1019static const struct hda_verb ad1986a_ch2_init[] = {
9230d214 1020 /* Surround out -> Line In */
fb956c16
TI		 1021 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1022 /* Line-in selectors */
1023 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x1 },
9230d214 1024 /* CLFE -> Mic in */
fb956c16
TI		 1025 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1026 /* Mic selector, mix C/LFE (backmic) and Mic (frontmic) */
1027 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
9230d214
TI		 1028 { } /* end */
1029};
1030
498f5b17 1031static const struct hda_verb ad1986a_ch4_init[] = {
9230d214 1032 /* Surround out -> Surround */
fb956c16
TI		 1033 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1034 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
9230d214 1035 /* CLFE -> Mic in */
fb956c16
TI		 1036 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1037 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
9230d214
TI		 1038 { } /* end */
1039};
1040
498f5b17 1041static const struct hda_verb ad1986a_ch6_init[] = {
9230d214 1042 /* Surround out -> Surround out */
fb956c16
TI		 1043 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1044 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
9230d214 1045 /* CLFE -> CLFE */
fb956c16
TI		 1046 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1047 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x0 },
9230d214
TI		 1048 { } /* end */
1049};
1050
498f5b17 1051static const struct hda_channel_mode ad1986a_modes[3] = {
9230d214
TI		 1052 { 2, ad1986a_ch2_init },
1053 { 4, ad1986a_ch4_init },
1054 { 6, ad1986a_ch6_init },
1055};
1056
825aa972 1057/* eapd initialization */
498f5b17 1058static const struct hda_verb ad1986a_eapd_init_verbs[] = {
f36090fe 1059 {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
825aa972
TI		 1060 {}
1061};
1062
498f5b17 1063static const struct hda_verb ad1986a_automic_verbs[] = {
5d5d5f43
TI		 1064 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1065 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1066 /*{0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},*/
1067 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
1068 {0x1f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_MIC_EVENT},
1069 {}
1070};
1071
f36090fe 1072/* Ultra initialization */
498f5b17 1073static const struct hda_verb ad1986a_ultra_init[] = {
f36090fe
TD		 1074 /* eapd initialization */
1075 { 0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
1076 /* CLFE -> Mic in */
1077 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2 },
1078 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1079 { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
1080 { } /* end */
1081};
1082
8ab78c74 1083/* pin sensing on HP jack */
498f5b17 1084static const struct hda_verb ad1986a_hp_init_verbs[] = {
8ab78c74
TI		 1085 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_HP_EVENT},
1086 {}
1087};
1088
c912e7a5
TI		 1089static void ad1986a_samsung_p50_unsol_event(struct hda_codec *codec,
1090 unsigned int res)
1091{
1092 switch (res >> 26) {
1093 case AD1986A_HP_EVENT:
1094 ad1986a_hp_automute(codec);
1095 break;
1096 case AD1986A_MIC_EVENT:
1097 ad1986a_automic(codec);
1098 break;
1099 }
1100}
1101
1102static int ad1986a_samsung_p50_init(struct hda_codec *codec)
1103{
1104 ad198x_init(codec);
1105 ad1986a_hp_automute(codec);
1106 ad1986a_automic(codec);
1107 return 0;
1108}
1109
8ab78c74 1110
9230d214 1111/* models */
f5fcc13c 1112enum {
78bb3cb0 1113 AD1986A_AUTO,
f5fcc13c
TI		 1114 AD1986A_6STACK,
1115 AD1986A_3STACK,
1116 AD1986A_LAPTOP,
1117 AD1986A_LAPTOP_EAPD,
8ab78c74 1118 AD1986A_LAPTOP_AUTOMUTE,
f36090fe 1119 AD1986A_ULTRA,
1725b82a 1120 AD1986A_SAMSUNG,
c912e7a5 1121 AD1986A_SAMSUNG_P50,
f5fcc13c
TI		 1122 AD1986A_MODELS
1123};
1124
ea734963 1125static const char * const ad1986a_models[AD1986A_MODELS] = {
78bb3cb0 1126 [AD1986A_AUTO] = "auto",
f5fcc13c
TI		 1127 [AD1986A_6STACK] = "6stack",
1128 [AD1986A_3STACK] = "3stack",
1129 [AD1986A_LAPTOP] = "laptop",
1130 [AD1986A_LAPTOP_EAPD] = "laptop-eapd",
8ab78c74 1131 [AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute",
f36090fe 1132 [AD1986A_ULTRA] = "ultra",
1725b82a 1133 [AD1986A_SAMSUNG] = "samsung",
c912e7a5 1134 [AD1986A_SAMSUNG_P50] = "samsung-p50",
f5fcc13c
TI		 1135};
1136
498f5b17 1137static const struct snd_pci_quirk ad1986a_cfg_tbl[] = {
f5fcc13c 1138 SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_LAPTOP_EAPD),
f5fcc13c 1139 SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9", AD1986A_LAPTOP_EAPD),
f5fcc13c 1140 SND_PCI_QUIRK(0x1043, 0x11f7, "ASUS U5A", AD1986A_LAPTOP_EAPD),
ac3e3741 1141 SND_PCI_QUIRK(0x1043, 0x1213, "ASUS A6J", AD1986A_LAPTOP_EAPD),
f5fcc13c
TI		 1142 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS U5F", AD1986A_LAPTOP_EAPD),
1143 SND_PCI_QUIRK(0x1043, 0x1297, "ASUS Z62F", AD1986A_LAPTOP_EAPD),
1144 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS V1j", AD1986A_LAPTOP_EAPD),
1145 SND_PCI_QUIRK(0x1043, 0x1302, "ASUS W3j", AD1986A_LAPTOP_EAPD),
d9f9b8ba 1146 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS VX1", AD1986A_LAPTOP),
658fba0e 1147 SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8J", AD1986A_3STACK),
f5fcc13c
TI		 1148 SND_PCI_QUIRK(0x1043, 0x817f, "ASUS P5", AD1986A_3STACK),
1149 SND_PCI_QUIRK(0x1043, 0x818f, "ASUS P5", AD1986A_LAPTOP),
1150 SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS P5", AD1986A_3STACK),
1151 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK),
1152 SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK),
ac3e3741 1153 SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK),
ba579eb7 1154 SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba Satellite L40-10Q", AD1986A_3STACK),
18768991 1155 SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK),
f5fcc13c 1156 SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),
c912e7a5 1157 SND_PCI_QUIRK(0x144d, 0xc024, "Samsung P50", AD1986A_SAMSUNG_P50),
f36090fe 1158 SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA),
dea0a509 1159 SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc000, "Samsung", AD1986A_SAMSUNG),
ac3e3741 1160 SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK),
18768991 1161 SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_LAPTOP),
f5fcc13c 1162 SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK),
8ab78c74 1163 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_LAPTOP_AUTOMUTE),
f5fcc13c 1164 SND_PCI_QUIRK(0x17c0, 0x2017, "Samsung M50", AD1986A_LAPTOP),
9230d214
TI		 1165 {}
1166};
1da177e4 1167
83012a7c 1168#ifdef CONFIG_PM
498f5b17 1169static const struct hda_amp_list ad1986a_loopbacks[] = {
cb53c626
TI		 1170 { 0x13, HDA_OUTPUT, 0 }, /* Mic */
1171 { 0x14, HDA_OUTPUT, 0 }, /* Phone */
1172 { 0x15, HDA_OUTPUT, 0 }, /* CD */
1173 { 0x16, HDA_OUTPUT, 0 }, /* Aux */
1174 { 0x17, HDA_OUTPUT, 0 }, /* Line */
1175 { } /* end */
1176};
1177#endif
1178
8c0d9649
TI		 1179static int is_jack_available(struct hda_codec *codec, hda_nid_t nid)
1180{
2f334f92 1181 unsigned int conf = snd_hda_codec_get_pincfg(codec, nid);
8c0d9649
TI		 1182 return get_defcfg_connect(conf) != AC_JACK_PORT_NONE;
1183}
9ff4bc8f 1184#endif /* ENABLE_AD_STATIC_QUIRKS */
8c0d9649 1185
361dab3e 1186static int alloc_ad_spec(struct hda_codec *codec)
1da177e4 1187{
4a3fdf3d 1188 struct ad198x_spec *spec;
1da177e4 1189
e560d8d8 1190 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
361dab3e 1191 if (!spec)
4a3fdf3d 1192 return -ENOMEM;
4a3fdf3d 1193 codec->spec = spec;
78bb3cb0 1194 snd_hda_gen_spec_init(&spec->gen);
361dab3e
TI		 1195 return 0;
1196}
1197
78bb3cb0
TI		 1198/*
1199 */
1200static int ad1986a_parse_auto_config(struct hda_codec *codec)
1201{
9ff4bc8f
TI		 1202 int err;
1203 struct ad198x_spec *spec;
1204
1205 err = alloc_ad_spec(codec);
1206 if (err < 0)
1207 return err;
1208 spec = codec->spec;
78bb3cb0
TI		 1209
1210 /* AD1986A has the inverted EAPD implementation */
1211 codec->inv_eapd = 1;
1212
f2f8be43 1213 spec->gen.mixer_nid = 0x07;
78bb3cb0
TI		 1214 spec->beep_dev_nid = 0x19;
1215 set_beep_amp(spec, 0x18, 0, HDA_OUTPUT);
1216
1217 /* AD1986A has a hardware problem that it can't share a stream
1218 * with multiple output pins. The copy of front to surrounds
1219 * causes noisy or silent outputs at a certain timing, e.g.
1220 * changing the volume.
1221 * So, let's disable the shared stream.
1222 */
1223 spec->gen.multiout.no_share_stream = 1;
1224
9ff4bc8f
TI		 1225 err = ad198x_parse_auto_config(codec);
1226 if (err < 0) {
1227 ad198x_free(codec);
1228 return err;
1229 }
1230
1231 return 0;
78bb3cb0
TI		 1232}
1233
9ff4bc8f 1234#ifdef ENABLE_AD_STATIC_QUIRKS
361dab3e
TI		 1235static int patch_ad1986a(struct hda_codec *codec)
1236{
1237 struct ad198x_spec *spec;
1238 int err, board_config;
1239
9ff4bc8f
TI		 1240 board_config = snd_hda_check_board_config(codec, AD1986A_MODELS,
1241 ad1986a_models,
1242 ad1986a_cfg_tbl);
1243 if (board_config == AD1986A_AUTO)
1244 return ad1986a_parse_auto_config(codec);
1245
361dab3e
TI		 1246 err = alloc_ad_spec(codec);
1247 if (err < 0)
1248 return err;
1249 spec = codec->spec;
4a3fdf3d 1250
c5a4bcd0
TI		 1251 err = snd_hda_attach_beep_device(codec, 0x19);
1252 if (err < 0) {
1253 ad198x_free(codec);
1254 return err;
1255 }
1256 set_beep_amp(spec, 0x18, 0, HDA_OUTPUT);
1257
4a3fdf3d
TI		 1258 spec->multiout.max_channels = 6;
1259 spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids);
1260 spec->multiout.dac_nids = ad1986a_dac_nids;
1261 spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT;
985be54b
TI		 1262 spec->num_adc_nids = 1;
1263 spec->adc_nids = ad1986a_adc_nids;
a7ee8201 1264 spec->capsrc_nids = ad1986a_capsrc_nids;
4a3fdf3d 1265 spec->input_mux = &ad1986a_capture_source;
985be54b
TI		 1266 spec->num_mixers = 1;
1267 spec->mixers[0] = ad1986a_mixers;
1268 spec->num_init_verbs = 1;
1269 spec->init_verbs[0] = ad1986a_init_verbs;
83012a7c 1270#ifdef CONFIG_PM
cb53c626
TI		 1271 spec->loopback.amplist = ad1986a_loopbacks;
1272#endif
2134ea4f 1273 spec->vmaster_nid = 0x1b;
78bb3cb0 1274 codec->inv_eapd = 1; /* AD1986A has the inverted EAPD implementation */
4a3fdf3d
TI		 1275
1276 codec->patch_ops = ad198x_patch_ops;
1da177e4 1277
9230d214 1278 /* override some parameters */
9230d214
TI		 1279 switch (board_config) {
1280 case AD1986A_3STACK:
1281 spec->num_mixers = 2;
1282 spec->mixers[1] = ad1986a_3st_mixers;
fb956c16
TI		 1283 spec->num_init_verbs = 2;
1284 spec->init_verbs[1] = ad1986a_ch2_init;
9230d214
TI		 1285 spec->channel_mode = ad1986a_modes;
1286 spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes);
2125cad2
TI		 1287 spec->need_dac_fix = 1;
1288 spec->multiout.max_channels = 2;
1289 spec->multiout.num_dacs = 1;
9230d214
TI		 1290 break;
1291 case AD1986A_LAPTOP:
1292 spec->mixers[0] = ad1986a_laptop_mixers;
1293 spec->multiout.max_channels = 2;
1294 spec->multiout.num_dacs = 1;
1295 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1296 break;
825aa972 1297 case AD1986A_LAPTOP_EAPD:
16d11a82
TI		 1298 spec->num_mixers = 3;
1299 spec->mixers[0] = ad1986a_laptop_master_mixers;
1300 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1301 spec->mixers[2] = ad1986a_laptop_intmic_mixers;
1725b82a
TI		 1302 spec->num_init_verbs = 2;
1303 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1304 spec->multiout.max_channels = 2;
1305 spec->multiout.num_dacs = 1;
1306 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1307 if (!is_jack_available(codec, 0x25))
1308 spec->multiout.dig_out_nid = 0;
1309 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1310 break;
1311 case AD1986A_SAMSUNG:
16d11a82
TI		 1312 spec->num_mixers = 2;
1313 spec->mixers[0] = ad1986a_laptop_master_mixers;
1314 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
5d5d5f43 1315 spec->num_init_verbs = 3;
825aa972 1316 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
5d5d5f43 1317 spec->init_verbs[2] = ad1986a_automic_verbs;
825aa972
TI		 1318 spec->multiout.max_channels = 2;
1319 spec->multiout.num_dacs = 1;
1320 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
8c0d9649
TI		 1321 if (!is_jack_available(codec, 0x25))
1322 spec->multiout.dig_out_nid = 0;
5d5d5f43
TI		 1323 spec->input_mux = &ad1986a_automic_capture_source;
1324 codec->patch_ops.unsol_event = ad1986a_automic_unsol_event;
1325 codec->patch_ops.init = ad1986a_automic_init;
825aa972 1326 break;
c912e7a5
TI		 1327 case AD1986A_SAMSUNG_P50:
1328 spec->num_mixers = 2;
1329 spec->mixers[0] = ad1986a_automute_master_mixers;
1330 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1331 spec->num_init_verbs = 4;
1332 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1333 spec->init_verbs[2] = ad1986a_automic_verbs;
1334 spec->init_verbs[3] = ad1986a_hp_init_verbs;
1335 spec->multiout.max_channels = 2;
1336 spec->multiout.num_dacs = 1;
1337 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1338 if (!is_jack_available(codec, 0x25))
1339 spec->multiout.dig_out_nid = 0;
1340 spec->input_mux = &ad1986a_automic_capture_source;
1341 codec->patch_ops.unsol_event = ad1986a_samsung_p50_unsol_event;
1342 codec->patch_ops.init = ad1986a_samsung_p50_init;
1343 break;
8ab78c74 1344 case AD1986A_LAPTOP_AUTOMUTE:
16d11a82
TI		 1345 spec->num_mixers = 3;
1346 spec->mixers[0] = ad1986a_automute_master_mixers;
1347 spec->mixers[1] = ad1986a_laptop_eapd_mixers;
1348 spec->mixers[2] = ad1986a_laptop_intmic_mixers;
8ab78c74
TI		 1349 spec->num_init_verbs = 3;
1350 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1351 spec->init_verbs[2] = ad1986a_hp_init_verbs;
1352 spec->multiout.max_channels = 2;
1353 spec->multiout.num_dacs = 1;
1354 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
8c0d9649
TI		 1355 if (!is_jack_available(codec, 0x25))
1356 spec->multiout.dig_out_nid = 0;
8ab78c74
TI		 1357 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1358 codec->patch_ops.unsol_event = ad1986a_hp_unsol_event;
1359 codec->patch_ops.init = ad1986a_hp_init;
03c405ad
TI		 1360 /* Lenovo N100 seems to report the reversed bit
1361 * for HP jack-sensing
1362 */
1363 spec->inv_jack_detect = 1;
8ab78c74 1364 break;
f36090fe
TD		 1365 case AD1986A_ULTRA:
1366 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
1367 spec->num_init_verbs = 2;
1368 spec->init_verbs[1] = ad1986a_ultra_init;
1369 spec->multiout.max_channels = 2;
1370 spec->multiout.num_dacs = 1;
1371 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1372 spec->multiout.dig_out_nid = 0;
1373 break;
9230d214
TI		 1374 }
1375
d29240ce
TI		 1376 /* AD1986A has a hardware problem that it can't share a stream
1377 * with multiple output pins. The copy of front to surrounds
1378 * causes noisy or silent outputs at a certain timing, e.g.
1379 * changing the volume.
1380 * So, let's disable the shared stream.
1381 */
1382 spec->multiout.no_share_stream = 1;
1383
729d55ba 1384 codec->no_trigger_sense = 1;
0e7adbe2 1385 codec->no_sticky_stream = 1;
729d55ba 1386
1da177e4
LT		 1387 return 0;
1388}
9ff4bc8f
TI		 1389#else /* ENABLE_AD_STATIC_QUIRKS */
1390#define patch_ad1986a ad1986a_parse_auto_config
1391#endif /* ENABLE_AD_STATIC_QUIRKS */
1da177e4
LT		 1392
1393/*
4a3fdf3d 1394 * AD1983 specific
1da177e4 1395 */
1da177e4 1396
9ff4bc8f 1397#ifdef ENABLE_AD_STATIC_QUIRKS
4a3fdf3d
TI		 1398#define AD1983_SPDIF_OUT 0x02
1399#define AD1983_DAC 0x03
1400#define AD1983_ADC 0x04
1da177e4 1401
498f5b17
TI		 1402static const hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC };
1403static const hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC };
1404static const hda_nid_t ad1983_capsrc_nids[1] = { 0x15 };
4a3fdf3d 1405
498f5b17 1406static const struct hda_input_mux ad1983_capture_source = {
4a3fdf3d
TI		 1407 .num_items = 4,
1408 .items = {
1409 { "Mic", 0x0 },
1410 { "Line", 0x1 },
1411 { "Mix", 0x2 },
1412 { "Mix Mono", 0x3 },
1413 },
1414};
1da177e4
LT		 1415
1416/*
4a3fdf3d 1417 * SPDIF playback route
1da177e4 1418 */
c8b6bf9b 1419static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1da177e4 1420{
498f5b17 1421 static const char * const texts[] = { "PCM", "ADC" };
4a3fdf3d
TI		 1422
1423 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1424 uinfo->count = 1;
1425 uinfo->value.enumerated.items = 2;
1426 if (uinfo->value.enumerated.item > 1)
1427 uinfo->value.enumerated.item = 1;
1428 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1429 return 0;
1da177e4
LT		 1430}
1431
c8b6bf9b 1432static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1da177e4 1433{
4a3fdf3d
TI		 1434 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1435 struct ad198x_spec *spec = codec->spec;
1da177e4 1436
4a3fdf3d 1437 ucontrol->value.enumerated.item[0] = spec->spdif_route;
1da177e4
LT		 1438 return 0;
1439}
1440
c8b6bf9b 1441static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1da177e4 1442{
4a3fdf3d
TI		 1443 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1444 struct ad198x_spec *spec = codec->spec;
1445
68ea7b2f
TI		 1446 if (ucontrol->value.enumerated.item[0] > 1)
1447 return -EINVAL;
4a3fdf3d
TI		 1448 if (spec->spdif_route != ucontrol->value.enumerated.item[0]) {
1449 spec->spdif_route = ucontrol->value.enumerated.item[0];
82beb8fd
TI		 1450 snd_hda_codec_write_cache(codec, spec->multiout.dig_out_nid, 0,
1451 AC_VERB_SET_CONNECT_SEL,
1452 spec->spdif_route);
4a3fdf3d
TI		 1453 return 1;
1454 }
1da177e4
LT		 1455 return 0;
1456}
1457
498f5b17 1458static const struct snd_kcontrol_new ad1983_mixers[] = {
4a3fdf3d
TI		 1459 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1460 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1461 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1462 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1463 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1464 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1465 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1466 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1467 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1468 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1469 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1470 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
5f99f86a 1471 HDA_CODEC_VOLUME("Mic Boost Volume", 0x0c, 0x0, HDA_OUTPUT),
4a3fdf3d
TI		 1472 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1473 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1474 {
1475 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1476 .name = "Capture Source",
1477 .info = ad198x_mux_enum_info,
1478 .get = ad198x_mux_enum_get,
1479 .put = ad198x_mux_enum_put,
1da177e4 1480 },
4a3fdf3d
TI		 1481 {
1482 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6540dffa 1483 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
4a3fdf3d
TI		 1484 .info = ad1983_spdif_route_info,
1485 .get = ad1983_spdif_route_get,
1486 .put = ad1983_spdif_route_put,
1da177e4 1487 },
4a3fdf3d 1488 { } /* end */
1da177e4
LT		 1489};
1490
498f5b17 1491static const struct hda_verb ad1983_init_verbs[] = {
4a3fdf3d
TI		 1492 /* Front, HP, Mono; mute as default */
1493 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1494 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1495 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1496 /* Beep, PCM, Mic, Line-In: mute */
1497 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1498 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1499 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1500 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1501 /* Front, HP selectors; from Mix */
1502 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1503 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1504 /* Mono selector; from Mix */
1505 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1506 /* Mic selector; Mic */
1507 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
1508 /* Line-in selector: Line-in */
1509 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
1510 /* Mic boost: 0dB */
1511 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1512 /* Record selector: mic */
1513 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1514 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1515 /* SPDIF route: PCM */
1516 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1517 /* Front Pin */
1518 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1519 /* HP Pin */
1520 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1521 /* Mono Pin */
1522 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1523 /* Mic Pin */
1524 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1525 /* Line Pin */
1526 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1527 { } /* end */
1da177e4
LT		 1528};
1529
83012a7c 1530#ifdef CONFIG_PM
498f5b17 1531static const struct hda_amp_list ad1983_loopbacks[] = {
cb53c626
TI		 1532 { 0x12, HDA_OUTPUT, 0 }, /* Mic */
1533 { 0x13, HDA_OUTPUT, 0 }, /* Line */
1534 { } /* end */
1535};
1536#endif
985be54b 1537
78bb3cb0
TI		 1538/* models */
1539enum {
1540 AD1983_AUTO,
1541 AD1983_BASIC,
1542 AD1983_MODELS
1543};
1544
1545static const char * const ad1983_models[AD1983_MODELS] = {
1546 [AD1983_AUTO] = "auto",
1547 [AD1983_BASIC] = "basic",
1548};
9ff4bc8f
TI		 1549#endif /* ENABLE_AD_STATIC_QUIRKS */
1550
78bb3cb0 1551
272f3ea3
TI		 1552/*
1553 * SPDIF mux control for AD1983 auto-parser
1554 */
1555static int ad1983_auto_smux_enum_info(struct snd_kcontrol *kcontrol,
1556 struct snd_ctl_elem_info *uinfo)
1557{
1558 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1559 struct ad198x_spec *spec = codec->spec;
1560 static const char * const texts2[] = { "PCM", "ADC" };
1561 static const char * const texts3[] = { "PCM", "ADC1", "ADC2" };
1562 hda_nid_t dig_out = spec->gen.multiout.dig_out_nid;
1563 int num_conns = snd_hda_get_num_conns(codec, dig_out);
1564
1565 if (num_conns == 2)
1566 return snd_hda_enum_helper_info(kcontrol, uinfo, 2, texts2);
1567 else if (num_conns == 3)
1568 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3);
1569 else
1570 return -EINVAL;
1571}
1572
1573static int ad1983_auto_smux_enum_get(struct snd_kcontrol *kcontrol,
1574 struct snd_ctl_elem_value *ucontrol)
1575{
1576 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1577 struct ad198x_spec *spec = codec->spec;
1578
1579 ucontrol->value.enumerated.item[0] = spec->cur_smux;
1580 return 0;
1581}
1582
1583static int ad1983_auto_smux_enum_put(struct snd_kcontrol *kcontrol,
1584 struct snd_ctl_elem_value *ucontrol)
1585{
1586 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1587 struct ad198x_spec *spec = codec->spec;
1588 unsigned int val = ucontrol->value.enumerated.item[0];
1589 hda_nid_t dig_out = spec->gen.multiout.dig_out_nid;
1590 int num_conns = snd_hda_get_num_conns(codec, dig_out);
1591
1592 if (val >= num_conns)
1593 return -EINVAL;
1594 if (spec->cur_smux == val)
1595 return 0;
1596 spec->cur_smux = val;
1597 snd_hda_codec_write_cache(codec, dig_out, 0,
1598 AC_VERB_SET_CONNECT_SEL, val);
1599 return 1;
1600}
1601
1602static struct snd_kcontrol_new ad1983_auto_smux_mixer = {
1603 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1604 .name = "IEC958 Playback Source",
1605 .info = ad1983_auto_smux_enum_info,
1606 .get = ad1983_auto_smux_enum_get,
1607 .put = ad1983_auto_smux_enum_put,
1608};
1609
1610static int ad1983_add_spdif_mux_ctl(struct hda_codec *codec)
1611{
1612 struct ad198x_spec *spec = codec->spec;
1613 hda_nid_t dig_out = spec->gen.multiout.dig_out_nid;
1614 int num_conns;
1615
1616 if (!dig_out)
1617 return 0;
1618 num_conns = snd_hda_get_num_conns(codec, dig_out);
1619 if (num_conns != 2 && num_conns != 3)
1620 return 0;
1621 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &ad1983_auto_smux_mixer))
1622 return -ENOMEM;
1623 return 0;
1624}
1625
78bb3cb0
TI		 1626static int ad1983_parse_auto_config(struct hda_codec *codec)
1627{
9ff4bc8f 1628 struct ad198x_spec *spec;
272f3ea3 1629 int err;
78bb3cb0 1630
9ff4bc8f
TI		 1631 err = alloc_ad_spec(codec);
1632 if (err < 0)
1633 return err;
1634 spec = codec->spec;
1635
78bb3cb0
TI		 1636 spec->beep_dev_nid = 0x10;
1637 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
272f3ea3
TI		 1638 err = ad198x_parse_auto_config(codec);
1639 if (err < 0)
9ff4bc8f 1640 goto error;
272f3ea3
TI		 1641 err = ad1983_add_spdif_mux_ctl(codec);
1642 if (err < 0)
9ff4bc8f 1643 goto error;
272f3ea3 1644 return 0;
9ff4bc8f
TI		 1645
1646 error:
1647 ad198x_free(codec);
1648 return err;
78bb3cb0
TI		 1649}
1650
9ff4bc8f 1651#ifdef ENABLE_AD_STATIC_QUIRKS
4a3fdf3d 1652static int patch_ad1983(struct hda_codec *codec)
1da177e4 1653{
4a3fdf3d 1654 struct ad198x_spec *spec;
78bb3cb0 1655 int board_config;
c5a4bcd0 1656 int err;
1da177e4 1657
9ff4bc8f
TI		 1658 board_config = snd_hda_check_board_config(codec, AD1983_MODELS,
1659 ad1983_models, NULL);
1660 if (board_config == AD1983_AUTO)
1661 return ad1983_parse_auto_config(codec);
1662
361dab3e
TI		 1663 err = alloc_ad_spec(codec);
1664 if (err < 0)
1665 return err;
1666 spec = codec->spec;
4a3fdf3d 1667
c5a4bcd0
TI		 1668 err = snd_hda_attach_beep_device(codec, 0x10);
1669 if (err < 0) {
1670 ad198x_free(codec);
1671 return err;
1672 }
1673 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
1674
4a3fdf3d
TI		 1675 spec->multiout.max_channels = 2;
1676 spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids);
1677 spec->multiout.dac_nids = ad1983_dac_nids;
1678 spec->multiout.dig_out_nid = AD1983_SPDIF_OUT;
985be54b
TI		 1679 spec->num_adc_nids = 1;
1680 spec->adc_nids = ad1983_adc_nids;
18a815d7 1681 spec->capsrc_nids = ad1983_capsrc_nids;
4a3fdf3d 1682 spec->input_mux = &ad1983_capture_source;
985be54b
TI		 1683 spec->num_mixers = 1;
1684 spec->mixers[0] = ad1983_mixers;
1685 spec->num_init_verbs = 1;
1686 spec->init_verbs[0] = ad1983_init_verbs;
4a3fdf3d 1687 spec->spdif_route = 0;
83012a7c 1688#ifdef CONFIG_PM
cb53c626
TI		 1689 spec->loopback.amplist = ad1983_loopbacks;
1690#endif
2134ea4f 1691 spec->vmaster_nid = 0x05;
1da177e4 1692
4a3fdf3d 1693 codec->patch_ops = ad198x_patch_ops;
1da177e4 1694
729d55ba 1695 codec->no_trigger_sense = 1;
0e7adbe2 1696 codec->no_sticky_stream = 1;
729d55ba 1697
1da177e4
LT		 1698 return 0;
1699}
9ff4bc8f
TI		 1700#else /* ENABLE_AD_STATIC_QUIRKS */
1701#define patch_ad1983 ad1983_parse_auto_config
1702#endif /* ENABLE_AD_STATIC_QUIRKS */
1da177e4 1703
1da177e4 1704
4a3fdf3d
TI		 1705/*
1706 * AD1981 HD specific
1707 */
1da177e4 1708
9ff4bc8f 1709#ifdef ENABLE_AD_STATIC_QUIRKS
4a3fdf3d
TI		 1710#define AD1981_SPDIF_OUT 0x02
1711#define AD1981_DAC 0x03
1712#define AD1981_ADC 0x04
1713
498f5b17
TI		 1714static const hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC };
1715static const hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC };
1716static const hda_nid_t ad1981_capsrc_nids[1] = { 0x15 };
4a3fdf3d
TI		 1717
1718/* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */
498f5b17 1719static const struct hda_input_mux ad1981_capture_source = {
4a3fdf3d
TI		 1720 .num_items = 7,
1721 .items = {
1722 { "Front Mic", 0x0 },
1723 { "Line", 0x1 },
1724 { "Mix", 0x2 },
1725 { "Mix Mono", 0x3 },
1726 { "CD", 0x4 },
1727 { "Mic", 0x6 },
1728 { "Aux", 0x7 },
1729 },
1da177e4
LT		 1730};
1731
498f5b17 1732static const struct snd_kcontrol_new ad1981_mixers[] = {
4a3fdf3d
TI		 1733 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1734 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1735 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1736 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1737 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1738 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1739 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1740 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1741 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1742 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1743 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1744 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1745 HDA_CODEC_VOLUME("Aux Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
1746 HDA_CODEC_MUTE("Aux Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1747 HDA_CODEC_VOLUME("Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1748 HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1749 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1750 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
5f99f86a
DH		 1751 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x08, 0x0, HDA_INPUT),
1752 HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x0, HDA_INPUT),
4a3fdf3d
TI		 1753 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1754 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1755 {
1756 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1757 .name = "Capture Source",
1758 .info = ad198x_mux_enum_info,
1759 .get = ad198x_mux_enum_get,
1760 .put = ad198x_mux_enum_put,
1761 },
1762 /* identical with AD1983 */
1763 {
1764 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6540dffa 1765 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
4a3fdf3d
TI		 1766 .info = ad1983_spdif_route_info,
1767 .get = ad1983_spdif_route_get,
1768 .put = ad1983_spdif_route_put,
1769 },
1770 { } /* end */
1771};
1772
498f5b17 1773static const struct hda_verb ad1981_init_verbs[] = {
4a3fdf3d
TI		 1774 /* Front, HP, Mono; mute as default */
1775 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1776 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1777 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1778 /* Beep, PCM, Front Mic, Line, Rear Mic, Aux, CD-In: mute */
1779 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1780 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1781 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1782 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1783 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1784 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1785 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1786 /* Front, HP selectors; from Mix */
1787 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1788 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1789 /* Mono selector; from Mix */
1790 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1791 /* Mic Mixer; select Front Mic */
1792 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1793 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1794 /* Mic boost: 0dB */
6d6e17de
TI		 1795 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1796 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4a3fdf3d
TI		 1797 /* Record selector: Front mic */
1798 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1799 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1800 /* SPDIF route: PCM */
1801 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1802 /* Front Pin */
1803 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1804 /* HP Pin */
1805 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1806 /* Mono Pin */
1807 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1808 /* Front & Rear Mic Pins */
1809 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1810 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1811 /* Line Pin */
1812 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1813 /* Digital Beep */
1814 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
1815 /* Line-Out as Input: disabled */
1816 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1817 { } /* end */
1818};
1819
83012a7c 1820#ifdef CONFIG_PM
498f5b17 1821static const struct hda_amp_list ad1981_loopbacks[] = {
cb53c626
TI		 1822 { 0x12, HDA_OUTPUT, 0 }, /* Front Mic */
1823 { 0x13, HDA_OUTPUT, 0 }, /* Line */
1824 { 0x1b, HDA_OUTPUT, 0 }, /* Aux */
1825 { 0x1c, HDA_OUTPUT, 0 }, /* Mic */
1826 { 0x1d, HDA_OUTPUT, 0 }, /* CD */
1827 { } /* end */
1828};
1829#endif
1830
18a815d7
TI		 1831/*
1832 * Patch for HP nx6320
1833 *
18768991 1834 * nx6320 uses EAPD in the reverse way - EAPD-on means the internal
18a815d7
TI		 1835 * speaker output enabled _and_ mute-LED off.
1836 */
1837
1838#define AD1981_HP_EVENT 0x37
1839#define AD1981_MIC_EVENT 0x38
1840
498f5b17 1841static const struct hda_verb ad1981_hp_init_verbs[] = {
18a815d7
TI		 1842 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */
1843 /* pin sensing on HP and Mic jacks */
1844 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1845 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1846 {}
1847};
1848
1849/* turn on/off EAPD (+ mute HP) as a master switch */
1850static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1851 struct snd_ctl_elem_value *ucontrol)
1852{
1853 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1854 struct ad198x_spec *spec = codec->spec;
1855
1856 if (! ad198x_eapd_put(kcontrol, ucontrol))
1857 return 0;
f0824812 1858 /* change speaker pin appropriately */
cdd03ced 1859 snd_hda_set_pin_ctl(codec, 0x05, spec->cur_eapd ? PIN_OUT : 0);
18a815d7 1860 /* toggle HP mute appropriately */
47fd830a
TI		 1861 snd_hda_codec_amp_stereo(codec, 0x06, HDA_OUTPUT, 0,
1862 HDA_AMP_MUTE,
1863 spec->cur_eapd ? 0 : HDA_AMP_MUTE);
18a815d7
TI		 1864 return 1;
1865}
1866
1867/* bind volumes of both NID 0x05 and 0x06 */
498f5b17 1868static const struct hda_bind_ctls ad1981_hp_bind_master_vol = {
cca3b371
TI		 1869 .ops = &snd_hda_bind_vol,
1870 .values = {
1871 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
1872 HDA_COMPOSE_AMP_VAL(0x06, 3, 0, HDA_OUTPUT),
1873 0
1874 },
1875};
18a815d7
TI		 1876
1877/* mute internal speaker if HP is plugged */
1878static void ad1981_hp_automute(struct hda_codec *codec)
1879{
1880 unsigned int present;
1881
d56757ab 1882 present = snd_hda_jack_detect(codec, 0x06);
47fd830a
TI		 1883 snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0,
1884 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
18a815d7
TI		 1885}
1886
1887/* toggle input of built-in and mic jack appropriately */
1888static void ad1981_hp_automic(struct hda_codec *codec)
1889{
498f5b17 1890 static const struct hda_verb mic_jack_on[] = {
18a815d7
TI		 1891 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1892 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1893 {}
1894 };
498f5b17 1895 static const struct hda_verb mic_jack_off[] = {
18a815d7
TI		 1896 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1897 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1898 {}
1899 };
1900 unsigned int present;
1901
d56757ab 1902 present = snd_hda_jack_detect(codec, 0x08);
18a815d7
TI		 1903 if (present)
1904 snd_hda_sequence_write(codec, mic_jack_on);
1905 else
1906 snd_hda_sequence_write(codec, mic_jack_off);
1907}
1908
1909/* unsolicited event for HP jack sensing */
1910static void ad1981_hp_unsol_event(struct hda_codec *codec,
1911 unsigned int res)
1912{
1913 res >>= 26;
1914 switch (res) {
1915 case AD1981_HP_EVENT:
1916 ad1981_hp_automute(codec);
1917 break;
1918 case AD1981_MIC_EVENT:
1919 ad1981_hp_automic(codec);
1920 break;
1921 }
1922}
1923
498f5b17 1924static const struct hda_input_mux ad1981_hp_capture_source = {
18a815d7
TI		 1925 .num_items = 3,
1926 .items = {
1927 { "Mic", 0x0 },
c40bd914 1928 { "Dock Mic", 0x1 },
18a815d7
TI		 1929 { "Mix", 0x2 },
1930 },
1931};
1932
498f5b17 1933static const struct snd_kcontrol_new ad1981_hp_mixers[] = {
cca3b371 1934 HDA_BIND_VOL("Master Playback Volume", &ad1981_hp_bind_master_vol),
18a815d7
TI		 1935 {
1936 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5b0cb1d8 1937 .subdevice = HDA_SUBDEV_NID_FLAG | 0x05,
18a815d7
TI		 1938 .name = "Master Playback Switch",
1939 .info = ad198x_eapd_info,
1940 .get = ad198x_eapd_get,
1941 .put = ad1981_hp_master_sw_put,
1942 .private_value = 0x05,
1943 },
1944 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1945 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1946#if 0
1947 /* FIXME: analog mic/line loopback doesn't work with my tests...
1948 * (although recording is OK)
1949 */
1950 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1951 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
c40bd914
DH		 1952 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1953 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
18a815d7
TI		 1954 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1955 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1956 /* FIXME: does this laptop have analog CD connection? */
1957 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1958 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1959#endif
5f99f86a
DH		 1960 HDA_CODEC_VOLUME("Mic Boost Volume", 0x08, 0x0, HDA_INPUT),
1961 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x18, 0x0, HDA_INPUT),
18a815d7
TI		 1962 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1963 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1964 {
1965 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1966 .name = "Capture Source",
1967 .info = ad198x_mux_enum_info,
1968 .get = ad198x_mux_enum_get,
1969 .put = ad198x_mux_enum_put,
1970 },
1971 { } /* end */
1972};
1973
1974/* initialize jack-sensing, too */
1975static int ad1981_hp_init(struct hda_codec *codec)
1976{
1977 ad198x_init(codec);
1978 ad1981_hp_automute(codec);
1979 ad1981_hp_automic(codec);
1980 return 0;
1981}
1982
18768991 1983/* configuration for Toshiba Laptops */
498f5b17 1984static const struct hda_verb ad1981_toshiba_init_verbs[] = {
18768991
TD		 1985 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x01 }, /* default on */
1986 /* pin sensing on HP and Mic jacks */
1987 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1988 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1989 {}
1990};
1991
498f5b17 1992static const struct snd_kcontrol_new ad1981_toshiba_mixers[] = {
18768991
TD		 1993 HDA_CODEC_VOLUME("Amp Volume", 0x1a, 0x0, HDA_OUTPUT),
1994 HDA_CODEC_MUTE("Amp Switch", 0x1a, 0x0, HDA_OUTPUT),
1995 { }
1996};
1997
01686c5f 1998/* configuration for Lenovo Thinkpad T60 */
498f5b17 1999static const struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {
01686c5f
TI		 2000 HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
2001 HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
2002 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
2003 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
2004 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
2005 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
2006 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
2007 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
5f99f86a 2008 HDA_CODEC_VOLUME("Mic Boost Volume", 0x08, 0x0, HDA_INPUT),
01686c5f
TI		 2009 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
2010 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
2011 {
2012 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2013 .name = "Capture Source",
2014 .info = ad198x_mux_enum_info,
2015 .get = ad198x_mux_enum_get,
2016 .put = ad198x_mux_enum_put,
2017 },
6540dffa
TI		 2018 /* identical with AD1983 */
2019 {
2020 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2021 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
2022 .info = ad1983_spdif_route_info,
2023 .get = ad1983_spdif_route_get,
2024 .put = ad1983_spdif_route_put,
2025 },
01686c5f
TI		 2026 { } /* end */
2027};
2028
498f5b17 2029static const struct hda_input_mux ad1981_thinkpad_capture_source = {
01686c5f
TI		 2030 .num_items = 3,
2031 .items = {
2032 { "Mic", 0x0 },
2033 { "Mix", 0x2 },
2034 { "CD", 0x4 },
2035 },
2036};
2037
18a815d7 2038/* models */
f5fcc13c 2039enum {
78bb3cb0 2040 AD1981_AUTO,
f5fcc13c
TI		 2041 AD1981_BASIC,
2042 AD1981_HP,
2043 AD1981_THINKPAD,
18768991 2044 AD1981_TOSHIBA,
f5fcc13c
TI		 2045 AD1981_MODELS
2046};
18a815d7 2047
ea734963 2048static const char * const ad1981_models[AD1981_MODELS] = {
78bb3cb0 2049 [AD1981_AUTO] = "auto",
f5fcc13c
TI		 2050 [AD1981_HP] = "hp",
2051 [AD1981_THINKPAD] = "thinkpad",
2052 [AD1981_BASIC] = "basic",
18768991 2053 [AD1981_TOSHIBA] = "toshiba"
f5fcc13c
TI		 2054};
2055
498f5b17 2056static const struct snd_pci_quirk ad1981_cfg_tbl[] = {
ac3e3741 2057 SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD),
470eaf6b 2058 SND_PCI_QUIRK(0x1014, 0x05b7, "Lenovo Z60m", AD1981_THINKPAD),
8970ccda 2059 /* All HP models */
dea0a509 2060 SND_PCI_QUIRK_VENDOR(0x103c, "HP nx", AD1981_HP),
ac3e3741 2061 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA),
01686c5f 2062 /* Lenovo Thinkpad T60/X60/Z6xx */
dea0a509 2063 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1981_THINKPAD),
ac3e3741
TI		 2064 /* HP nx6320 (reversed SSID, H/W bug) */
2065 SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP),
18a815d7
TI		 2066 {}
2067};
9ff4bc8f
TI		 2068#endif /* ENABLE_AD_STATIC_QUIRKS */
2069
18a815d7 2070
78bb3cb0
TI		 2071static int ad1981_parse_auto_config(struct hda_codec *codec)
2072{
9ff4bc8f 2073 struct ad198x_spec *spec;
272f3ea3 2074 int err;
78bb3cb0 2075
9ff4bc8f
TI		 2076 err = alloc_ad_spec(codec);
2077 if (err < 0)
2078 return -ENOMEM;
2079 spec = codec->spec;
2080
f2f8be43 2081 spec->gen.mixer_nid = 0x0e;
78bb3cb0
TI		 2082 spec->beep_dev_nid = 0x10;
2083 set_beep_amp(spec, 0x0d, 0, HDA_OUTPUT);
272f3ea3
TI		 2084 err = ad198x_parse_auto_config(codec);
2085 if (err < 0)
9ff4bc8f 2086 goto error;
272f3ea3
TI		 2087 err = ad1983_add_spdif_mux_ctl(codec);
2088 if (err < 0)
9ff4bc8f 2089 goto error;
272f3ea3 2090 return 0;
9ff4bc8f
TI		 2091
2092 error:
2093 ad198x_free(codec);
2094 return err;
78bb3cb0
TI		 2095}
2096
9ff4bc8f 2097#ifdef ENABLE_AD_STATIC_QUIRKS
4a3fdf3d 2098static int patch_ad1981(struct hda_codec *codec)
1da177e4 2099{
4a3fdf3d 2100 struct ad198x_spec *spec;
c5a4bcd0 2101 int err, board_config;
1da177e4 2102
9ff4bc8f
TI		 2103 board_config = snd_hda_check_board_config(codec, AD1981_MODELS,
2104 ad1981_models,
2105 ad1981_cfg_tbl);
2106 if (board_config == AD1981_AUTO)
2107 return ad1981_parse_auto_config(codec);
2108
361dab3e
TI		 2109 err = alloc_ad_spec(codec);
2110 if (err < 0)
1da177e4 2111 return -ENOMEM;
361dab3e 2112 spec = codec->spec;
1da177e4 2113
c5a4bcd0
TI		 2114 err = snd_hda_attach_beep_device(codec, 0x10);
2115 if (err < 0) {
2116 ad198x_free(codec);
2117 return err;
2118 }
2119 set_beep_amp(spec, 0x0d, 0, HDA_OUTPUT);
2120
4a3fdf3d
TI		 2121 spec->multiout.max_channels = 2;
2122 spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
2123 spec->multiout.dac_nids = ad1981_dac_nids;
2124 spec->multiout.dig_out_nid = AD1981_SPDIF_OUT;
985be54b
TI		 2125 spec->num_adc_nids = 1;
2126 spec->adc_nids = ad1981_adc_nids;
18a815d7 2127 spec->capsrc_nids = ad1981_capsrc_nids;
4a3fdf3d 2128 spec->input_mux = &ad1981_capture_source;
985be54b
TI		 2129 spec->num_mixers = 1;
2130 spec->mixers[0] = ad1981_mixers;
2131 spec->num_init_verbs = 1;
2132 spec->init_verbs[0] = ad1981_init_verbs;
4a3fdf3d 2133 spec->spdif_route = 0;
83012a7c 2134#ifdef CONFIG_PM
cb53c626
TI		 2135 spec->loopback.amplist = ad1981_loopbacks;
2136#endif
2134ea4f 2137 spec->vmaster_nid = 0x05;
1da177e4 2138
4a3fdf3d 2139 codec->patch_ops = ad198x_patch_ops;
1da177e4 2140
18a815d7 2141 /* override some parameters */
18a815d7
TI		 2142 switch (board_config) {
2143 case AD1981_HP:
2144 spec->mixers[0] = ad1981_hp_mixers;
2145 spec->num_init_verbs = 2;
2146 spec->init_verbs[1] = ad1981_hp_init_verbs;
695cd4a3
TI		 2147 if (!is_jack_available(codec, 0x0a))
2148 spec->multiout.dig_out_nid = 0;
18a815d7
TI		 2149 spec->input_mux = &ad1981_hp_capture_source;
2150
2151 codec->patch_ops.init = ad1981_hp_init;
2152 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
01f5966d
DC		 2153 /* set the upper-limit for mixer amp to 0dB for avoiding the
2154 * possible damage by overloading
2155 */
2156 snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,
2157 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
2158 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
2159 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2160 (1 << AC_AMPCAP_MUTE_SHIFT));
18a815d7 2161 break;
01686c5f
TI		 2162 case AD1981_THINKPAD:
2163 spec->mixers[0] = ad1981_thinkpad_mixers;
01686c5f 2164 spec->input_mux = &ad1981_thinkpad_capture_source;
b8e80cf3
DC		 2165 /* set the upper-limit for mixer amp to 0dB for avoiding the
2166 * possible damage by overloading
2167 */
2168 snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT,
2169 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
2170 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
2171 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2172 (1 << AC_AMPCAP_MUTE_SHIFT));
01686c5f 2173 break;
18768991
TD		 2174 case AD1981_TOSHIBA:
2175 spec->mixers[0] = ad1981_hp_mixers;
2176 spec->mixers[1] = ad1981_toshiba_mixers;
2177 spec->num_init_verbs = 2;
2178 spec->init_verbs[1] = ad1981_toshiba_init_verbs;
2179 spec->multiout.dig_out_nid = 0;
2180 spec->input_mux = &ad1981_hp_capture_source;
2181 codec->patch_ops.init = ad1981_hp_init;
2182 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
2183 break;
18a815d7 2184 }
729d55ba
TI		 2185
2186 codec->no_trigger_sense = 1;
0e7adbe2 2187 codec->no_sticky_stream = 1;
729d55ba 2188
1da177e4
LT		 2189 return 0;
2190}
9ff4bc8f
TI		 2191#else /* ENABLE_AD_STATIC_QUIRKS */
2192#define patch_ad1981 ad1981_parse_auto_config
2193#endif /* ENABLE_AD_STATIC_QUIRKS */
1da177e4 2194
4a3fdf3d 2195
fd66e0d0
TI		 2196/*
2197 * AD1988
2198 *
2199 * Output pins and routes
2200 *
d32410b1 2201 * Pin Mix Sel DAC (*)
fd66e0d0
TI		 2202 * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
2203 * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
2204 * port-C 0x15 (mute) <- 0x2c <- 0x31 <- 05/0a
2205 * port-D 0x12 (mute/hp) <- 0x29 <- 04
2206 * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
2207 * port-F 0x16 (mute) <- 0x2a <- 06
2208 * port-G 0x24 (mute) <- 0x27 <- 05
2209 * port-H 0x25 (mute) <- 0x28 <- 0a
2210 * mono 0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
2211 *
d32410b1
TI		 2212 * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
2213 * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.
fd66e0d0
TI		 2214 *
2215 * Input pins and routes
2216 *
2217 * pin boost mix input # / adc input #
2218 * port-A 0x11 -> 0x38 -> mix 2, ADC 0
2219 * port-B 0x14 -> 0x39 -> mix 0, ADC 1
2220 * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
2221 * port-D 0x12 -> 0x3d -> mix 3, ADC 8
2222 * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
2223 * port-F 0x16 -> 0x3b -> mix 5, ADC 3
2224 * port-G 0x24 -> N/A -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
2225 * port-H 0x25 -> N/A -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
2226 *
2227 *
2228 * DAC assignment
d32410b1 2229 * 6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03
f8c7c7b8 2230 * 3stack - front/surr/CLFE/opt DACs - 04/05/0a/03
fd66e0d0
TI		 2231 *
2232 * Inputs of Analog Mix (0x20)
2233 * 0:Port-B (front mic)
2234 * 1:Port-C/G/H (line-in)
2235 * 2:Port-A
2236 * 3:Port-D (line-in/2)
2237 * 4:Port-E/G/H (mic-in)
2238 * 5:Port-F (mic2-in)
2239 * 6:CD
2240 * 7:Beep
2241 *
2242 * ADC selection
2243 * 0:Port-A
2244 * 1:Port-B (front mic-in)
2245 * 2:Port-C (line-in)
2246 * 3:Port-F (mic2-in)
2247 * 4:Port-E (mic-in)
2248 * 5:CD
2249 * 6:Port-G
2250 * 7:Port-H
2251 * 8:Port-D (line-in/2)
2252 * 9:Mix
2253 *
2254 * Proposed pin assignments by the datasheet
2255 *
2256 * 6-stack
2257 * Port-A front headphone
2258 * B front mic-in
2259 * C rear line-in
2260 * D rear front-out
2261 * E rear mic-in
2262 * F rear surround
2263 * G rear CLFE
2264 * H rear side
2265 *
2266 * 3-stack
2267 * Port-A front headphone
2268 * B front mic
2269 * C rear line-in/surround
2270 * D rear front-out
2271 * E rear mic-in/CLFE
2272 *
2273 * laptop
2274 * Port-A headphone
2275 * B mic-in
2276 * C docking station
2277 * D internal speaker (with EAPD)
2278 * E/F quad mic array
2279 */
2280
2281
9ff4bc8f 2282#ifdef ENABLE_AD_STATIC_QUIRKS
fd66e0d0
TI		 2283/* models */
2284enum {
78bb3cb0 2285 AD1988_AUTO,
fd66e0d0
TI		 2286 AD1988_6STACK,
2287 AD1988_6STACK_DIG,
2288 AD1988_3STACK,
2289 AD1988_3STACK_DIG,
2290 AD1988_LAPTOP,
2291 AD1988_LAPTOP_DIG,
2292 AD1988_MODEL_LAST,
2293};
2294
d32410b1
TI		 2295/* reivision id to check workarounds */
2296#define AD1988A_REV2 0x100200
2297
1a806f48
TI		 2298#define is_rev2(codec) \
2299 ((codec)->vendor_id == 0x11d41988 && \
2300 (codec)->revision_id == AD1988A_REV2)
fd66e0d0
TI		 2301
2302/*
2303 * mixers
2304 */
2305
498f5b17 2306static const hda_nid_t ad1988_6stack_dac_nids[4] = {
fd66e0d0
TI		 2307 0x04, 0x06, 0x05, 0x0a
2308};
2309
498f5b17 2310static const hda_nid_t ad1988_3stack_dac_nids[3] = {
f8c7c7b8 2311 0x04, 0x05, 0x0a
d32410b1
TI		 2312};
2313
2314/* for AD1988A revision-2, DAC2-4 are swapped */
498f5b17 2315static const hda_nid_t ad1988_6stack_dac_nids_rev2[4] = {
d32410b1
TI		 2316 0x04, 0x05, 0x0a, 0x06
2317};
2318
498f5b17 2319static const hda_nid_t ad1988_alt_dac_nid[1] = {
c66ddf32
RY		 2320 0x03
2321};
2322
498f5b17 2323static const hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {
f8c7c7b8 2324 0x04, 0x0a, 0x06
d32410b1
TI		 2325};
2326
498f5b17 2327static const hda_nid_t ad1988_adc_nids[3] = {
fd66e0d0
TI		 2328 0x08, 0x09, 0x0f
2329};
2330
498f5b17 2331static const hda_nid_t ad1988_capsrc_nids[3] = {
2e5b9567
TI		 2332 0x0c, 0x0d, 0x0e
2333};
2334
9cae0c63
RJ		 2335#define AD1988_SPDIF_OUT 0x02
2336#define AD1988_SPDIF_OUT_HDMI 0x0b
fd66e0d0
TI		 2337#define AD1988_SPDIF_IN 0x07
2338
498f5b17 2339static const hda_nid_t ad1989b_slave_dig_outs[] = {
3a08e30d 2340 AD1988_SPDIF_OUT, AD1988_SPDIF_OUT_HDMI, 0
9cae0c63
RJ		 2341};
2342
498f5b17 2343static const struct hda_input_mux ad1988_6stack_capture_source = {
fd66e0d0
TI		 2344 .num_items = 5,
2345 .items = {
fb304ce5
TI		 2346 { "Front Mic", 0x1 }, /* port-B */
2347 { "Line", 0x2 }, /* port-C */
2348 { "Mic", 0x4 }, /* port-E */
fd66e0d0
TI		 2349 { "CD", 0x5 },
2350 { "Mix", 0x9 },
2351 },
2352};
2353
498f5b17 2354static const struct hda_input_mux ad1988_laptop_capture_source = {
fd66e0d0
TI		 2355 .num_items = 3,
2356 .items = {
fb304ce5 2357 { "Mic/Line", 0x1 }, /* port-B */
fd66e0d0
TI		 2358 { "CD", 0x5 },
2359 { "Mix", 0x9 },
2360 },
2361};
2362
2363/*
2364 */
2365static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
2366 struct snd_ctl_elem_info *uinfo)
2367{
2368 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2369 struct ad198x_spec *spec = codec->spec;
2370 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
2371 spec->num_channel_mode);
2372}
2373
2374static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
2375 struct snd_ctl_elem_value *ucontrol)
2376{
2377 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2378 struct ad198x_spec *spec = codec->spec;
2379 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
2380 spec->num_channel_mode, spec->multiout.max_channels);
2381}
2382
2383static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
2384 struct snd_ctl_elem_value *ucontrol)
2385{
2386 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2387 struct ad198x_spec *spec = codec->spec;
4e195a7b
TI		 2388 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
2389 spec->num_channel_mode,
2390 &spec->multiout.max_channels);
bd2033f2 2391 if (err >= 0 && spec->need_dac_fix)
2125cad2 2392 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
4e195a7b 2393 return err;
fd66e0d0
TI		 2394}
2395
fd66e0d0 2396/* 6-stack mode */
498f5b17 2397static const struct snd_kcontrol_new ad1988_6stack_mixers1[] = {
fd66e0d0
TI		 2398 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2399 HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT),
2400 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
2401 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
2402 HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2ece5f42 2403 { } /* end */
d32410b1
TI		 2404};
2405
498f5b17 2406static const struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = {
d32410b1
TI		 2407 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2408 HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT),
2409 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
2410 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT),
2411 HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT),
2ece5f42 2412 { } /* end */
d32410b1 2413};
fd66e0d0 2414
498f5b17 2415static const struct snd_kcontrol_new ad1988_6stack_mixers2[] = {
356aab7d 2416 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
fd66e0d0
TI		 2417 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
2418 HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT),
2419 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT),
2420 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT),
2421 HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT),
2422 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
2423 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2424
2425 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2426 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2427 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2428 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2429 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2430 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2431 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
2432 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
2433
2e5b9567 2434 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
fd66e0d0
TI		 2435 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2436
5f99f86a
DH		 2437 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x39, 0x0, HDA_OUTPUT),
2438 HDA_CODEC_VOLUME("Mic Boost Volume", 0x3c, 0x0, HDA_OUTPUT),
fd66e0d0
TI		 2439 { } /* end */
2440};
2441
2442/* 3-stack mode */
498f5b17 2443static const struct snd_kcontrol_new ad1988_3stack_mixers1[] = {
fd66e0d0 2444 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
d32410b1 2445 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
fd66e0d0
TI		 2446 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
2447 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
2ece5f42 2448 { } /* end */
d32410b1
TI		 2449};
2450
498f5b17 2451static const struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = {
d32410b1 2452 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
f8c7c7b8
TI		 2453 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2454 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT),
2455 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT),
2ece5f42 2456 { } /* end */
d32410b1 2457};
fd66e0d0 2458
498f5b17 2459static const struct snd_kcontrol_new ad1988_3stack_mixers2[] = {
356aab7d 2460 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
fd66e0d0 2461 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
d32410b1
TI		 2462 HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT),
2463 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT),
2464 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT),
fd66e0d0
TI		 2465 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
2466 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2467
2468 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2469 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2470 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2471 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2472 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2473 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2474 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
2475 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
2476
2e5b9567 2477 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
fd66e0d0
TI		 2478 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2479
5f99f86a
DH		 2480 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x39, 0x0, HDA_OUTPUT),
2481 HDA_CODEC_VOLUME("Mic Boost Volume", 0x3c, 0x0, HDA_OUTPUT),
fd66e0d0
TI		 2482 {
2483 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2484 .name = "Channel Mode",
2485 .info = ad198x_ch_mode_info,
2486 .get = ad198x_ch_mode_get,
2487 .put = ad198x_ch_mode_put,
2488 },
2489
2490 { } /* end */
2491};
2492
2493/* laptop mode */
498f5b17 2494static const struct snd_kcontrol_new ad1988_laptop_mixers[] = {
356aab7d 2495 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
fd66e0d0
TI		 2496 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2497 HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT),
2498 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2499
2500 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2501 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2502 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2503 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2504 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2505 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2506
2e5b9567 2507 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
fd66e0d0
TI		 2508 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2509
5f99f86a 2510 HDA_CODEC_VOLUME("Mic Boost Volume", 0x39, 0x0, HDA_OUTPUT),
fd66e0d0
TI		 2511
2512 {
2513 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2514 .name = "External Amplifier",
5b0cb1d8 2515 .subdevice = HDA_SUBDEV_NID_FLAG | 0x12,
18a815d7
TI		 2516 .info = ad198x_eapd_info,
2517 .get = ad198x_eapd_get,
2518 .put = ad198x_eapd_put,
ee6e365e 2519 .private_value = 0x12, /* port-D */
fd66e0d0
TI		 2520 },
2521
2522 { } /* end */
2523};
2524
2525/* capture */
498f5b17 2526static const struct snd_kcontrol_new ad1988_capture_mixers[] = {
fd66e0d0
TI		 2527 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
2528 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
2529 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
2530 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
2531 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT),
2532 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT),
2533 {
2534 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2535 /* The multiple "Capture Source" controls confuse alsamixer
2536 * So call somewhat different..
fd66e0d0
TI		 2537 */
2538 /* .name = "Capture Source", */
2539 .name = "Input Source",
2540 .count = 3,
2541 .info = ad198x_mux_enum_info,
2542 .get = ad198x_mux_enum_get,
2543 .put = ad198x_mux_enum_put,
2544 },
2545 { } /* end */
2546};
2547
2548static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol,
2549 struct snd_ctl_elem_info *uinfo)
2550{
498f5b17 2551 static const char * const texts[] = {
fd66e0d0
TI		 2552 "PCM", "ADC1", "ADC2", "ADC3"
2553 };
2554 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2555 uinfo->count = 1;
2556 uinfo->value.enumerated.items = 4;
2557 if (uinfo->value.enumerated.item >= 4)
2558 uinfo->value.enumerated.item = 3;
2559 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2560 return 0;
2561}
2562
2563static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol,
2564 struct snd_ctl_elem_value *ucontrol)
2565{
2566 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2567 unsigned int sel;
2568
bddcf541
TI		 2569 sel = snd_hda_codec_read(codec, 0x1d, 0, AC_VERB_GET_AMP_GAIN_MUTE,
2570 AC_AMP_GET_INPUT);
2571 if (!(sel & 0x80))
2572 ucontrol->value.enumerated.item[0] = 0;
2573 else {
35b26722
TI		 2574 sel = snd_hda_codec_read(codec, 0x0b, 0,
2575 AC_VERB_GET_CONNECT_SEL, 0);
2576 if (sel < 3)
fd66e0d0
TI		 2577 sel++;
2578 else
2579 sel = 0;
bddcf541 2580 ucontrol->value.enumerated.item[0] = sel;
fd66e0d0 2581 }
fd66e0d0
TI		 2582 return 0;
2583}
2584
2585static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol,
2586 struct snd_ctl_elem_value *ucontrol)
2587{
2588 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
35b26722 2589 unsigned int val, sel;
fd66e0d0
TI		 2590 int change;
2591
35b26722 2592 val = ucontrol->value.enumerated.item[0];
68ea7b2f
TI		 2593 if (val > 3)
2594 return -EINVAL;
35b26722 2595 if (!val) {
bddcf541
TI		 2596 sel = snd_hda_codec_read(codec, 0x1d, 0,
2597 AC_VERB_GET_AMP_GAIN_MUTE,
2598 AC_AMP_GET_INPUT);
2599 change = sel & 0x80;
82beb8fd
TI		 2600 if (change) {
2601 snd_hda_codec_write_cache(codec, 0x1d, 0,
2602 AC_VERB_SET_AMP_GAIN_MUTE,
2603 AMP_IN_UNMUTE(0));
2604 snd_hda_codec_write_cache(codec, 0x1d, 0,
2605 AC_VERB_SET_AMP_GAIN_MUTE,
2606 AMP_IN_MUTE(1));
bddcf541 2607 }
fd66e0d0 2608 } else {
bddcf541
TI		 2609 sel = snd_hda_codec_read(codec, 0x1d, 0,
2610 AC_VERB_GET_AMP_GAIN_MUTE,
2611 AC_AMP_GET_INPUT | 0x01);
2612 change = sel & 0x80;
82beb8fd
TI		 2613 if (change) {
2614 snd_hda_codec_write_cache(codec, 0x1d, 0,
2615 AC_VERB_SET_AMP_GAIN_MUTE,
2616 AMP_IN_MUTE(0));
2617 snd_hda_codec_write_cache(codec, 0x1d, 0,
2618 AC_VERB_SET_AMP_GAIN_MUTE,
2619 AMP_IN_UNMUTE(1));
bddcf541 2620 }
35b26722
TI		 2621 sel = snd_hda_codec_read(codec, 0x0b, 0,
2622 AC_VERB_GET_CONNECT_SEL, 0) + 1;
2623 change |= sel != val;
82beb8fd
TI		 2624 if (change)
2625 snd_hda_codec_write_cache(codec, 0x0b, 0,
2626 AC_VERB_SET_CONNECT_SEL,
2627 val - 1);
fd66e0d0
TI		 2628 }
2629 return change;
2630}
2631
498f5b17 2632static const struct snd_kcontrol_new ad1988_spdif_out_mixers[] = {
fd66e0d0
TI		 2633 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2634 {
2635 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2636 .name = "IEC958 Playback Source",
5b0cb1d8 2637 .subdevice = HDA_SUBDEV_NID_FLAG | 0x1b,
fd66e0d0
TI		 2638 .info = ad1988_spdif_playback_source_info,
2639 .get = ad1988_spdif_playback_source_get,
2640 .put = ad1988_spdif_playback_source_put,
2641 },
2642 { } /* end */
2643};
2644
498f5b17 2645static const struct snd_kcontrol_new ad1988_spdif_in_mixers[] = {
fd66e0d0
TI		 2646 HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT),
2647 { } /* end */
2648};
2649
498f5b17 2650static const struct snd_kcontrol_new ad1989_spdif_out_mixers[] = {
3adb8abc 2651 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
9cae0c63 2652 HDA_CODEC_VOLUME("HDMI Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
3adb8abc
TI		 2653 { } /* end */
2654};
fd66e0d0
TI		 2655
2656/*
2657 * initialization verbs
2658 */
2659
2660/*
2661 * for 6-stack (+dig)
2662 */
498f5b17 2663static const struct hda_verb ad1988_6stack_init_verbs[] = {
2e5b9567
TI		 2664 /* Front, Surround, CLFE, side DAC; unmute as default */
2665 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2666 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2667 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2668 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
fd66e0d0 2669 /* Port-A front headphon path */
356aab7d 2670 {0x37, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC0:03h */
fd66e0d0
TI		 2671 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2672 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2673 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2674 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2675 /* Port-D line-out path */
2676 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2677 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2678 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2679 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2680 /* Port-F surround path */
2681 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2682 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2683 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2684 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2685 /* Port-G CLFE path */
2686 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2687 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2688 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2689 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2690 /* Port-H side path */
2691 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2692 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2693 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2694 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2695 /* Mono out path */
2696 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2697 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2698 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2699 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2700 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2701 /* Port-B front mic-in path */
2702 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2703 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2704 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2705 /* Port-C line-in path */
2706 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2707 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2708 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2709 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2710 /* Port-E mic-in path */
2711 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2712 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2713 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2714 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
695005cf
JS		 2715 /* Analog CD Input */
2716 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
db3da6c1
TI		 2717 /* Analog Mix output amp */
2718 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
fd66e0d0
TI		 2719
2720 { }
2721};
2722
498f5b17 2723static const struct hda_verb ad1988_6stack_fp_init_verbs[] = {
c66ddf32
RY		 2724 /* Headphone; unmute as default */
2725 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2726 /* Port-A front headphon path */
2727 {0x37, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC0:03h */
2728 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2729 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2730 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2731 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
c66ddf32
RY		 2732
2733 { }
2734};
2735
498f5b17 2736static const struct hda_verb ad1988_capture_init_verbs[] = {
fd66e0d0
TI		 2737 /* mute analog mix */
2738 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2739 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2740 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2741 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2742 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2743 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2744 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2745 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2746 /* select ADCs - front-mic */
2747 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2748 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2749 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
fd66e0d0
TI		 2750
2751 { }
2752};
2753
498f5b17 2754static const struct hda_verb ad1988_spdif_init_verbs[] = {
fd66e0d0
TI		 2755 /* SPDIF out sel */
2756 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
2757 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */
2758 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
bddcf541 2759 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
fd66e0d0
TI		 2760 /* SPDIF out pin */
2761 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
fd66e0d0
TI		 2762
2763 { }
2764};
2765
498f5b17 2766static const struct hda_verb ad1988_spdif_in_init_verbs[] = {
fd0b092a
JK		 2767 /* unmute SPDIF input pin */
2768 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2769 { }
2770};
2771
3adb8abc 2772/* AD1989 has no ADC -> SPDIF route */
498f5b17 2773static const struct hda_verb ad1989_spdif_init_verbs[] = {
e8bfc6c1
RJ		 2774 /* SPDIF-1 out pin */
2775 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
3adb8abc 2776 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
e8bfc6c1
RJ		 2777 /* SPDIF-2/HDMI out pin */
2778 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2779 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3adb8abc
TI		 2780 { }
2781};
2782
fd66e0d0
TI		 2783/*
2784 * verbs for 3stack (+dig)
2785 */
498f5b17 2786static const struct hda_verb ad1988_3stack_ch2_init[] = {
fd66e0d0
TI		 2787 /* set port-C to line-in */
2788 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2789 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2790 /* set port-E to mic-in */
2791 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2792 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2793 { } /* end */
2794};
2795
498f5b17 2796static const struct hda_verb ad1988_3stack_ch6_init[] = {
fd66e0d0 2797 /* set port-C to surround out */
fd66e0d0 2798 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
d32410b1 2799 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
fd66e0d0 2800 /* set port-E to CLFE out */
fd66e0d0 2801 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
d32410b1 2802 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
fd66e0d0
TI		 2803 { } /* end */
2804};
2805
498f5b17 2806static const struct hda_channel_mode ad1988_3stack_modes[2] = {
fd66e0d0
TI		 2807 { 2, ad1988_3stack_ch2_init },
2808 { 6, ad1988_3stack_ch6_init },
2809};
2810
498f5b17 2811static const struct hda_verb ad1988_3stack_init_verbs[] = {
2e5b9567
TI		 2812 /* Front, Surround, CLFE, side DAC; unmute as default */
2813 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2814 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2815 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2816 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
fd66e0d0 2817 /* Port-A front headphon path */
356aab7d 2818 {0x37, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC0:03h */
fd66e0d0
TI		 2819 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2820 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2821 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2822 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2823 /* Port-D line-out path */
2824 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2825 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2826 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2827 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2828 /* Mono out path */
2829 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2830 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2831 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2832 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2833 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2834 /* Port-B front mic-in path */
2835 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2836 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2837 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
d32410b1
TI		 2838 /* Port-C line-in/surround path - 6ch mode as default */
2839 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2840 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
fd66e0d0 2841 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
d32410b1 2842 {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */
fd66e0d0 2843 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
d32410b1
TI		 2844 /* Port-E mic-in/CLFE path - 6ch mode as default */
2845 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2846 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
fd66e0d0 2847 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
f8c7c7b8 2848 {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */
fd66e0d0
TI		 2849 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2850 /* mute analog mix */
2851 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2852 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2853 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2854 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2855 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2856 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2857 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2858 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2859 /* select ADCs - front-mic */
2860 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2861 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2862 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
db3da6c1
TI		 2863 /* Analog Mix output amp */
2864 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
fd66e0d0
TI		 2865 { }
2866};
2867
2868/*
2869 * verbs for laptop mode (+dig)
2870 */
498f5b17 2871static const struct hda_verb ad1988_laptop_hp_on[] = {
fd66e0d0
TI		 2872 /* unmute port-A and mute port-D */
2873 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2874 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2875 { } /* end */
2876};
498f5b17 2877static const struct hda_verb ad1988_laptop_hp_off[] = {
fd66e0d0
TI		 2878 /* mute port-A and unmute port-D */
2879 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2880 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2881 { } /* end */
2882};
2883
2884#define AD1988_HP_EVENT 0x01
2885
498f5b17 2886static const struct hda_verb ad1988_laptop_init_verbs[] = {
2e5b9567
TI		 2887 /* Front, Surround, CLFE, side DAC; unmute as default */
2888 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2889 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2890 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2891 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
fd66e0d0 2892 /* Port-A front headphon path */
356aab7d 2893 {0x37, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC0:03h */
fd66e0d0
TI		 2894 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2895 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2896 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2897 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2898 /* unsolicited event for pin-sense */
2899 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT },
2900 /* Port-D line-out path + EAPD */
2901 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2902 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2903 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2904 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2905 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */
2906 /* Mono out path */
2907 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2908 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2909 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2910 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2911 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2912 /* Port-B mic-in path */
2913 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2914 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2915 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2916 /* Port-C docking station - try to output */
2917 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2918 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2919 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2920 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2921 /* mute analog mix */
2922 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2923 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2924 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2925 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2926 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2927 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2928 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2929 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2930 /* select ADCs - mic */
2931 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2932 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2933 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
db3da6c1
TI		 2934 /* Analog Mix output amp */
2935 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
fd66e0d0
TI		 2936 { }
2937};
2938
2939static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res)
2940{
2941 if ((res >> 26) != AD1988_HP_EVENT)
2942 return;
d56757ab 2943 if (snd_hda_jack_detect(codec, 0x11))
fd66e0d0
TI		 2944 snd_hda_sequence_write(codec, ad1988_laptop_hp_on);
2945 else
2946 snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
2947}
2948
83012a7c 2949#ifdef CONFIG_PM
498f5b17 2950static const struct hda_amp_list ad1988_loopbacks[] = {
cb53c626
TI		 2951 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
2952 { 0x20, HDA_INPUT, 1 }, /* Line */
2953 { 0x20, HDA_INPUT, 4 }, /* Mic */
2954 { 0x20, HDA_INPUT, 6 }, /* CD */
2955 { } /* end */
2956};
2957#endif
9ff4bc8f 2958#endif /* ENABLE_AD_STATIC_QUIRKS */
fd66e0d0 2959
272f3ea3
TI		 2960static int ad1988_auto_smux_enum_info(struct snd_kcontrol *kcontrol,
2961 struct snd_ctl_elem_info *uinfo)
2962{
2963 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2964 static const char * const texts[] = {
2965 "PCM", "ADC1", "ADC2", "ADC3",
2966 };
2967 int num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1;
2968 if (num_conns > 4)
2969 num_conns = 4;
2970 return snd_hda_enum_helper_info(kcontrol, uinfo, num_conns, texts);
2971}
2972
2973static int ad1988_auto_smux_enum_get(struct snd_kcontrol *kcontrol,
2974 struct snd_ctl_elem_value *ucontrol)
2975{
2976 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2977 struct ad198x_spec *spec = codec->spec;
2978
2979 ucontrol->value.enumerated.item[0] = spec->cur_smux;
2980 return 0;
2981}
2982
2983static int ad1988_auto_smux_enum_put(struct snd_kcontrol *kcontrol,
2984 struct snd_ctl_elem_value *ucontrol)
2985{
2986 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2987 struct ad198x_spec *spec = codec->spec;
2988 unsigned int val = ucontrol->value.enumerated.item[0];
2989 struct nid_path *path;
2990 int num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1;
2991
2992 if (val >= num_conns)
2993 return -EINVAL;
2994 if (spec->cur_smux == val)
2995 return 0;
2996
2997 mutex_lock(&codec->control_mutex);
2998 codec->cached_write = 1;
2999 path = snd_hda_get_path_from_idx(codec,
3000 spec->smux_paths[spec->cur_smux]);
3001 if (path)
3002 snd_hda_activate_path(codec, path, false, true);
3003 path = snd_hda_get_path_from_idx(codec, spec->smux_paths[val]);
3004 if (path)
3005 snd_hda_activate_path(codec, path, true, true);
3006 spec->cur_smux = val;
3007 codec->cached_write = 0;
3008 mutex_unlock(&codec->control_mutex);
3009 snd_hda_codec_flush_cache(codec); /* flush the updates */
3010 return 1;
3011}
3012
3013static struct snd_kcontrol_new ad1988_auto_smux_mixer = {
3014 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3015 .name = "IEC958 Playback Source",
3016 .info = ad1988_auto_smux_enum_info,
3017 .get = ad1988_auto_smux_enum_get,
3018 .put = ad1988_auto_smux_enum_put,
3019};
3020
3021static int ad1988_auto_init(struct hda_codec *codec)
3022{
3023 struct ad198x_spec *spec = codec->spec;
3024 int i, err;
3025
3026 err = snd_hda_gen_init(codec);
3027 if (err < 0)
3028 return err;
3029 if (!spec->gen.autocfg.dig_outs)
3030 return 0;
3031
3032 for (i = 0; i < 4; i++) {
3033 struct nid_path *path;
3034 path = snd_hda_get_path_from_idx(codec, spec->smux_paths[i]);
3035 if (path)
3036 snd_hda_activate_path(codec, path, path->active, false);
3037 }
3038
3039 return 0;
3040}
3041
3042static int ad1988_add_spdif_mux_ctl(struct hda_codec *codec)
3043{
3044 struct ad198x_spec *spec = codec->spec;
3045 int i, num_conns;
3046 /* we create four static faked paths, since AD codecs have odd
3047 * widget connections regarding the SPDIF out source
3048 */
3049 static struct nid_path fake_paths[4] = {
3050 {
3051 .depth = 3,
3052 .path = { 0x02, 0x1d, 0x1b },
3053 .idx = { 0, 0, 0 },
3054 .multi = { 0, 0, 0 },
3055 },
3056 {
3057 .depth = 4,
3058 .path = { 0x08, 0x0b, 0x1d, 0x1b },
3059 .idx = { 0, 0, 1, 0 },
3060 .multi = { 0, 1, 0, 0 },
3061 },
3062 {
3063 .depth = 4,
3064 .path = { 0x09, 0x0b, 0x1d, 0x1b },
3065 .idx = { 0, 1, 1, 0 },
3066 .multi = { 0, 1, 0, 0 },
3067 },
3068 {
3069 .depth = 4,
3070 .path = { 0x0f, 0x0b, 0x1d, 0x1b },
3071 .idx = { 0, 2, 1, 0 },
3072 .multi = { 0, 1, 0, 0 },
3073 },
3074 };
3075
3076 /* SPDIF source mux appears to be present only on AD1988A */
3077 if (!spec->gen.autocfg.dig_outs ||
3078 get_wcaps_type(get_wcaps(codec, 0x1d)) != AC_WID_AUD_MIX)
3079 return 0;
3080
3081 num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1;
3082 if (num_conns != 3 && num_conns != 4)
3083 return 0;
3084
3085 for (i = 0; i < num_conns; i++) {
3086 struct nid_path *path = snd_array_new(&spec->gen.paths);
3087 if (!path)
3088 return -ENOMEM;
3089 *path = fake_paths[i];
3090 if (!i)
3091 path->active = 1;
3092 spec->smux_paths[i] = snd_hda_get_path_idx(codec, path);
3093 }
3094
3095 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &ad1988_auto_smux_mixer))
3096 return -ENOMEM;
3097
3098 codec->patch_ops.init = ad1988_auto_init;
3099
3100 return 0;
3101}
3102
d32410b1 3103/*
d32410b1
TI		 3104 */
3105
d32410b1
TI		 3106static int ad1988_parse_auto_config(struct hda_codec *codec)
3107{
9ff4bc8f 3108 struct ad198x_spec *spec;
272f3ea3 3109 int err;
d32410b1 3110
9ff4bc8f
TI		 3111 err = alloc_ad_spec(codec);
3112 if (err < 0)
3113 return err;
3114 spec = codec->spec;
3115
f2f8be43 3116 spec->gen.mixer_nid = 0x20;
78bb3cb0
TI		 3117 spec->beep_dev_nid = 0x10;
3118 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
272f3ea3
TI		 3119 err = ad198x_parse_auto_config(codec);
3120 if (err < 0)
9ff4bc8f 3121 goto error;
272f3ea3
TI		 3122 err = ad1988_add_spdif_mux_ctl(codec);
3123 if (err < 0)
9ff4bc8f 3124 goto error;
272f3ea3 3125 return 0;
9ff4bc8f
TI		 3126
3127 error:
3128 ad198x_free(codec);
3129 return err;
d32410b1
TI		 3130}
3131
fd66e0d0
TI		 3132/*
3133 */
3134
9ff4bc8f 3135#ifdef ENABLE_AD_STATIC_QUIRKS
ea734963 3136static const char * const ad1988_models[AD1988_MODEL_LAST] = {
f5fcc13c
TI		 3137 [AD1988_6STACK] = "6stack",
3138 [AD1988_6STACK_DIG] = "6stack-dig",
3139 [AD1988_3STACK] = "3stack",
3140 [AD1988_3STACK_DIG] = "3stack-dig",
3141 [AD1988_LAPTOP] = "laptop",
3142 [AD1988_LAPTOP_DIG] = "laptop-dig",
3143 [AD1988_AUTO] = "auto",
fd66e0d0
TI		 3144};
3145
498f5b17 3146static const struct snd_pci_quirk ad1988_cfg_tbl[] = {
18768991 3147 SND_PCI_QUIRK(0x1043, 0x81ec, "Asus P5B-DLX", AD1988_6STACK_DIG),
ac3e3741 3148 SND_PCI_QUIRK(0x1043, 0x81f6, "Asus M2N-SLI", AD1988_6STACK_DIG),
b9e16bc5 3149 SND_PCI_QUIRK(0x1043, 0x8277, "Asus P5K-E/WIFI-AP", AD1988_6STACK_DIG),
4e60b4f8 3150 SND_PCI_QUIRK(0x1043, 0x82c0, "Asus M3N-HT Deluxe", AD1988_6STACK_DIG),
f51ff993 3151 SND_PCI_QUIRK(0x1043, 0x8311, "Asus P5Q-Premium/Pro", AD1988_6STACK_DIG),
a64c8cd6
TD		 3152 {}
3153};
3154
fd66e0d0
TI		 3155static int patch_ad1988(struct hda_codec *codec)
3156{
3157 struct ad198x_spec *spec;
c5a4bcd0 3158 int err, board_config;
fd66e0d0 3159
f5fcc13c 3160 board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
a64c8cd6 3161 ad1988_models, ad1988_cfg_tbl);
f5fcc13c 3162 if (board_config < 0) {
9a11f1aa
TI		 3163 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3164 codec->chip_name);
d32410b1
TI		 3165 board_config = AD1988_AUTO;
3166 }
3167
9ff4bc8f
TI		 3168 if (board_config == AD1988_AUTO)
3169 return ad1988_parse_auto_config(codec);
3170
3171 err = alloc_ad_spec(codec);
3172 if (err < 0)
3173 return err;
3174 spec = codec->spec;
fd66e0d0 3175
78bb3cb0
TI		 3176 if (is_rev2(codec))
3177 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
3178
c5a4bcd0
TI		 3179 err = snd_hda_attach_beep_device(codec, 0x10);
3180 if (err < 0) {
3181 ad198x_free(codec);
3182 return err;
3183 }
3184 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
3185
356aab7d 3186 if (!spec->multiout.hp_nid)
34588709 3187 spec->multiout.hp_nid = ad1988_alt_dac_nid[0];
fd66e0d0
TI		 3188 switch (board_config) {
3189 case AD1988_6STACK:
3190 case AD1988_6STACK_DIG:
3191 spec->multiout.max_channels = 8;
3192 spec->multiout.num_dacs = 4;
1a806f48 3193 if (is_rev2(codec))
d32410b1
TI		 3194 spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2;
3195 else
3196 spec->multiout.dac_nids = ad1988_6stack_dac_nids;
fd66e0d0 3197 spec->input_mux = &ad1988_6stack_capture_source;
d32410b1 3198 spec->num_mixers = 2;
1a806f48 3199 if (is_rev2(codec))
d32410b1
TI		 3200 spec->mixers[0] = ad1988_6stack_mixers1_rev2;
3201 else
3202 spec->mixers[0] = ad1988_6stack_mixers1;
28220846
RY		 3203 spec->mixers[1] = ad1988_6stack_mixers2;
3204 spec->num_init_verbs = 1;
3205 spec->init_verbs[0] = ad1988_6stack_init_verbs;
34588709 3206 if (board_config == AD1988_6STACK_DIG) {
fd66e0d0
TI		 3207 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3208 spec->dig_in_nid = AD1988_SPDIF_IN;
3209 }
3210 break;
3211 case AD1988_3STACK:
3212 case AD1988_3STACK_DIG:
3213 spec->multiout.max_channels = 6;
3214 spec->multiout.num_dacs = 3;
1a806f48 3215 if (is_rev2(codec))
d32410b1
TI		 3216 spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2;
3217 else
3218 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
fd66e0d0
TI		 3219 spec->input_mux = &ad1988_6stack_capture_source;
3220 spec->channel_mode = ad1988_3stack_modes;
3221 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes);
d32410b1 3222 spec->num_mixers = 2;
1a806f48 3223 if (is_rev2(codec))
d32410b1
TI		 3224 spec->mixers[0] = ad1988_3stack_mixers1_rev2;
3225 else
3226 spec->mixers[0] = ad1988_3stack_mixers1;
3227 spec->mixers[1] = ad1988_3stack_mixers2;
fd66e0d0
TI		 3228 spec->num_init_verbs = 1;
3229 spec->init_verbs[0] = ad1988_3stack_init_verbs;
3230 if (board_config == AD1988_3STACK_DIG)
3231 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3232 break;
3233 case AD1988_LAPTOP:
3234 case AD1988_LAPTOP_DIG:
3235 spec->multiout.max_channels = 2;
3236 spec->multiout.num_dacs = 1;
d32410b1 3237 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
fd66e0d0
TI		 3238 spec->input_mux = &ad1988_laptop_capture_source;
3239 spec->num_mixers = 1;
3240 spec->mixers[0] = ad1988_laptop_mixers;
78bb3cb0 3241 codec->inv_eapd = 1; /* inverted EAPD */
fd66e0d0
TI		 3242 spec->num_init_verbs = 1;
3243 spec->init_verbs[0] = ad1988_laptop_init_verbs;
3244 if (board_config == AD1988_LAPTOP_DIG)
3245 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3246 break;
3247 }
3248
d32410b1
TI		 3249 spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids);
3250 spec->adc_nids = ad1988_adc_nids;
3251 spec->capsrc_nids = ad1988_capsrc_nids;
fd66e0d0
TI		 3252 spec->mixers[spec->num_mixers++] = ad1988_capture_mixers;
3253 spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs;
3254 if (spec->multiout.dig_out_nid) {
3adb8abc
TI		 3255 if (codec->vendor_id >= 0x11d4989a) {
3256 spec->mixers[spec->num_mixers++] =
3257 ad1989_spdif_out_mixers;
3258 spec->init_verbs[spec->num_init_verbs++] =
3259 ad1989_spdif_init_verbs;
9cae0c63 3260 codec->slave_dig_outs = ad1989b_slave_dig_outs;
3adb8abc
TI		 3261 } else {
3262 spec->mixers[spec->num_mixers++] =
3263 ad1988_spdif_out_mixers;
3264 spec->init_verbs[spec->num_init_verbs++] =
3265 ad1988_spdif_init_verbs;
3266 }
fd66e0d0 3267 }
fd0b092a 3268 if (spec->dig_in_nid && codec->vendor_id < 0x11d4989a) {
fd66e0d0 3269 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers;
fd0b092a
JK		 3270 spec->init_verbs[spec->num_init_verbs++] =
3271 ad1988_spdif_in_init_verbs;
3272 }
fd66e0d0
TI		 3273
3274 codec->patch_ops = ad198x_patch_ops;
3275 switch (board_config) {
3276 case AD1988_LAPTOP:
3277 case AD1988_LAPTOP_DIG:
3278 codec->patch_ops.unsol_event = ad1988_laptop_unsol_event;
3279 break;
3280 }
83012a7c 3281#ifdef CONFIG_PM
cb53c626
TI		 3282 spec->loopback.amplist = ad1988_loopbacks;
3283#endif
2134ea4f 3284 spec->vmaster_nid = 0x04;
fd66e0d0 3285
729d55ba 3286 codec->no_trigger_sense = 1;
0e7adbe2 3287 codec->no_sticky_stream = 1;
729d55ba 3288
fd66e0d0
TI		 3289 return 0;
3290}
9ff4bc8f
TI		 3291#else /* ENABLE_AD_STATIC_QUIRKS */
3292#define patch_ad1988 ad1988_parse_auto_config
3293#endif /* ENABLE_AD_STATIC_QUIRKS */
fd66e0d0
TI		 3294
3295
2bac647c
TI		 3296/*
3297 * AD1884 / AD1984
3298 *
3299 * port-B - front line/mic-in
3300 * port-E - aux in/out
3301 * port-F - aux in/out
3302 * port-C - rear line/mic-in
3303 * port-D - rear line/hp-out
3304 * port-A - front line/hp-out
3305 *
3306 * AD1984 = AD1884 + two digital mic-ins
3307 *
3308 * FIXME:
3309 * For simplicity, we share the single DAC for both HP and line-outs
3310 * right now. The inidividual playbacks could be easily implemented,
3311 * but no build-up framework is given, so far.
3312 */
3313
9ff4bc8f 3314#ifdef ENABLE_AD_STATIC_QUIRKS
498f5b17 3315static const hda_nid_t ad1884_dac_nids[1] = {
2bac647c
TI		 3316 0x04,
3317};
3318
498f5b17 3319static const hda_nid_t ad1884_adc_nids[2] = {
2bac647c
TI		 3320 0x08, 0x09,
3321};
3322
498f5b17 3323static const hda_nid_t ad1884_capsrc_nids[2] = {
2bac647c
TI		 3324 0x0c, 0x0d,
3325};
3326
3327#define AD1884_SPDIF_OUT 0x02
3328
498f5b17 3329static const struct hda_input_mux ad1884_capture_source = {
2bac647c
TI		 3330 .num_items = 4,
3331 .items = {
3332 { "Front Mic", 0x0 },
3333 { "Mic", 0x1 },
3334 { "CD", 0x2 },
3335 { "Mix", 0x3 },
3336 },
3337};
3338
498f5b17 3339static const struct snd_kcontrol_new ad1884_base_mixers[] = {
2bac647c
TI		 3340 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3341 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3342 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3343 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3344 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3345 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3346 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3347 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3348 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3349 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3350 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3351 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
5f99f86a
DH		 3352 HDA_CODEC_VOLUME("Mic Boost Volume", 0x15, 0x0, HDA_INPUT),
3353 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
2bac647c
TI		 3354 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3355 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3356 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3357 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3358 {
3359 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3360 /* The multiple "Capture Source" controls confuse alsamixer
3361 * So call somewhat different..
2bac647c
TI		 3362 */
3363 /* .name = "Capture Source", */
3364 .name = "Input Source",
3365 .count = 2,
3366 .info = ad198x_mux_enum_info,
3367 .get = ad198x_mux_enum_get,
3368 .put = ad198x_mux_enum_put,
3369 },
3370 /* SPDIF controls */
3371 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3372 {
3373 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3374 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3375 /* identical with ad1983 */
3376 .info = ad1983_spdif_route_info,
3377 .get = ad1983_spdif_route_get,
3378 .put = ad1983_spdif_route_put,
3379 },
3380 { } /* end */
3381};
3382
498f5b17 3383static const struct snd_kcontrol_new ad1984_dmic_mixers[] = {
2bac647c
TI		 3384 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x05, 0x0, HDA_INPUT),
3385 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x05, 0x0, HDA_INPUT),
3386 HDA_CODEC_VOLUME_IDX("Digital Mic Capture Volume", 1, 0x06, 0x0,
538c49c4 3387 HDA_INPUT),
2bac647c 3388 HDA_CODEC_MUTE_IDX("Digital Mic Capture Switch", 1, 0x06, 0x0,
538c49c4 3389 HDA_INPUT),
2bac647c
TI		 3390 { } /* end */
3391};
3392
3393/*
3394 * initialization verbs
3395 */
498f5b17 3396static const struct hda_verb ad1884_init_verbs[] = {
2bac647c 3397 /* DACs; mute as default */
3b194401
TI		 3398 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3399 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2bac647c
TI		 3400 /* Port-A (HP) mixer */
3401 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3402 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3403 /* Port-A pin */
3404 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3405 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3406 /* HP selector - select DAC2 */
3407 {0x22, AC_VERB_SET_CONNECT_SEL, 0x1},
3408 /* Port-D (Line-out) mixer */
3409 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3410 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3411 /* Port-D pin */
3412 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3413 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3414 /* Mono-out mixer */
3415 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3416 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3417 /* Mono-out pin */
3418 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3419 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3420 /* Mono selector */
3421 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
3422 /* Port-B (front mic) pin */
3423 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
60e388e8 3424 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2bac647c
TI		 3425 /* Port-C (rear mic) pin */
3426 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
60e388e8 3427 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2bac647c
TI		 3428 /* Analog mixer; mute as default */
3429 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3430 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3431 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3432 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3433 /* Analog Mix output amp */
3434 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3435 /* SPDIF output selector */
3436 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
3437 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3438 { } /* end */
3439};
3440
83012a7c 3441#ifdef CONFIG_PM
498f5b17 3442static const struct hda_amp_list ad1884_loopbacks[] = {
cb53c626
TI		 3443 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3444 { 0x20, HDA_INPUT, 1 }, /* Mic */
3445 { 0x20, HDA_INPUT, 2 }, /* CD */
3446 { 0x20, HDA_INPUT, 4 }, /* Docking */
3447 { } /* end */
3448};
3449#endif
3450
ea734963 3451static const char * const ad1884_slave_vols[] = {
9322ca54 3452 "PCM", "Mic", "Mono", "Front Mic", "Mic", "CD",
c40bd914 3453 "Internal Mic", "Dock Mic", /* "Beep", */ "IEC958",
2134ea4f
TI		 3454 NULL
3455};
3456
78bb3cb0
TI		 3457enum {
3458 AD1884_AUTO,
3459 AD1884_BASIC,
3460 AD1884_MODELS
3461};
3462
3463static const char * const ad1884_models[AD1884_MODELS] = {
3464 [AD1884_AUTO] = "auto",
3465 [AD1884_BASIC] = "basic",
3466};
9ff4bc8f 3467#endif /* ENABLE_AD_STATIC_QUIRKS */
78bb3cb0
TI		 3468
3469static int ad1884_parse_auto_config(struct hda_codec *codec)
3470{
9ff4bc8f 3471 struct ad198x_spec *spec;
272f3ea3 3472 int err;
78bb3cb0 3473
9ff4bc8f
TI		 3474 err = alloc_ad_spec(codec);
3475 if (err < 0)
3476 return err;
3477 spec = codec->spec;
3478
f2f8be43 3479 spec->gen.mixer_nid = 0x20;
78bb3cb0
TI		 3480 spec->beep_dev_nid = 0x10;
3481 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
272f3ea3
TI		 3482 err = ad198x_parse_auto_config(codec);
3483 if (err < 0)
9ff4bc8f 3484 goto error;
272f3ea3
TI		 3485 err = ad1983_add_spdif_mux_ctl(codec);
3486 if (err < 0)
9ff4bc8f 3487 goto error;
272f3ea3 3488 return 0;
78bb3cb0 3489
9ff4bc8f
TI		 3490 error:
3491 ad198x_free(codec);
3492 return err;
78bb3cb0
TI		 3493}
3494
9ff4bc8f 3495#ifdef ENABLE_AD_STATIC_QUIRKS
78bb3cb0 3496static int patch_ad1884_basic(struct hda_codec *codec)
2bac647c
TI		 3497{
3498 struct ad198x_spec *spec;
c5a4bcd0 3499 int err;
2bac647c 3500
361dab3e
TI		 3501 err = alloc_ad_spec(codec);
3502 if (err < 0)
3503 return err;
3504 spec = codec->spec;
2bac647c 3505
c5a4bcd0
TI		 3506 err = snd_hda_attach_beep_device(codec, 0x10);
3507 if (err < 0) {
3508 ad198x_free(codec);
3509 return err;
3510 }
3511 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
3512
2bac647c
TI		 3513 spec->multiout.max_channels = 2;
3514 spec->multiout.num_dacs = ARRAY_SIZE(ad1884_dac_nids);
3515 spec->multiout.dac_nids = ad1884_dac_nids;
3516 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3517 spec->num_adc_nids = ARRAY_SIZE(ad1884_adc_nids);
3518 spec->adc_nids = ad1884_adc_nids;
3519 spec->capsrc_nids = ad1884_capsrc_nids;
3520 spec->input_mux = &ad1884_capture_source;
3521 spec->num_mixers = 1;
3522 spec->mixers[0] = ad1884_base_mixers;
3523 spec->num_init_verbs = 1;
3524 spec->init_verbs[0] = ad1884_init_verbs;
3525 spec->spdif_route = 0;
83012a7c 3526#ifdef CONFIG_PM
cb53c626
TI		 3527 spec->loopback.amplist = ad1884_loopbacks;
3528#endif
2134ea4f
TI		 3529 spec->vmaster_nid = 0x04;
3530 /* we need to cover all playback volumes */
3531 spec->slave_vols = ad1884_slave_vols;
18478e8b
TI		 3532 /* slaves may contain input volumes, so we can't raise to 0dB blindly */
3533 spec->avoid_init_slave_vol = 1;
2bac647c
TI		 3534
3535 codec->patch_ops = ad198x_patch_ops;
3536
729d55ba 3537 codec->no_trigger_sense = 1;
0e7adbe2 3538 codec->no_sticky_stream = 1;
729d55ba 3539
2bac647c
TI		 3540 return 0;
3541}
3542
78bb3cb0
TI		 3543static int patch_ad1884(struct hda_codec *codec)
3544{
3545 int board_config;
3546
3547 board_config = snd_hda_check_board_config(codec, AD1884_MODELS,
3548 ad1884_models, NULL);
3549 if (board_config == AD1884_AUTO)
9ff4bc8f 3550 return ad1884_parse_auto_config(codec);
78bb3cb0
TI		 3551 else
3552 return patch_ad1884_basic(codec);
3553}
9ff4bc8f
TI		 3554#else /* ENABLE_AD_STATIC_QUIRKS */
3555#define patch_ad1884 ad1884_parse_auto_config
3556#endif /* ENABLE_AD_STATIC_QUIRKS */
78bb3cb0 3557
9ff4bc8f
TI		 3558
3559#ifdef ENABLE_AD_STATIC_QUIRKS
2bac647c
TI		 3560/*
3561 * Lenovo Thinkpad T61/X61
3562 */
498f5b17 3563static const struct hda_input_mux ad1984_thinkpad_capture_source = {
b26451c0 3564 .num_items = 4,
2bac647c
TI		 3565 .items = {
3566 { "Mic", 0x0 },
3567 { "Internal Mic", 0x1 },
3568 { "Mix", 0x3 },
c40bd914 3569 { "Dock Mic", 0x4 },
2bac647c
TI		 3570 },
3571};
3572
0aaa22e5
DK		 3573
3574/*
3575 * Dell Precision T3400
3576 */
498f5b17 3577static const struct hda_input_mux ad1984_dell_desktop_capture_source = {
0aaa22e5
DK		 3578 .num_items = 3,
3579 .items = {
3580 { "Front Mic", 0x0 },
3581 { "Line-In", 0x1 },
3582 { "Mix", 0x3 },
3583 },
3584};
3585
3586
498f5b17 3587static const struct snd_kcontrol_new ad1984_thinkpad_mixers[] = {
2bac647c
TI		 3588 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3589 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3590 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3591 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3592 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3593 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3594 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3595 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
0bf0e5a6
JK		 3596 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3597 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
c40bd914
DH		 3598 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3599 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
5f99f86a
DH		 3600 HDA_CODEC_VOLUME("Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
3601 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x15, 0x0, HDA_INPUT),
3602 HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x25, 0x0, HDA_OUTPUT),
2bac647c
TI		 3603 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3604 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3605 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3606 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3607 {
3608 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3609 /* The multiple "Capture Source" controls confuse alsamixer
3610 * So call somewhat different..
2bac647c
TI		 3611 */
3612 /* .name = "Capture Source", */
3613 .name = "Input Source",
3614 .count = 2,
3615 .info = ad198x_mux_enum_info,
3616 .get = ad198x_mux_enum_get,
3617 .put = ad198x_mux_enum_put,
3618 },
ebf00c54
JY		 3619 /* SPDIF controls */
3620 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3621 {
3622 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3623 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3624 /* identical with ad1983 */
3625 .info = ad1983_spdif_route_info,
3626 .get = ad1983_spdif_route_get,
3627 .put = ad1983_spdif_route_put,
3628 },
2bac647c
TI		 3629 { } /* end */
3630};
3631
3632/* additional verbs */
498f5b17 3633static const struct hda_verb ad1984_thinkpad_init_verbs[] = {
2bac647c
TI		 3634 /* Port-E (docking station mic) pin */
3635 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3636 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3637 /* docking mic boost */
70040c07 3638 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
0bf0e5a6
JK		 3639 /* Analog PC Beeper - allow firmware/ACPI beeps */
3640 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3) | 0x1a},
2bac647c
TI		 3641 /* Analog mixer - docking mic; mute as default */
3642 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
b959d1f8
TI		 3643 /* enable EAPD bit */
3644 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
2bac647c
TI		 3645 { } /* end */
3646};
3647
0aaa22e5
DK		 3648/*
3649 * Dell Precision T3400
3650 */
498f5b17 3651static const struct snd_kcontrol_new ad1984_dell_desktop_mixers[] = {
0aaa22e5
DK		 3652 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3653 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3654 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3655 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3656 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3657 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3658 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3659 HDA_CODEC_VOLUME("Line-In Playback Volume", 0x20, 0x01, HDA_INPUT),
3660 HDA_CODEC_MUTE("Line-In Playback Switch", 0x20, 0x01, HDA_INPUT),
5f99f86a
DH		 3661 HDA_CODEC_VOLUME("Line-In Boost Volume", 0x15, 0x0, HDA_INPUT),
3662 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
0aaa22e5
DK		 3663 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3664 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3665 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3666 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3667 {
3668 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3669 /* The multiple "Capture Source" controls confuse alsamixer
3670 * So call somewhat different..
3671 */
3672 /* .name = "Capture Source", */
3673 .name = "Input Source",
3674 .count = 2,
3675 .info = ad198x_mux_enum_info,
3676 .get = ad198x_mux_enum_get,
3677 .put = ad198x_mux_enum_put,
3678 },
3679 { } /* end */
3680};
3681
2bac647c
TI		 3682/* Digial MIC ADC NID 0x05 + 0x06 */
3683static int ad1984_pcm_dmic_prepare(struct hda_pcm_stream *hinfo,
3684 struct hda_codec *codec,
3685 unsigned int stream_tag,
3686 unsigned int format,
3687 struct snd_pcm_substream *substream)
3688{
3689 snd_hda_codec_setup_stream(codec, 0x05 + substream->number,
3690 stream_tag, 0, format);
3691 return 0;
3692}
3693
3694static int ad1984_pcm_dmic_cleanup(struct hda_pcm_stream *hinfo,
3695 struct hda_codec *codec,
3696 struct snd_pcm_substream *substream)
3697{
888afa15 3698 snd_hda_codec_cleanup_stream(codec, 0x05 + substream->number);
2bac647c
TI		 3699 return 0;
3700}
3701
498f5b17 3702static const struct hda_pcm_stream ad1984_pcm_dmic_capture = {
2bac647c
TI		 3703 .substreams = 2,
3704 .channels_min = 2,
3705 .channels_max = 2,
3706 .nid = 0x05,
3707 .ops = {
3708 .prepare = ad1984_pcm_dmic_prepare,
3709 .cleanup = ad1984_pcm_dmic_cleanup
3710 },
3711};
3712
3713static int ad1984_build_pcms(struct hda_codec *codec)
3714{
3715 struct ad198x_spec *spec = codec->spec;
3716 struct hda_pcm *info;
3717 int err;
3718
3719 err = ad198x_build_pcms(codec);
3720 if (err < 0)
3721 return err;
3722
3723 info = spec->pcm_rec + codec->num_pcms;
3724 codec->num_pcms++;
3725 info->name = "AD1984 Digital Mic";
3726 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad1984_pcm_dmic_capture;
3727 return 0;
3728}
3729
3730/* models */
3731enum {
78bb3cb0 3732 AD1984_AUTO,
2bac647c
TI		 3733 AD1984_BASIC,
3734 AD1984_THINKPAD,
0aaa22e5 3735 AD1984_DELL_DESKTOP,
2bac647c
TI		 3736 AD1984_MODELS
3737};
3738
ea734963 3739static const char * const ad1984_models[AD1984_MODELS] = {
78bb3cb0 3740 [AD1984_AUTO] = "auto",
2bac647c
TI		 3741 [AD1984_BASIC] = "basic",
3742 [AD1984_THINKPAD] = "thinkpad",
0aaa22e5 3743 [AD1984_DELL_DESKTOP] = "dell_desktop",
2bac647c
TI		 3744};
3745
498f5b17 3746static const struct snd_pci_quirk ad1984_cfg_tbl[] = {
2bac647c 3747 /* Lenovo Thinkpad T61/X61 */
dea0a509 3748 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1984_THINKPAD),
0aaa22e5 3749 SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP),
0f9f1ee9 3750 SND_PCI_QUIRK(0x1028, 0x0233, "Dell Latitude E6400", AD1984_DELL_DESKTOP),
2bac647c
TI		 3751 {}
3752};
3753
3754static int patch_ad1984(struct hda_codec *codec)
3755{
3756 struct ad198x_spec *spec;
3757 int board_config, err;
3758
78bb3cb0
TI		 3759 board_config = snd_hda_check_board_config(codec, AD1984_MODELS,
3760 ad1984_models, ad1984_cfg_tbl);
3761 if (board_config == AD1984_AUTO)
9ff4bc8f 3762 return ad1884_parse_auto_config(codec);
78bb3cb0
TI		 3763
3764 err = patch_ad1884_basic(codec);
2bac647c
TI		 3765 if (err < 0)
3766 return err;
3767 spec = codec->spec;
78bb3cb0 3768
2bac647c
TI		 3769 switch (board_config) {
3770 case AD1984_BASIC:
3771 /* additional digital mics */
3772 spec->mixers[spec->num_mixers++] = ad1984_dmic_mixers;
3773 codec->patch_ops.build_pcms = ad1984_build_pcms;
3774 break;
3775 case AD1984_THINKPAD:
68c18697
JY		 3776 if (codec->subsystem_id == 0x17aa20fb) {
3777 /* Thinpad X300 does not have the ability to do SPDIF,
3778 or attach to docking station to use SPDIF */
3779 spec->multiout.dig_out_nid = 0;
3780 } else
3781 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
2bac647c
TI		 3782 spec->input_mux = &ad1984_thinkpad_capture_source;
3783 spec->mixers[0] = ad1984_thinkpad_mixers;
3784 spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs;
0bf0e5a6 3785 spec->analog_beep = 1;
2bac647c 3786 break;
0aaa22e5
DK		 3787 case AD1984_DELL_DESKTOP:
3788 spec->multiout.dig_out_nid = 0;
3789 spec->input_mux = &ad1984_dell_desktop_capture_source;
3790 spec->mixers[0] = ad1984_dell_desktop_mixers;
3791 break;
2bac647c
TI		 3792 }
3793 return 0;
3794}
9ff4bc8f
TI		 3795#else /* ENABLE_AD_STATIC_QUIRKS */
3796#define patch_ad1984 ad1884_parse_auto_config
3797#endif /* ENABLE_AD_STATIC_QUIRKS */
2bac647c
TI		 3798
3799
c5059259
TI		 3800/*
3801 * AD1883 / AD1884A / AD1984A / AD1984B
3802 *
3803 * port-B (0x14) - front mic-in
3804 * port-E (0x1c) - rear mic-in
3805 * port-F (0x16) - CD / ext out
3806 * port-C (0x15) - rear line-in
3807 * port-D (0x12) - rear line-out
3808 * port-A (0x11) - front hp-out
3809 *
3810 * AD1984A = AD1884A + digital-mic
3811 * AD1883 = equivalent with AD1984A
3812 * AD1984B = AD1984A + extra SPDIF-out
3813 *
3814 * FIXME:
3815 * We share the single DAC for both HP and line-outs (see AD1884/1984).
3816 */
3817
9ff4bc8f 3818#ifdef ENABLE_AD_STATIC_QUIRKS
498f5b17 3819static const hda_nid_t ad1884a_dac_nids[1] = {
c5059259
TI		 3820 0x03,
3821};
3822
3823#define ad1884a_adc_nids ad1884_adc_nids
3824#define ad1884a_capsrc_nids ad1884_capsrc_nids
3825
3826#define AD1884A_SPDIF_OUT 0x02
3827
498f5b17 3828static const struct hda_input_mux ad1884a_capture_source = {
c5059259
TI		 3829 .num_items = 5,
3830 .items = {
3831 { "Front Mic", 0x0 },
3832 { "Mic", 0x4 },
3833 { "Line", 0x1 },
3834 { "CD", 0x2 },
3835 { "Mix", 0x3 },
3836 },
3837};
3838
498f5b17 3839static const struct snd_kcontrol_new ad1884a_base_mixers[] = {
c5059259
TI		 3840 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
3841 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
3842 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3843 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3844 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3845 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3846 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3847 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3848 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3849 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3850 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT),
3851 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
3852 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3853 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3854 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3855 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
5f99f86a
DH		 3856 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
3857 HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x0, HDA_INPUT),
3858 HDA_CODEC_VOLUME("Mic Boost Volume", 0x25, 0x0, HDA_OUTPUT),
c5059259
TI		 3859 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3860 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3861 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3862 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3863 {
3864 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3865 /* The multiple "Capture Source" controls confuse alsamixer
3866 * So call somewhat different..
3867 */
3868 /* .name = "Capture Source", */
3869 .name = "Input Source",
3870 .count = 2,
3871 .info = ad198x_mux_enum_info,
3872 .get = ad198x_mux_enum_get,
3873 .put = ad198x_mux_enum_put,
3874 },
3875 /* SPDIF controls */
3876 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3877 {
3878 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3879 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3880 /* identical with ad1983 */
3881 .info = ad1983_spdif_route_info,
3882 .get = ad1983_spdif_route_get,
3883 .put = ad1983_spdif_route_put,
3884 },
3885 { } /* end */
3886};
3887
3888/*
3889 * initialization verbs
3890 */
498f5b17 3891static const struct hda_verb ad1884a_init_verbs[] = {
c5059259
TI		 3892 /* DACs; unmute as default */
3893 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3894 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
3895 /* Port-A (HP) mixer - route only from analog mixer */
3896 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3897 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3898 /* Port-A pin */
3899 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3900 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3901 /* Port-D (Line-out) mixer - route only from analog mixer */
3902 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3903 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3904 /* Port-D pin */
3905 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3906 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3907 /* Mono-out mixer - route only from analog mixer */
3908 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3909 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3910 /* Mono-out pin */
3911 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3912 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3913 /* Port-B (front mic) pin */
3914 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
60e388e8 3915 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
c5059259
TI		 3916 /* Port-C (rear line-in) pin */
3917 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
60e388e8 3918 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
c5059259
TI		 3919 /* Port-E (rear mic) pin */
3920 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3921 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3922 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* no boost */
3923 /* Port-F (CD) pin */
3924 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3925 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3926 /* Analog mixer; mute as default */
3927 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3928 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3929 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3930 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3931 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, /* aux */
3932 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
3933 /* Analog Mix output amp */
3934 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3935 /* capture sources */
3936 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
3937 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3938 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
3939 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3940 /* SPDIF output amp */
3941 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3942 { } /* end */
3943};
3944
83012a7c 3945#ifdef CONFIG_PM
498f5b17 3946static const struct hda_amp_list ad1884a_loopbacks[] = {
c5059259
TI		 3947 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3948 { 0x20, HDA_INPUT, 1 }, /* Mic */
3949 { 0x20, HDA_INPUT, 2 }, /* CD */
3950 { 0x20, HDA_INPUT, 4 }, /* Docking */
3951 { } /* end */
3952};
3953#endif
3954
3955/*
3956 * Laptop model
3957 *
3958 * Port A: Headphone jack
3959 * Port B: MIC jack
3960 * Port C: Internal MIC
3961 * Port D: Dock Line Out (if enabled)
3962 * Port E: Dock Line In (if enabled)
3963 * Port F: Internal speakers
3964 */
3965
17bbaa6f
TI		 3966static int ad1884a_mobile_master_sw_put(struct snd_kcontrol *kcontrol,
3967 struct snd_ctl_elem_value *ucontrol)
3968{
3969 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3970 int ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3971 int mute = (!ucontrol->value.integer.value[0] &&
3972 !ucontrol->value.integer.value[1]);
3973 /* toggle GPIO1 according to the mute state */
3974 snd_hda_codec_write_cache(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
3975 mute ? 0x02 : 0x0);
3976 return ret;
3977}
c5059259 3978
498f5b17 3979static const struct snd_kcontrol_new ad1884a_laptop_mixers[] = {
c5059259 3980 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
17bbaa6f
TI		 3981 {
3982 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3983 .name = "Master Playback Switch",
5e26dfd0 3984 .subdevice = HDA_SUBDEV_AMP_FLAG,
17bbaa6f
TI		 3985 .info = snd_hda_mixer_amp_switch_info,
3986 .get = snd_hda_mixer_amp_switch_get,
3987 .put = ad1884a_mobile_master_sw_put,
3988 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
3989 },
c5059259
TI		 3990 HDA_CODEC_MUTE("Dock Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3991 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
3992 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
3993 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3994 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3995 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3996 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3997 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3998 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
5f99f86a
DH		 3999 HDA_CODEC_VOLUME("Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
4000 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x15, 0x0, HDA_INPUT),
4001 HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x25, 0x0, HDA_OUTPUT),
c5059259
TI		 4002 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4003 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
c5059259
TI		 4004 { } /* end */
4005};
4006
498f5b17 4007static const struct snd_kcontrol_new ad1884a_mobile_mixers[] = {
b40b04ad 4008 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
099db17e
TI		 4009 /*HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),*/
4010 {
4011 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4012 .name = "Master Playback Switch",
5e26dfd0 4013 .subdevice = HDA_SUBDEV_AMP_FLAG,
099db17e
TI		 4014 .info = snd_hda_mixer_amp_switch_info,
4015 .get = snd_hda_mixer_amp_switch_get,
4016 .put = ad1884a_mobile_master_sw_put,
4017 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
4018 },
b40b04ad
TI		 4019 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4020 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
269ef19c
TI		 4021 HDA_CODEC_VOLUME("Mic Capture Volume", 0x14, 0x0, HDA_INPUT),
4022 HDA_CODEC_VOLUME("Internal Mic Capture Volume", 0x15, 0x0, HDA_INPUT),
b40b04ad
TI		 4023 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4024 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
b40b04ad
TI		 4025 { } /* end */
4026};
4027
c5059259
TI		 4028/* mute internal speaker if HP is plugged */
4029static void ad1884a_hp_automute(struct hda_codec *codec)
4030{
4031 unsigned int present;
4032
d56757ab 4033 present = snd_hda_jack_detect(codec, 0x11);
c5059259
TI		 4034 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
4035 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
4036 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE,
4037 present ? 0x00 : 0x02);
4038}
4039
269ef19c
TI		 4040/* switch to external mic if plugged */
4041static void ad1884a_hp_automic(struct hda_codec *codec)
4042{
4043 unsigned int present;
4044
d56757ab 4045 present = snd_hda_jack_detect(codec, 0x14);
269ef19c
TI		 4046 snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL,
4047 present ? 0 : 1);
4048}
4049
c5059259 4050#define AD1884A_HP_EVENT 0x37
269ef19c 4051#define AD1884A_MIC_EVENT 0x36
c5059259
TI		 4052
4053/* unsolicited event for HP jack sensing */
4054static void ad1884a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4055{
269ef19c
TI		 4056 switch (res >> 26) {
4057 case AD1884A_HP_EVENT:
4058 ad1884a_hp_automute(codec);
4059 break;
4060 case AD1884A_MIC_EVENT:
4061 ad1884a_hp_automic(codec);
4062 break;
4063 }
c5059259
TI		 4064}
4065
4066/* initialize jack-sensing, too */
4067static int ad1884a_hp_init(struct hda_codec *codec)
4068{
4069 ad198x_init(codec);
4070 ad1884a_hp_automute(codec);
269ef19c 4071 ad1884a_hp_automic(codec);
c5059259
TI		 4072 return 0;
4073}
4074
17bbaa6f
TI		 4075/* mute internal speaker if HP or docking HP is plugged */
4076static void ad1884a_laptop_automute(struct hda_codec *codec)
4077{
4078 unsigned int present;
4079
d56757ab
TI		 4080 present = snd_hda_jack_detect(codec, 0x11);
4081 if (!present)
4082 present = snd_hda_jack_detect(codec, 0x12);
17bbaa6f
TI		 4083 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
4084 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
4085 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE,
4086 present ? 0x00 : 0x02);
4087}
4088
4089/* switch to external mic if plugged */
4090static void ad1884a_laptop_automic(struct hda_codec *codec)
4091{
4092 unsigned int idx;
4093
d56757ab 4094 if (snd_hda_jack_detect(codec, 0x14))
17bbaa6f 4095 idx = 0;
d56757ab 4096 else if (snd_hda_jack_detect(codec, 0x1c))
17bbaa6f
TI		 4097 idx = 4;
4098 else
4099 idx = 1;
4100 snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL, idx);
4101}
4102
4103/* unsolicited event for HP jack sensing */
4104static void ad1884a_laptop_unsol_event(struct hda_codec *codec,
4105 unsigned int res)
4106{
4107 switch (res >> 26) {
4108 case AD1884A_HP_EVENT:
4109 ad1884a_laptop_automute(codec);
4110 break;
4111 case AD1884A_MIC_EVENT:
4112 ad1884a_laptop_automic(codec);
4113 break;
4114 }
4115}
4116
4117/* initialize jack-sensing, too */
4118static int ad1884a_laptop_init(struct hda_codec *codec)
4119{
4120 ad198x_init(codec);
4121 ad1884a_laptop_automute(codec);
4122 ad1884a_laptop_automic(codec);
4123 return 0;
4124}
4125
c5059259 4126/* additional verbs for laptop model */
498f5b17 4127static const struct hda_verb ad1884a_laptop_verbs[] = {
c5059259
TI		 4128 /* Port-A (HP) pin - always unmuted */
4129 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4130 /* Port-F (int speaker) mixer - route only from analog mixer */
4131 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4132 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
150fe14c
WF		 4133 /* Port-F (int speaker) pin */
4134 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
c5059259 4135 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
150fe14c
WF		 4136 /* required for compaq 6530s/6531s speaker output */
4137 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
269ef19c
TI		 4138 /* Port-C pin - internal mic-in */
4139 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4140 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4141 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
2ad81ba0
TI		 4142 /* Port-D (docking line-out) pin - default unmuted */
4143 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
c5059259
TI		 4144 /* analog mix */
4145 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4146 /* unsolicited event for pin-sense */
4147 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
17bbaa6f 4148 {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
269ef19c 4149 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
17bbaa6f 4150 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
fe7e5681
TI		 4151 /* allow to touch GPIO1 (for mute control) */
4152 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
4153 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
4154 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
c5059259
TI		 4155 { } /* end */
4156};
4157
498f5b17 4158static const struct hda_verb ad1884a_mobile_verbs[] = {
7315613f
TI		 4159 /* DACs; unmute as default */
4160 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4161 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4162 /* Port-A (HP) mixer - route only from analog mixer */
4163 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4164 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4165 /* Port-A pin */
4166 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4167 /* Port-A (HP) pin - always unmuted */
4168 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4169 /* Port-B (mic jack) pin */
4170 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4171 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4172 /* Port-C (int mic) pin */
4173 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4174 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4175 /* Port-F (int speaker) mixer - route only from analog mixer */
4176 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4177 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4178 /* Port-F pin */
4179 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4180 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4181 /* Analog mixer; mute as default */
4182 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4183 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4184 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4185 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4186 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4187 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4188 /* Analog Mix output amp */
4189 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4190 /* capture sources */
4191 /* {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, */ /* set via unsol */
4192 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4193 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
4194 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4195 /* unsolicited event for pin-sense */
4196 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4197 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
099db17e
TI		 4198 /* allow to touch GPIO1 (for mute control) */
4199 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
4200 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
4201 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
7315613f
TI		 4202 { } /* end */
4203};
4204
f081374b
TI		 4205/*
4206 * Thinkpad X300
4207 * 0x11 - HP
4208 * 0x12 - speaker
4209 * 0x14 - mic-in
4210 * 0x17 - built-in mic
4211 */
4212
498f5b17 4213static const struct hda_verb ad1984a_thinkpad_verbs[] = {
f081374b
TI		 4214 /* HP unmute */
4215 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4216 /* analog mix */
4217 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4218 /* turn on EAPD */
4219 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4220 /* unsolicited event for pin-sense */
4221 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4222 /* internal mic - dmic */
4223 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
05808ecc
TI		 4224 /* set magic COEFs for dmic */
4225 {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7},
4226 {0x01, AC_VERB_SET_PROC_COEF, 0x08},
f081374b
TI		 4227 { } /* end */
4228};
4229
498f5b17 4230static const struct snd_kcontrol_new ad1984a_thinkpad_mixers[] = {
f081374b
TI		 4231 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
4232 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
4233 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4234 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4235 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4236 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
5f99f86a
DH		 4237 HDA_CODEC_VOLUME("Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
4238 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x17, 0x0, HDA_INPUT),
f081374b
TI		 4239 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4240 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4241 {
4242 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4243 .name = "Capture Source",
4244 .info = ad198x_mux_enum_info,
4245 .get = ad198x_mux_enum_get,
4246 .put = ad198x_mux_enum_put,
4247 },
4248 { } /* end */
4249};
4250
498f5b17 4251static const struct hda_input_mux ad1984a_thinkpad_capture_source = {
f081374b
TI		 4252 .num_items = 3,
4253 .items = {
4254 { "Mic", 0x0 },
4255 { "Internal Mic", 0x5 },
4256 { "Mix", 0x3 },
4257 },
4258};
4259
4260/* mute internal speaker if HP is plugged */
4261static void ad1984a_thinkpad_automute(struct hda_codec *codec)
4262{
4263 unsigned int present;
4264
d56757ab 4265 present = snd_hda_jack_detect(codec, 0x11);
f081374b
TI		 4266 snd_hda_codec_amp_stereo(codec, 0x12, HDA_OUTPUT, 0,
4267 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
4268}
4269
4270/* unsolicited event for HP jack sensing */
4271static void ad1984a_thinkpad_unsol_event(struct hda_codec *codec,
4272 unsigned int res)
4273{
4274 if ((res >> 26) != AD1884A_HP_EVENT)
4275 return;
4276 ad1984a_thinkpad_automute(codec);
4277}
4278
4279/* initialize jack-sensing, too */
4280static int ad1984a_thinkpad_init(struct hda_codec *codec)
4281{
4282 ad198x_init(codec);
4283 ad1984a_thinkpad_automute(codec);
4284 return 0;
4285}
4286
677cd904
DH		 4287/*
4288 * Precision R5500
4289 * 0x12 - HP/line-out
4290 * 0x13 - speaker (mono)
4291 * 0x15 - mic-in
4292 */
4293
498f5b17 4294static const struct hda_verb ad1984a_precision_verbs[] = {
677cd904
DH		 4295 /* Unmute main output path */
4296 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4297 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE + 0x1f}, /* 0dB */
4298 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) + 0x17}, /* 0dB */
4299 /* Analog mixer; mute as default */
4300 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4301 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4302 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4303 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4304 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4305 /* Select mic as input */
4306 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
4307 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE + 0x27}, /* 0dB */
4308 /* Configure as mic */
4309 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4310 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */
4311 /* HP unmute */
4312 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4313 /* turn on EAPD */
4314 {0x13, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4315 /* unsolicited event for pin-sense */
4316 {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4317 { } /* end */
4318};
4319
498f5b17 4320static const struct snd_kcontrol_new ad1984a_precision_mixers[] = {
677cd904
DH		 4321 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
4322 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),
4323 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4324 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4325 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
4326 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
4327 HDA_CODEC_VOLUME("Mic Boost Volume", 0x15, 0x0, HDA_INPUT),
4328 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
4329 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x13, 0x0, HDA_OUTPUT),
4330 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4331 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4332 { } /* end */
4333};
4334
4335
4336/* mute internal speaker if HP is plugged */
4337static void ad1984a_precision_automute(struct hda_codec *codec)
4338{
4339 unsigned int present;
4340
4341 present = snd_hda_jack_detect(codec, 0x12);
4342 snd_hda_codec_amp_stereo(codec, 0x13, HDA_OUTPUT, 0,
4343 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
4344}
4345
4346
4347/* unsolicited event for HP jack sensing */
4348static void ad1984a_precision_unsol_event(struct hda_codec *codec,
4349 unsigned int res)
4350{
4351 if ((res >> 26) != AD1884A_HP_EVENT)
4352 return;
4353 ad1984a_precision_automute(codec);
4354}
4355
4356/* initialize jack-sensing, too */
4357static int ad1984a_precision_init(struct hda_codec *codec)
4358{
4359 ad198x_init(codec);
4360 ad1984a_precision_automute(codec);
4361 return 0;
4362}
4363
4364
a72cb4bc
MB		 4365/*
4366 * HP Touchsmart
4367 * port-A (0x11) - front hp-out
4368 * port-B (0x14) - unused
4369 * port-C (0x15) - unused
4370 * port-D (0x12) - rear line out
4371 * port-E (0x1c) - front mic-in
4372 * port-F (0x16) - Internal speakers
4373 * digital-mic (0x17) - Internal mic
4374 */
4375
498f5b17 4376static const struct hda_verb ad1984a_touchsmart_verbs[] = {
a72cb4bc
MB		 4377 /* DACs; unmute as default */
4378 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4379 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */
4380 /* Port-A (HP) mixer - route only from analog mixer */
4381 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4382 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4383 /* Port-A pin */
4384 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4385 /* Port-A (HP) pin - always unmuted */
4386 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4387 /* Port-E (int speaker) mixer - route only from analog mixer */
4388 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, 0x03},
4389 /* Port-E pin */
4390 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4391 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4392 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4393 /* Port-F (int speaker) mixer - route only from analog mixer */
4394 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4395 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4396 /* Port-F pin */
4397 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4398 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4399 /* Analog mixer; mute as default */
4400 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4401 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4402 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4403 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4404 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4405 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4406 /* Analog Mix output amp */
4407 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4408 /* capture sources */
4409 /* {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, */ /* set via unsol */
4410 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4411 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
4412 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4413 /* unsolicited event for pin-sense */
4414 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT},
4415 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT},
4416 /* allow to touch GPIO1 (for mute control) */
4417 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
4418 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
4419 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */
4420 /* internal mic - dmic */
4421 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4422 /* set magic COEFs for dmic */
4423 {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7},
4424 {0x01, AC_VERB_SET_PROC_COEF, 0x08},
4425 { } /* end */
4426};
4427
498f5b17 4428static const struct snd_kcontrol_new ad1984a_touchsmart_mixers[] = {
a72cb4bc
MB		 4429 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT),
4430/* HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),*/
4431 {
4432 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5e26dfd0 4433 .subdevice = HDA_SUBDEV_AMP_FLAG,
a72cb4bc
MB		 4434 .name = "Master Playback Switch",
4435 .info = snd_hda_mixer_amp_switch_info,
4436 .get = snd_hda_mixer_amp_switch_get,
4437 .put = ad1884a_mobile_master_sw_put,
4438 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
4439 },
4440 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT),
4441 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4442 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4443 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
5f99f86a
DH		 4444 HDA_CODEC_VOLUME("Mic Boost Volume", 0x25, 0x0, HDA_OUTPUT),
4445 HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x17, 0x0, HDA_INPUT),
a72cb4bc
MB		 4446 { } /* end */
4447};
4448
4449/* switch to external mic if plugged */
4450static void ad1984a_touchsmart_automic(struct hda_codec *codec)
4451{
d56757ab 4452 if (snd_hda_jack_detect(codec, 0x1c))
a72cb4bc
MB		 4453 snd_hda_codec_write(codec, 0x0c, 0,
4454 AC_VERB_SET_CONNECT_SEL, 0x4);
d56757ab 4455 else
a72cb4bc
MB		 4456 snd_hda_codec_write(codec, 0x0c, 0,
4457 AC_VERB_SET_CONNECT_SEL, 0x5);
a72cb4bc
MB		 4458}
4459
4460
4461/* unsolicited event for HP jack sensing */
4462static void ad1984a_touchsmart_unsol_event(struct hda_codec *codec,
4463 unsigned int res)
4464{
4465 switch (res >> 26) {
4466 case AD1884A_HP_EVENT:
4467 ad1884a_hp_automute(codec);
4468 break;
4469 case AD1884A_MIC_EVENT:
4470 ad1984a_touchsmart_automic(codec);
4471 break;
4472 }
4473}
4474
4475/* initialize jack-sensing, too */
4476static int ad1984a_touchsmart_init(struct hda_codec *codec)
4477{
4478 ad198x_init(codec);
4479 ad1884a_hp_automute(codec);
4480 ad1984a_touchsmart_automic(codec);
4481 return 0;
4482}
4483
4484
c5059259
TI		 4485/*
4486 */
4487
4488enum {
78bb3cb0 4489 AD1884A_AUTO,
c5059259
TI		 4490 AD1884A_DESKTOP,
4491 AD1884A_LAPTOP,
b40b04ad 4492 AD1884A_MOBILE,
f081374b 4493 AD1884A_THINKPAD,
a72cb4bc 4494 AD1984A_TOUCHSMART,
677cd904 4495 AD1984A_PRECISION,
c5059259
TI		 4496 AD1884A_MODELS
4497};
4498
ea734963 4499static const char * const ad1884a_models[AD1884A_MODELS] = {
78bb3cb0 4500 [AD1884A_AUTO] = "auto",
c5059259
TI		 4501 [AD1884A_DESKTOP] = "desktop",
4502 [AD1884A_LAPTOP] = "laptop",
b40b04ad 4503 [AD1884A_MOBILE] = "mobile",
f081374b 4504 [AD1884A_THINKPAD] = "thinkpad",
a72cb4bc 4505 [AD1984A_TOUCHSMART] = "touchsmart",
677cd904 4506 [AD1984A_PRECISION] = "precision",
b40b04ad
TI		 4507};
4508
498f5b17 4509static const struct snd_pci_quirk ad1884a_cfg_tbl[] = {
677cd904 4510 SND_PCI_QUIRK(0x1028, 0x04ac, "Precision R5500", AD1984A_PRECISION),
b40b04ad 4511 SND_PCI_QUIRK(0x103c, 0x3030, "HP", AD1884A_MOBILE),
d5337deb 4512 SND_PCI_QUIRK(0x103c, 0x3037, "HP 2230s", AD1884A_LAPTOP),
5695ff44 4513 SND_PCI_QUIRK(0x103c, 0x3056, "HP", AD1884A_MOBILE),
c2312756 4514 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x3070, "HP", AD1884A_MOBILE),
ff848471 4515 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30d0, "HP laptop", AD1884A_LAPTOP),
873dc78a
TI		 4516 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30e0, "HP laptop", AD1884A_LAPTOP),
4517 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3600, "HP laptop", AD1884A_LAPTOP),
286f5875 4518 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x7010, "HP laptop", AD1884A_MOBILE),
f081374b 4519 SND_PCI_QUIRK(0x17aa, 0x20ac, "Thinkpad X300", AD1884A_THINKPAD),
a72cb4bc 4520 SND_PCI_QUIRK(0x103c, 0x2a82, "Touchsmart", AD1984A_TOUCHSMART),
b40b04ad 4521 {}
c5059259
TI		 4522};
4523
4524static int patch_ad1884a(struct hda_codec *codec)
4525{
4526 struct ad198x_spec *spec;
c5a4bcd0 4527 int err, board_config;
c5059259 4528
78bb3cb0
TI		 4529 board_config = snd_hda_check_board_config(codec, AD1884A_MODELS,
4530 ad1884a_models,
4531 ad1884a_cfg_tbl);
4532 if (board_config == AD1884_AUTO)
9ff4bc8f 4533 return ad1884_parse_auto_config(codec);
78bb3cb0 4534
361dab3e
TI		 4535 err = alloc_ad_spec(codec);
4536 if (err < 0)
4537 return err;
4538 spec = codec->spec;
c5059259 4539
c5a4bcd0
TI		 4540 err = snd_hda_attach_beep_device(codec, 0x10);
4541 if (err < 0) {
4542 ad198x_free(codec);
4543 return err;
4544 }
4545 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
4546
c5059259
TI		 4547 spec->multiout.max_channels = 2;
4548 spec->multiout.num_dacs = ARRAY_SIZE(ad1884a_dac_nids);
4549 spec->multiout.dac_nids = ad1884a_dac_nids;
4550 spec->multiout.dig_out_nid = AD1884A_SPDIF_OUT;
4551 spec->num_adc_nids = ARRAY_SIZE(ad1884a_adc_nids);
4552 spec->adc_nids = ad1884a_adc_nids;
4553 spec->capsrc_nids = ad1884a_capsrc_nids;
4554 spec->input_mux = &ad1884a_capture_source;
4555 spec->num_mixers = 1;
4556 spec->mixers[0] = ad1884a_base_mixers;
4557 spec->num_init_verbs = 1;
4558 spec->init_verbs[0] = ad1884a_init_verbs;
4559 spec->spdif_route = 0;
83012a7c 4560#ifdef CONFIG_PM
c5059259
TI		 4561 spec->loopback.amplist = ad1884a_loopbacks;
4562#endif
4563 codec->patch_ops = ad198x_patch_ops;
4564
4565 /* override some parameters */
c5059259
TI		 4566 switch (board_config) {
4567 case AD1884A_LAPTOP:
4568 spec->mixers[0] = ad1884a_laptop_mixers;
4569 spec->init_verbs[spec->num_init_verbs++] = ad1884a_laptop_verbs;
4570 spec->multiout.dig_out_nid = 0;
17bbaa6f
TI		 4571 codec->patch_ops.unsol_event = ad1884a_laptop_unsol_event;
4572 codec->patch_ops.init = ad1884a_laptop_init;
4dc1f87f
TI		 4573 /* set the upper-limit for mixer amp to 0dB for avoiding the
4574 * possible damage by overloading
4575 */
4576 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4577 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4578 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4579 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4580 (1 << AC_AMPCAP_MUTE_SHIFT));
c5059259 4581 break;
b40b04ad
TI		 4582 case AD1884A_MOBILE:
4583 spec->mixers[0] = ad1884a_mobile_mixers;
7315613f 4584 spec->init_verbs[0] = ad1884a_mobile_verbs;
b40b04ad 4585 spec->multiout.dig_out_nid = 0;
b40b04ad
TI		 4586 codec->patch_ops.unsol_event = ad1884a_hp_unsol_event;
4587 codec->patch_ops.init = ad1884a_hp_init;
13c989be
TI		 4588 /* set the upper-limit for mixer amp to 0dB for avoiding the
4589 * possible damage by overloading
4590 */
4591 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4592 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4593 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4594 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4595 (1 << AC_AMPCAP_MUTE_SHIFT));
b40b04ad 4596 break;
f081374b
TI		 4597 case AD1884A_THINKPAD:
4598 spec->mixers[0] = ad1984a_thinkpad_mixers;
4599 spec->init_verbs[spec->num_init_verbs++] =
4600 ad1984a_thinkpad_verbs;
4601 spec->multiout.dig_out_nid = 0;
4602 spec->input_mux = &ad1984a_thinkpad_capture_source;
4603 codec->patch_ops.unsol_event = ad1984a_thinkpad_unsol_event;
4604 codec->patch_ops.init = ad1984a_thinkpad_init;
4605 break;
677cd904
DH		 4606 case AD1984A_PRECISION:
4607 spec->mixers[0] = ad1984a_precision_mixers;
4608 spec->init_verbs[spec->num_init_verbs++] =
4609 ad1984a_precision_verbs;
4610 spec->multiout.dig_out_nid = 0;
4611 codec->patch_ops.unsol_event = ad1984a_precision_unsol_event;
4612 codec->patch_ops.init = ad1984a_precision_init;
4613 break;
a72cb4bc
MB		 4614 case AD1984A_TOUCHSMART:
4615 spec->mixers[0] = ad1984a_touchsmart_mixers;
4616 spec->init_verbs[0] = ad1984a_touchsmart_verbs;
4617 spec->multiout.dig_out_nid = 0;
4618 codec->patch_ops.unsol_event = ad1984a_touchsmart_unsol_event;
4619 codec->patch_ops.init = ad1984a_touchsmart_init;
4620 /* set the upper-limit for mixer amp to 0dB for avoiding the
4621 * possible damage by overloading
4622 */
4623 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT,
4624 (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4625 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4626 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4627 (1 << AC_AMPCAP_MUTE_SHIFT));
4628 break;
c5059259
TI		 4629 }
4630
729d55ba 4631 codec->no_trigger_sense = 1;
0e7adbe2 4632 codec->no_sticky_stream = 1;
729d55ba 4633
c5059259
TI		 4634 return 0;
4635}
9ff4bc8f
TI		 4636#else /* ENABLE_AD_STATIC_QUIRKS */
4637#define patch_ad1884a ad1884_parse_auto_config
4638#endif /* ENABLE_AD_STATIC_QUIRKS */
c5059259
TI		 4639
4640
0ac8551e 4641/*
9e44c6e4 4642 * AD1882 / AD1882A
0ac8551e
TI		 4643 *
4644 * port-A - front hp-out
4645 * port-B - front mic-in
4646 * port-C - rear line-in, shared surr-out (3stack)
4647 * port-D - rear line-out
4648 * port-E - rear mic-in, shared clfe-out (3stack)
4649 * port-F - rear surr-out (6stack)
4650 * port-G - rear clfe-out (6stack)
4651 */
4652
9ff4bc8f 4653#ifdef ENABLE_AD_STATIC_QUIRKS
498f5b17 4654static const hda_nid_t ad1882_dac_nids[3] = {
0ac8551e
TI		 4655 0x04, 0x03, 0x05
4656};
4657
498f5b17 4658static const hda_nid_t ad1882_adc_nids[2] = {
0ac8551e
TI		 4659 0x08, 0x09,
4660};
4661
498f5b17 4662static const hda_nid_t ad1882_capsrc_nids[2] = {
0ac8551e
TI		 4663 0x0c, 0x0d,
4664};
4665
4666#define AD1882_SPDIF_OUT 0x02
4667
4668/* list: 0x11, 0x39, 0x3a, 0x18, 0x3c, 0x3b, 0x12, 0x20 */
498f5b17 4669static const struct hda_input_mux ad1882_capture_source = {
0ac8551e
TI		 4670 .num_items = 5,
4671 .items = {
4672 { "Front Mic", 0x1 },
4673 { "Mic", 0x4 },
4674 { "Line", 0x2 },
4675 { "CD", 0x3 },
4676 { "Mix", 0x7 },
4677 },
4678};
4679
9e44c6e4 4680/* list: 0x11, 0x39, 0x3a, 0x3c, 0x18, 0x1f, 0x12, 0x20 */
498f5b17 4681static const struct hda_input_mux ad1882a_capture_source = {
9e44c6e4
TI		 4682 .num_items = 5,
4683 .items = {
4684 { "Front Mic", 0x1 },
4685 { "Mic", 0x4},
4686 { "Line", 0x2 },
4687 { "Digital Mic", 0x06 },
4688 { "Mix", 0x7 },
4689 },
4690};
4691
498f5b17 4692static const struct snd_kcontrol_new ad1882_base_mixers[] = {
0ac8551e
TI		 4693 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
4694 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
4695 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
4696 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
4697 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
4698 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
4699 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
4700 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
9e44c6e4 4701
5f99f86a
DH		 4702 HDA_CODEC_VOLUME("Mic Boost Volume", 0x3c, 0x0, HDA_OUTPUT),
4703 HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x39, 0x0, HDA_OUTPUT),
4704 HDA_CODEC_VOLUME("Line-In Boost Volume", 0x3a, 0x0, HDA_OUTPUT),
0ac8551e
TI		 4705 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4706 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4707 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
4708 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
4709 {
4710 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4711 /* The multiple "Capture Source" controls confuse alsamixer
4712 * So call somewhat different..
0ac8551e
TI		 4713 */
4714 /* .name = "Capture Source", */
4715 .name = "Input Source",
4716 .count = 2,
4717 .info = ad198x_mux_enum_info,
4718 .get = ad198x_mux_enum_get,
4719 .put = ad198x_mux_enum_put,
4720 },
4721 /* SPDIF controls */
4722 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
4723 {
4724 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4725 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
4726 /* identical with ad1983 */
4727 .info = ad1983_spdif_route_info,
4728 .get = ad1983_spdif_route_get,
4729 .put = ad1983_spdif_route_put,
4730 },
4731 { } /* end */
4732};
4733
498f5b17 4734static const struct snd_kcontrol_new ad1882_loopback_mixers[] = {
9e44c6e4
TI		 4735 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4736 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4737 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
4738 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
4739 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x04, HDA_INPUT),
4740 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x04, HDA_INPUT),
4741 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
4742 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
9e44c6e4
TI		 4743 { } /* end */
4744};
4745
498f5b17 4746static const struct snd_kcontrol_new ad1882a_loopback_mixers[] = {
9e44c6e4
TI		 4747 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4748 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4749 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
4750 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
4751 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT),
4752 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
4753 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
4754 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
5f99f86a 4755 HDA_CODEC_VOLUME("Digital Mic Boost Volume", 0x1f, 0x0, HDA_INPUT),
9e44c6e4
TI		 4756 { } /* end */
4757};
4758
498f5b17 4759static const struct snd_kcontrol_new ad1882_3stack_mixers[] = {
0ac8551e
TI		 4760 HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4761 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x17, 1, 0x0, HDA_OUTPUT),
4762 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x17, 2, 0x0, HDA_OUTPUT),
4763 {
4764 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4765 .name = "Channel Mode",
4766 .info = ad198x_ch_mode_info,
4767 .get = ad198x_ch_mode_get,
4768 .put = ad198x_ch_mode_put,
4769 },
4770 { } /* end */
4771};
4772
1c868452
TI		 4773/* simple auto-mute control for AD1882 3-stack board */
4774#define AD1882_HP_EVENT 0x01
4775
4776static void ad1882_3stack_automute(struct hda_codec *codec)
4777{
4778 bool mute = snd_hda_jack_detect(codec, 0x11);
4779 snd_hda_codec_write(codec, 0x12, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4780 mute ? 0 : PIN_OUT);
4781}
4782
4783static int ad1882_3stack_automute_init(struct hda_codec *codec)
4784{
4785 ad198x_init(codec);
4786 ad1882_3stack_automute(codec);
4787 return 0;
4788}
4789
4790static void ad1882_3stack_unsol_event(struct hda_codec *codec, unsigned int res)
4791{
4792 switch (res >> 26) {
4793 case AD1882_HP_EVENT:
4794 ad1882_3stack_automute(codec);
4795 break;
4796 }
4797}
4798
498f5b17 4799static const struct snd_kcontrol_new ad1882_6stack_mixers[] = {
0ac8551e
TI		 4800 HDA_CODEC_MUTE("Surround Playback Switch", 0x16, 0x0, HDA_OUTPUT),
4801 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x24, 1, 0x0, HDA_OUTPUT),
4802 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x24, 2, 0x0, HDA_OUTPUT),
4803 { } /* end */
4804};
4805
498f5b17 4806static const struct hda_verb ad1882_ch2_init[] = {
0ac8551e
TI		 4807 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4808 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4809 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4810 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4811 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4812 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4813 { } /* end */
4814};
4815
498f5b17 4816static const struct hda_verb ad1882_ch4_init[] = {
0ac8551e
TI		 4817 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4818 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4819 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4820 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4821 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4822 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4823 { } /* end */
4824};
4825
498f5b17 4826static const struct hda_verb ad1882_ch6_init[] = {
0ac8551e
TI		 4827 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4828 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4829 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4830 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4831 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4832 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4833 { } /* end */
4834};
4835
498f5b17 4836static const struct hda_channel_mode ad1882_modes[3] = {
0ac8551e
TI		 4837 { 2, ad1882_ch2_init },
4838 { 4, ad1882_ch4_init },
4839 { 6, ad1882_ch6_init },
4840};
4841
4842/*
4843 * initialization verbs
4844 */
498f5b17 4845static const struct hda_verb ad1882_init_verbs[] = {
0ac8551e
TI		 4846 /* DACs; mute as default */
4847 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4848 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4849 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4850 /* Port-A (HP) mixer */
4851 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4852 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4853 /* Port-A pin */
4854 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4855 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4856 /* HP selector - select DAC2 */
4857 {0x37, AC_VERB_SET_CONNECT_SEL, 0x1},
4858 /* Port-D (Line-out) mixer */
4859 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4860 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4861 /* Port-D pin */
4862 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4863 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4864 /* Mono-out mixer */
4865 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4866 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4867 /* Mono-out pin */
4868 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4869 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4870 /* Port-B (front mic) pin */
4871 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4872 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4873 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4874 /* Port-C (line-in) pin */
4875 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4876 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4877 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4878 /* Port-C mixer - mute as input */
4879 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4880 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4881 /* Port-E (mic-in) pin */
4882 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4883 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4884 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
4885 /* Port-E mixer - mute as input */
4886 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4887 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4888 /* Port-F (surround) */
4889 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4890 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4891 /* Port-G (CLFE) */
4892 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4893 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4894 /* Analog mixer; mute as default */
4895 /* list: 0x39, 0x3a, 0x11, 0x12, 0x3c, 0x3b, 0x18, 0x1a */
4896 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4897 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4898 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4899 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4900 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4901 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4902 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
4903 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
4904 /* Analog Mix output amp */
4905 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
4906 /* SPDIF output selector */
4907 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
4908 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
4909 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
4910 { } /* end */
4911};
4912
1c868452
TI		 4913static const struct hda_verb ad1882_3stack_automute_verbs[] = {
4914 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1882_HP_EVENT},
4915 { } /* end */
4916};
4917
83012a7c 4918#ifdef CONFIG_PM
498f5b17 4919static const struct hda_amp_list ad1882_loopbacks[] = {
cb53c626
TI		 4920 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
4921 { 0x20, HDA_INPUT, 1 }, /* Mic */
4922 { 0x20, HDA_INPUT, 4 }, /* Line */
4923 { 0x20, HDA_INPUT, 6 }, /* CD */
4924 { } /* end */
4925};
4926#endif
4927
0ac8551e
TI		 4928/* models */
4929enum {
78bb3cb0 4930 AD1882_AUTO,
0ac8551e
TI		 4931 AD1882_3STACK,
4932 AD1882_6STACK,
1c868452 4933 AD1882_3STACK_AUTOMUTE,
0ac8551e
TI		 4934 AD1882_MODELS
4935};
4936
ea734963 4937static const char * const ad1882_models[AD1986A_MODELS] = {
78bb3cb0 4938 [AD1882_AUTO] = "auto",
0ac8551e
TI		 4939 [AD1882_3STACK] = "3stack",
4940 [AD1882_6STACK] = "6stack",
1c868452 4941 [AD1882_3STACK_AUTOMUTE] = "3stack-automute",
0ac8551e 4942};
9ff4bc8f 4943#endif /* ENABLE_AD_STATIC_QUIRKS */
0ac8551e 4944
78bb3cb0
TI		 4945static int ad1882_parse_auto_config(struct hda_codec *codec)
4946{
9ff4bc8f 4947 struct ad198x_spec *spec;
272f3ea3 4948 int err;
78bb3cb0 4949
9ff4bc8f
TI		 4950 err = alloc_ad_spec(codec);
4951 if (err < 0)
4952 return err;
4953 spec = codec->spec;
4954
f2f8be43 4955 spec->gen.mixer_nid = 0x20;
78bb3cb0
TI		 4956 spec->beep_dev_nid = 0x10;
4957 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
272f3ea3
TI		 4958 err = ad198x_parse_auto_config(codec);
4959 if (err < 0)
9ff4bc8f 4960 goto error;
272f3ea3
TI		 4961 err = ad1988_add_spdif_mux_ctl(codec);
4962 if (err < 0)
9ff4bc8f 4963 goto error;
272f3ea3 4964 return 0;
9ff4bc8f
TI		 4965
4966 error:
4967 ad198x_free(codec);
4968 return err;
78bb3cb0 4969}
0ac8551e 4970
9ff4bc8f 4971#ifdef ENABLE_AD_STATIC_QUIRKS
0ac8551e
TI		 4972static int patch_ad1882(struct hda_codec *codec)
4973{
4974 struct ad198x_spec *spec;
c5a4bcd0 4975 int err, board_config;
0ac8551e 4976
9ff4bc8f
TI		 4977 board_config = snd_hda_check_board_config(codec, AD1882_MODELS,
4978 ad1882_models, NULL);
4979 if (board_config == AD1882_AUTO)
4980 return ad1882_parse_auto_config(codec);
4981
361dab3e
TI		 4982 err = alloc_ad_spec(codec);
4983 if (err < 0)
4984 return err;
4985 spec = codec->spec;
0ac8551e 4986
c5a4bcd0
TI		 4987 err = snd_hda_attach_beep_device(codec, 0x10);
4988 if (err < 0) {
4989 ad198x_free(codec);
4990 return err;
4991 }
4992 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT);
4993
0ac8551e
TI		 4994 spec->multiout.max_channels = 6;
4995 spec->multiout.num_dacs = 3;
4996 spec->multiout.dac_nids = ad1882_dac_nids;
4997 spec->multiout.dig_out_nid = AD1882_SPDIF_OUT;
4998 spec->num_adc_nids = ARRAY_SIZE(ad1882_adc_nids);
4999 spec->adc_nids = ad1882_adc_nids;
5000 spec->capsrc_nids = ad1882_capsrc_nids;
c247ed6f 5001 if (codec->vendor_id == 0x11d41882)
9e44c6e4
TI		 5002 spec->input_mux = &ad1882_capture_source;
5003 else
5004 spec->input_mux = &ad1882a_capture_source;
5005 spec->num_mixers = 2;
0ac8551e 5006 spec->mixers[0] = ad1882_base_mixers;
c247ed6f 5007 if (codec->vendor_id == 0x11d41882)
9e44c6e4
TI		 5008 spec->mixers[1] = ad1882_loopback_mixers;
5009 else
5010 spec->mixers[1] = ad1882a_loopback_mixers;
0ac8551e
TI		 5011 spec->num_init_verbs = 1;
5012 spec->init_verbs[0] = ad1882_init_verbs;
5013 spec->spdif_route = 0;
83012a7c 5014#ifdef CONFIG_PM
cb53c626
TI		 5015 spec->loopback.amplist = ad1882_loopbacks;
5016#endif
2134ea4f 5017 spec->vmaster_nid = 0x04;
0ac8551e
TI		 5018
5019 codec->patch_ops = ad198x_patch_ops;
5020
5021 /* override some parameters */
0ac8551e
TI		 5022 switch (board_config) {
5023 default:
5024 case AD1882_3STACK:
1c868452 5025 case AD1882_3STACK_AUTOMUTE:
9e44c6e4
TI		 5026 spec->num_mixers = 3;
5027 spec->mixers[2] = ad1882_3stack_mixers;
0ac8551e
TI		 5028 spec->channel_mode = ad1882_modes;
5029 spec->num_channel_mode = ARRAY_SIZE(ad1882_modes);
5030 spec->need_dac_fix = 1;
5031 spec->multiout.max_channels = 2;
5032 spec->multiout.num_dacs = 1;
1c868452
TI		 5033 if (board_config != AD1882_3STACK) {
5034 spec->init_verbs[spec->num_init_verbs++] =
5035 ad1882_3stack_automute_verbs;
5036 codec->patch_ops.unsol_event = ad1882_3stack_unsol_event;
5037 codec->patch_ops.init = ad1882_3stack_automute_init;
5038 }
0ac8551e
TI		 5039 break;
5040 case AD1882_6STACK:
9e44c6e4
TI		 5041 spec->num_mixers = 3;
5042 spec->mixers[2] = ad1882_6stack_mixers;
0ac8551e
TI		 5043 break;
5044 }
729d55ba
TI		 5045
5046 codec->no_trigger_sense = 1;
0e7adbe2 5047 codec->no_sticky_stream = 1;
729d55ba 5048
0ac8551e
TI		 5049 return 0;
5050}
9ff4bc8f
TI		 5051#else /* ENABLE_AD_STATIC_QUIRKS */
5052#define patch_ad1882 ad1882_parse_auto_config
5053#endif /* ENABLE_AD_STATIC_QUIRKS */
0ac8551e
TI		 5054
5055
1da177e4
LT		 5056/*
5057 * patch entries
5058 */
498f5b17 5059static const struct hda_codec_preset snd_hda_preset_analog[] = {
c5059259 5060 { .id = 0x11d4184a, .name = "AD1884A", .patch = patch_ad1884a },
0ac8551e 5061 { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 },
c5059259 5062 { .id = 0x11d41883, .name = "AD1883", .patch = patch_ad1884a },
2bac647c 5063 { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 },
c5059259
TI		 5064 { .id = 0x11d4194a, .name = "AD1984A", .patch = patch_ad1884a },
5065 { .id = 0x11d4194b, .name = "AD1984B", .patch = patch_ad1884a },
4a3fdf3d
TI		 5066 { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 },
5067 { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 },
2bac647c 5068 { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1984 },
1da177e4 5069 { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a },
fd66e0d0 5070 { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 },
71b2ccc3 5071 { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 },
9e44c6e4 5072 { .id = 0x11d4882a, .name = "AD1882A", .patch = patch_ad1882 },
3adb8abc
TI		 5073 { .id = 0x11d4989a, .name = "AD1989A", .patch = patch_ad1988 },
5074 { .id = 0x11d4989b, .name = "AD1989B", .patch = patch_ad1988 },
1da177e4
LT		 5075 {} /* terminator */
5076};
1289e9e8
TI		 5077
5078MODULE_ALIAS("snd-hda-codec-id:11d4*");
5079
5080MODULE_LICENSE("GPL");
5081MODULE_DESCRIPTION("Analog Devices HD-audio codec");
5082
5083static struct hda_codec_preset_list analog_list = {
5084 .preset = snd_hda_preset_analog,
5085 .owner = THIS_MODULE,
5086};
5087
5088static int __init patch_analog_init(void)
5089{
5090 return snd_hda_add_codec_preset(&analog_list);
5091}
5092
5093static void __exit patch_analog_exit(void)
5094{
5095 snd_hda_delete_codec_preset(&analog_list);
5096}
5097
5098module_init(patch_analog_init)
5099module_exit(patch_analog_exit)
Linux kernel - Deliverables
This page took 0.8804 seconds and 5 git commands to generate.