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