?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.25.20
[linux/fpc-iii.git] / sound / pci / hda / patch_analog.c
blobd7cba536d30574f6dd5e5b39ff89f0c7f9875aaf
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 SND_PCI_QUIRK(0x1014, 0x05b7, "Lenovo Z60m", AD1981_THINKPAD),
1567 /* All HP models */
1568 SND_PCI_QUIRK(0x103c, 0, "HP nx", AD1981_HP),
1569 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA),
1570 /* Lenovo Thinkpad T60/X60/Z6xx */
1571 SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1981_THINKPAD),
1572 /* HP nx6320 (reversed SSID, H/W bug) */
1573 SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP),
1574 {}
1575 };
1576
1577 static int patch_ad1981(struct hda_codec *codec)
1578 {
1579 struct ad198x_spec *spec;
1580 int board_config;
1581
1582 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1583 if (spec == NULL)
1584 return -ENOMEM;
1585
1586 codec->spec = spec;
1587
1588 spec->multiout.max_channels = 2;
1589 spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
1590 spec->multiout.dac_nids = ad1981_dac_nids;
1591 spec->multiout.dig_out_nid = AD1981_SPDIF_OUT;
1592 spec->num_adc_nids = 1;
1593 spec->adc_nids = ad1981_adc_nids;
1594 spec->capsrc_nids = ad1981_capsrc_nids;
1595 spec->input_mux = &ad1981_capture_source;
1596 spec->num_mixers = 1;
1597 spec->mixers[0] = ad1981_mixers;
1598 spec->num_init_verbs = 1;
1599 spec->init_verbs[0] = ad1981_init_verbs;
1600 spec->spdif_route = 0;
1601 #ifdef CONFIG_SND_HDA_POWER_SAVE
1602 spec->loopback.amplist = ad1981_loopbacks;
1603 #endif
1604 spec->vmaster_nid = 0x05;
1605
1606 codec->patch_ops = ad198x_patch_ops;
1607
1608 /* override some parameters */
1609 board_config = snd_hda_check_board_config(codec, AD1981_MODELS,
1610 ad1981_models,
1611 ad1981_cfg_tbl);
1612 switch (board_config) {
1613 case AD1981_HP:
1614 spec->mixers[0] = ad1981_hp_mixers;
1615 spec->num_init_verbs = 2;
1616 spec->init_verbs[1] = ad1981_hp_init_verbs;
1617 spec->multiout.dig_out_nid = 0;
1618 spec->input_mux = &ad1981_hp_capture_source;
1619
1620 codec->patch_ops.init = ad1981_hp_init;
1621 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1622 break;
1623 case AD1981_THINKPAD:
1624 spec->mixers[0] = ad1981_thinkpad_mixers;
1625 spec->input_mux = &ad1981_thinkpad_capture_source;
1626 break;
1627 case AD1981_TOSHIBA:
1628 spec->mixers[0] = ad1981_hp_mixers;
1629 spec->mixers[1] = ad1981_toshiba_mixers;
1630 spec->num_init_verbs = 2;
1631 spec->init_verbs[1] = ad1981_toshiba_init_verbs;
1632 spec->multiout.dig_out_nid = 0;
1633 spec->input_mux = &ad1981_hp_capture_source;
1634 codec->patch_ops.init = ad1981_hp_init;
1635 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1636 break;
1637 }
1638 return 0;
1639 }
1640
1641
1642 /*
1643 * AD1988
1644 *
1645 * Output pins and routes
1646 *
1647 * Pin Mix Sel DAC (*)
1648 * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
1649 * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
1650 * port-C 0x15 (mute) <- 0x2c <- 0x31 <- 05/0a
1651 * port-D 0x12 (mute/hp) <- 0x29 <- 04
1652 * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
1653 * port-F 0x16 (mute) <- 0x2a <- 06
1654 * port-G 0x24 (mute) <- 0x27 <- 05
1655 * port-H 0x25 (mute) <- 0x28 <- 0a
1656 * mono 0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
1657 *
1658 * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
1659 * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.
1660 *
1661 * Input pins and routes
1662 *
1663 * pin boost mix input # / adc input #
1664 * port-A 0x11 -> 0x38 -> mix 2, ADC 0
1665 * port-B 0x14 -> 0x39 -> mix 0, ADC 1
1666 * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
1667 * port-D 0x12 -> 0x3d -> mix 3, ADC 8
1668 * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
1669 * port-F 0x16 -> 0x3b -> mix 5, ADC 3
1670 * port-G 0x24 -> N/A -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
1671 * port-H 0x25 -> N/A -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
1672 *
1673 *
1674 * DAC assignment
1675 * 6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03
1676 * 3stack - front/surr/CLFE/opt DACs - 04/05/0a/03
1677 *
1678 * Inputs of Analog Mix (0x20)
1679 * 0:Port-B (front mic)
1680 * 1:Port-C/G/H (line-in)
1681 * 2:Port-A
1682 * 3:Port-D (line-in/2)
1683 * 4:Port-E/G/H (mic-in)
1684 * 5:Port-F (mic2-in)
1685 * 6:CD
1686 * 7:Beep
1687 *
1688 * ADC selection
1689 * 0:Port-A
1690 * 1:Port-B (front mic-in)
1691 * 2:Port-C (line-in)
1692 * 3:Port-F (mic2-in)
1693 * 4:Port-E (mic-in)
1694 * 5:CD
1695 * 6:Port-G
1696 * 7:Port-H
1697 * 8:Port-D (line-in/2)
1698 * 9:Mix
1699 *
1700 * Proposed pin assignments by the datasheet
1701 *
1702 * 6-stack
1703 * Port-A front headphone
1704 * B front mic-in
1705 * C rear line-in
1706 * D rear front-out
1707 * E rear mic-in
1708 * F rear surround
1709 * G rear CLFE
1710 * H rear side
1711 *
1712 * 3-stack
1713 * Port-A front headphone
1714 * B front mic
1715 * C rear line-in/surround
1716 * D rear front-out
1717 * E rear mic-in/CLFE
1718 *
1719 * laptop
1720 * Port-A headphone
1721 * B mic-in
1722 * C docking station
1723 * D internal speaker (with EAPD)
1724 * E/F quad mic array
1725 */
1726
1727
1728 /* models */
1729 enum {
1730 AD1988_6STACK,
1731 AD1988_6STACK_DIG,
1732 AD1988_3STACK,
1733 AD1988_3STACK_DIG,
1734 AD1988_LAPTOP,
1735 AD1988_LAPTOP_DIG,
1736 AD1988_AUTO,
1737 AD1988_MODEL_LAST,
1738 };
1739
1740 /* reivision id to check workarounds */
1741 #define AD1988A_REV2 0x100200
1742
1743 #define is_rev2(codec) \
1744 ((codec)->vendor_id == 0x11d41988 && \
1745 (codec)->revision_id == AD1988A_REV2)
1746
1747 /*
1748 * mixers
1749 */
1750
1751 static hda_nid_t ad1988_6stack_dac_nids[4] = {
1752 0x04, 0x06, 0x05, 0x0a
1753 };
1754
1755 static hda_nid_t ad1988_3stack_dac_nids[3] = {
1756 0x04, 0x05, 0x0a
1757 };
1758
1759 /* for AD1988A revision-2, DAC2-4 are swapped */
1760 static hda_nid_t ad1988_6stack_dac_nids_rev2[4] = {
1761 0x04, 0x05, 0x0a, 0x06
1762 };
1763
1764 static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {
1765 0x04, 0x0a, 0x06
1766 };
1767
1768 static hda_nid_t ad1988_adc_nids[3] = {
1769 0x08, 0x09, 0x0f
1770 };
1771
1772 static hda_nid_t ad1988_capsrc_nids[3] = {
1773 0x0c, 0x0d, 0x0e
1774 };
1775
1776 #define AD1988_SPDIF_OUT 0x02
1777 #define AD1988_SPDIF_IN 0x07
1778
1779 static struct hda_input_mux ad1988_6stack_capture_source = {
1780 .num_items = 5,
1781 .items = {
1782 { "Front Mic", 0x1 }, /* port-B */
1783 { "Line", 0x2 }, /* port-C */
1784 { "Mic", 0x4 }, /* port-E */
1785 { "CD", 0x5 },
1786 { "Mix", 0x9 },
1787 },
1788 };
1789
1790 static struct hda_input_mux ad1988_laptop_capture_source = {
1791 .num_items = 3,
1792 .items = {
1793 { "Mic/Line", 0x1 }, /* port-B */
1794 { "CD", 0x5 },
1795 { "Mix", 0x9 },
1796 },
1797 };
1798
1799 /*
1800 */
1801 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
1802 struct snd_ctl_elem_info *uinfo)
1803 {
1804 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1805 struct ad198x_spec *spec = codec->spec;
1806 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
1807 spec->num_channel_mode);
1808 }
1809
1810 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
1811 struct snd_ctl_elem_value *ucontrol)
1812 {
1813 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1814 struct ad198x_spec *spec = codec->spec;
1815 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
1816 spec->num_channel_mode, spec->multiout.max_channels);
1817 }
1818
1819 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
1820 struct snd_ctl_elem_value *ucontrol)
1821 {
1822 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1823 struct ad198x_spec *spec = codec->spec;
1824 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
1825 spec->num_channel_mode,
1826 &spec->multiout.max_channels);
1827 if (err >= 0 && spec->need_dac_fix)
1828 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
1829 return err;
1830 }
1831
1832 /* 6-stack mode */
1833 static struct snd_kcontrol_new ad1988_6stack_mixers1[] = {
1834 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1835 HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1836 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
1837 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
1838 HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1839 { } /* end */
1840 };
1841
1842 static struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = {
1843 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1844 HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1845 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
1846 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT),
1847 HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1848 { } /* end */
1849 };
1850
1851 static struct snd_kcontrol_new ad1988_6stack_mixers2[] = {
1852 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
1853 HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT),
1854 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT),
1855 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT),
1856 HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT),
1857 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
1858 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1859
1860 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1861 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1862 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1863 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1864 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1865 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
1866 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
1867 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
1868
1869 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
1870 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
1871
1872 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
1873 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
1874
1875 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
1876 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
1877
1878 { } /* end */
1879 };
1880
1881 /* 3-stack mode */
1882 static struct snd_kcontrol_new ad1988_3stack_mixers1[] = {
1883 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1884 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1885 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
1886 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
1887 { } /* end */
1888 };
1889
1890 static struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = {
1891 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1892 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1893 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT),
1894 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT),
1895 { } /* end */
1896 };
1897
1898 static struct snd_kcontrol_new ad1988_3stack_mixers2[] = {
1899 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
1900 HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT),
1901 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT),
1902 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT),
1903 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
1904 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1905
1906 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1907 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1908 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1909 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1910 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1911 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
1912 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
1913 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
1914
1915 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
1916 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
1917
1918 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
1919 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
1920
1921 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
1922 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
1923 {
1924 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1925 .name = "Channel Mode",
1926 .info = ad198x_ch_mode_info,
1927 .get = ad198x_ch_mode_get,
1928 .put = ad198x_ch_mode_put,
1929 },
1930
1931 { } /* end */
1932 };
1933
1934 /* laptop mode */
1935 static struct snd_kcontrol_new ad1988_laptop_mixers[] = {
1936 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1937 HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT),
1938 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1939
1940 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1941 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1942 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1943 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1944 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1945 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
1946
1947 HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
1948 HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
1949
1950 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
1951 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
1952
1953 HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT),
1954
1955 {
1956 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1957 .name = "External Amplifier",
1958 .info = ad198x_eapd_info,
1959 .get = ad198x_eapd_get,
1960 .put = ad198x_eapd_put,
1961 .private_value = 0x12 | (1 << 8), /* port-D, inversed */
1962 },
1963
1964 { } /* end */
1965 };
1966
1967 /* capture */
1968 static struct snd_kcontrol_new ad1988_capture_mixers[] = {
1969 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
1970 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
1971 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
1972 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
1973 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT),
1974 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT),
1975 {
1976 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1977 /* The multiple "Capture Source" controls confuse alsamixer
1978 * So call somewhat different..
1979 */
1980 /* .name = "Capture Source", */
1981 .name = "Input Source",
1982 .count = 3,
1983 .info = ad198x_mux_enum_info,
1984 .get = ad198x_mux_enum_get,
1985 .put = ad198x_mux_enum_put,
1986 },
1987 { } /* end */
1988 };
1989
1990 static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol,
1991 struct snd_ctl_elem_info *uinfo)
1992 {
1993 static char *texts[] = {
1994 "PCM", "ADC1", "ADC2", "ADC3"
1995 };
1996 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1997 uinfo->count = 1;
1998 uinfo->value.enumerated.items = 4;
1999 if (uinfo->value.enumerated.item >= 4)
2000 uinfo->value.enumerated.item = 3;
2001 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2002 return 0;
2003 }
2004
2005 static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol,
2006 struct snd_ctl_elem_value *ucontrol)
2007 {
2008 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2009 unsigned int sel;
2010
2011 sel = snd_hda_codec_read(codec, 0x1d, 0, AC_VERB_GET_AMP_GAIN_MUTE,
2012 AC_AMP_GET_INPUT);
2013 if (!(sel & 0x80))
2014 ucontrol->value.enumerated.item[0] = 0;
2015 else {
2016 sel = snd_hda_codec_read(codec, 0x0b, 0,
2017 AC_VERB_GET_CONNECT_SEL, 0);
2018 if (sel < 3)
2019 sel++;
2020 else
2021 sel = 0;
2022 ucontrol->value.enumerated.item[0] = sel;
2023 }
2024 return 0;
2025 }
2026
2027 static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol,
2028 struct snd_ctl_elem_value *ucontrol)
2029 {
2030 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2031 unsigned int val, sel;
2032 int change;
2033
2034 val = ucontrol->value.enumerated.item[0];
2035 if (val > 3)
2036 return -EINVAL;
2037 if (!val) {
2038 sel = snd_hda_codec_read(codec, 0x1d, 0,
2039 AC_VERB_GET_AMP_GAIN_MUTE,
2040 AC_AMP_GET_INPUT);
2041 change = sel & 0x80;
2042 if (change) {
2043 snd_hda_codec_write_cache(codec, 0x1d, 0,
2044 AC_VERB_SET_AMP_GAIN_MUTE,
2045 AMP_IN_UNMUTE(0));
2046 snd_hda_codec_write_cache(codec, 0x1d, 0,
2047 AC_VERB_SET_AMP_GAIN_MUTE,
2048 AMP_IN_MUTE(1));
2049 }
2050 } else {
2051 sel = snd_hda_codec_read(codec, 0x1d, 0,
2052 AC_VERB_GET_AMP_GAIN_MUTE,
2053 AC_AMP_GET_INPUT | 0x01);
2054 change = sel & 0x80;
2055 if (change) {
2056 snd_hda_codec_write_cache(codec, 0x1d, 0,
2057 AC_VERB_SET_AMP_GAIN_MUTE,
2058 AMP_IN_MUTE(0));
2059 snd_hda_codec_write_cache(codec, 0x1d, 0,
2060 AC_VERB_SET_AMP_GAIN_MUTE,
2061 AMP_IN_UNMUTE(1));
2062 }
2063 sel = snd_hda_codec_read(codec, 0x0b, 0,
2064 AC_VERB_GET_CONNECT_SEL, 0) + 1;
2065 change |= sel != val;
2066 if (change)
2067 snd_hda_codec_write_cache(codec, 0x0b, 0,
2068 AC_VERB_SET_CONNECT_SEL,
2069 val - 1);
2070 }
2071 return change;
2072 }
2073
2074 static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = {
2075 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2076 {
2077 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2078 .name = "IEC958 Playback Source",
2079 .info = ad1988_spdif_playback_source_info,
2080 .get = ad1988_spdif_playback_source_get,
2081 .put = ad1988_spdif_playback_source_put,
2082 },
2083 { } /* end */
2084 };
2085
2086 static struct snd_kcontrol_new ad1988_spdif_in_mixers[] = {
2087 HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT),
2088 { } /* end */
2089 };
2090
2091
2092 /*
2093 * initialization verbs
2094 */
2095
2096 /*
2097 * for 6-stack (+dig)
2098 */
2099 static struct hda_verb ad1988_6stack_init_verbs[] = {
2100 /* Front, Surround, CLFE, side DAC; unmute as default */
2101 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2102 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2103 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2104 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2105 /* Port-A front headphon path */
2106 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2107 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2108 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2109 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2110 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2111 /* Port-D line-out path */
2112 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2113 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2114 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2115 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2116 /* Port-F surround path */
2117 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2118 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2119 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2120 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2121 /* Port-G CLFE path */
2122 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2123 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2124 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2125 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2126 /* Port-H side path */
2127 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2128 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2129 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2130 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2131 /* Mono out path */
2132 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2133 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2134 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2135 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2136 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2137 /* Port-B front mic-in path */
2138 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2139 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2140 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2141 /* Port-C line-in path */
2142 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2143 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2144 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2145 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2146 /* Port-E mic-in path */
2147 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2148 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2149 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2150 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2151 /* Analog CD Input */
2152 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2153
2154 { }
2155 };
2156
2157 static struct hda_verb ad1988_capture_init_verbs[] = {
2158 /* mute analog mix */
2159 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2160 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2161 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2162 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2163 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2164 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2165 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2166 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2167 /* select ADCs - front-mic */
2168 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2169 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2170 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2171 /* ADCs; muted */
2172 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2173 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2174 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2175
2176 { }
2177 };
2178
2179 static struct hda_verb ad1988_spdif_init_verbs[] = {
2180 /* SPDIF out sel */
2181 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
2182 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */
2183 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2184 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2185 /* SPDIF out pin */
2186 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2187
2188 { }
2189 };
2190
2191 /*
2192 * verbs for 3stack (+dig)
2193 */
2194 static struct hda_verb ad1988_3stack_ch2_init[] = {
2195 /* set port-C to line-in */
2196 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2197 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2198 /* set port-E to mic-in */
2199 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2200 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2201 { } /* end */
2202 };
2203
2204 static struct hda_verb ad1988_3stack_ch6_init[] = {
2205 /* set port-C to surround out */
2206 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2207 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2208 /* set port-E to CLFE out */
2209 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2210 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2211 { } /* end */
2212 };
2213
2214 static struct hda_channel_mode ad1988_3stack_modes[2] = {
2215 { 2, ad1988_3stack_ch2_init },
2216 { 6, ad1988_3stack_ch6_init },
2217 };
2218
2219 static struct hda_verb ad1988_3stack_init_verbs[] = {
2220 /* Front, Surround, CLFE, side DAC; unmute as default */
2221 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2222 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2223 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2224 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2225 /* Port-A front headphon path */
2226 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2227 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2228 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2229 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2230 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2231 /* Port-D line-out path */
2232 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2233 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2234 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2235 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2236 /* Mono out path */
2237 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2238 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2239 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2240 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2241 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2242 /* Port-B front mic-in path */
2243 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2244 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2245 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2246 /* Port-C line-in/surround path - 6ch mode as default */
2247 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2248 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2249 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2250 {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */
2251 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2252 /* Port-E mic-in/CLFE path - 6ch mode as default */
2253 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2254 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2255 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2256 {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */
2257 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2258 /* mute analog mix */
2259 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2260 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2261 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2262 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2263 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2264 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2265 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2266 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2267 /* select ADCs - front-mic */
2268 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2269 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2270 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2271 /* ADCs; muted */
2272 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2273 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2274 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2275 { }
2276 };
2277
2278 /*
2279 * verbs for laptop mode (+dig)
2280 */
2281 static struct hda_verb ad1988_laptop_hp_on[] = {
2282 /* unmute port-A and mute port-D */
2283 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2284 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2285 { } /* end */
2286 };
2287 static struct hda_verb ad1988_laptop_hp_off[] = {
2288 /* mute port-A and unmute port-D */
2289 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2290 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2291 { } /* end */
2292 };
2293
2294 #define AD1988_HP_EVENT 0x01
2295
2296 static struct hda_verb ad1988_laptop_init_verbs[] = {
2297 /* Front, Surround, CLFE, side DAC; unmute as default */
2298 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2299 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2300 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2301 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2302 /* Port-A front headphon path */
2303 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2304 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2305 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2306 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2307 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2308 /* unsolicited event for pin-sense */
2309 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT },
2310 /* Port-D line-out path + EAPD */
2311 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2312 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2313 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2314 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2315 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */
2316 /* Mono out path */
2317 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2318 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2319 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2320 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2321 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2322 /* Port-B mic-in path */
2323 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2324 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2325 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2326 /* Port-C docking station - try to output */
2327 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2328 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2329 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2330 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2331 /* mute analog mix */
2332 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2333 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2334 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2335 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2336 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2337 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2338 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2339 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2340 /* select ADCs - mic */
2341 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2342 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2343 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2344 /* ADCs; muted */
2345 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2346 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2347 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2348 { }
2349 };
2350
2351 static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res)
2352 {
2353 if ((res >> 26) != AD1988_HP_EVENT)
2354 return;
2355 if (snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0) & (1 << 31))
2356 snd_hda_sequence_write(codec, ad1988_laptop_hp_on);
2357 else
2358 snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
2359 }
2360
2361 #ifdef CONFIG_SND_HDA_POWER_SAVE
2362 static struct hda_amp_list ad1988_loopbacks[] = {
2363 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
2364 { 0x20, HDA_INPUT, 1 }, /* Line */
2365 { 0x20, HDA_INPUT, 4 }, /* Mic */
2366 { 0x20, HDA_INPUT, 6 }, /* CD */
2367 { } /* end */
2368 };
2369 #endif
2370
2371 /*
2372 * Automatic parse of I/O pins from the BIOS configuration
2373 */
2374
2375 #define NUM_CONTROL_ALLOC 32
2376 #define NUM_VERB_ALLOC 32
2377
2378 enum {
2379 AD_CTL_WIDGET_VOL,
2380 AD_CTL_WIDGET_MUTE,
2381 AD_CTL_BIND_MUTE,
2382 };
2383 static struct snd_kcontrol_new ad1988_control_templates[] = {
2384 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2385 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2386 HDA_BIND_MUTE(NULL, 0, 0, 0),
2387 };
2388
2389 /* add dynamic controls */
2390 static int add_control(struct ad198x_spec *spec, int type, const char *name,
2391 unsigned long val)
2392 {
2393 struct snd_kcontrol_new *knew;
2394
2395 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
2396 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
2397
2398 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
2399 if (! knew)
2400 return -ENOMEM;
2401 if (spec->kctl_alloc) {
2402 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
2403 kfree(spec->kctl_alloc);
2404 }
2405 spec->kctl_alloc = knew;
2406 spec->num_kctl_alloc = num;
2407 }
2408
2409 knew = &spec->kctl_alloc[spec->num_kctl_used];
2410 *knew = ad1988_control_templates[type];
2411 knew->name = kstrdup(name, GFP_KERNEL);
2412 if (! knew->name)
2413 return -ENOMEM;
2414 knew->private_value = val;
2415 spec->num_kctl_used++;
2416 return 0;
2417 }
2418
2419 #define AD1988_PIN_CD_NID 0x18
2420 #define AD1988_PIN_BEEP_NID 0x10
2421
2422 static hda_nid_t ad1988_mixer_nids[8] = {
2423 /* A B C D E F G H */
2424 0x22, 0x2b, 0x2c, 0x29, 0x26, 0x2a, 0x27, 0x28
2425 };
2426
2427 static inline hda_nid_t ad1988_idx_to_dac(struct hda_codec *codec, int idx)
2428 {
2429 static hda_nid_t idx_to_dac[8] = {
2430 /* A B C D E F G H */
2431 0x04, 0x06, 0x05, 0x04, 0x0a, 0x06, 0x05, 0x0a
2432 };
2433 static hda_nid_t idx_to_dac_rev2[8] = {
2434 /* A B C D E F G H */
2435 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06
2436 };
2437 if (is_rev2(codec))
2438 return idx_to_dac_rev2[idx];
2439 else
2440 return idx_to_dac[idx];
2441 }
2442
2443 static hda_nid_t ad1988_boost_nids[8] = {
2444 0x38, 0x39, 0x3a, 0x3d, 0x3c, 0x3b, 0, 0
2445 };
2446
2447 static int ad1988_pin_idx(hda_nid_t nid)
2448 {
2449 static hda_nid_t ad1988_io_pins[8] = {
2450 0x11, 0x14, 0x15, 0x12, 0x17, 0x16, 0x24, 0x25
2451 };
2452 int i;
2453 for (i = 0; i < ARRAY_SIZE(ad1988_io_pins); i++)
2454 if (ad1988_io_pins[i] == nid)
2455 return i;
2456 return 0; /* should be -1 */
2457 }
2458
2459 static int ad1988_pin_to_loopback_idx(hda_nid_t nid)
2460 {
2461 static int loopback_idx[8] = {
2462 2, 0, 1, 3, 4, 5, 1, 4
2463 };
2464 switch (nid) {
2465 case AD1988_PIN_CD_NID:
2466 return 6;
2467 default:
2468 return loopback_idx[ad1988_pin_idx(nid)];
2469 }
2470 }
2471
2472 static int ad1988_pin_to_adc_idx(hda_nid_t nid)
2473 {
2474 static int adc_idx[8] = {
2475 0, 1, 2, 8, 4, 3, 6, 7
2476 };
2477 switch (nid) {
2478 case AD1988_PIN_CD_NID:
2479 return 5;
2480 default:
2481 return adc_idx[ad1988_pin_idx(nid)];
2482 }
2483 }
2484
2485 /* fill in the dac_nids table from the parsed pin configuration */
2486 static int ad1988_auto_fill_dac_nids(struct hda_codec *codec,
2487 const struct auto_pin_cfg *cfg)
2488 {
2489 struct ad198x_spec *spec = codec->spec;
2490 int i, idx;
2491
2492 spec->multiout.dac_nids = spec->private_dac_nids;
2493
2494 /* check the pins hardwired to audio widget */
2495 for (i = 0; i < cfg->line_outs; i++) {
2496 idx = ad1988_pin_idx(cfg->line_out_pins[i]);
2497 spec->multiout.dac_nids[i] = ad1988_idx_to_dac(codec, idx);
2498 }
2499 spec->multiout.num_dacs = cfg->line_outs;
2500 return 0;
2501 }
2502
2503 /* add playback controls from the parsed DAC table */
2504 static int ad1988_auto_create_multi_out_ctls(struct ad198x_spec *spec,
2505 const struct auto_pin_cfg *cfg)
2506 {
2507 char name[32];
2508 static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
2509 hda_nid_t nid;
2510 int i, err;
2511
2512 for (i = 0; i < cfg->line_outs; i++) {
2513 hda_nid_t dac = spec->multiout.dac_nids[i];
2514 if (! dac)
2515 continue;
2516 nid = ad1988_mixer_nids[ad1988_pin_idx(cfg->line_out_pins[i])];
2517 if (i == 2) {
2518 /* Center/LFE */
2519 err = add_control(spec, AD_CTL_WIDGET_VOL,
2520 "Center Playback Volume",
2521 HDA_COMPOSE_AMP_VAL(dac, 1, 0, HDA_OUTPUT));
2522 if (err < 0)
2523 return err;
2524 err = add_control(spec, AD_CTL_WIDGET_VOL,
2525 "LFE Playback Volume",
2526 HDA_COMPOSE_AMP_VAL(dac, 2, 0, HDA_OUTPUT));
2527 if (err < 0)
2528 return err;
2529 err = add_control(spec, AD_CTL_BIND_MUTE,
2530 "Center Playback Switch",
2531 HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT));
2532 if (err < 0)
2533 return err;
2534 err = add_control(spec, AD_CTL_BIND_MUTE,
2535 "LFE Playback Switch",
2536 HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT));
2537 if (err < 0)
2538 return err;
2539 } else {
2540 sprintf(name, "%s Playback Volume", chname[i]);
2541 err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2542 HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT));
2543 if (err < 0)
2544 return err;
2545 sprintf(name, "%s Playback Switch", chname[i]);
2546 err = add_control(spec, AD_CTL_BIND_MUTE, name,
2547 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
2548 if (err < 0)
2549 return err;
2550 }
2551 }
2552 return 0;
2553 }
2554
2555 /* add playback controls for speaker and HP outputs */
2556 static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
2557 const char *pfx)
2558 {
2559 struct ad198x_spec *spec = codec->spec;
2560 hda_nid_t nid;
2561 int i, idx, err;
2562 char name[32];
2563
2564 if (! pin)
2565 return 0;
2566
2567 idx = ad1988_pin_idx(pin);
2568 nid = ad1988_idx_to_dac(codec, idx);
2569 /* check whether the corresponding DAC was already taken */
2570 for (i = 0; i < spec->autocfg.line_outs; i++) {
2571 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2572 hda_nid_t dac = ad1988_idx_to_dac(codec, ad1988_pin_idx(pin));
2573 if (dac == nid)
2574 break;
2575 }
2576 if (i >= spec->autocfg.line_outs) {
2577 /* specify the DAC as the extra output */
2578 if (!spec->multiout.hp_nid)
2579 spec->multiout.hp_nid = nid;
2580 else
2581 spec->multiout.extra_out_nid[0] = nid;
2582 /* control HP volume/switch on the output mixer amp */
2583 sprintf(name, "%s Playback Volume", pfx);
2584 err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2585 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
2586 if (err < 0)
2587 return err;
2588 }
2589 nid = ad1988_mixer_nids[idx];
2590 sprintf(name, "%s Playback Switch", pfx);
2591 if ((err = add_control(spec, AD_CTL_BIND_MUTE, name,
2592 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2593 return err;
2594 return 0;
2595 }
2596
2597 /* create input playback/capture controls for the given pin */
2598 static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin,
2599 const char *ctlname, int boost)
2600 {
2601 char name[32];
2602 int err, idx;
2603
2604 sprintf(name, "%s Playback Volume", ctlname);
2605 idx = ad1988_pin_to_loopback_idx(pin);
2606 if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2607 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2608 return err;
2609 sprintf(name, "%s Playback Switch", ctlname);
2610 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, name,
2611 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2612 return err;
2613 if (boost) {
2614 hda_nid_t bnid;
2615 idx = ad1988_pin_idx(pin);
2616 bnid = ad1988_boost_nids[idx];
2617 if (bnid) {
2618 sprintf(name, "%s Boost", ctlname);
2619 return add_control(spec, AD_CTL_WIDGET_VOL, name,
2620 HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT));
2621
2622 }
2623 }
2624 return 0;
2625 }
2626
2627 /* create playback/capture controls for input pins */
2628 static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec,
2629 const struct auto_pin_cfg *cfg)
2630 {
2631 struct hda_input_mux *imux = &spec->private_imux;
2632 int i, err;
2633
2634 for (i = 0; i < AUTO_PIN_LAST; i++) {
2635 err = new_analog_input(spec, cfg->input_pins[i],
2636 auto_pin_cfg_labels[i],
2637 i <= AUTO_PIN_FRONT_MIC);
2638 if (err < 0)
2639 return err;
2640 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2641 imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]);
2642 imux->num_items++;
2643 }
2644 imux->items[imux->num_items].label = "Mix";
2645 imux->items[imux->num_items].index = 9;
2646 imux->num_items++;
2647
2648 if ((err = add_control(spec, AD_CTL_WIDGET_VOL,
2649 "Analog Mix Playback Volume",
2650 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2651 return err;
2652 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE,
2653 "Analog Mix Playback Switch",
2654 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2655 return err;
2656
2657 return 0;
2658 }
2659
2660 static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec,
2661 hda_nid_t nid, int pin_type,
2662 int dac_idx)
2663 {
2664 /* set as output */
2665 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2666 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
2667 switch (nid) {
2668 case 0x11: /* port-A - DAC 04 */
2669 snd_hda_codec_write(codec, 0x37, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2670 break;
2671 case 0x14: /* port-B - DAC 06 */
2672 snd_hda_codec_write(codec, 0x30, 0, AC_VERB_SET_CONNECT_SEL, 0x02);
2673 break;
2674 case 0x15: /* port-C - DAC 05 */
2675 snd_hda_codec_write(codec, 0x31, 0, AC_VERB_SET_CONNECT_SEL, 0x00);
2676 break;
2677 case 0x17: /* port-E - DAC 0a */
2678 snd_hda_codec_write(codec, 0x32, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2679 break;
2680 case 0x13: /* mono - DAC 04 */
2681 snd_hda_codec_write(codec, 0x36, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2682 break;
2683 }
2684 }
2685
2686 static void ad1988_auto_init_multi_out(struct hda_codec *codec)
2687 {
2688 struct ad198x_spec *spec = codec->spec;
2689 int i;
2690
2691 for (i = 0; i < spec->autocfg.line_outs; i++) {
2692 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2693 ad1988_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
2694 }
2695 }
2696
2697 static void ad1988_auto_init_extra_out(struct hda_codec *codec)
2698 {
2699 struct ad198x_spec *spec = codec->spec;
2700 hda_nid_t pin;
2701
2702 pin = spec->autocfg.speaker_pins[0];
2703 if (pin) /* connect to front */
2704 ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
2705 pin = spec->autocfg.hp_pins[0];
2706 if (pin) /* connect to front */
2707 ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
2708 }
2709
2710 static void ad1988_auto_init_analog_input(struct hda_codec *codec)
2711 {
2712 struct ad198x_spec *spec = codec->spec;
2713 int i, idx;
2714
2715 for (i = 0; i < AUTO_PIN_LAST; i++) {
2716 hda_nid_t nid = spec->autocfg.input_pins[i];
2717 if (! nid)
2718 continue;
2719 switch (nid) {
2720 case 0x15: /* port-C */
2721 snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2722 break;
2723 case 0x17: /* port-E */
2724 snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2725 break;
2726 }
2727 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2728 i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
2729 if (nid != AD1988_PIN_CD_NID)
2730 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2731 AMP_OUT_MUTE);
2732 idx = ad1988_pin_idx(nid);
2733 if (ad1988_boost_nids[idx])
2734 snd_hda_codec_write(codec, ad1988_boost_nids[idx], 0,
2735 AC_VERB_SET_AMP_GAIN_MUTE,
2736 AMP_OUT_ZERO);
2737 }
2738 }
2739
2740 /* parse the BIOS configuration and set up the alc_spec */
2741 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
2742 static int ad1988_parse_auto_config(struct hda_codec *codec)
2743 {
2744 struct ad198x_spec *spec = codec->spec;
2745 int err;
2746
2747 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2748 return err;
2749 if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2750 return err;
2751 if (! spec->autocfg.line_outs)
2752 return 0; /* can't find valid BIOS pin config */
2753 if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
2754 (err = ad1988_auto_create_extra_out(codec,
2755 spec->autocfg.speaker_pins[0],
2756 "Speaker")) < 0 ||
2757 (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
2758 "Headphone")) < 0 ||
2759 (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
2760 return err;
2761
2762 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2763
2764 if (spec->autocfg.dig_out_pin)
2765 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2766 if (spec->autocfg.dig_in_pin)
2767 spec->dig_in_nid = AD1988_SPDIF_IN;
2768
2769 if (spec->kctl_alloc)
2770 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2771
2772 spec->init_verbs[spec->num_init_verbs++] = ad1988_6stack_init_verbs;
2773
2774 spec->input_mux = &spec->private_imux;
2775
2776 return 1;
2777 }
2778
2779 /* init callback for auto-configuration model -- overriding the default init */
2780 static int ad1988_auto_init(struct hda_codec *codec)
2781 {
2782 ad198x_init(codec);
2783 ad1988_auto_init_multi_out(codec);
2784 ad1988_auto_init_extra_out(codec);
2785 ad1988_auto_init_analog_input(codec);
2786 return 0;
2787 }
2788
2789
2790 /*
2791 */
2792
2793 static const char *ad1988_models[AD1988_MODEL_LAST] = {
2794 [AD1988_6STACK] = "6stack",
2795 [AD1988_6STACK_DIG] = "6stack-dig",
2796 [AD1988_3STACK] = "3stack",
2797 [AD1988_3STACK_DIG] = "3stack-dig",
2798 [AD1988_LAPTOP] = "laptop",
2799 [AD1988_LAPTOP_DIG] = "laptop-dig",
2800 [AD1988_AUTO] = "auto",
2801 };
2802
2803 static struct snd_pci_quirk ad1988_cfg_tbl[] = {
2804 SND_PCI_QUIRK(0x1043, 0x81ec, "Asus P5B-DLX", AD1988_6STACK_DIG),
2805 SND_PCI_QUIRK(0x1043, 0x81f6, "Asus M2N-SLI", AD1988_6STACK_DIG),
2806 {}
2807 };
2808
2809 static int patch_ad1988(struct hda_codec *codec)
2810 {
2811 struct ad198x_spec *spec;
2812 int board_config;
2813
2814 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2815 if (spec == NULL)
2816 return -ENOMEM;
2817
2818 codec->spec = spec;
2819
2820 if (is_rev2(codec))
2821 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
2822
2823 board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
2824 ad1988_models, ad1988_cfg_tbl);
2825 if (board_config < 0) {
2826 printk(KERN_INFO "hda_codec: Unknown model for AD1988, trying auto-probe from BIOS...\n");
2827 board_config = AD1988_AUTO;
2828 }
2829
2830 if (board_config == AD1988_AUTO) {
2831 /* automatic parse from the BIOS config */
2832 int err = ad1988_parse_auto_config(codec);
2833 if (err < 0) {
2834 ad198x_free(codec);
2835 return err;
2836 } else if (! err) {
2837 printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS. Using 6-stack mode...\n");
2838 board_config = AD1988_6STACK;
2839 }
2840 }
2841
2842 switch (board_config) {
2843 case AD1988_6STACK:
2844 case AD1988_6STACK_DIG:
2845 spec->multiout.max_channels = 8;
2846 spec->multiout.num_dacs = 4;
2847 if (is_rev2(codec))
2848 spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2;
2849 else
2850 spec->multiout.dac_nids = ad1988_6stack_dac_nids;
2851 spec->input_mux = &ad1988_6stack_capture_source;
2852 spec->num_mixers = 2;
2853 if (is_rev2(codec))
2854 spec->mixers[0] = ad1988_6stack_mixers1_rev2;
2855 else
2856 spec->mixers[0] = ad1988_6stack_mixers1;
2857 spec->mixers[1] = ad1988_6stack_mixers2;
2858 spec->num_init_verbs = 1;
2859 spec->init_verbs[0] = ad1988_6stack_init_verbs;
2860 if (board_config == AD1988_6STACK_DIG) {
2861 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2862 spec->dig_in_nid = AD1988_SPDIF_IN;
2863 }
2864 break;
2865 case AD1988_3STACK:
2866 case AD1988_3STACK_DIG:
2867 spec->multiout.max_channels = 6;
2868 spec->multiout.num_dacs = 3;
2869 if (is_rev2(codec))
2870 spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2;
2871 else
2872 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
2873 spec->input_mux = &ad1988_6stack_capture_source;
2874 spec->channel_mode = ad1988_3stack_modes;
2875 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes);
2876 spec->num_mixers = 2;
2877 if (is_rev2(codec))
2878 spec->mixers[0] = ad1988_3stack_mixers1_rev2;
2879 else
2880 spec->mixers[0] = ad1988_3stack_mixers1;
2881 spec->mixers[1] = ad1988_3stack_mixers2;
2882 spec->num_init_verbs = 1;
2883 spec->init_verbs[0] = ad1988_3stack_init_verbs;
2884 if (board_config == AD1988_3STACK_DIG)
2885 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2886 break;
2887 case AD1988_LAPTOP:
2888 case AD1988_LAPTOP_DIG:
2889 spec->multiout.max_channels = 2;
2890 spec->multiout.num_dacs = 1;
2891 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
2892 spec->input_mux = &ad1988_laptop_capture_source;
2893 spec->num_mixers = 1;
2894 spec->mixers[0] = ad1988_laptop_mixers;
2895 spec->num_init_verbs = 1;
2896 spec->init_verbs[0] = ad1988_laptop_init_verbs;
2897 if (board_config == AD1988_LAPTOP_DIG)
2898 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2899 break;
2900 }
2901
2902 spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids);
2903 spec->adc_nids = ad1988_adc_nids;
2904 spec->capsrc_nids = ad1988_capsrc_nids;
2905 spec->mixers[spec->num_mixers++] = ad1988_capture_mixers;
2906 spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs;
2907 if (spec->multiout.dig_out_nid) {
2908 spec->mixers[spec->num_mixers++] = ad1988_spdif_out_mixers;
2909 spec->init_verbs[spec->num_init_verbs++] = ad1988_spdif_init_verbs;
2910 }
2911 if (spec->dig_in_nid)
2912 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers;
2913
2914 codec->patch_ops = ad198x_patch_ops;
2915 switch (board_config) {
2916 case AD1988_AUTO:
2917 codec->patch_ops.init = ad1988_auto_init;
2918 break;
2919 case AD1988_LAPTOP:
2920 case AD1988_LAPTOP_DIG:
2921 codec->patch_ops.unsol_event = ad1988_laptop_unsol_event;
2922 break;
2923 }
2924 #ifdef CONFIG_SND_HDA_POWER_SAVE
2925 spec->loopback.amplist = ad1988_loopbacks;
2926 #endif
2927 spec->vmaster_nid = 0x04;
2928
2929 return 0;
2930 }
2931
2932
2933 /*
2934 * AD1884 / AD1984
2935 *
2936 * port-B - front line/mic-in
2937 * port-E - aux in/out
2938 * port-F - aux in/out
2939 * port-C - rear line/mic-in
2940 * port-D - rear line/hp-out
2941 * port-A - front line/hp-out
2942 *
2943 * AD1984 = AD1884 + two digital mic-ins
2944 *
2945 * FIXME:
2946 * For simplicity, we share the single DAC for both HP and line-outs
2947 * right now. The inidividual playbacks could be easily implemented,
2948 * but no build-up framework is given, so far.
2949 */
2950
2951 static hda_nid_t ad1884_dac_nids[1] = {
2952 0x04,
2953 };
2954
2955 static hda_nid_t ad1884_adc_nids[2] = {
2956 0x08, 0x09,
2957 };
2958
2959 static hda_nid_t ad1884_capsrc_nids[2] = {
2960 0x0c, 0x0d,
2961 };
2962
2963 #define AD1884_SPDIF_OUT 0x02
2964
2965 static struct hda_input_mux ad1884_capture_source = {
2966 .num_items = 4,
2967 .items = {
2968 { "Front Mic", 0x0 },
2969 { "Mic", 0x1 },
2970 { "CD", 0x2 },
2971 { "Mix", 0x3 },
2972 },
2973 };
2974
2975 static struct snd_kcontrol_new ad1884_base_mixers[] = {
2976 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2977 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
2978 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
2979 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
2980 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
2981 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
2982 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
2983 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
2984 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
2985 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
2986 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
2987 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
2988 /*
2989 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x20, 0x03, HDA_INPUT),
2990 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x20, 0x03, HDA_INPUT),
2991 HDA_CODEC_VOLUME("Digital Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
2992 HDA_CODEC_MUTE("Digital Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
2993 */
2994 HDA_CODEC_VOLUME("Mic Boost", 0x15, 0x0, HDA_INPUT),
2995 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
2996 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
2997 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
2998 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
2999 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3000 {
3001 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3002 /* The multiple "Capture Source" controls confuse alsamixer
3003 * So call somewhat different..
3004 */
3005 /* .name = "Capture Source", */
3006 .name = "Input Source",
3007 .count = 2,
3008 .info = ad198x_mux_enum_info,
3009 .get = ad198x_mux_enum_get,
3010 .put = ad198x_mux_enum_put,
3011 },
3012 /* SPDIF controls */
3013 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3014 {
3015 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3016 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3017 /* identical with ad1983 */
3018 .info = ad1983_spdif_route_info,
3019 .get = ad1983_spdif_route_get,
3020 .put = ad1983_spdif_route_put,
3021 },
3022 { } /* end */
3023 };
3024
3025 static struct snd_kcontrol_new ad1984_dmic_mixers[] = {
3026 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x05, 0x0, HDA_INPUT),
3027 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x05, 0x0, HDA_INPUT),
3028 HDA_CODEC_VOLUME_IDX("Digital Mic Capture Volume", 1, 0x06, 0x0,
3029 HDA_INPUT),
3030 HDA_CODEC_MUTE_IDX("Digital Mic Capture Switch", 1, 0x06, 0x0,
3031 HDA_INPUT),
3032 { } /* end */
3033 };
3034
3035 /*
3036 * initialization verbs
3037 */
3038 static struct hda_verb ad1884_init_verbs[] = {
3039 /* DACs; mute as default */
3040 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3041 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3042 /* Port-A (HP) mixer */
3043 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3044 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3045 /* Port-A pin */
3046 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3047 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3048 /* HP selector - select DAC2 */
3049 {0x22, AC_VERB_SET_CONNECT_SEL, 0x1},
3050 /* Port-D (Line-out) mixer */
3051 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3052 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3053 /* Port-D pin */
3054 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3055 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3056 /* Mono-out mixer */
3057 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3058 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3059 /* Mono-out pin */
3060 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3061 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3062 /* Mono selector */
3063 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
3064 /* Port-B (front mic) pin */
3065 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3066 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3067 /* Port-C (rear mic) pin */
3068 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3069 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3070 /* Analog mixer; mute as default */
3071 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3072 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3073 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3074 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3075 /* Analog Mix output amp */
3076 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3077 /* SPDIF output selector */
3078 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
3079 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3080 { } /* end */
3081 };
3082
3083 #ifdef CONFIG_SND_HDA_POWER_SAVE
3084 static struct hda_amp_list ad1884_loopbacks[] = {
3085 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3086 { 0x20, HDA_INPUT, 1 }, /* Mic */
3087 { 0x20, HDA_INPUT, 2 }, /* CD */
3088 { 0x20, HDA_INPUT, 4 }, /* Docking */
3089 { } /* end */
3090 };
3091 #endif
3092
3093 static const char *ad1884_slave_vols[] = {
3094 "PCM Playback Volume",
3095 "Mic Playback Volume",
3096 "Mono Playback Volume",
3097 "Front Mic Playback Volume",
3098 "Mic Playback Volume",
3099 "CD Playback Volume",
3100 "Internal Mic Playback Volume",
3101 "Docking Mic Playback Volume"
3102 "Beep Playback Volume",
3103 "IEC958 Playback Volume",
3104 NULL
3105 };
3106
3107 static int patch_ad1884(struct hda_codec *codec)
3108 {
3109 struct ad198x_spec *spec;
3110
3111 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3112 if (spec == NULL)
3113 return -ENOMEM;
3114
3115 mutex_init(&spec->amp_mutex);
3116 codec->spec = spec;
3117
3118 spec->multiout.max_channels = 2;
3119 spec->multiout.num_dacs = ARRAY_SIZE(ad1884_dac_nids);
3120 spec->multiout.dac_nids = ad1884_dac_nids;
3121 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3122 spec->num_adc_nids = ARRAY_SIZE(ad1884_adc_nids);
3123 spec->adc_nids = ad1884_adc_nids;
3124 spec->capsrc_nids = ad1884_capsrc_nids;
3125 spec->input_mux = &ad1884_capture_source;
3126 spec->num_mixers = 1;
3127 spec->mixers[0] = ad1884_base_mixers;
3128 spec->num_init_verbs = 1;
3129 spec->init_verbs[0] = ad1884_init_verbs;
3130 spec->spdif_route = 0;
3131 #ifdef CONFIG_SND_HDA_POWER_SAVE
3132 spec->loopback.amplist = ad1884_loopbacks;
3133 #endif
3134 spec->vmaster_nid = 0x04;
3135 /* we need to cover all playback volumes */
3136 spec->slave_vols = ad1884_slave_vols;
3137
3138 codec->patch_ops = ad198x_patch_ops;
3139
3140 return 0;
3141 }
3142
3143 /*
3144 * Lenovo Thinkpad T61/X61
3145 */
3146 static struct hda_input_mux ad1984_thinkpad_capture_source = {
3147 .num_items = 3,
3148 .items = {
3149 { "Mic", 0x0 },
3150 { "Internal Mic", 0x1 },
3151 { "Mix", 0x3 },
3152 },
3153 };
3154
3155
3156 /*
3157 * Dell Precision T3400
3158 */
3159 static struct hda_input_mux ad1984_dell_desktop_capture_source = {
3160 .num_items = 3,
3161 .items = {
3162 { "Front Mic", 0x0 },
3163 { "Line-In", 0x1 },
3164 { "Mix", 0x3 },
3165 },
3166 };
3167
3168
3169 static struct snd_kcontrol_new ad1984_thinkpad_mixers[] = {
3170 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3171 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3172 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3173 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3174 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3175 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3176 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3177 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3178 HDA_CODEC_VOLUME("Docking Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3179 HDA_CODEC_MUTE("Docking Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3180 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3181 HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3182 HDA_CODEC_VOLUME("Docking Mic Boost", 0x25, 0x0, HDA_OUTPUT),
3183 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x03, HDA_INPUT),
3184 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3185 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3186 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3187 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3188 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3189 {
3190 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3191 /* The multiple "Capture Source" controls confuse alsamixer
3192 * So call somewhat different..
3193 */
3194 /* .name = "Capture Source", */
3195 .name = "Input Source",
3196 .count = 2,
3197 .info = ad198x_mux_enum_info,
3198 .get = ad198x_mux_enum_get,
3199 .put = ad198x_mux_enum_put,
3200 },
3201 /* SPDIF controls */
3202 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3203 {
3204 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3205 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3206 /* identical with ad1983 */
3207 .info = ad1983_spdif_route_info,
3208 .get = ad1983_spdif_route_get,
3209 .put = ad1983_spdif_route_put,
3210 },
3211 { } /* end */
3212 };
3213
3214 /* additional verbs */
3215 static struct hda_verb ad1984_thinkpad_init_verbs[] = {
3216 /* Port-E (docking station mic) pin */
3217 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3218 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3219 /* docking mic boost */
3220 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3221 /* Analog mixer - docking mic; mute as default */
3222 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3223 /* enable EAPD bit */
3224 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
3225 { } /* end */
3226 };
3227
3228 /*
3229 * Dell Precision T3400
3230 */
3231 static struct snd_kcontrol_new ad1984_dell_desktop_mixers[] = {
3232 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3233 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3234 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3235 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3236 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3237 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3238 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3239 HDA_CODEC_VOLUME("Line-In Playback Volume", 0x20, 0x01, HDA_INPUT),
3240 HDA_CODEC_MUTE("Line-In Playback Switch", 0x20, 0x01, HDA_INPUT),
3241 /*
3242 HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x20, 0x03, HDA_INPUT),
3243 HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x20, 0x03, HDA_INPUT),
3244 */
3245 HDA_CODEC_VOLUME("Line-In Boost", 0x15, 0x0, HDA_INPUT),
3246 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3247 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3248 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3249 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3250 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3251 {
3252 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3253 /* The multiple "Capture Source" controls confuse alsamixer
3254 * So call somewhat different..
3255 */
3256 /* .name = "Capture Source", */
3257 .name = "Input Source",
3258 .count = 2,
3259 .info = ad198x_mux_enum_info,
3260 .get = ad198x_mux_enum_get,
3261 .put = ad198x_mux_enum_put,
3262 },
3263 { } /* end */
3264 };
3265
3266 /* Digial MIC ADC NID 0x05 + 0x06 */
3267 static int ad1984_pcm_dmic_prepare(struct hda_pcm_stream *hinfo,
3268 struct hda_codec *codec,
3269 unsigned int stream_tag,
3270 unsigned int format,
3271 struct snd_pcm_substream *substream)
3272 {
3273 snd_hda_codec_setup_stream(codec, 0x05 + substream->number,
3274 stream_tag, 0, format);
3275 return 0;
3276 }
3277
3278 static int ad1984_pcm_dmic_cleanup(struct hda_pcm_stream *hinfo,
3279 struct hda_codec *codec,
3280 struct snd_pcm_substream *substream)
3281 {
3282 snd_hda_codec_setup_stream(codec, 0x05 + substream->number,
3283 0, 0, 0);
3284 return 0;
3285 }
3286
3287 static struct hda_pcm_stream ad1984_pcm_dmic_capture = {
3288 .substreams = 2,
3289 .channels_min = 2,
3290 .channels_max = 2,
3291 .nid = 0x05,
3292 .ops = {
3293 .prepare = ad1984_pcm_dmic_prepare,
3294 .cleanup = ad1984_pcm_dmic_cleanup
3295 },
3296 };
3297
3298 static int ad1984_build_pcms(struct hda_codec *codec)
3299 {
3300 struct ad198x_spec *spec = codec->spec;
3301 struct hda_pcm *info;
3302 int err;
3303
3304 err = ad198x_build_pcms(codec);
3305 if (err < 0)
3306 return err;
3307
3308 info = spec->pcm_rec + codec->num_pcms;
3309 codec->num_pcms++;
3310 info->name = "AD1984 Digital Mic";
3311 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad1984_pcm_dmic_capture;
3312 return 0;
3313 }
3314
3315 /* models */
3316 enum {
3317 AD1984_BASIC,
3318 AD1984_THINKPAD,
3319 AD1984_DELL_DESKTOP,
3320 AD1984_MODELS
3321 };
3322
3323 static const char *ad1984_models[AD1984_MODELS] = {
3324 [AD1984_BASIC] = "basic",
3325 [AD1984_THINKPAD] = "thinkpad",
3326 [AD1984_DELL_DESKTOP] = "dell_desktop",
3327 };
3328
3329 static struct snd_pci_quirk ad1984_cfg_tbl[] = {
3330 /* Lenovo Thinkpad T61/X61 */
3331 SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1984_THINKPAD),
3332 SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP),
3333 {}
3334 };
3335
3336 static int patch_ad1984(struct hda_codec *codec)
3337 {
3338 struct ad198x_spec *spec;
3339 int board_config, err;
3340
3341 err = patch_ad1884(codec);
3342 if (err < 0)
3343 return err;
3344 spec = codec->spec;
3345 board_config = snd_hda_check_board_config(codec, AD1984_MODELS,
3346 ad1984_models, ad1984_cfg_tbl);
3347 switch (board_config) {
3348 case AD1984_BASIC:
3349 /* additional digital mics */
3350 spec->mixers[spec->num_mixers++] = ad1984_dmic_mixers;
3351 codec->patch_ops.build_pcms = ad1984_build_pcms;
3352 break;
3353 case AD1984_THINKPAD:
3354 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3355 spec->input_mux = &ad1984_thinkpad_capture_source;
3356 spec->mixers[0] = ad1984_thinkpad_mixers;
3357 spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs;
3358 break;
3359 case AD1984_DELL_DESKTOP:
3360 spec->multiout.dig_out_nid = 0;
3361 spec->input_mux = &ad1984_dell_desktop_capture_source;
3362 spec->mixers[0] = ad1984_dell_desktop_mixers;
3363 break;
3364 }
3365 return 0;
3366 }
3367
3368
3369 /*
3370 * AD1882
3371 *
3372 * port-A - front hp-out
3373 * port-B - front mic-in
3374 * port-C - rear line-in, shared surr-out (3stack)
3375 * port-D - rear line-out
3376 * port-E - rear mic-in, shared clfe-out (3stack)
3377 * port-F - rear surr-out (6stack)
3378 * port-G - rear clfe-out (6stack)
3379 */
3380
3381 static hda_nid_t ad1882_dac_nids[3] = {
3382 0x04, 0x03, 0x05
3383 };
3384
3385 static hda_nid_t ad1882_adc_nids[2] = {
3386 0x08, 0x09,
3387 };
3388
3389 static hda_nid_t ad1882_capsrc_nids[2] = {
3390 0x0c, 0x0d,
3391 };
3392
3393 #define AD1882_SPDIF_OUT 0x02
3394
3395 /* list: 0x11, 0x39, 0x3a, 0x18, 0x3c, 0x3b, 0x12, 0x20 */
3396 static struct hda_input_mux ad1882_capture_source = {
3397 .num_items = 5,
3398 .items = {
3399 { "Front Mic", 0x1 },
3400 { "Mic", 0x4 },
3401 { "Line", 0x2 },
3402 { "CD", 0x3 },
3403 { "Mix", 0x7 },
3404 },
3405 };
3406
3407 static struct snd_kcontrol_new ad1882_base_mixers[] = {
3408 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3409 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
3410 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
3411 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
3412 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3413 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3414 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3415 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3416 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3417 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3418 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3419 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3420 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x04, HDA_INPUT),
3421 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x04, HDA_INPUT),
3422 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
3423 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
3424 HDA_CODEC_VOLUME("Beep Playback Volume", 0x20, 0x07, HDA_INPUT),
3425 HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x07, HDA_INPUT),
3426 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
3427 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
3428 HDA_CODEC_VOLUME("Line-In Boost", 0x3a, 0x0, HDA_OUTPUT),
3429 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3430 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3431 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3432 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3433 {
3434 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3435 /* The multiple "Capture Source" controls confuse alsamixer
3436 * So call somewhat different..
3437 */
3438 /* .name = "Capture Source", */
3439 .name = "Input Source",
3440 .count = 2,
3441 .info = ad198x_mux_enum_info,
3442 .get = ad198x_mux_enum_get,
3443 .put = ad198x_mux_enum_put,
3444 },
3445 /* SPDIF controls */
3446 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3447 {
3448 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3449 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3450 /* identical with ad1983 */
3451 .info = ad1983_spdif_route_info,
3452 .get = ad1983_spdif_route_get,
3453 .put = ad1983_spdif_route_put,
3454 },
3455 { } /* end */
3456 };
3457
3458 static struct snd_kcontrol_new ad1882_3stack_mixers[] = {
3459 HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT),
3460 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x17, 1, 0x0, HDA_OUTPUT),
3461 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x17, 2, 0x0, HDA_OUTPUT),
3462 {
3463 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3464 .name = "Channel Mode",
3465 .info = ad198x_ch_mode_info,
3466 .get = ad198x_ch_mode_get,
3467 .put = ad198x_ch_mode_put,
3468 },
3469 { } /* end */
3470 };
3471
3472 static struct snd_kcontrol_new ad1882_6stack_mixers[] = {
3473 HDA_CODEC_MUTE("Surround Playback Switch", 0x16, 0x0, HDA_OUTPUT),
3474 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x24, 1, 0x0, HDA_OUTPUT),
3475 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x24, 2, 0x0, HDA_OUTPUT),
3476 { } /* end */
3477 };
3478
3479 static struct hda_verb ad1882_ch2_init[] = {
3480 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3481 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3482 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3483 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3484 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3485 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3486 { } /* end */
3487 };
3488
3489 static struct hda_verb ad1882_ch4_init[] = {
3490 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3491 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3492 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3493 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3494 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3495 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3496 { } /* end */
3497 };
3498
3499 static struct hda_verb ad1882_ch6_init[] = {
3500 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3501 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3502 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3503 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3504 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3505 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3506 { } /* end */
3507 };
3508
3509 static struct hda_channel_mode ad1882_modes[3] = {
3510 { 2, ad1882_ch2_init },
3511 { 4, ad1882_ch4_init },
3512 { 6, ad1882_ch6_init },
3513 };
3514
3515 /*
3516 * initialization verbs
3517 */
3518 static struct hda_verb ad1882_init_verbs[] = {
3519 /* DACs; mute as default */
3520 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3521 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3522 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3523 /* Port-A (HP) mixer */
3524 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3525 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3526 /* Port-A pin */
3527 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3528 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3529 /* HP selector - select DAC2 */
3530 {0x37, AC_VERB_SET_CONNECT_SEL, 0x1},
3531 /* Port-D (Line-out) mixer */
3532 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3533 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3534 /* Port-D pin */
3535 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3536 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3537 /* Mono-out mixer */
3538 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3539 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3540 /* Mono-out pin */
3541 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3542 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3543 /* Port-B (front mic) pin */
3544 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3545 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3546 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
3547 /* Port-C (line-in) pin */
3548 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3549 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3550 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
3551 /* Port-C mixer - mute as input */
3552 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3553 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3554 /* Port-E (mic-in) pin */
3555 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3556 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3557 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */
3558 /* Port-E mixer - mute as input */
3559 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3560 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3561 /* Port-F (surround) */
3562 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3563 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3564 /* Port-G (CLFE) */
3565 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3566 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3567 /* Analog mixer; mute as default */
3568 /* list: 0x39, 0x3a, 0x11, 0x12, 0x3c, 0x3b, 0x18, 0x1a */
3569 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3570 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3571 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3572 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3573 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3574 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
3575 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3576 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3577 /* Analog Mix output amp */
3578 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3579 /* SPDIF output selector */
3580 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3581 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
3582 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3583 { } /* end */
3584 };
3585
3586 #ifdef CONFIG_SND_HDA_POWER_SAVE
3587 static struct hda_amp_list ad1882_loopbacks[] = {
3588 { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3589 { 0x20, HDA_INPUT, 1 }, /* Mic */
3590 { 0x20, HDA_INPUT, 4 }, /* Line */
3591 { 0x20, HDA_INPUT, 6 }, /* CD */
3592 { } /* end */
3593 };
3594 #endif
3595
3596 /* models */
3597 enum {
3598 AD1882_3STACK,
3599 AD1882_6STACK,
3600 AD1882_MODELS
3601 };
3602
3603 static const char *ad1882_models[AD1986A_MODELS] = {
3604 [AD1882_3STACK] = "3stack",
3605 [AD1882_6STACK] = "6stack",
3606 };
3607
3608
3609 static int patch_ad1882(struct hda_codec *codec)
3610 {
3611 struct ad198x_spec *spec;
3612 int board_config;
3613
3614 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3615 if (spec == NULL)
3616 return -ENOMEM;
3617
3618 mutex_init(&spec->amp_mutex);
3619 codec->spec = spec;
3620
3621 spec->multiout.max_channels = 6;
3622 spec->multiout.num_dacs = 3;
3623 spec->multiout.dac_nids = ad1882_dac_nids;
3624 spec->multiout.dig_out_nid = AD1882_SPDIF_OUT;
3625 spec->num_adc_nids = ARRAY_SIZE(ad1882_adc_nids);
3626 spec->adc_nids = ad1882_adc_nids;
3627 spec->capsrc_nids = ad1882_capsrc_nids;
3628 spec->input_mux = &ad1882_capture_source;
3629 spec->num_mixers = 1;
3630 spec->mixers[0] = ad1882_base_mixers;
3631 spec->num_init_verbs = 1;
3632 spec->init_verbs[0] = ad1882_init_verbs;
3633 spec->spdif_route = 0;
3634 #ifdef CONFIG_SND_HDA_POWER_SAVE
3635 spec->loopback.amplist = ad1882_loopbacks;
3636 #endif
3637 spec->vmaster_nid = 0x04;
3638
3639 codec->patch_ops = ad198x_patch_ops;
3640
3641 /* override some parameters */
3642 board_config = snd_hda_check_board_config(codec, AD1882_MODELS,
3643 ad1882_models, NULL);
3644 switch (board_config) {
3645 default:
3646 case AD1882_3STACK:
3647 spec->num_mixers = 2;
3648 spec->mixers[1] = ad1882_3stack_mixers;
3649 spec->channel_mode = ad1882_modes;
3650 spec->num_channel_mode = ARRAY_SIZE(ad1882_modes);
3651 spec->need_dac_fix = 1;
3652 spec->multiout.max_channels = 2;
3653 spec->multiout.num_dacs = 1;
3654 break;
3655 case AD1882_6STACK:
3656 spec->num_mixers = 2;
3657 spec->mixers[1] = ad1882_6stack_mixers;
3658 break;
3659 }
3660 return 0;
3661 }
3662
3663
3664 /*
3665 * patch entries
3666 */
3667 struct hda_codec_preset snd_hda_preset_analog[] = {
3668 { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 },
3669 { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 },
3670 { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 },
3671 { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 },
3672 { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1984 },
3673 { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a },
3674 { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 },
3675 { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 },
3676 {} /* terminator */
3677 };
Linux with added FPC-III support