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