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