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