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