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