projects / deliverable / linux.git / blob
? search:


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