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