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