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