1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
4 * Universal interface for Audio Codec '97
6 * For more details look to AC '97 component specification revision 2.2
7 * by Intel Corporation (http://developer.intel.com) and to datasheets
11 #include "ac97_local.h"
12 #include "ac97_patch.h"
15 * Forward declarations
18 static struct snd_kcontrol *snd_ac97_find_mixer_ctl(struct snd_ac97 *ac97,
20 static int snd_ac97_add_vmaster(struct snd_ac97 *ac97, char *name,
21 const unsigned int *tlv,
22 const char * const *followers);
25 * Chip specific initialization
28 static int patch_build_controls(struct snd_ac97 * ac97, const struct snd_kcontrol_new *controls, int count)
32 for (idx = 0; idx < count; idx++)
33 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&controls[idx], ac97))) < 0)
38 /* replace with a new TLV */
39 static void reset_tlv(struct snd_ac97 *ac97, const char *name,
40 const unsigned int *tlv)
42 struct snd_ctl_elem_id sid;
43 struct snd_kcontrol *kctl;
44 memset(&sid, 0, sizeof(sid));
45 strcpy(sid.name, name);
46 sid.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
47 kctl = snd_ctl_find_id(ac97->bus->card, &sid);
48 if (kctl && kctl->tlv.p)
52 /* set to the page, update bits and restore the page */
53 static int ac97_update_bits_page(struct snd_ac97 *ac97, unsigned short reg, unsigned short mask, unsigned short value, unsigned short page)
55 unsigned short page_save;
58 mutex_lock(&ac97->page_mutex);
59 page_save = snd_ac97_read(ac97, AC97_INT_PAGING) & AC97_PAGE_MASK;
60 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page);
61 ret = snd_ac97_update_bits(ac97, reg, mask, value);
62 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, page_save);
63 mutex_unlock(&ac97->page_mutex); /* unlock paging */
68 * shared line-in/mic controls
70 static int ac97_surround_jack_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
72 static const char * const texts[] = { "Shared", "Independent" };
74 return snd_ctl_enum_info(uinfo, 1, 2, texts);
77 static int ac97_surround_jack_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
79 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
81 ucontrol->value.enumerated.item[0] = ac97->indep_surround;
85 static int ac97_surround_jack_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
87 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
88 unsigned char indep = !!ucontrol->value.enumerated.item[0];
90 if (indep != ac97->indep_surround) {
91 ac97->indep_surround = indep;
92 if (ac97->build_ops->update_jacks)
93 ac97->build_ops->update_jacks(ac97);
99 static int ac97_channel_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
101 static const char * const texts[] = { "2ch", "4ch", "6ch", "8ch" };
103 return snd_ctl_enum_info(uinfo, 1, kcontrol->private_value, texts);
106 static int ac97_channel_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
108 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
110 ucontrol->value.enumerated.item[0] = ac97->channel_mode;
114 static int ac97_channel_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
116 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
117 unsigned char mode = ucontrol->value.enumerated.item[0];
119 if (mode >= kcontrol->private_value)
122 if (mode != ac97->channel_mode) {
123 ac97->channel_mode = mode;
124 if (ac97->build_ops->update_jacks)
125 ac97->build_ops->update_jacks(ac97);
131 #define AC97_SURROUND_JACK_MODE_CTL \
133 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
134 .name = "Surround Jack Mode", \
135 .info = ac97_surround_jack_mode_info, \
136 .get = ac97_surround_jack_mode_get, \
137 .put = ac97_surround_jack_mode_put, \
140 #define AC97_CHANNEL_MODE_CTL \
142 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
143 .name = "Channel Mode", \
144 .info = ac97_channel_mode_info, \
145 .get = ac97_channel_mode_get, \
146 .put = ac97_channel_mode_put, \
147 .private_value = 3, \
150 #define AC97_CHANNEL_MODE_4CH_CTL \
152 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
153 .name = "Channel Mode", \
154 .info = ac97_channel_mode_info, \
155 .get = ac97_channel_mode_get, \
156 .put = ac97_channel_mode_put, \
157 .private_value = 2, \
160 #define AC97_CHANNEL_MODE_8CH_CTL \
162 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
163 .name = "Channel Mode", \
164 .info = ac97_channel_mode_info, \
165 .get = ac97_channel_mode_get, \
166 .put = ac97_channel_mode_put, \
167 .private_value = 4, \
170 static inline int is_surround_on(struct snd_ac97 *ac97)
172 return ac97->channel_mode >= 1;
175 static inline int is_clfe_on(struct snd_ac97 *ac97)
177 return ac97->channel_mode >= 2;
180 /* system has shared jacks with surround out enabled */
181 static inline int is_shared_surrout(struct snd_ac97 *ac97)
183 return !ac97->indep_surround && is_surround_on(ac97);
186 /* system has shared jacks with center/lfe out enabled */
187 static inline int is_shared_clfeout(struct snd_ac97 *ac97)
189 return !ac97->indep_surround && is_clfe_on(ac97);
192 /* system has shared jacks with line in enabled */
193 static inline int is_shared_linein(struct snd_ac97 *ac97)
195 return !ac97->indep_surround && !is_surround_on(ac97);
198 /* system has shared jacks with mic in enabled */
199 static inline int is_shared_micin(struct snd_ac97 *ac97)
201 return !ac97->indep_surround && !is_clfe_on(ac97);
204 static inline int alc850_is_aux_back_surround(struct snd_ac97 *ac97)
206 return is_surround_on(ac97);
209 /* The following snd_ac97_ymf753_... items added by David Shust (dshust@shustring.com) */
210 /* Modified for YMF743 by Keita Maehara <maehara@debian.org> */
212 /* It is possible to indicate to the Yamaha YMF7x3 the type of
213 speakers being used. */
215 static int snd_ac97_ymf7x3_info_speaker(struct snd_kcontrol *kcontrol,
216 struct snd_ctl_elem_info *uinfo)
218 static const char * const texts[3] = {
219 "Standard", "Small", "Smaller"
222 return snd_ctl_enum_info(uinfo, 1, 3, texts);
225 static int snd_ac97_ymf7x3_get_speaker(struct snd_kcontrol *kcontrol,
226 struct snd_ctl_elem_value *ucontrol)
228 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
231 val = ac97->regs[AC97_YMF7X3_3D_MODE_SEL];
232 val = (val >> 10) & 3;
233 if (val > 0) /* 0 = invalid */
235 ucontrol->value.enumerated.item[0] = val;
239 static int snd_ac97_ymf7x3_put_speaker(struct snd_kcontrol *kcontrol,
240 struct snd_ctl_elem_value *ucontrol)
242 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
245 if (ucontrol->value.enumerated.item[0] > 2)
247 val = (ucontrol->value.enumerated.item[0] + 1) << 10;
248 return snd_ac97_update(ac97, AC97_YMF7X3_3D_MODE_SEL, val);
251 static const struct snd_kcontrol_new snd_ac97_ymf7x3_controls_speaker =
253 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
254 .name = "3D Control - Speaker",
255 .info = snd_ac97_ymf7x3_info_speaker,
256 .get = snd_ac97_ymf7x3_get_speaker,
257 .put = snd_ac97_ymf7x3_put_speaker,
260 /* It is possible to indicate to the Yamaha YMF7x3 the source to
261 direct to the S/PDIF output. */
262 static int snd_ac97_ymf7x3_spdif_source_info(struct snd_kcontrol *kcontrol,
263 struct snd_ctl_elem_info *uinfo)
265 static const char * const texts[2] = { "AC-Link", "A/D Converter" };
267 return snd_ctl_enum_info(uinfo, 1, 2, texts);
270 static int snd_ac97_ymf7x3_spdif_source_get(struct snd_kcontrol *kcontrol,
271 struct snd_ctl_elem_value *ucontrol)
273 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
276 val = ac97->regs[AC97_YMF7X3_DIT_CTRL];
277 ucontrol->value.enumerated.item[0] = (val >> 1) & 1;
281 static int snd_ac97_ymf7x3_spdif_source_put(struct snd_kcontrol *kcontrol,
282 struct snd_ctl_elem_value *ucontrol)
284 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
287 if (ucontrol->value.enumerated.item[0] > 1)
289 val = ucontrol->value.enumerated.item[0] << 1;
290 return snd_ac97_update_bits(ac97, AC97_YMF7X3_DIT_CTRL, 0x0002, val);
293 static int patch_yamaha_ymf7x3_3d(struct snd_ac97 *ac97)
295 struct snd_kcontrol *kctl;
298 kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97);
299 err = snd_ctl_add(ac97->bus->card, kctl);
302 strcpy(kctl->id.name, "3D Control - Wide");
303 kctl->private_value = AC97_SINGLE_VALUE(AC97_3D_CONTROL, 9, 7, 0);
304 snd_ac97_write_cache(ac97, AC97_3D_CONTROL, 0x0000);
305 err = snd_ctl_add(ac97->bus->card,
306 snd_ac97_cnew(&snd_ac97_ymf7x3_controls_speaker,
310 snd_ac97_write_cache(ac97, AC97_YMF7X3_3D_MODE_SEL, 0x0c00);
314 static const struct snd_kcontrol_new snd_ac97_yamaha_ymf743_controls_spdif[3] =
316 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
317 AC97_YMF7X3_DIT_CTRL, 0, 1, 0),
319 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
320 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, NONE) "Source",
321 .info = snd_ac97_ymf7x3_spdif_source_info,
322 .get = snd_ac97_ymf7x3_spdif_source_get,
323 .put = snd_ac97_ymf7x3_spdif_source_put,
325 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("", NONE, NONE) "Mute",
326 AC97_YMF7X3_DIT_CTRL, 2, 1, 1)
329 static int patch_yamaha_ymf743_build_spdif(struct snd_ac97 *ac97)
333 err = patch_build_controls(ac97, &snd_ac97_controls_spdif[0], 3);
336 err = patch_build_controls(ac97,
337 snd_ac97_yamaha_ymf743_controls_spdif, 3);
340 /* set default PCM S/PDIF params */
341 /* PCM audio,no copyright,no preemphasis,PCM coder,original */
342 snd_ac97_write_cache(ac97, AC97_YMF7X3_DIT_CTRL, 0xa201);
346 static const struct snd_ac97_build_ops patch_yamaha_ymf743_ops = {
347 .build_spdif = patch_yamaha_ymf743_build_spdif,
348 .build_3d = patch_yamaha_ymf7x3_3d,
351 static int patch_yamaha_ymf743(struct snd_ac97 *ac97)
353 ac97->build_ops = &patch_yamaha_ymf743_ops;
354 ac97->caps |= AC97_BC_BASS_TREBLE;
355 ac97->caps |= 0x04 << 10; /* Yamaha 3D enhancement */
356 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000; /* 48k only */
357 ac97->ext_id |= AC97_EI_SPDIF; /* force the detection of spdif */
361 /* The AC'97 spec states that the S/PDIF signal is to be output at pin 48.
362 The YMF753 will output the S/PDIF signal to pin 43, 47 (EAPD), or 48.
363 By default, no output pin is selected, and the S/PDIF signal is not output.
364 There is also a bit to mute S/PDIF output in a vendor-specific register. */
365 static int snd_ac97_ymf753_spdif_output_pin_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
367 static const char * const texts[3] = { "Disabled", "Pin 43", "Pin 48" };
369 return snd_ctl_enum_info(uinfo, 1, 3, texts);
372 static int snd_ac97_ymf753_spdif_output_pin_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
374 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
377 val = ac97->regs[AC97_YMF7X3_DIT_CTRL];
378 ucontrol->value.enumerated.item[0] = (val & 0x0008) ? 2 : (val & 0x0020) ? 1 : 0;
382 static int snd_ac97_ymf753_spdif_output_pin_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
384 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
387 if (ucontrol->value.enumerated.item[0] > 2)
389 val = (ucontrol->value.enumerated.item[0] == 2) ? 0x0008 :
390 (ucontrol->value.enumerated.item[0] == 1) ? 0x0020 : 0;
391 return snd_ac97_update_bits(ac97, AC97_YMF7X3_DIT_CTRL, 0x0028, val);
392 /* The following can be used to direct S/PDIF output to pin 47 (EAPD).
393 snd_ac97_write_cache(ac97, 0x62, snd_ac97_read(ac97, 0x62) | 0x0008); */
396 static const struct snd_kcontrol_new snd_ac97_ymf753_controls_spdif[3] = {
398 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
399 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
400 .info = snd_ac97_ymf7x3_spdif_source_info,
401 .get = snd_ac97_ymf7x3_spdif_source_get,
402 .put = snd_ac97_ymf7x3_spdif_source_put,
405 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
406 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Output Pin",
407 .info = snd_ac97_ymf753_spdif_output_pin_info,
408 .get = snd_ac97_ymf753_spdif_output_pin_get,
409 .put = snd_ac97_ymf753_spdif_output_pin_put,
411 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("", NONE, NONE) "Mute",
412 AC97_YMF7X3_DIT_CTRL, 2, 1, 1)
415 static int patch_yamaha_ymf753_post_spdif(struct snd_ac97 * ac97)
419 if ((err = patch_build_controls(ac97, snd_ac97_ymf753_controls_spdif, ARRAY_SIZE(snd_ac97_ymf753_controls_spdif))) < 0)
424 static const struct snd_ac97_build_ops patch_yamaha_ymf753_ops = {
425 .build_3d = patch_yamaha_ymf7x3_3d,
426 .build_post_spdif = patch_yamaha_ymf753_post_spdif
429 static int patch_yamaha_ymf753(struct snd_ac97 * ac97)
431 /* Patch for Yamaha YMF753, Copyright (c) by David Shust, dshust@shustring.com.
432 This chip has nonstandard and extended behaviour with regard to its S/PDIF output.
433 The AC'97 spec states that the S/PDIF signal is to be output at pin 48.
434 The YMF753 will ouput the S/PDIF signal to pin 43, 47 (EAPD), or 48.
435 By default, no output pin is selected, and the S/PDIF signal is not output.
436 There is also a bit to mute S/PDIF output in a vendor-specific register.
438 ac97->build_ops = &patch_yamaha_ymf753_ops;
439 ac97->caps |= AC97_BC_BASS_TREBLE;
440 ac97->caps |= 0x04 << 10; /* Yamaha 3D enhancement */
445 * May 2, 2003 Liam Girdwood <lrg@slimlogic.co.uk>
446 * removed broken wolfson00 patch.
447 * added support for WM9705,WM9708,WM9709,WM9710,WM9711,WM9712 and WM9717.
450 static const struct snd_kcontrol_new wm97xx_snd_ac97_controls[] = {
451 AC97_DOUBLE("Front Playback Volume", AC97_WM97XX_FMIXER_VOL, 8, 0, 31, 1),
452 AC97_SINGLE("Front Playback Switch", AC97_WM97XX_FMIXER_VOL, 15, 1, 1),
455 static int patch_wolfson_wm9703_specific(struct snd_ac97 * ac97)
457 /* This is known to work for the ViewSonic ViewPad 1000
458 * Randolph Bentson <bentson@holmsjoen.com>
459 * WM9703/9707/9708/9717
463 for (i = 0; i < ARRAY_SIZE(wm97xx_snd_ac97_controls); i++) {
464 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm97xx_snd_ac97_controls[i], ac97))) < 0)
467 snd_ac97_write_cache(ac97, AC97_WM97XX_FMIXER_VOL, 0x0808);
471 static const struct snd_ac97_build_ops patch_wolfson_wm9703_ops = {
472 .build_specific = patch_wolfson_wm9703_specific,
475 static int patch_wolfson03(struct snd_ac97 * ac97)
477 ac97->build_ops = &patch_wolfson_wm9703_ops;
481 static const struct snd_kcontrol_new wm9704_snd_ac97_controls[] = {
482 AC97_DOUBLE("Front Playback Volume", AC97_WM97XX_FMIXER_VOL, 8, 0, 31, 1),
483 AC97_SINGLE("Front Playback Switch", AC97_WM97XX_FMIXER_VOL, 15, 1, 1),
484 AC97_DOUBLE("Rear Playback Volume", AC97_WM9704_RMIXER_VOL, 8, 0, 31, 1),
485 AC97_SINGLE("Rear Playback Switch", AC97_WM9704_RMIXER_VOL, 15, 1, 1),
486 AC97_DOUBLE("Rear DAC Volume", AC97_WM9704_RPCM_VOL, 8, 0, 31, 1),
487 AC97_DOUBLE("Surround Volume", AC97_SURROUND_MASTER, 8, 0, 31, 1),
490 static int patch_wolfson_wm9704_specific(struct snd_ac97 * ac97)
493 for (i = 0; i < ARRAY_SIZE(wm9704_snd_ac97_controls); i++) {
494 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm9704_snd_ac97_controls[i], ac97))) < 0)
497 /* patch for DVD noise */
498 snd_ac97_write_cache(ac97, AC97_WM9704_TEST, 0x0200);
502 static const struct snd_ac97_build_ops patch_wolfson_wm9704_ops = {
503 .build_specific = patch_wolfson_wm9704_specific,
506 static int patch_wolfson04(struct snd_ac97 * ac97)
509 ac97->build_ops = &patch_wolfson_wm9704_ops;
513 static int patch_wolfson05(struct snd_ac97 * ac97)
516 ac97->build_ops = &patch_wolfson_wm9703_ops;
517 #ifdef CONFIG_TOUCHSCREEN_WM9705
518 /* WM9705 touchscreen uses AUX and VIDEO for touch */
519 ac97->flags |= AC97_HAS_NO_VIDEO | AC97_HAS_NO_AUX;
524 static const char* wm9711_alc_select[] = {"None", "Left", "Right", "Stereo"};
525 static const char* wm9711_alc_mix[] = {"Stereo", "Right", "Left", "None"};
526 static const char* wm9711_out3_src[] = {"Left", "VREF", "Left + Right", "Mono"};
527 static const char* wm9711_out3_lrsrc[] = {"Master Mix", "Headphone Mix"};
528 static const char* wm9711_rec_adc[] = {"Stereo", "Left", "Right", "Mute"};
529 static const char* wm9711_base[] = {"Linear Control", "Adaptive Boost"};
530 static const char* wm9711_rec_gain[] = {"+1.5dB Steps", "+0.75dB Steps"};
531 static const char* wm9711_mic[] = {"Mic 1", "Differential", "Mic 2", "Stereo"};
532 static const char* wm9711_rec_sel[] =
533 {"Mic 1", "NC", "NC", "Master Mix", "Line", "Headphone Mix", "Phone Mix", "Phone"};
534 static const char* wm9711_ng_type[] = {"Constant Gain", "Mute"};
536 static const struct ac97_enum wm9711_enum[] = {
537 AC97_ENUM_SINGLE(AC97_PCI_SVID, 14, 4, wm9711_alc_select),
538 AC97_ENUM_SINGLE(AC97_VIDEO, 10, 4, wm9711_alc_mix),
539 AC97_ENUM_SINGLE(AC97_AUX, 9, 4, wm9711_out3_src),
540 AC97_ENUM_SINGLE(AC97_AUX, 8, 2, wm9711_out3_lrsrc),
541 AC97_ENUM_SINGLE(AC97_REC_SEL, 12, 4, wm9711_rec_adc),
542 AC97_ENUM_SINGLE(AC97_MASTER_TONE, 15, 2, wm9711_base),
543 AC97_ENUM_DOUBLE(AC97_REC_GAIN, 14, 6, 2, wm9711_rec_gain),
544 AC97_ENUM_SINGLE(AC97_MIC, 5, 4, wm9711_mic),
545 AC97_ENUM_DOUBLE(AC97_REC_SEL, 8, 0, 8, wm9711_rec_sel),
546 AC97_ENUM_SINGLE(AC97_PCI_SVID, 5, 2, wm9711_ng_type),
549 static const struct snd_kcontrol_new wm9711_snd_ac97_controls[] = {
550 AC97_SINGLE("ALC Target Volume", AC97_CODEC_CLASS_REV, 12, 15, 0),
551 AC97_SINGLE("ALC Hold Time", AC97_CODEC_CLASS_REV, 8, 15, 0),
552 AC97_SINGLE("ALC Decay Time", AC97_CODEC_CLASS_REV, 4, 15, 0),
553 AC97_SINGLE("ALC Attack Time", AC97_CODEC_CLASS_REV, 0, 15, 0),
554 AC97_ENUM("ALC Function", wm9711_enum[0]),
555 AC97_SINGLE("ALC Max Volume", AC97_PCI_SVID, 11, 7, 1),
556 AC97_SINGLE("ALC ZC Timeout", AC97_PCI_SVID, 9, 3, 1),
557 AC97_SINGLE("ALC ZC Switch", AC97_PCI_SVID, 8, 1, 0),
558 AC97_SINGLE("ALC NG Switch", AC97_PCI_SVID, 7, 1, 0),
559 AC97_ENUM("ALC NG Type", wm9711_enum[9]),
560 AC97_SINGLE("ALC NG Threshold", AC97_PCI_SVID, 0, 31, 1),
562 AC97_SINGLE("Side Tone Switch", AC97_VIDEO, 15, 1, 1),
563 AC97_SINGLE("Side Tone Volume", AC97_VIDEO, 12, 7, 1),
564 AC97_ENUM("ALC Headphone Mux", wm9711_enum[1]),
565 AC97_SINGLE("ALC Headphone Volume", AC97_VIDEO, 7, 7, 1),
567 AC97_SINGLE("Out3 Switch", AC97_AUX, 15, 1, 1),
568 AC97_SINGLE("Out3 ZC Switch", AC97_AUX, 7, 1, 0),
569 AC97_ENUM("Out3 Mux", wm9711_enum[2]),
570 AC97_ENUM("Out3 LR Mux", wm9711_enum[3]),
571 AC97_SINGLE("Out3 Volume", AC97_AUX, 0, 31, 1),
573 AC97_SINGLE("Beep to Headphone Switch", AC97_PC_BEEP, 15, 1, 1),
574 AC97_SINGLE("Beep to Headphone Volume", AC97_PC_BEEP, 12, 7, 1),
575 AC97_SINGLE("Beep to Side Tone Switch", AC97_PC_BEEP, 11, 1, 1),
576 AC97_SINGLE("Beep to Side Tone Volume", AC97_PC_BEEP, 8, 7, 1),
577 AC97_SINGLE("Beep to Phone Switch", AC97_PC_BEEP, 7, 1, 1),
578 AC97_SINGLE("Beep to Phone Volume", AC97_PC_BEEP, 4, 7, 1),
580 AC97_SINGLE("Aux to Headphone Switch", AC97_CD, 15, 1, 1),
581 AC97_SINGLE("Aux to Headphone Volume", AC97_CD, 12, 7, 1),
582 AC97_SINGLE("Aux to Side Tone Switch", AC97_CD, 11, 1, 1),
583 AC97_SINGLE("Aux to Side Tone Volume", AC97_CD, 8, 7, 1),
584 AC97_SINGLE("Aux to Phone Switch", AC97_CD, 7, 1, 1),
585 AC97_SINGLE("Aux to Phone Volume", AC97_CD, 4, 7, 1),
587 AC97_SINGLE("Phone to Headphone Switch", AC97_PHONE, 15, 1, 1),
588 AC97_SINGLE("Phone to Master Switch", AC97_PHONE, 14, 1, 1),
590 AC97_SINGLE("Line to Headphone Switch", AC97_LINE, 15, 1, 1),
591 AC97_SINGLE("Line to Master Switch", AC97_LINE, 14, 1, 1),
592 AC97_SINGLE("Line to Phone Switch", AC97_LINE, 13, 1, 1),
594 AC97_SINGLE("PCM Playback to Headphone Switch", AC97_PCM, 15, 1, 1),
595 AC97_SINGLE("PCM Playback to Master Switch", AC97_PCM, 14, 1, 1),
596 AC97_SINGLE("PCM Playback to Phone Switch", AC97_PCM, 13, 1, 1),
598 AC97_SINGLE("Capture 20dB Boost Switch", AC97_REC_SEL, 14, 1, 0),
599 AC97_ENUM("Capture to Phone Mux", wm9711_enum[4]),
600 AC97_SINGLE("Capture to Phone 20dB Boost Switch", AC97_REC_SEL, 11, 1, 1),
601 AC97_ENUM("Capture Select", wm9711_enum[8]),
603 AC97_SINGLE("3D Upper Cut-off Switch", AC97_3D_CONTROL, 5, 1, 1),
604 AC97_SINGLE("3D Lower Cut-off Switch", AC97_3D_CONTROL, 4, 1, 1),
606 AC97_ENUM("Bass Control", wm9711_enum[5]),
607 AC97_SINGLE("Bass Cut-off Switch", AC97_MASTER_TONE, 12, 1, 1),
608 AC97_SINGLE("Tone Cut-off Switch", AC97_MASTER_TONE, 4, 1, 1),
609 AC97_SINGLE("Playback Attenuate (-6dB) Switch", AC97_MASTER_TONE, 6, 1, 0),
611 AC97_SINGLE("ADC Switch", AC97_REC_GAIN, 15, 1, 1),
612 AC97_ENUM("Capture Volume Steps", wm9711_enum[6]),
613 AC97_DOUBLE("Capture Volume", AC97_REC_GAIN, 8, 0, 63, 1),
614 AC97_SINGLE("Capture ZC Switch", AC97_REC_GAIN, 7, 1, 0),
616 AC97_SINGLE("Mic 1 to Phone Switch", AC97_MIC, 14, 1, 1),
617 AC97_SINGLE("Mic 2 to Phone Switch", AC97_MIC, 13, 1, 1),
618 AC97_ENUM("Mic Select Source", wm9711_enum[7]),
619 AC97_SINGLE("Mic 1 Volume", AC97_MIC, 8, 31, 1),
620 AC97_SINGLE("Mic 2 Volume", AC97_MIC, 0, 31, 1),
621 AC97_SINGLE("Mic 20dB Boost Switch", AC97_MIC, 7, 1, 0),
623 AC97_SINGLE("Master Left Inv Switch", AC97_MASTER, 6, 1, 0),
624 AC97_SINGLE("Master ZC Switch", AC97_MASTER, 7, 1, 0),
625 AC97_SINGLE("Headphone ZC Switch", AC97_HEADPHONE, 7, 1, 0),
626 AC97_SINGLE("Mono ZC Switch", AC97_MASTER_MONO, 7, 1, 0),
629 static int patch_wolfson_wm9711_specific(struct snd_ac97 * ac97)
633 for (i = 0; i < ARRAY_SIZE(wm9711_snd_ac97_controls); i++) {
634 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm9711_snd_ac97_controls[i], ac97))) < 0)
637 snd_ac97_write_cache(ac97, AC97_CODEC_CLASS_REV, 0x0808);
638 snd_ac97_write_cache(ac97, AC97_PCI_SVID, 0x0808);
639 snd_ac97_write_cache(ac97, AC97_VIDEO, 0x0808);
640 snd_ac97_write_cache(ac97, AC97_AUX, 0x0808);
641 snd_ac97_write_cache(ac97, AC97_PC_BEEP, 0x0808);
642 snd_ac97_write_cache(ac97, AC97_CD, 0x0000);
646 static const struct snd_ac97_build_ops patch_wolfson_wm9711_ops = {
647 .build_specific = patch_wolfson_wm9711_specific,
650 static int patch_wolfson11(struct snd_ac97 * ac97)
653 ac97->build_ops = &patch_wolfson_wm9711_ops;
655 ac97->flags |= AC97_HAS_NO_REC_GAIN | AC97_STEREO_MUTES | AC97_HAS_NO_MIC |
656 AC97_HAS_NO_PC_BEEP | AC97_HAS_NO_VIDEO | AC97_HAS_NO_CD;
661 static const char* wm9713_mic_mixer[] = {"Stereo", "Mic 1", "Mic 2", "Mute"};
662 static const char* wm9713_rec_mux[] = {"Stereo", "Left", "Right", "Mute"};
663 static const char* wm9713_rec_src[] =
664 {"Mic 1", "Mic 2", "Line", "Mono In", "Headphone Mix", "Master Mix",
666 static const char* wm9713_rec_gain[] = {"+1.5dB Steps", "+0.75dB Steps"};
667 static const char* wm9713_alc_select[] = {"None", "Left", "Right", "Stereo"};
668 static const char* wm9713_mono_pga[] = {"Vmid", "Zh", "Mono Mix", "Inv 1"};
669 static const char* wm9713_spk_pga[] =
670 {"Vmid", "Zh", "Headphone Mix", "Master Mix", "Inv", "NC", "NC", "NC"};
671 static const char* wm9713_hp_pga[] = {"Vmid", "Zh", "Headphone Mix", "NC"};
672 static const char* wm9713_out3_pga[] = {"Vmid", "Zh", "Inv 1", "NC"};
673 static const char* wm9713_out4_pga[] = {"Vmid", "Zh", "Inv 2", "NC"};
674 static const char* wm9713_dac_inv[] =
675 {"Off", "Mono Mix", "Master Mix", "Headphone Mix L", "Headphone Mix R",
676 "Headphone Mix Mono", "NC", "Vmid"};
677 static const char* wm9713_base[] = {"Linear Control", "Adaptive Boost"};
678 static const char* wm9713_ng_type[] = {"Constant Gain", "Mute"};
680 static const struct ac97_enum wm9713_enum[] = {
681 AC97_ENUM_SINGLE(AC97_LINE, 3, 4, wm9713_mic_mixer),
682 AC97_ENUM_SINGLE(AC97_VIDEO, 14, 4, wm9713_rec_mux),
683 AC97_ENUM_SINGLE(AC97_VIDEO, 9, 4, wm9713_rec_mux),
684 AC97_ENUM_DOUBLE(AC97_VIDEO, 3, 0, 8, wm9713_rec_src),
685 AC97_ENUM_DOUBLE(AC97_CD, 14, 6, 2, wm9713_rec_gain),
686 AC97_ENUM_SINGLE(AC97_PCI_SVID, 14, 4, wm9713_alc_select),
687 AC97_ENUM_SINGLE(AC97_REC_GAIN, 14, 4, wm9713_mono_pga),
688 AC97_ENUM_DOUBLE(AC97_REC_GAIN, 11, 8, 8, wm9713_spk_pga),
689 AC97_ENUM_DOUBLE(AC97_REC_GAIN, 6, 4, 4, wm9713_hp_pga),
690 AC97_ENUM_SINGLE(AC97_REC_GAIN, 2, 4, wm9713_out3_pga),
691 AC97_ENUM_SINGLE(AC97_REC_GAIN, 0, 4, wm9713_out4_pga),
692 AC97_ENUM_DOUBLE(AC97_REC_GAIN_MIC, 13, 10, 8, wm9713_dac_inv),
693 AC97_ENUM_SINGLE(AC97_GENERAL_PURPOSE, 15, 2, wm9713_base),
694 AC97_ENUM_SINGLE(AC97_PCI_SVID, 5, 2, wm9713_ng_type),
697 static const struct snd_kcontrol_new wm13_snd_ac97_controls[] = {
698 AC97_DOUBLE("Line In Volume", AC97_PC_BEEP, 8, 0, 31, 1),
699 AC97_SINGLE("Line In to Headphone Switch", AC97_PC_BEEP, 15, 1, 1),
700 AC97_SINGLE("Line In to Master Switch", AC97_PC_BEEP, 14, 1, 1),
701 AC97_SINGLE("Line In to Mono Switch", AC97_PC_BEEP, 13, 1, 1),
703 AC97_DOUBLE("PCM Playback Volume", AC97_PHONE, 8, 0, 31, 1),
704 AC97_SINGLE("PCM Playback to Headphone Switch", AC97_PHONE, 15, 1, 1),
705 AC97_SINGLE("PCM Playback to Master Switch", AC97_PHONE, 14, 1, 1),
706 AC97_SINGLE("PCM Playback to Mono Switch", AC97_PHONE, 13, 1, 1),
708 AC97_SINGLE("Mic 1 Volume", AC97_MIC, 8, 31, 1),
709 AC97_SINGLE("Mic 2 Volume", AC97_MIC, 0, 31, 1),
710 AC97_SINGLE("Mic 1 to Mono Switch", AC97_LINE, 7, 1, 1),
711 AC97_SINGLE("Mic 2 to Mono Switch", AC97_LINE, 6, 1, 1),
712 AC97_SINGLE("Mic Boost (+20dB) Switch", AC97_LINE, 5, 1, 0),
713 AC97_ENUM("Mic to Headphone Mux", wm9713_enum[0]),
714 AC97_SINGLE("Mic Headphone Mixer Volume", AC97_LINE, 0, 7, 1),
716 AC97_SINGLE("Capture Switch", AC97_CD, 15, 1, 1),
717 AC97_ENUM("Capture Volume Steps", wm9713_enum[4]),
718 AC97_DOUBLE("Capture Volume", AC97_CD, 8, 0, 15, 0),
719 AC97_SINGLE("Capture ZC Switch", AC97_CD, 7, 1, 0),
721 AC97_ENUM("Capture to Headphone Mux", wm9713_enum[1]),
722 AC97_SINGLE("Capture to Headphone Volume", AC97_VIDEO, 11, 7, 1),
723 AC97_ENUM("Capture to Mono Mux", wm9713_enum[2]),
724 AC97_SINGLE("Capture to Mono Boost (+20dB) Switch", AC97_VIDEO, 8, 1, 0),
725 AC97_SINGLE("Capture ADC Boost (+20dB) Switch", AC97_VIDEO, 6, 1, 0),
726 AC97_ENUM("Capture Select", wm9713_enum[3]),
728 AC97_SINGLE("ALC Target Volume", AC97_CODEC_CLASS_REV, 12, 15, 0),
729 AC97_SINGLE("ALC Hold Time", AC97_CODEC_CLASS_REV, 8, 15, 0),
730 AC97_SINGLE("ALC Decay Time ", AC97_CODEC_CLASS_REV, 4, 15, 0),
731 AC97_SINGLE("ALC Attack Time", AC97_CODEC_CLASS_REV, 0, 15, 0),
732 AC97_ENUM("ALC Function", wm9713_enum[5]),
733 AC97_SINGLE("ALC Max Volume", AC97_PCI_SVID, 11, 7, 0),
734 AC97_SINGLE("ALC ZC Timeout", AC97_PCI_SVID, 9, 3, 0),
735 AC97_SINGLE("ALC ZC Switch", AC97_PCI_SVID, 8, 1, 0),
736 AC97_SINGLE("ALC NG Switch", AC97_PCI_SVID, 7, 1, 0),
737 AC97_ENUM("ALC NG Type", wm9713_enum[13]),
738 AC97_SINGLE("ALC NG Threshold", AC97_PCI_SVID, 0, 31, 0),
740 AC97_DOUBLE("Master ZC Switch", AC97_MASTER, 14, 6, 1, 0),
741 AC97_DOUBLE("Headphone ZC Switch", AC97_HEADPHONE, 14, 6, 1, 0),
742 AC97_DOUBLE("Out3/4 ZC Switch", AC97_MASTER_MONO, 14, 6, 1, 0),
743 AC97_SINGLE("Master Right Switch", AC97_MASTER, 7, 1, 1),
744 AC97_SINGLE("Headphone Right Switch", AC97_HEADPHONE, 7, 1, 1),
745 AC97_SINGLE("Out3/4 Right Switch", AC97_MASTER_MONO, 7, 1, 1),
747 AC97_SINGLE("Mono In to Headphone Switch", AC97_MASTER_TONE, 15, 1, 1),
748 AC97_SINGLE("Mono In to Master Switch", AC97_MASTER_TONE, 14, 1, 1),
749 AC97_SINGLE("Mono In Volume", AC97_MASTER_TONE, 8, 31, 1),
750 AC97_SINGLE("Mono Switch", AC97_MASTER_TONE, 7, 1, 1),
751 AC97_SINGLE("Mono ZC Switch", AC97_MASTER_TONE, 6, 1, 0),
752 AC97_SINGLE("Mono Volume", AC97_MASTER_TONE, 0, 31, 1),
754 AC97_SINGLE("Beep to Headphone Switch", AC97_AUX, 15, 1, 1),
755 AC97_SINGLE("Beep to Headphone Volume", AC97_AUX, 12, 7, 1),
756 AC97_SINGLE("Beep to Master Switch", AC97_AUX, 11, 1, 1),
757 AC97_SINGLE("Beep to Master Volume", AC97_AUX, 8, 7, 1),
758 AC97_SINGLE("Beep to Mono Switch", AC97_AUX, 7, 1, 1),
759 AC97_SINGLE("Beep to Mono Volume", AC97_AUX, 4, 7, 1),
761 AC97_SINGLE("Voice to Headphone Switch", AC97_PCM, 15, 1, 1),
762 AC97_SINGLE("Voice to Headphone Volume", AC97_PCM, 12, 7, 1),
763 AC97_SINGLE("Voice to Master Switch", AC97_PCM, 11, 1, 1),
764 AC97_SINGLE("Voice to Master Volume", AC97_PCM, 8, 7, 1),
765 AC97_SINGLE("Voice to Mono Switch", AC97_PCM, 7, 1, 1),
766 AC97_SINGLE("Voice to Mono Volume", AC97_PCM, 4, 7, 1),
768 AC97_SINGLE("Aux to Headphone Switch", AC97_REC_SEL, 15, 1, 1),
769 AC97_SINGLE("Aux to Headphone Volume", AC97_REC_SEL, 12, 7, 1),
770 AC97_SINGLE("Aux to Master Switch", AC97_REC_SEL, 11, 1, 1),
771 AC97_SINGLE("Aux to Master Volume", AC97_REC_SEL, 8, 7, 1),
772 AC97_SINGLE("Aux to Mono Switch", AC97_REC_SEL, 7, 1, 1),
773 AC97_SINGLE("Aux to Mono Volume", AC97_REC_SEL, 4, 7, 1),
775 AC97_ENUM("Mono Input Mux", wm9713_enum[6]),
776 AC97_ENUM("Master Input Mux", wm9713_enum[7]),
777 AC97_ENUM("Headphone Input Mux", wm9713_enum[8]),
778 AC97_ENUM("Out 3 Input Mux", wm9713_enum[9]),
779 AC97_ENUM("Out 4 Input Mux", wm9713_enum[10]),
781 AC97_ENUM("Bass Control", wm9713_enum[12]),
782 AC97_SINGLE("Bass Cut-off Switch", AC97_GENERAL_PURPOSE, 12, 1, 1),
783 AC97_SINGLE("Tone Cut-off Switch", AC97_GENERAL_PURPOSE, 4, 1, 1),
784 AC97_SINGLE("Playback Attenuate (-6dB) Switch", AC97_GENERAL_PURPOSE, 6, 1, 0),
785 AC97_SINGLE("Bass Volume", AC97_GENERAL_PURPOSE, 8, 15, 1),
786 AC97_SINGLE("Tone Volume", AC97_GENERAL_PURPOSE, 0, 15, 1),
789 static const struct snd_kcontrol_new wm13_snd_ac97_controls_3d[] = {
790 AC97_ENUM("Inv Input Mux", wm9713_enum[11]),
791 AC97_SINGLE("3D Upper Cut-off Switch", AC97_REC_GAIN_MIC, 5, 1, 0),
792 AC97_SINGLE("3D Lower Cut-off Switch", AC97_REC_GAIN_MIC, 4, 1, 0),
793 AC97_SINGLE("3D Depth", AC97_REC_GAIN_MIC, 0, 15, 1),
796 static int patch_wolfson_wm9713_3d (struct snd_ac97 * ac97)
800 for (i = 0; i < ARRAY_SIZE(wm13_snd_ac97_controls_3d); i++) {
801 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm13_snd_ac97_controls_3d[i], ac97))) < 0)
807 static int patch_wolfson_wm9713_specific(struct snd_ac97 * ac97)
811 for (i = 0; i < ARRAY_SIZE(wm13_snd_ac97_controls); i++) {
812 if ((err = snd_ctl_add(ac97->bus->card, snd_ac97_cnew(&wm13_snd_ac97_controls[i], ac97))) < 0)
815 snd_ac97_write_cache(ac97, AC97_PC_BEEP, 0x0808);
816 snd_ac97_write_cache(ac97, AC97_PHONE, 0x0808);
817 snd_ac97_write_cache(ac97, AC97_MIC, 0x0808);
818 snd_ac97_write_cache(ac97, AC97_LINE, 0x00da);
819 snd_ac97_write_cache(ac97, AC97_CD, 0x0808);
820 snd_ac97_write_cache(ac97, AC97_VIDEO, 0xd612);
821 snd_ac97_write_cache(ac97, AC97_REC_GAIN, 0x1ba0);
826 static void patch_wolfson_wm9713_suspend (struct snd_ac97 * ac97)
828 snd_ac97_write_cache(ac97, AC97_EXTENDED_MID, 0xfeff);
829 snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0xffff);
832 static void patch_wolfson_wm9713_resume (struct snd_ac97 * ac97)
834 snd_ac97_write_cache(ac97, AC97_EXTENDED_MID, 0xda00);
835 snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0x3810);
836 snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0x0);
840 static const struct snd_ac97_build_ops patch_wolfson_wm9713_ops = {
841 .build_specific = patch_wolfson_wm9713_specific,
842 .build_3d = patch_wolfson_wm9713_3d,
844 .suspend = patch_wolfson_wm9713_suspend,
845 .resume = patch_wolfson_wm9713_resume
849 static int patch_wolfson13(struct snd_ac97 * ac97)
852 ac97->build_ops = &patch_wolfson_wm9713_ops;
854 ac97->flags |= AC97_HAS_NO_REC_GAIN | AC97_STEREO_MUTES | AC97_HAS_NO_PHONE |
855 AC97_HAS_NO_PC_BEEP | AC97_HAS_NO_VIDEO | AC97_HAS_NO_CD | AC97_HAS_NO_TONE |
857 ac97->scaps &= ~AC97_SCAP_MODEM;
859 snd_ac97_write_cache(ac97, AC97_EXTENDED_MID, 0xda00);
860 snd_ac97_write_cache(ac97, AC97_EXTENDED_MSTATUS, 0x3810);
861 snd_ac97_write_cache(ac97, AC97_POWERDOWN, 0x0);
869 static int patch_tritech_tr28028(struct snd_ac97 * ac97)
871 snd_ac97_write_cache(ac97, 0x26, 0x0300);
872 snd_ac97_write_cache(ac97, 0x26, 0x0000);
873 snd_ac97_write_cache(ac97, AC97_SURROUND_MASTER, 0x0000);
874 snd_ac97_write_cache(ac97, AC97_SPDIF, 0x0000);
879 * Sigmatel STAC97xx codecs
881 static int patch_sigmatel_stac9700_3d(struct snd_ac97 * ac97)
883 struct snd_kcontrol *kctl;
886 if ((err = snd_ctl_add(ac97->bus->card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0)
888 strcpy(kctl->id.name, "3D Control Sigmatel - Depth");
889 kctl->private_value = AC97_SINGLE_VALUE(AC97_3D_CONTROL, 2, 3, 0);
890 snd_ac97_write_cache(ac97, AC97_3D_CONTROL, 0x0000);
894 static int patch_sigmatel_stac9708_3d(struct snd_ac97 * ac97)
896 struct snd_kcontrol *kctl;
899 if ((err = snd_ctl_add(ac97->bus->card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0)
901 strcpy(kctl->id.name, "3D Control Sigmatel - Depth");
902 kctl->private_value = AC97_SINGLE_VALUE(AC97_3D_CONTROL, 0, 3, 0);
903 if ((err = snd_ctl_add(ac97->bus->card, kctl = snd_ac97_cnew(&snd_ac97_controls_3d[0], ac97))) < 0)
905 strcpy(kctl->id.name, "3D Control Sigmatel - Rear Depth");
906 kctl->private_value = AC97_SINGLE_VALUE(AC97_3D_CONTROL, 2, 3, 0);
907 snd_ac97_write_cache(ac97, AC97_3D_CONTROL, 0x0000);
911 static const struct snd_kcontrol_new snd_ac97_sigmatel_4speaker =
912 AC97_SINGLE("Sigmatel 4-Speaker Stereo Playback Switch",
913 AC97_SIGMATEL_DAC2INVERT, 2, 1, 0);
915 /* "Sigmatel " removed due to excessive name length: */
916 static const struct snd_kcontrol_new snd_ac97_sigmatel_phaseinvert =
917 AC97_SINGLE("Surround Phase Inversion Playback Switch",
918 AC97_SIGMATEL_DAC2INVERT, 3, 1, 0);
920 static const struct snd_kcontrol_new snd_ac97_sigmatel_controls[] = {
921 AC97_SINGLE("Sigmatel DAC 6dB Attenuate", AC97_SIGMATEL_ANALOG, 1, 1, 0),
922 AC97_SINGLE("Sigmatel ADC 6dB Attenuate", AC97_SIGMATEL_ANALOG, 0, 1, 0)
925 static int patch_sigmatel_stac97xx_specific(struct snd_ac97 * ac97)
929 snd_ac97_write_cache(ac97, AC97_SIGMATEL_ANALOG, snd_ac97_read(ac97, AC97_SIGMATEL_ANALOG) & ~0x0003);
930 if (snd_ac97_try_bit(ac97, AC97_SIGMATEL_ANALOG, 1))
931 if ((err = patch_build_controls(ac97, &snd_ac97_sigmatel_controls[0], 1)) < 0)
933 if (snd_ac97_try_bit(ac97, AC97_SIGMATEL_ANALOG, 0))
934 if ((err = patch_build_controls(ac97, &snd_ac97_sigmatel_controls[1], 1)) < 0)
936 if (snd_ac97_try_bit(ac97, AC97_SIGMATEL_DAC2INVERT, 2))
937 if ((err = patch_build_controls(ac97, &snd_ac97_sigmatel_4speaker, 1)) < 0)
939 if (snd_ac97_try_bit(ac97, AC97_SIGMATEL_DAC2INVERT, 3))
940 if ((err = patch_build_controls(ac97, &snd_ac97_sigmatel_phaseinvert, 1)) < 0)
945 static const struct snd_ac97_build_ops patch_sigmatel_stac9700_ops = {
946 .build_3d = patch_sigmatel_stac9700_3d,
947 .build_specific = patch_sigmatel_stac97xx_specific
950 static int patch_sigmatel_stac9700(struct snd_ac97 * ac97)
952 ac97->build_ops = &patch_sigmatel_stac9700_ops;
956 static int snd_ac97_stac9708_put_bias(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
958 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
961 mutex_lock(&ac97->page_mutex);
962 snd_ac97_write(ac97, AC97_SIGMATEL_BIAS1, 0xabba);
963 err = snd_ac97_update_bits(ac97, AC97_SIGMATEL_BIAS2, 0x0010,
964 (ucontrol->value.integer.value[0] & 1) << 4);
965 snd_ac97_write(ac97, AC97_SIGMATEL_BIAS1, 0);
966 mutex_unlock(&ac97->page_mutex);
970 static const struct snd_kcontrol_new snd_ac97_stac9708_bias_control = {
971 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
972 .name = "Sigmatel Output Bias Switch",
973 .info = snd_ac97_info_volsw,
974 .get = snd_ac97_get_volsw,
975 .put = snd_ac97_stac9708_put_bias,
976 .private_value = AC97_SINGLE_VALUE(AC97_SIGMATEL_BIAS2, 4, 1, 0),
979 static int patch_sigmatel_stac9708_specific(struct snd_ac97 *ac97)
983 /* the register bit is writable, but the function is not implemented: */
984 snd_ac97_remove_ctl(ac97, "PCM Out Path & Mute", NULL);
986 snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Sigmatel Surround Playback");
987 if ((err = patch_build_controls(ac97, &snd_ac97_stac9708_bias_control, 1)) < 0)
989 return patch_sigmatel_stac97xx_specific(ac97);
992 static const struct snd_ac97_build_ops patch_sigmatel_stac9708_ops = {
993 .build_3d = patch_sigmatel_stac9708_3d,
994 .build_specific = patch_sigmatel_stac9708_specific
997 static int patch_sigmatel_stac9708(struct snd_ac97 * ac97)
999 unsigned int codec72, codec6c;
1001 ac97->build_ops = &patch_sigmatel_stac9708_ops;
1002 ac97->caps |= 0x10; /* HP (sigmatel surround) support */
1004 codec72 = snd_ac97_read(ac97, AC97_SIGMATEL_BIAS2) & 0x8000;
1005 codec6c = snd_ac97_read(ac97, AC97_SIGMATEL_ANALOG);
1007 if ((codec72==0) && (codec6c==0)) {
1008 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba);
1009 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x1000);
1010 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS1, 0xabba);
1011 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS2, 0x0007);
1012 } else if ((codec72==0x8000) && (codec6c==0)) {
1013 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba);
1014 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x1001);
1015 snd_ac97_write_cache(ac97, AC97_SIGMATEL_DAC2INVERT, 0x0008);
1016 } else if ((codec72==0x8000) && (codec6c==0x0080)) {
1019 snd_ac97_write_cache(ac97, AC97_SIGMATEL_MULTICHN, 0x0000);
1023 static int patch_sigmatel_stac9721(struct snd_ac97 * ac97)
1025 ac97->build_ops = &patch_sigmatel_stac9700_ops;
1026 if (snd_ac97_read(ac97, AC97_SIGMATEL_ANALOG) == 0) {
1027 // patch for SigmaTel
1028 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba);
1029 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x4000);
1030 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS1, 0xabba);
1031 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS2, 0x0002);
1033 snd_ac97_write_cache(ac97, AC97_SIGMATEL_MULTICHN, 0x0000);
1037 static int patch_sigmatel_stac9744(struct snd_ac97 * ac97)
1039 // patch for SigmaTel
1040 ac97->build_ops = &patch_sigmatel_stac9700_ops;
1041 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba);
1042 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x0000); /* is this correct? --jk */
1043 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS1, 0xabba);
1044 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS2, 0x0002);
1045 snd_ac97_write_cache(ac97, AC97_SIGMATEL_MULTICHN, 0x0000);
1049 static int patch_sigmatel_stac9756(struct snd_ac97 * ac97)
1051 // patch for SigmaTel
1052 ac97->build_ops = &patch_sigmatel_stac9700_ops;
1053 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC1, 0xabba);
1054 snd_ac97_write_cache(ac97, AC97_SIGMATEL_CIC2, 0x0000); /* is this correct? --jk */
1055 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS1, 0xabba);
1056 snd_ac97_write_cache(ac97, AC97_SIGMATEL_BIAS2, 0x0002);
1057 snd_ac97_write_cache(ac97, AC97_SIGMATEL_MULTICHN, 0x0000);
1061 static int snd_ac97_stac9758_output_jack_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1063 static const char * const texts[5] = {
1064 "Input/Disabled", "Front Output",
1065 "Rear Output", "Center/LFE Output", "Mixer Output" };
1067 return snd_ctl_enum_info(uinfo, 1, 5, texts);
1070 static int snd_ac97_stac9758_output_jack_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1072 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
1073 int shift = kcontrol->private_value;
1076 val = ac97->regs[AC97_SIGMATEL_OUTSEL] >> shift;
1078 ucontrol->value.enumerated.item[0] = 0;
1080 ucontrol->value.enumerated.item[0] = 1 + (val & 3);
1084 static int snd_ac97_stac9758_output_jack_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1086 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
1087 int shift = kcontrol->private_value;
1090 if (ucontrol->value.enumerated.item[0] > 4)
1092 if (ucontrol->value.enumerated.item[0] == 0)
1095 val = 4 | (ucontrol->value.enumerated.item[0] - 1);
1096 return ac97_update_bits_page(ac97, AC97_SIGMATEL_OUTSEL,
1097 7 << shift, val << shift, 0);
1100 static int snd_ac97_stac9758_input_jack_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1102 static const char * const texts[7] = {
1103 "Mic2 Jack", "Mic1 Jack", "Line In Jack",
1104 "Front Jack", "Rear Jack", "Center/LFE Jack", "Mute" };
1106 return snd_ctl_enum_info(uinfo, 1, 7, texts);
1109 static int snd_ac97_stac9758_input_jack_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1111 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
1112 int shift = kcontrol->private_value;
1115 val = ac97->regs[AC97_SIGMATEL_INSEL];
1116 ucontrol->value.enumerated.item[0] = (val >> shift) & 7;
1120 static int snd_ac97_stac9758_input_jack_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1122 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
1123 int shift = kcontrol->private_value;
1125 return ac97_update_bits_page(ac97, AC97_SIGMATEL_INSEL, 7 << shift,
1126 ucontrol->value.enumerated.item[0] << shift, 0);
1129 static int snd_ac97_stac9758_phonesel_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1131 static const char * const texts[3] = {
1132 "None", "Front Jack", "Rear Jack"
1135 return snd_ctl_enum_info(uinfo, 1, 3, texts);
1138 static int snd_ac97_stac9758_phonesel_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1140 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
1142 ucontrol->value.enumerated.item[0] = ac97->regs[AC97_SIGMATEL_IOMISC] & 3;
1146 static int snd_ac97_stac9758_phonesel_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1148 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
1150 return ac97_update_bits_page(ac97, AC97_SIGMATEL_IOMISC, 3,
1151 ucontrol->value.enumerated.item[0], 0);
1154 #define STAC9758_OUTPUT_JACK(xname, shift) \
1155 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
1156 .info = snd_ac97_stac9758_output_jack_info, \
1157 .get = snd_ac97_stac9758_output_jack_get, \
1158 .put = snd_ac97_stac9758_output_jack_put, \
1159 .private_value = shift }
1160 #define STAC9758_INPUT_JACK(xname, shift) \
1161 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
1162 .info = snd_ac97_stac9758_input_jack_info, \
1163 .get = snd_ac97_stac9758_input_jack_get, \
1164 .put = snd_ac97_stac9758_input_jack_put, \
1165 .private_value = shift }
1166 static const struct snd_kcontrol_new snd_ac97_sigmatel_stac9758_controls[] = {
1167 STAC9758_OUTPUT_JACK("Mic1 Jack", 1),
1168 STAC9758_OUTPUT_JACK("LineIn Jack", 4),
1169 STAC9758_OUTPUT_JACK("Front Jack", 7),
1170 STAC9758_OUTPUT_JACK("Rear Jack", 10),
1171 STAC9758_OUTPUT_JACK("Center/LFE Jack", 13),
1172 STAC9758_INPUT_JACK("Mic Input Source", 0),
1173 STAC9758_INPUT_JACK("Line Input Source", 8),
1175 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1176 .name = "Headphone Amp",
1177 .info = snd_ac97_stac9758_phonesel_info,
1178 .get = snd_ac97_stac9758_phonesel_get,
1179 .put = snd_ac97_stac9758_phonesel_put
1181 AC97_SINGLE("Exchange Center/LFE", AC97_SIGMATEL_IOMISC, 4, 1, 0),
1182 AC97_SINGLE("Headphone +3dB Boost", AC97_SIGMATEL_IOMISC, 8, 1, 0)
1185 static int patch_sigmatel_stac9758_specific(struct snd_ac97 *ac97)
1189 err = patch_sigmatel_stac97xx_specific(ac97);
1192 err = patch_build_controls(ac97, snd_ac97_sigmatel_stac9758_controls,
1193 ARRAY_SIZE(snd_ac97_sigmatel_stac9758_controls));
1197 snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Front Playback");
1198 /* DAC-A to Mix = PCM */
1199 /* DAC-B direct = Surround */
1201 snd_ac97_rename_vol_ctl(ac97, "Video Playback", "Surround Mix Playback");
1202 /* DAC-C direct = Center/LFE */
1207 static const struct snd_ac97_build_ops patch_sigmatel_stac9758_ops = {
1208 .build_3d = patch_sigmatel_stac9700_3d,
1209 .build_specific = patch_sigmatel_stac9758_specific
1212 static int patch_sigmatel_stac9758(struct snd_ac97 * ac97)
1214 static const unsigned short regs[4] = {
1215 AC97_SIGMATEL_OUTSEL,
1216 AC97_SIGMATEL_IOMISC,
1217 AC97_SIGMATEL_INSEL,
1218 AC97_SIGMATEL_VARIOUS
1220 static const unsigned short def_regs[4] = {
1221 /* OUTSEL */ 0xd794, /* CL:CL, SR:SR, LO:MX, LI:DS, MI:DS */
1222 /* IOMISC */ 0x2001,
1223 /* INSEL */ 0x0201, /* LI:LI, MI:M1 */
1224 /* VARIOUS */ 0x0040
1226 static const unsigned short m675_regs[4] = {
1227 /* OUTSEL */ 0xfc70, /* CL:MX, SR:MX, LO:DS, LI:MX, MI:DS */
1228 /* IOMISC */ 0x2102, /* HP amp on */
1229 /* INSEL */ 0x0203, /* LI:LI, MI:FR */
1230 /* VARIOUS */ 0x0041 /* stereo mic */
1232 const unsigned short *pregs = def_regs;
1235 /* Gateway M675 notebook */
1237 ac97->subsystem_vendor == 0x107b &&
1238 ac97->subsystem_device == 0x0601)
1241 // patch for SigmaTel
1242 ac97->build_ops = &patch_sigmatel_stac9758_ops;
1243 /* FIXME: assume only page 0 for writing cache */
1244 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, AC97_PAGE_VENDOR);
1245 for (i = 0; i < 4; i++)
1246 snd_ac97_write_cache(ac97, regs[i], pregs[i]);
1248 ac97->flags |= AC97_STEREO_MUTES;
1253 * Cirrus Logic CS42xx codecs
1255 static const struct snd_kcontrol_new snd_ac97_cirrus_controls_spdif[2] = {
1256 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), AC97_CSR_SPDIF, 15, 1, 0),
1257 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "AC97-SPSA", AC97_CSR_ACMODE, 0, 3, 0)
1260 static int patch_cirrus_build_spdif(struct snd_ac97 * ac97)
1264 /* con mask, pro mask, default */
1265 if ((err = patch_build_controls(ac97, &snd_ac97_controls_spdif[0], 3)) < 0)
1268 if ((err = patch_build_controls(ac97, &snd_ac97_cirrus_controls_spdif[0], 1)) < 0)
1270 switch (ac97->id & AC97_ID_CS_MASK) {
1271 case AC97_ID_CS4205:
1272 if ((err = patch_build_controls(ac97, &snd_ac97_cirrus_controls_spdif[1], 1)) < 0)
1276 /* set default PCM S/PDIF params */
1277 /* consumer,PCM audio,no copyright,no preemphasis,PCM coder,original,48000Hz */
1278 snd_ac97_write_cache(ac97, AC97_CSR_SPDIF, 0x0a20);
1282 static const struct snd_ac97_build_ops patch_cirrus_ops = {
1283 .build_spdif = patch_cirrus_build_spdif
1286 static int patch_cirrus_spdif(struct snd_ac97 * ac97)
1288 /* Basically, the cs4201/cs4205/cs4297a has non-standard sp/dif registers.
1289 WHY CAN'T ANYONE FOLLOW THE BLOODY SPEC? *sigh*
1290 - sp/dif EA ID is not set, but sp/dif is always present.
1291 - enable/disable is spdif register bit 15.
1292 - sp/dif control register is 0x68. differs from AC97:
1293 - valid is bit 14 (vs 15)
1295 - only 44.1/48k [00 = 48, 01=44,1] (AC97 is 00=44.1, 10=48)
1296 - sp/dif ssource select is in 0x5e bits 0,1.
1299 ac97->build_ops = &patch_cirrus_ops;
1300 ac97->flags |= AC97_CS_SPDIF;
1301 ac97->rates[AC97_RATES_SPDIF] &= ~SNDRV_PCM_RATE_32000;
1302 ac97->ext_id |= AC97_EI_SPDIF; /* force the detection of spdif */
1303 snd_ac97_write_cache(ac97, AC97_CSR_ACMODE, 0x0080);
1307 static int patch_cirrus_cs4299(struct snd_ac97 * ac97)
1309 /* force the detection of PC Beep */
1310 ac97->flags |= AC97_HAS_PC_BEEP;
1312 return patch_cirrus_spdif(ac97);
1318 static const struct snd_kcontrol_new snd_ac97_conexant_controls_spdif[1] = {
1319 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH), AC97_CXR_AUDIO_MISC, 3, 1, 0),
1322 static int patch_conexant_build_spdif(struct snd_ac97 * ac97)
1326 /* con mask, pro mask, default */
1327 if ((err = patch_build_controls(ac97, &snd_ac97_controls_spdif[0], 3)) < 0)
1330 if ((err = patch_build_controls(ac97, &snd_ac97_conexant_controls_spdif[0], 1)) < 0)
1332 /* set default PCM S/PDIF params */
1333 /* consumer,PCM audio,no copyright,no preemphasis,PCM coder,original,48000Hz */
1334 snd_ac97_write_cache(ac97, AC97_CXR_AUDIO_MISC,
1335 snd_ac97_read(ac97, AC97_CXR_AUDIO_MISC) & ~(AC97_CXR_SPDIFEN|AC97_CXR_COPYRGT|AC97_CXR_SPDIF_MASK));
1339 static const struct snd_ac97_build_ops patch_conexant_ops = {
1340 .build_spdif = patch_conexant_build_spdif
1343 static int patch_conexant(struct snd_ac97 * ac97)
1345 ac97->build_ops = &patch_conexant_ops;
1346 ac97->flags |= AC97_CX_SPDIF;
1347 ac97->ext_id |= AC97_EI_SPDIF; /* force the detection of spdif */
1348 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000; /* 48k only */
1352 static int patch_cx20551(struct snd_ac97 *ac97)
1354 snd_ac97_update_bits(ac97, 0x5c, 0x01, 0x01);
1359 * Analog Devices AD18xx, AD19xx codecs
1362 static void ad18xx_resume(struct snd_ac97 *ac97)
1364 static const unsigned short setup_regs[] = {
1365 AC97_AD_MISC, AC97_AD_SERIAL_CFG, AC97_AD_JACK_SPDIF,
1369 for (i = 0; i < (int)ARRAY_SIZE(setup_regs); i++) {
1370 unsigned short reg = setup_regs[i];
1371 if (test_bit(reg, ac97->reg_accessed)) {
1372 snd_ac97_write(ac97, reg, ac97->regs[reg]);
1373 snd_ac97_read(ac97, reg);
1377 if (! (ac97->flags & AC97_AD_MULTI))
1378 /* normal restore */
1379 snd_ac97_restore_status(ac97);
1381 /* restore the AD18xx codec configurations */
1382 for (codec = 0; codec < 3; codec++) {
1383 if (! ac97->spec.ad18xx.id[codec])
1385 /* select single codec */
1386 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000,
1387 ac97->spec.ad18xx.unchained[codec] | ac97->spec.ad18xx.chained[codec]);
1388 ac97->bus->ops->write(ac97, AC97_AD_CODEC_CFG, ac97->spec.ad18xx.codec_cfg[codec]);
1390 /* select all codecs */
1391 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 0x7000);
1393 /* restore status */
1394 for (i = 2; i < 0x7c ; i += 2) {
1395 if (i == AC97_POWERDOWN || i == AC97_EXTENDED_ID)
1397 if (test_bit(i, ac97->reg_accessed)) {
1398 /* handle multi codecs for AD18xx */
1399 if (i == AC97_PCM) {
1400 for (codec = 0; codec < 3; codec++) {
1401 if (! ac97->spec.ad18xx.id[codec])
1403 /* select single codec */
1404 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000,
1405 ac97->spec.ad18xx.unchained[codec] | ac97->spec.ad18xx.chained[codec]);
1406 /* update PCM bits */
1407 ac97->bus->ops->write(ac97, AC97_PCM, ac97->spec.ad18xx.pcmreg[codec]);
1409 /* select all codecs */
1410 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 0x7000);
1412 } else if (i == AC97_AD_TEST ||
1413 i == AC97_AD_CODEC_CFG ||
1414 i == AC97_AD_SERIAL_CFG)
1415 continue; /* ignore */
1417 snd_ac97_write(ac97, i, ac97->regs[i]);
1418 snd_ac97_read(ac97, i);
1422 snd_ac97_restore_iec958(ac97);
1425 static void ad1888_resume(struct snd_ac97 *ac97)
1427 ad18xx_resume(ac97);
1428 snd_ac97_write_cache(ac97, AC97_CODEC_CLASS_REV, 0x8080);
1433 static const struct snd_ac97_res_table ad1819_restbl[] = {
1434 { AC97_PHONE, 0x9f1f },
1435 { AC97_MIC, 0x9f1f },
1436 { AC97_LINE, 0x9f1f },
1437 { AC97_CD, 0x9f1f },
1438 { AC97_VIDEO, 0x9f1f },
1439 { AC97_AUX, 0x9f1f },
1440 { AC97_PCM, 0x9f1f },
1441 { } /* terminator */
1444 static int patch_ad1819(struct snd_ac97 * ac97)
1446 unsigned short scfg;
1448 // patch for Analog Devices
1449 scfg = snd_ac97_read(ac97, AC97_AD_SERIAL_CFG);
1450 snd_ac97_write_cache(ac97, AC97_AD_SERIAL_CFG, scfg | 0x7000); /* select all codecs */
1451 ac97->res_table = ad1819_restbl;
1455 static unsigned short patch_ad1881_unchained(struct snd_ac97 * ac97, int idx, unsigned short mask)
1459 // test for unchained codec
1460 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, mask);
1461 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, 0x0000); /* ID0C, ID1C, SDIE = off */
1462 val = snd_ac97_read(ac97, AC97_VENDOR_ID2);
1463 if ((val & 0xff40) != 0x5340)
1465 ac97->spec.ad18xx.unchained[idx] = mask;
1466 ac97->spec.ad18xx.id[idx] = val;
1467 ac97->spec.ad18xx.codec_cfg[idx] = 0x0000;
1471 static int patch_ad1881_chained1(struct snd_ac97 * ac97, int idx, unsigned short codec_bits)
1473 static const int cfg_bits[3] = { 1<<12, 1<<14, 1<<13 };
1476 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, cfg_bits[idx]);
1477 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, 0x0004); // SDIE
1478 val = snd_ac97_read(ac97, AC97_VENDOR_ID2);
1479 if ((val & 0xff40) != 0x5340)
1482 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, codec_bits);
1483 ac97->spec.ad18xx.chained[idx] = cfg_bits[idx];
1484 ac97->spec.ad18xx.id[idx] = val;
1485 ac97->spec.ad18xx.codec_cfg[idx] = codec_bits ? codec_bits : 0x0004;
1489 static void patch_ad1881_chained(struct snd_ac97 * ac97, int unchained_idx, int cidx1, int cidx2)
1491 // already detected?
1492 if (ac97->spec.ad18xx.unchained[cidx1] || ac97->spec.ad18xx.chained[cidx1])
1494 if (ac97->spec.ad18xx.unchained[cidx2] || ac97->spec.ad18xx.chained[cidx2])
1496 if (cidx1 < 0 && cidx2 < 0)
1498 // test for chained codecs
1499 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000,
1500 ac97->spec.ad18xx.unchained[unchained_idx]);
1501 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, 0x0002); // ID1C
1502 ac97->spec.ad18xx.codec_cfg[unchained_idx] = 0x0002;
1505 patch_ad1881_chained1(ac97, cidx1, 0);
1506 else if (patch_ad1881_chained1(ac97, cidx1, 0x0006)) // SDIE | ID1C
1507 patch_ad1881_chained1(ac97, cidx2, 0);
1508 else if (patch_ad1881_chained1(ac97, cidx2, 0x0006)) // SDIE | ID1C
1509 patch_ad1881_chained1(ac97, cidx1, 0);
1510 } else if (cidx2 >= 0) {
1511 patch_ad1881_chained1(ac97, cidx2, 0);
1515 static const struct snd_ac97_build_ops patch_ad1881_build_ops = {
1517 .resume = ad18xx_resume
1521 static int patch_ad1881(struct snd_ac97 * ac97)
1523 static const char cfg_idxs[3][2] = {
1529 // patch for Analog Devices
1530 unsigned short codecs[3];
1534 val = snd_ac97_read(ac97, AC97_AD_SERIAL_CFG);
1535 snd_ac97_write_cache(ac97, AC97_AD_SERIAL_CFG, val);
1536 codecs[0] = patch_ad1881_unchained(ac97, 0, (1<<12));
1537 codecs[1] = patch_ad1881_unchained(ac97, 1, (1<<14));
1538 codecs[2] = patch_ad1881_unchained(ac97, 2, (1<<13));
1540 if (! (codecs[0] || codecs[1] || codecs[2]))
1543 for (idx = 0; idx < 3; idx++)
1544 if (ac97->spec.ad18xx.unchained[idx])
1545 patch_ad1881_chained(ac97, idx, cfg_idxs[idx][0], cfg_idxs[idx][1]);
1547 if (ac97->spec.ad18xx.id[1]) {
1548 ac97->flags |= AC97_AD_MULTI;
1549 ac97->scaps |= AC97_SCAP_SURROUND_DAC;
1551 if (ac97->spec.ad18xx.id[2]) {
1552 ac97->flags |= AC97_AD_MULTI;
1553 ac97->scaps |= AC97_SCAP_CENTER_LFE_DAC;
1557 /* select all codecs */
1558 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x7000, 0x7000);
1559 /* check if only one codec is present */
1560 for (idx = num = 0; idx < 3; idx++)
1561 if (ac97->spec.ad18xx.id[idx])
1564 /* ok, deselect all ID bits */
1565 snd_ac97_write_cache(ac97, AC97_AD_CODEC_CFG, 0x0000);
1566 ac97->spec.ad18xx.codec_cfg[0] =
1567 ac97->spec.ad18xx.codec_cfg[1] =
1568 ac97->spec.ad18xx.codec_cfg[2] = 0x0000;
1570 /* required for AD1886/AD1885 combination */
1571 ac97->ext_id = snd_ac97_read(ac97, AC97_EXTENDED_ID);
1572 if (ac97->spec.ad18xx.id[0]) {
1573 ac97->id &= 0xffff0000;
1574 ac97->id |= ac97->spec.ad18xx.id[0];
1576 ac97->build_ops = &patch_ad1881_build_ops;
1580 static const struct snd_kcontrol_new snd_ac97_controls_ad1885[] = {
1581 AC97_SINGLE("Digital Mono Direct", AC97_AD_MISC, 11, 1, 0),
1582 /* AC97_SINGLE("Digital Audio Mode", AC97_AD_MISC, 12, 1, 0), */ /* seems problematic */
1583 AC97_SINGLE("Low Power Mixer", AC97_AD_MISC, 14, 1, 0),
1584 AC97_SINGLE("Zero Fill DAC", AC97_AD_MISC, 15, 1, 0),
1585 AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 9, 1, 1), /* inverted */
1586 AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 8, 1, 1), /* inverted */
1589 static const DECLARE_TLV_DB_SCALE(db_scale_6bit_6db_max, -8850, 150, 0);
1591 static int patch_ad1885_specific(struct snd_ac97 * ac97)
1595 if ((err = patch_build_controls(ac97, snd_ac97_controls_ad1885, ARRAY_SIZE(snd_ac97_controls_ad1885))) < 0)
1597 reset_tlv(ac97, "Headphone Playback Volume",
1598 db_scale_6bit_6db_max);
1602 static const struct snd_ac97_build_ops patch_ad1885_build_ops = {
1603 .build_specific = &patch_ad1885_specific,
1605 .resume = ad18xx_resume
1609 static int patch_ad1885(struct snd_ac97 * ac97)
1612 /* This is required to deal with the Intel D815EEAL2 */
1613 /* i.e. Line out is actually headphone out from codec */
1616 snd_ac97_write_cache(ac97, AC97_AD_MISC, 0x0404);
1618 ac97->build_ops = &patch_ad1885_build_ops;
1622 static int patch_ad1886_specific(struct snd_ac97 * ac97)
1624 reset_tlv(ac97, "Headphone Playback Volume",
1625 db_scale_6bit_6db_max);
1629 static const struct snd_ac97_build_ops patch_ad1886_build_ops = {
1630 .build_specific = &patch_ad1886_specific,
1632 .resume = ad18xx_resume
1636 static int patch_ad1886(struct snd_ac97 * ac97)
1639 /* Presario700 workaround */
1640 /* for Jack Sense/SPDIF Register misetting causing */
1641 snd_ac97_write_cache(ac97, AC97_AD_JACK_SPDIF, 0x0010);
1642 ac97->build_ops = &patch_ad1886_build_ops;
1646 /* MISC bits (AD1888/AD1980/AD1985 register 0x76) */
1647 #define AC97_AD198X_MBC 0x0003 /* mic boost */
1648 #define AC97_AD198X_MBC_20 0x0000 /* +20dB */
1649 #define AC97_AD198X_MBC_10 0x0001 /* +10dB */
1650 #define AC97_AD198X_MBC_30 0x0002 /* +30dB */
1651 #define AC97_AD198X_VREFD 0x0004 /* VREF high-Z */
1652 #define AC97_AD198X_VREFH 0x0008 /* 0=2.25V, 1=3.7V */
1653 #define AC97_AD198X_VREF_0 0x000c /* 0V (AD1985 only) */
1654 #define AC97_AD198X_VREF_MASK (AC97_AD198X_VREFH | AC97_AD198X_VREFD)
1655 #define AC97_AD198X_VREF_SHIFT 2
1656 #define AC97_AD198X_SRU 0x0010 /* sample rate unlock */
1657 #define AC97_AD198X_LOSEL 0x0020 /* LINE_OUT amplifiers input select */
1658 #define AC97_AD198X_2MIC 0x0040 /* 2-channel mic select */
1659 #define AC97_AD198X_SPRD 0x0080 /* SPREAD enable */
1660 #define AC97_AD198X_DMIX0 0x0100 /* downmix mode: */
1661 /* 0 = 6-to-4, 1 = 6-to-2 downmix */
1662 #define AC97_AD198X_DMIX1 0x0200 /* downmix mode: 1 = enabled */
1663 #define AC97_AD198X_HPSEL 0x0400 /* headphone amplifier input select */
1664 #define AC97_AD198X_CLDIS 0x0800 /* center/lfe disable */
1665 #define AC97_AD198X_LODIS 0x1000 /* LINE_OUT disable */
1666 #define AC97_AD198X_MSPLT 0x2000 /* mute split */
1667 #define AC97_AD198X_AC97NC 0x4000 /* AC97 no compatible mode */
1668 #define AC97_AD198X_DACZ 0x8000 /* DAC zero-fill mode */
1670 /* MISC 1 bits (AD1986 register 0x76) */
1671 #define AC97_AD1986_MBC 0x0003 /* mic boost */
1672 #define AC97_AD1986_MBC_20 0x0000 /* +20dB */
1673 #define AC97_AD1986_MBC_10 0x0001 /* +10dB */
1674 #define AC97_AD1986_MBC_30 0x0002 /* +30dB */
1675 #define AC97_AD1986_LISEL0 0x0004 /* LINE_IN select bit 0 */
1676 #define AC97_AD1986_LISEL1 0x0008 /* LINE_IN select bit 1 */
1677 #define AC97_AD1986_LISEL_MASK (AC97_AD1986_LISEL1 | AC97_AD1986_LISEL0)
1678 #define AC97_AD1986_LISEL_LI 0x0000 /* LINE_IN pins as LINE_IN source */
1679 #define AC97_AD1986_LISEL_SURR 0x0004 /* SURROUND pins as LINE_IN source */
1680 #define AC97_AD1986_LISEL_MIC 0x0008 /* MIC_1/2 pins as LINE_IN source */
1681 #define AC97_AD1986_SRU 0x0010 /* sample rate unlock */
1682 #define AC97_AD1986_SOSEL 0x0020 /* SURROUND_OUT amplifiers input sel */
1683 #define AC97_AD1986_2MIC 0x0040 /* 2-channel mic select */
1684 #define AC97_AD1986_SPRD 0x0080 /* SPREAD enable */
1685 #define AC97_AD1986_DMIX0 0x0100 /* downmix mode: */
1686 /* 0 = 6-to-4, 1 = 6-to-2 downmix */
1687 #define AC97_AD1986_DMIX1 0x0200 /* downmix mode: 1 = enabled */
1688 #define AC97_AD1986_CLDIS 0x0800 /* center/lfe disable */
1689 #define AC97_AD1986_SODIS 0x1000 /* SURROUND_OUT disable */
1690 #define AC97_AD1986_MSPLT 0x2000 /* mute split (read only 1) */
1691 #define AC97_AD1986_AC97NC 0x4000 /* AC97 no compatible mode (r/o 1) */
1692 #define AC97_AD1986_DACZ 0x8000 /* DAC zero-fill mode */
1694 /* MISC 2 bits (AD1986 register 0x70) */
1695 #define AC97_AD_MISC2 0x70 /* Misc Control Bits 2 (AD1986) */
1697 #define AC97_AD1986_CVREF0 0x0004 /* C/LFE VREF_OUT 2.25V */
1698 #define AC97_AD1986_CVREF1 0x0008 /* C/LFE VREF_OUT 0V */
1699 #define AC97_AD1986_CVREF2 0x0010 /* C/LFE VREF_OUT 3.7V */
1700 #define AC97_AD1986_CVREF_MASK \
1701 (AC97_AD1986_CVREF2 | AC97_AD1986_CVREF1 | AC97_AD1986_CVREF0)
1702 #define AC97_AD1986_JSMAP 0x0020 /* Jack Sense Mapping 1 = alternate */
1703 #define AC97_AD1986_MMDIS 0x0080 /* Mono Mute Disable */
1704 #define AC97_AD1986_MVREF0 0x0400 /* MIC VREF_OUT 2.25V */
1705 #define AC97_AD1986_MVREF1 0x0800 /* MIC VREF_OUT 0V */
1706 #define AC97_AD1986_MVREF2 0x1000 /* MIC VREF_OUT 3.7V */
1707 #define AC97_AD1986_MVREF_MASK \
1708 (AC97_AD1986_MVREF2 | AC97_AD1986_MVREF1 | AC97_AD1986_MVREF0)
1710 /* MISC 3 bits (AD1986 register 0x7a) */
1711 #define AC97_AD_MISC3 0x7a /* Misc Control Bits 3 (AD1986) */
1713 #define AC97_AD1986_MMIX 0x0004 /* Mic Mix, left/right */
1714 #define AC97_AD1986_GPO 0x0008 /* General Purpose Out */
1715 #define AC97_AD1986_LOHPEN 0x0010 /* LINE_OUT headphone drive */
1716 #define AC97_AD1986_LVREF0 0x0100 /* LINE_OUT VREF_OUT 2.25V */
1717 #define AC97_AD1986_LVREF1 0x0200 /* LINE_OUT VREF_OUT 0V */
1718 #define AC97_AD1986_LVREF2 0x0400 /* LINE_OUT VREF_OUT 3.7V */
1719 #define AC97_AD1986_LVREF_MASK \
1720 (AC97_AD1986_LVREF2 | AC97_AD1986_LVREF1 | AC97_AD1986_LVREF0)
1721 #define AC97_AD1986_JSINVA 0x0800 /* Jack Sense Invert SENSE_A */
1722 #define AC97_AD1986_LOSEL 0x1000 /* LINE_OUT amplifiers input select */
1723 #define AC97_AD1986_HPSEL0 0x2000 /* Headphone amplifiers */
1724 /* input select Surround DACs */
1725 #define AC97_AD1986_HPSEL1 0x4000 /* Headphone amplifiers input */
1726 /* select C/LFE DACs */
1727 #define AC97_AD1986_JSINVB 0x8000 /* Jack Sense Invert SENSE_B */
1729 /* Serial Config bits (AD1986 register 0x74) (incomplete) */
1730 #define AC97_AD1986_OMS0 0x0100 /* Optional Mic Selector bit 0 */
1731 #define AC97_AD1986_OMS1 0x0200 /* Optional Mic Selector bit 1 */
1732 #define AC97_AD1986_OMS2 0x0400 /* Optional Mic Selector bit 2 */
1733 #define AC97_AD1986_OMS_MASK \
1734 (AC97_AD1986_OMS2 | AC97_AD1986_OMS1 | AC97_AD1986_OMS0)
1735 #define AC97_AD1986_OMS_M 0x0000 /* MIC_1/2 pins are MIC sources */
1736 #define AC97_AD1986_OMS_L 0x0100 /* LINE_IN pins are MIC sources */
1737 #define AC97_AD1986_OMS_C 0x0200 /* Center/LFE pins are MCI sources */
1738 #define AC97_AD1986_OMS_MC 0x0400 /* Mix of MIC and C/LFE pins */
1739 /* are MIC sources */
1740 #define AC97_AD1986_OMS_ML 0x0500 /* MIX of MIC and LINE_IN pins */
1741 /* are MIC sources */
1742 #define AC97_AD1986_OMS_LC 0x0600 /* MIX of LINE_IN and C/LFE pins */
1743 /* are MIC sources */
1744 #define AC97_AD1986_OMS_MLC 0x0700 /* MIX of MIC, LINE_IN, C/LFE pins */
1745 /* are MIC sources */
1748 static int snd_ac97_ad198x_spdif_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1750 static const char * const texts[2] = { "AC-Link", "A/D Converter" };
1752 return snd_ctl_enum_info(uinfo, 1, 2, texts);
1755 static int snd_ac97_ad198x_spdif_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1757 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
1760 val = ac97->regs[AC97_AD_SERIAL_CFG];
1761 ucontrol->value.enumerated.item[0] = (val >> 2) & 1;
1765 static int snd_ac97_ad198x_spdif_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1767 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
1770 if (ucontrol->value.enumerated.item[0] > 1)
1772 val = ucontrol->value.enumerated.item[0] << 2;
1773 return snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 0x0004, val);
1776 static const struct snd_kcontrol_new snd_ac97_ad198x_spdif_source = {
1777 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1778 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1779 .info = snd_ac97_ad198x_spdif_source_info,
1780 .get = snd_ac97_ad198x_spdif_source_get,
1781 .put = snd_ac97_ad198x_spdif_source_put,
1784 static int patch_ad198x_post_spdif(struct snd_ac97 * ac97)
1786 return patch_build_controls(ac97, &snd_ac97_ad198x_spdif_source, 1);
1789 static const struct snd_kcontrol_new snd_ac97_ad1981x_jack_sense[] = {
1790 AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 11, 1, 0),
1791 AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 12, 1, 0),
1794 /* deny list to avoid HP/Line jack-sense controls
1795 * (SS vendor << 16 | device)
1797 static const unsigned int ad1981_jacks_denylist[] = {
1798 0x10140523, /* Thinkpad R40 */
1799 0x10140534, /* Thinkpad X31 */
1800 0x10140537, /* Thinkpad T41p */
1801 0x1014053e, /* Thinkpad R40e */
1802 0x10140554, /* Thinkpad T42p/R50p */
1803 0x10140567, /* Thinkpad T43p 2668-G7U */
1804 0x10140581, /* Thinkpad X41-2527 */
1805 0x10280160, /* Dell Dimension 2400 */
1806 0x104380b0, /* Asus A7V8X-MX */
1807 0x11790241, /* Toshiba Satellite A-15 S127 */
1808 0x1179ff10, /* Toshiba P500 */
1809 0x144dc01a, /* Samsung NP-X20C004/SEG */
1813 static int check_list(struct snd_ac97 *ac97, const unsigned int *list)
1815 u32 subid = ((u32)ac97->subsystem_vendor << 16) | ac97->subsystem_device;
1816 for (; *list; list++)
1822 static int patch_ad1981a_specific(struct snd_ac97 * ac97)
1824 if (check_list(ac97, ad1981_jacks_denylist))
1826 return patch_build_controls(ac97, snd_ac97_ad1981x_jack_sense,
1827 ARRAY_SIZE(snd_ac97_ad1981x_jack_sense));
1830 static const struct snd_ac97_build_ops patch_ad1981a_build_ops = {
1831 .build_post_spdif = patch_ad198x_post_spdif,
1832 .build_specific = patch_ad1981a_specific,
1834 .resume = ad18xx_resume
1838 /* allow list to enable HP jack-sense bits
1839 * (SS vendor << 16 | device)
1841 static const unsigned int ad1981_jacks_allowlist[] = {
1842 0x0e11005a, /* HP nc4000/4010 */
1843 0x103c0890, /* HP nc6000 */
1844 0x103c0938, /* HP nc4220 */
1845 0x103c099c, /* HP nx6110 */
1846 0x103c0944, /* HP nc6220 */
1847 0x103c0934, /* HP nc8220 */
1848 0x103c006d, /* HP nx9105 */
1849 0x103c300d, /* HP Compaq dc5100 SFF(PT003AW) */
1850 0x17340088, /* FSC Scenic-W */
1854 static void check_ad1981_hp_jack_sense(struct snd_ac97 *ac97)
1856 if (check_list(ac97, ad1981_jacks_allowlist))
1857 /* enable headphone jack sense */
1858 snd_ac97_update_bits(ac97, AC97_AD_JACK_SPDIF, 1<<11, 1<<11);
1861 static int patch_ad1981a(struct snd_ac97 *ac97)
1864 ac97->build_ops = &patch_ad1981a_build_ops;
1865 snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD198X_MSPLT, AC97_AD198X_MSPLT);
1866 ac97->flags |= AC97_STEREO_MUTES;
1867 check_ad1981_hp_jack_sense(ac97);
1871 static const struct snd_kcontrol_new snd_ac97_ad198x_2cmic =
1872 AC97_SINGLE("Stereo Mic", AC97_AD_MISC, 6, 1, 0);
1874 static int patch_ad1981b_specific(struct snd_ac97 *ac97)
1878 if ((err = patch_build_controls(ac97, &snd_ac97_ad198x_2cmic, 1)) < 0)
1880 if (check_list(ac97, ad1981_jacks_denylist))
1882 return patch_build_controls(ac97, snd_ac97_ad1981x_jack_sense,
1883 ARRAY_SIZE(snd_ac97_ad1981x_jack_sense));
1886 static const struct snd_ac97_build_ops patch_ad1981b_build_ops = {
1887 .build_post_spdif = patch_ad198x_post_spdif,
1888 .build_specific = patch_ad1981b_specific,
1890 .resume = ad18xx_resume
1894 static int patch_ad1981b(struct snd_ac97 *ac97)
1897 ac97->build_ops = &patch_ad1981b_build_ops;
1898 snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD198X_MSPLT, AC97_AD198X_MSPLT);
1899 ac97->flags |= AC97_STEREO_MUTES;
1900 check_ad1981_hp_jack_sense(ac97);
1904 #define snd_ac97_ad1888_lohpsel_info snd_ctl_boolean_mono_info
1906 static int snd_ac97_ad1888_lohpsel_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1908 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
1911 val = ac97->regs[AC97_AD_MISC];
1912 ucontrol->value.integer.value[0] = !(val & AC97_AD198X_LOSEL);
1913 if (ac97->spec.ad18xx.lo_as_master)
1914 ucontrol->value.integer.value[0] =
1915 !ucontrol->value.integer.value[0];
1919 static int snd_ac97_ad1888_lohpsel_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1921 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
1924 val = !ucontrol->value.integer.value[0];
1925 if (ac97->spec.ad18xx.lo_as_master)
1927 val = val ? (AC97_AD198X_LOSEL | AC97_AD198X_HPSEL) : 0;
1928 return snd_ac97_update_bits(ac97, AC97_AD_MISC,
1929 AC97_AD198X_LOSEL | AC97_AD198X_HPSEL, val);
1932 static int snd_ac97_ad1888_downmix_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1934 static const char * const texts[3] = {"Off", "6 -> 4", "6 -> 2"};
1936 return snd_ctl_enum_info(uinfo, 1, 3, texts);
1939 static int snd_ac97_ad1888_downmix_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1941 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
1944 val = ac97->regs[AC97_AD_MISC];
1945 if (!(val & AC97_AD198X_DMIX1))
1946 ucontrol->value.enumerated.item[0] = 0;
1948 ucontrol->value.enumerated.item[0] = 1 + ((val >> 8) & 1);
1952 static int snd_ac97_ad1888_downmix_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1954 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
1957 if (ucontrol->value.enumerated.item[0] > 2)
1959 if (ucontrol->value.enumerated.item[0] == 0)
1962 val = AC97_AD198X_DMIX1 |
1963 ((ucontrol->value.enumerated.item[0] - 1) << 8);
1964 return snd_ac97_update_bits(ac97, AC97_AD_MISC,
1965 AC97_AD198X_DMIX0 | AC97_AD198X_DMIX1, val);
1968 static void ad1888_update_jacks(struct snd_ac97 *ac97)
1970 unsigned short val = 0;
1971 /* clear LODIS if shared jack is to be used for Surround out */
1972 if (!ac97->spec.ad18xx.lo_as_master && is_shared_linein(ac97))
1974 /* clear CLDIS if shared jack is to be used for C/LFE out */
1975 if (is_shared_micin(ac97))
1977 /* shared Line-In */
1978 snd_ac97_update_bits(ac97, AC97_AD_MISC, (1 << 11) | (1 << 12), val);
1981 static const struct snd_kcontrol_new snd_ac97_ad1888_controls[] = {
1983 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1984 .name = "Exchange Front/Surround",
1985 .info = snd_ac97_ad1888_lohpsel_info,
1986 .get = snd_ac97_ad1888_lohpsel_get,
1987 .put = snd_ac97_ad1888_lohpsel_put
1989 AC97_SINGLE("V_REFOUT Enable", AC97_AD_MISC, AC97_AD_VREFD_SHIFT, 1, 1),
1990 AC97_SINGLE("High Pass Filter Enable", AC97_AD_TEST2,
1991 AC97_AD_HPFD_SHIFT, 1, 1),
1992 AC97_SINGLE("Spread Front to Surround and Center/LFE", AC97_AD_MISC, 7, 1, 0),
1994 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1996 .info = snd_ac97_ad1888_downmix_info,
1997 .get = snd_ac97_ad1888_downmix_get,
1998 .put = snd_ac97_ad1888_downmix_put
2000 AC97_SURROUND_JACK_MODE_CTL,
2001 AC97_CHANNEL_MODE_CTL,
2003 AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 10, 1, 0),
2004 AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 12, 1, 0),
2007 static int patch_ad1888_specific(struct snd_ac97 *ac97)
2009 if (!ac97->spec.ad18xx.lo_as_master) {
2010 /* rename 0x04 as "Master" and 0x02 as "Master Surround" */
2011 snd_ac97_rename_vol_ctl(ac97, "Master Playback",
2012 "Master Surround Playback");
2013 snd_ac97_rename_vol_ctl(ac97, "Headphone Playback",
2016 return patch_build_controls(ac97, snd_ac97_ad1888_controls, ARRAY_SIZE(snd_ac97_ad1888_controls));
2019 static const struct snd_ac97_build_ops patch_ad1888_build_ops = {
2020 .build_post_spdif = patch_ad198x_post_spdif,
2021 .build_specific = patch_ad1888_specific,
2023 .resume = ad1888_resume,
2025 .update_jacks = ad1888_update_jacks,
2028 static int patch_ad1888(struct snd_ac97 * ac97)
2030 unsigned short misc;
2033 ac97->build_ops = &patch_ad1888_build_ops;
2036 * LO can be used as a real line-out on some devices,
2037 * and we need to revert the front/surround mixer switches
2039 if (ac97->subsystem_vendor == 0x1043 &&
2040 ac97->subsystem_device == 0x1193) /* ASUS A9T laptop */
2041 ac97->spec.ad18xx.lo_as_master = 1;
2043 misc = snd_ac97_read(ac97, AC97_AD_MISC);
2044 /* AD-compatible mode */
2045 /* Stereo mutes enabled */
2046 misc |= AC97_AD198X_MSPLT | AC97_AD198X_AC97NC;
2047 if (!ac97->spec.ad18xx.lo_as_master)
2048 /* Switch FRONT/SURROUND LINE-OUT/HP-OUT default connection */
2049 /* it seems that most vendors connect line-out connector to
2050 * headphone out of AC'97
2052 misc |= AC97_AD198X_LOSEL | AC97_AD198X_HPSEL;
2054 snd_ac97_write_cache(ac97, AC97_AD_MISC, misc);
2055 ac97->flags |= AC97_STEREO_MUTES;
2059 static int patch_ad1980_specific(struct snd_ac97 *ac97)
2063 if ((err = patch_ad1888_specific(ac97)) < 0)
2065 return patch_build_controls(ac97, &snd_ac97_ad198x_2cmic, 1);
2068 static const struct snd_ac97_build_ops patch_ad1980_build_ops = {
2069 .build_post_spdif = patch_ad198x_post_spdif,
2070 .build_specific = patch_ad1980_specific,
2072 .resume = ad18xx_resume,
2074 .update_jacks = ad1888_update_jacks,
2077 static int patch_ad1980(struct snd_ac97 * ac97)
2080 ac97->build_ops = &patch_ad1980_build_ops;
2084 static int snd_ac97_ad1985_vrefout_info(struct snd_kcontrol *kcontrol,
2085 struct snd_ctl_elem_info *uinfo)
2087 static const char * const texts[4] = {
2088 "High-Z", "3.7 V", "2.25 V", "0 V"
2091 return snd_ctl_enum_info(uinfo, 1, 4, texts);
2094 static int snd_ac97_ad1985_vrefout_get(struct snd_kcontrol *kcontrol,
2095 struct snd_ctl_elem_value *ucontrol)
2097 static const int reg2ctrl[4] = {2, 0, 1, 3};
2098 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2100 val = (ac97->regs[AC97_AD_MISC] & AC97_AD198X_VREF_MASK)
2101 >> AC97_AD198X_VREF_SHIFT;
2102 ucontrol->value.enumerated.item[0] = reg2ctrl[val];
2106 static int snd_ac97_ad1985_vrefout_put(struct snd_kcontrol *kcontrol,
2107 struct snd_ctl_elem_value *ucontrol)
2109 static const int ctrl2reg[4] = {1, 2, 0, 3};
2110 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2113 if (ucontrol->value.enumerated.item[0] > 3)
2115 val = ctrl2reg[ucontrol->value.enumerated.item[0]]
2116 << AC97_AD198X_VREF_SHIFT;
2117 return snd_ac97_update_bits(ac97, AC97_AD_MISC,
2118 AC97_AD198X_VREF_MASK, val);
2121 static const struct snd_kcontrol_new snd_ac97_ad1985_controls[] = {
2122 AC97_SINGLE("Exchange Center/LFE", AC97_AD_SERIAL_CFG, 3, 1, 0),
2124 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2125 .name = "Exchange Front/Surround",
2126 .info = snd_ac97_ad1888_lohpsel_info,
2127 .get = snd_ac97_ad1888_lohpsel_get,
2128 .put = snd_ac97_ad1888_lohpsel_put
2130 AC97_SINGLE("High Pass Filter Enable", AC97_AD_TEST2, 12, 1, 1),
2131 AC97_SINGLE("Spread Front to Surround and Center/LFE",
2132 AC97_AD_MISC, 7, 1, 0),
2134 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2136 .info = snd_ac97_ad1888_downmix_info,
2137 .get = snd_ac97_ad1888_downmix_get,
2138 .put = snd_ac97_ad1888_downmix_put
2141 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2143 .info = snd_ac97_ad1985_vrefout_info,
2144 .get = snd_ac97_ad1985_vrefout_get,
2145 .put = snd_ac97_ad1985_vrefout_put
2147 AC97_SURROUND_JACK_MODE_CTL,
2148 AC97_CHANNEL_MODE_CTL,
2150 AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 10, 1, 0),
2151 AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 12, 1, 0),
2154 static void ad1985_update_jacks(struct snd_ac97 *ac97)
2156 ad1888_update_jacks(ac97);
2157 /* clear OMS if shared jack is to be used for C/LFE out */
2158 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG, 1 << 9,
2159 is_shared_micin(ac97) ? 1 << 9 : 0);
2162 static int patch_ad1985_specific(struct snd_ac97 *ac97)
2166 /* rename 0x04 as "Master" and 0x02 as "Master Surround" */
2167 snd_ac97_rename_vol_ctl(ac97, "Master Playback",
2168 "Master Surround Playback");
2169 snd_ac97_rename_vol_ctl(ac97, "Headphone Playback", "Master Playback");
2171 if ((err = patch_build_controls(ac97, &snd_ac97_ad198x_2cmic, 1)) < 0)
2174 return patch_build_controls(ac97, snd_ac97_ad1985_controls,
2175 ARRAY_SIZE(snd_ac97_ad1985_controls));
2178 static const struct snd_ac97_build_ops patch_ad1985_build_ops = {
2179 .build_post_spdif = patch_ad198x_post_spdif,
2180 .build_specific = patch_ad1985_specific,
2182 .resume = ad18xx_resume,
2184 .update_jacks = ad1985_update_jacks,
2187 static int patch_ad1985(struct snd_ac97 * ac97)
2189 unsigned short misc;
2192 ac97->build_ops = &patch_ad1985_build_ops;
2193 misc = snd_ac97_read(ac97, AC97_AD_MISC);
2194 /* switch front/surround line-out/hp-out */
2195 /* AD-compatible mode */
2196 /* Stereo mutes enabled */
2197 snd_ac97_write_cache(ac97, AC97_AD_MISC, misc |
2201 AC97_AD198X_AC97NC);
2202 ac97->flags |= AC97_STEREO_MUTES;
2204 /* update current jack configuration */
2205 ad1985_update_jacks(ac97);
2207 /* on AD1985 rev. 3, AC'97 revision bits are zero */
2208 ac97->ext_id = (ac97->ext_id & ~AC97_EI_REV_MASK) | AC97_EI_REV_23;
2212 #define snd_ac97_ad1986_bool_info snd_ctl_boolean_mono_info
2214 static int snd_ac97_ad1986_lososel_get(struct snd_kcontrol *kcontrol,
2215 struct snd_ctl_elem_value *ucontrol)
2217 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2220 val = ac97->regs[AC97_AD_MISC3];
2221 ucontrol->value.integer.value[0] = (val & AC97_AD1986_LOSEL) != 0;
2225 static int snd_ac97_ad1986_lososel_put(struct snd_kcontrol *kcontrol,
2226 struct snd_ctl_elem_value *ucontrol)
2228 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2231 int sprd = (ac97->regs[AC97_AD_MISC] & AC97_AD1986_SPRD) != 0;
2233 ret0 = snd_ac97_update_bits(ac97, AC97_AD_MISC3, AC97_AD1986_LOSEL,
2234 ucontrol->value.integer.value[0] != 0
2235 ? AC97_AD1986_LOSEL : 0);
2239 /* SOSEL is set to values of "Spread" or "Exchange F/S" controls */
2240 ret1 = snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD1986_SOSEL,
2241 (ucontrol->value.integer.value[0] != 0
2243 ? AC97_AD1986_SOSEL : 0);
2247 return (ret0 > 0 || ret1 > 0) ? 1 : 0;
2250 static int snd_ac97_ad1986_spread_get(struct snd_kcontrol *kcontrol,
2251 struct snd_ctl_elem_value *ucontrol)
2253 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2256 val = ac97->regs[AC97_AD_MISC];
2257 ucontrol->value.integer.value[0] = (val & AC97_AD1986_SPRD) != 0;
2261 static int snd_ac97_ad1986_spread_put(struct snd_kcontrol *kcontrol,
2262 struct snd_ctl_elem_value *ucontrol)
2264 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2267 int sprd = (ac97->regs[AC97_AD_MISC3] & AC97_AD1986_LOSEL) != 0;
2269 ret0 = snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD1986_SPRD,
2270 ucontrol->value.integer.value[0] != 0
2271 ? AC97_AD1986_SPRD : 0);
2275 /* SOSEL is set to values of "Spread" or "Exchange F/S" controls */
2276 ret1 = snd_ac97_update_bits(ac97, AC97_AD_MISC, AC97_AD1986_SOSEL,
2277 (ucontrol->value.integer.value[0] != 0
2279 ? AC97_AD1986_SOSEL : 0);
2283 return (ret0 > 0 || ret1 > 0) ? 1 : 0;
2286 static int snd_ac97_ad1986_miclisel_get(struct snd_kcontrol *kcontrol,
2287 struct snd_ctl_elem_value *ucontrol)
2289 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2291 ucontrol->value.integer.value[0] = ac97->spec.ad18xx.swap_mic_linein;
2295 static int snd_ac97_ad1986_miclisel_put(struct snd_kcontrol *kcontrol,
2296 struct snd_ctl_elem_value *ucontrol)
2298 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2299 unsigned char swap = ucontrol->value.integer.value[0] != 0;
2301 if (swap != ac97->spec.ad18xx.swap_mic_linein) {
2302 ac97->spec.ad18xx.swap_mic_linein = swap;
2303 if (ac97->build_ops->update_jacks)
2304 ac97->build_ops->update_jacks(ac97);
2310 static int snd_ac97_ad1986_vrefout_get(struct snd_kcontrol *kcontrol,
2311 struct snd_ctl_elem_value *ucontrol)
2313 /* Use MIC_1/2 V_REFOUT as the "get" value */
2314 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2316 unsigned short reg = ac97->regs[AC97_AD_MISC2];
2317 if ((reg & AC97_AD1986_MVREF0) != 0)
2319 else if ((reg & AC97_AD1986_MVREF1) != 0)
2321 else if ((reg & AC97_AD1986_MVREF2) != 0)
2325 ucontrol->value.enumerated.item[0] = val;
2329 static int snd_ac97_ad1986_vrefout_put(struct snd_kcontrol *kcontrol,
2330 struct snd_ctl_elem_value *ucontrol)
2332 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2333 unsigned short cval;
2334 unsigned short lval;
2335 unsigned short mval;
2340 switch (ucontrol->value.enumerated.item[0])
2342 case 0: /* High-Z */
2348 cval = AC97_AD1986_CVREF2;
2349 lval = AC97_AD1986_LVREF2;
2350 mval = AC97_AD1986_MVREF2;
2352 case 2: /* 2.25 V */
2353 cval = AC97_AD1986_CVREF0;
2354 lval = AC97_AD1986_LVREF0;
2355 mval = AC97_AD1986_MVREF0;
2358 cval = AC97_AD1986_CVREF1;
2359 lval = AC97_AD1986_LVREF1;
2360 mval = AC97_AD1986_MVREF1;
2366 cret = snd_ac97_update_bits(ac97, AC97_AD_MISC2,
2367 AC97_AD1986_CVREF_MASK, cval);
2370 lret = snd_ac97_update_bits(ac97, AC97_AD_MISC3,
2371 AC97_AD1986_LVREF_MASK, lval);
2374 mret = snd_ac97_update_bits(ac97, AC97_AD_MISC2,
2375 AC97_AD1986_MVREF_MASK, mval);
2379 return (cret > 0 || lret > 0 || mret > 0) ? 1 : 0;
2382 static const struct snd_kcontrol_new snd_ac97_ad1986_controls[] = {
2383 AC97_SINGLE("Exchange Center/LFE", AC97_AD_SERIAL_CFG, 3, 1, 0),
2385 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2386 .name = "Exchange Front/Surround",
2387 .info = snd_ac97_ad1986_bool_info,
2388 .get = snd_ac97_ad1986_lososel_get,
2389 .put = snd_ac97_ad1986_lososel_put
2392 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2393 .name = "Exchange Mic/Line In",
2394 .info = snd_ac97_ad1986_bool_info,
2395 .get = snd_ac97_ad1986_miclisel_get,
2396 .put = snd_ac97_ad1986_miclisel_put
2399 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2400 .name = "Spread Front to Surround and Center/LFE",
2401 .info = snd_ac97_ad1986_bool_info,
2402 .get = snd_ac97_ad1986_spread_get,
2403 .put = snd_ac97_ad1986_spread_put
2406 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2408 .info = snd_ac97_ad1888_downmix_info,
2409 .get = snd_ac97_ad1888_downmix_get,
2410 .put = snd_ac97_ad1888_downmix_put
2413 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2415 .info = snd_ac97_ad1985_vrefout_info,
2416 .get = snd_ac97_ad1986_vrefout_get,
2417 .put = snd_ac97_ad1986_vrefout_put
2419 AC97_SURROUND_JACK_MODE_CTL,
2420 AC97_CHANNEL_MODE_CTL,
2422 AC97_SINGLE("Headphone Jack Sense", AC97_AD_JACK_SPDIF, 10, 1, 0),
2423 AC97_SINGLE("Line Jack Sense", AC97_AD_JACK_SPDIF, 12, 1, 0)
2426 static void ad1986_update_jacks(struct snd_ac97 *ac97)
2428 unsigned short misc_val = 0;
2429 unsigned short ser_val;
2431 /* disable SURROUND and CENTER/LFE if not surround mode */
2432 if (!is_surround_on(ac97))
2433 misc_val |= AC97_AD1986_SODIS;
2434 if (!is_clfe_on(ac97))
2435 misc_val |= AC97_AD1986_CLDIS;
2437 /* select line input (default=LINE_IN, SURROUND or MIC_1/2) */
2438 if (is_shared_linein(ac97))
2439 misc_val |= AC97_AD1986_LISEL_SURR;
2440 else if (ac97->spec.ad18xx.swap_mic_linein != 0)
2441 misc_val |= AC97_AD1986_LISEL_MIC;
2442 snd_ac97_update_bits(ac97, AC97_AD_MISC,
2443 AC97_AD1986_SODIS | AC97_AD1986_CLDIS |
2444 AC97_AD1986_LISEL_MASK,
2447 /* select microphone input (MIC_1/2, Center/LFE or LINE_IN) */
2448 if (is_shared_micin(ac97))
2449 ser_val = AC97_AD1986_OMS_C;
2450 else if (ac97->spec.ad18xx.swap_mic_linein != 0)
2451 ser_val = AC97_AD1986_OMS_L;
2453 ser_val = AC97_AD1986_OMS_M;
2454 snd_ac97_update_bits(ac97, AC97_AD_SERIAL_CFG,
2455 AC97_AD1986_OMS_MASK,
2459 static int patch_ad1986_specific(struct snd_ac97 *ac97)
2463 if ((err = patch_build_controls(ac97, &snd_ac97_ad198x_2cmic, 1)) < 0)
2466 return patch_build_controls(ac97, snd_ac97_ad1986_controls,
2467 ARRAY_SIZE(snd_ac97_ad1985_controls));
2470 static const struct snd_ac97_build_ops patch_ad1986_build_ops = {
2471 .build_post_spdif = patch_ad198x_post_spdif,
2472 .build_specific = patch_ad1986_specific,
2474 .resume = ad18xx_resume,
2476 .update_jacks = ad1986_update_jacks,
2479 static int patch_ad1986(struct snd_ac97 * ac97)
2482 ac97->build_ops = &patch_ad1986_build_ops;
2483 ac97->flags |= AC97_STEREO_MUTES;
2485 /* update current jack configuration */
2486 ad1986_update_jacks(ac97);
2492 * realtek ALC203: use mono-out for pin 37
2494 static int patch_alc203(struct snd_ac97 *ac97)
2496 snd_ac97_update_bits(ac97, 0x7a, 0x400, 0x400);
2501 * realtek ALC65x/850 codecs
2503 static void alc650_update_jacks(struct snd_ac97 *ac97)
2507 /* shared Line-In / Surround Out */
2508 shared = is_shared_surrout(ac97);
2509 snd_ac97_update_bits(ac97, AC97_ALC650_MULTICH, 1 << 9,
2510 shared ? (1 << 9) : 0);
2511 /* update shared Mic In / Center/LFE Out */
2512 shared = is_shared_clfeout(ac97);
2513 /* disable/enable vref */
2514 snd_ac97_update_bits(ac97, AC97_ALC650_CLOCK, 1 << 12,
2515 shared ? (1 << 12) : 0);
2516 /* turn on/off center-on-mic */
2517 snd_ac97_update_bits(ac97, AC97_ALC650_MULTICH, 1 << 10,
2518 shared ? (1 << 10) : 0);
2519 /* GPIO0 high for mic */
2520 snd_ac97_update_bits(ac97, AC97_ALC650_GPIO_STATUS, 0x100,
2521 shared ? 0 : 0x100);
2524 static int alc650_swap_surround_put(struct snd_kcontrol *kcontrol,
2525 struct snd_ctl_elem_value *ucontrol)
2527 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2528 struct snd_pcm_chmap *map = ac97->chmaps[SNDRV_PCM_STREAM_PLAYBACK];
2531 if (ucontrol->value.integer.value[0])
2532 map->chmap = snd_pcm_std_chmaps;
2534 map->chmap = snd_pcm_alt_chmaps;
2536 return snd_ac97_put_volsw(kcontrol, ucontrol);
2539 static const struct snd_kcontrol_new snd_ac97_controls_alc650[] = {
2540 AC97_SINGLE("Duplicate Front", AC97_ALC650_MULTICH, 0, 1, 0),
2541 AC97_SINGLE("Surround Down Mix", AC97_ALC650_MULTICH, 1, 1, 0),
2542 AC97_SINGLE("Center/LFE Down Mix", AC97_ALC650_MULTICH, 2, 1, 0),
2543 AC97_SINGLE("Exchange Center/LFE", AC97_ALC650_MULTICH, 3, 1, 0),
2544 /* 4: Analog Input To Surround */
2545 /* 5: Analog Input To Center/LFE */
2546 /* 6: Independent Master Volume Right */
2547 /* 7: Independent Master Volume Left */
2549 /* 9: Line-In/Surround share */
2550 /* 10: Mic/CLFE share */
2551 /* 11-13: in IEC958 controls */
2553 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2554 .name = "Swap Surround Slot",
2555 .info = snd_ac97_info_volsw,
2556 .get = snd_ac97_get_volsw,
2557 .put = alc650_swap_surround_put,
2558 .private_value = AC97_SINGLE_VALUE(AC97_ALC650_MULTICH, 14, 1, 0),
2560 #if 0 /* always set in patch_alc650 */
2561 AC97_SINGLE("IEC958 Input Clock Enable", AC97_ALC650_CLOCK, 0, 1, 0),
2562 AC97_SINGLE("IEC958 Input Pin Enable", AC97_ALC650_CLOCK, 1, 1, 0),
2563 AC97_SINGLE("Surround DAC Switch", AC97_ALC650_SURR_DAC_VOL, 15, 1, 1),
2564 AC97_DOUBLE("Surround DAC Volume", AC97_ALC650_SURR_DAC_VOL, 8, 0, 31, 1),
2565 AC97_SINGLE("Center/LFE DAC Switch", AC97_ALC650_LFE_DAC_VOL, 15, 1, 1),
2566 AC97_DOUBLE("Center/LFE DAC Volume", AC97_ALC650_LFE_DAC_VOL, 8, 0, 31, 1),
2568 AC97_SURROUND_JACK_MODE_CTL,
2569 AC97_CHANNEL_MODE_CTL,
2572 static const struct snd_kcontrol_new snd_ac97_spdif_controls_alc650[] = {
2573 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), AC97_ALC650_MULTICH, 11, 1, 0),
2574 AC97_SINGLE("Analog to IEC958 Output", AC97_ALC650_MULTICH, 12, 1, 0),
2575 /* disable this controls since it doesn't work as expected */
2576 /* AC97_SINGLE("IEC958 Input Monitor", AC97_ALC650_MULTICH, 13, 1, 0), */
2579 static const DECLARE_TLV_DB_SCALE(db_scale_5bit_3db_max, -4350, 150, 0);
2581 static int patch_alc650_specific(struct snd_ac97 * ac97)
2585 if ((err = patch_build_controls(ac97, snd_ac97_controls_alc650, ARRAY_SIZE(snd_ac97_controls_alc650))) < 0)
2587 if (ac97->ext_id & AC97_EI_SPDIF) {
2588 if ((err = patch_build_controls(ac97, snd_ac97_spdif_controls_alc650, ARRAY_SIZE(snd_ac97_spdif_controls_alc650))) < 0)
2591 if (ac97->id != AC97_ID_ALC650F)
2592 reset_tlv(ac97, "Master Playback Volume",
2593 db_scale_5bit_3db_max);
2597 static const struct snd_ac97_build_ops patch_alc650_ops = {
2598 .build_specific = patch_alc650_specific,
2599 .update_jacks = alc650_update_jacks
2602 static int patch_alc650(struct snd_ac97 * ac97)
2606 ac97->build_ops = &patch_alc650_ops;
2608 /* determine the revision */
2609 val = snd_ac97_read(ac97, AC97_ALC650_REVISION) & 0x3f;
2611 ac97->id = 0x414c4720; /* Old version */
2612 else if (val < 0x10)
2613 ac97->id = 0x414c4721; /* D version */
2614 else if (val < 0x20)
2615 ac97->id = 0x414c4722; /* E version */
2616 else if (val < 0x30)
2617 ac97->id = 0x414c4723; /* F version */
2619 /* revision E or F */
2620 /* FIXME: what about revision D ? */
2621 ac97->spec.dev_flags = (ac97->id == 0x414c4722 ||
2622 ac97->id == 0x414c4723);
2624 /* enable AC97_ALC650_GPIO_SETUP, AC97_ALC650_CLOCK for R/W */
2625 snd_ac97_write_cache(ac97, AC97_ALC650_GPIO_STATUS,
2626 snd_ac97_read(ac97, AC97_ALC650_GPIO_STATUS) | 0x8000);
2628 /* Enable SPDIF-IN only on Rev.E and above */
2629 val = snd_ac97_read(ac97, AC97_ALC650_CLOCK);
2630 /* SPDIF IN with pin 47 */
2631 if (ac97->spec.dev_flags &&
2632 /* ASUS A6KM requires EAPD */
2633 ! (ac97->subsystem_vendor == 0x1043 &&
2634 ac97->subsystem_device == 0x1103))
2635 val |= 0x03; /* enable */
2637 val &= ~0x03; /* disable */
2638 snd_ac97_write_cache(ac97, AC97_ALC650_CLOCK, val);
2640 /* set default: slot 3,4,7,8,6,9
2641 spdif-in monitor off, analog-spdif off, spdif-in off
2642 center on mic off, surround on line-in off
2643 downmix off, duplicate front off
2645 snd_ac97_write_cache(ac97, AC97_ALC650_MULTICH, 0);
2647 /* set GPIO0 for mic bias */
2648 /* GPIO0 pin output, no interrupt, high */
2649 snd_ac97_write_cache(ac97, AC97_ALC650_GPIO_SETUP,
2650 snd_ac97_read(ac97, AC97_ALC650_GPIO_SETUP) | 0x01);
2651 snd_ac97_write_cache(ac97, AC97_ALC650_GPIO_STATUS,
2652 (snd_ac97_read(ac97, AC97_ALC650_GPIO_STATUS) | 0x100) & ~0x10);
2654 /* full DAC volume */
2655 snd_ac97_write_cache(ac97, AC97_ALC650_SURR_DAC_VOL, 0x0808);
2656 snd_ac97_write_cache(ac97, AC97_ALC650_LFE_DAC_VOL, 0x0808);
2660 static void alc655_update_jacks(struct snd_ac97 *ac97)
2664 /* shared Line-In / Surround Out */
2665 shared = is_shared_surrout(ac97);
2666 ac97_update_bits_page(ac97, AC97_ALC650_MULTICH, 1 << 9,
2667 shared ? (1 << 9) : 0, 0);
2668 /* update shared Mic In / Center/LFE Out */
2669 shared = is_shared_clfeout(ac97);
2670 /* misc control; vrefout disable */
2671 snd_ac97_update_bits(ac97, AC97_ALC650_CLOCK, 1 << 12,
2672 shared ? (1 << 12) : 0);
2673 ac97_update_bits_page(ac97, AC97_ALC650_MULTICH, 1 << 10,
2674 shared ? (1 << 10) : 0, 0);
2677 static const struct snd_kcontrol_new snd_ac97_controls_alc655[] = {
2678 AC97_PAGE_SINGLE("Duplicate Front", AC97_ALC650_MULTICH, 0, 1, 0, 0),
2679 AC97_SURROUND_JACK_MODE_CTL,
2680 AC97_CHANNEL_MODE_CTL,
2683 static int alc655_iec958_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2685 static const char * const texts_655[3] = {
2686 "PCM", "Analog In", "IEC958 In"
2688 static const char * const texts_658[4] = {
2689 "PCM", "Analog1 In", "Analog2 In", "IEC958 In"
2691 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2693 if (ac97->spec.dev_flags)
2694 return snd_ctl_enum_info(uinfo, 1, 4, texts_658);
2696 return snd_ctl_enum_info(uinfo, 1, 3, texts_655);
2699 static int alc655_iec958_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2701 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2704 val = ac97->regs[AC97_ALC650_MULTICH];
2705 val = (val >> 12) & 3;
2706 if (ac97->spec.dev_flags && val == 3)
2708 ucontrol->value.enumerated.item[0] = val;
2712 static int alc655_iec958_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2714 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2716 return ac97_update_bits_page(ac97, AC97_ALC650_MULTICH, 3 << 12,
2717 (unsigned short)ucontrol->value.enumerated.item[0] << 12,
2721 static const struct snd_kcontrol_new snd_ac97_spdif_controls_alc655[] = {
2722 AC97_PAGE_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), AC97_ALC650_MULTICH, 11, 1, 0, 0),
2723 /* disable this controls since it doesn't work as expected */
2724 /* AC97_PAGE_SINGLE("IEC958 Input Monitor", AC97_ALC650_MULTICH, 14, 1, 0, 0), */
2726 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2727 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
2728 .info = alc655_iec958_route_info,
2729 .get = alc655_iec958_route_get,
2730 .put = alc655_iec958_route_put,
2734 static int patch_alc655_specific(struct snd_ac97 * ac97)
2738 if ((err = patch_build_controls(ac97, snd_ac97_controls_alc655, ARRAY_SIZE(snd_ac97_controls_alc655))) < 0)
2740 if (ac97->ext_id & AC97_EI_SPDIF) {
2741 if ((err = patch_build_controls(ac97, snd_ac97_spdif_controls_alc655, ARRAY_SIZE(snd_ac97_spdif_controls_alc655))) < 0)
2747 static const struct snd_ac97_build_ops patch_alc655_ops = {
2748 .build_specific = patch_alc655_specific,
2749 .update_jacks = alc655_update_jacks
2752 static int patch_alc655(struct snd_ac97 * ac97)
2756 if (ac97->id == AC97_ID_ALC658) {
2757 ac97->spec.dev_flags = 1; /* ALC658 */
2758 if ((snd_ac97_read(ac97, AC97_ALC650_REVISION) & 0x3f) == 2) {
2759 ac97->id = AC97_ID_ALC658D;
2760 ac97->spec.dev_flags = 2;
2764 ac97->build_ops = &patch_alc655_ops;
2766 /* assume only page 0 for writing cache */
2767 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, AC97_PAGE_VENDOR);
2769 /* adjust default values */
2770 val = snd_ac97_read(ac97, 0x7a); /* misc control */
2771 if (ac97->spec.dev_flags) /* ALC658 */
2772 val &= ~(1 << 1); /* Pin 47 is spdif input pin */
2774 if (ac97->subsystem_vendor == 0x1462 &&
2775 (ac97->subsystem_device == 0x0131 || /* MSI S270 laptop */
2776 ac97->subsystem_device == 0x0161 || /* LG K1 Express */
2777 ac97->subsystem_device == 0x0351 || /* MSI L725 laptop */
2778 ac97->subsystem_device == 0x0471 || /* MSI L720 laptop */
2779 ac97->subsystem_device == 0x0061)) /* MSI S250 laptop */
2780 val &= ~(1 << 1); /* Pin 47 is EAPD (for internal speaker) */
2782 val |= (1 << 1); /* Pin 47 is spdif input pin */
2783 /* this seems missing on some hardwares */
2784 ac97->ext_id |= AC97_EI_SPDIF;
2786 val &= ~(1 << 12); /* vref enable */
2787 snd_ac97_write_cache(ac97, 0x7a, val);
2788 /* set default: spdif-in enabled,
2789 spdif-in monitor off, spdif-in PCM off
2790 center on mic off, surround on line-in off
2793 snd_ac97_write_cache(ac97, AC97_ALC650_MULTICH, 1<<15);
2795 /* full DAC volume */
2796 snd_ac97_write_cache(ac97, AC97_ALC650_SURR_DAC_VOL, 0x0808);
2797 snd_ac97_write_cache(ac97, AC97_ALC650_LFE_DAC_VOL, 0x0808);
2799 /* update undocumented bit... */
2800 if (ac97->id == AC97_ID_ALC658D)
2801 snd_ac97_update_bits(ac97, 0x74, 0x0800, 0x0800);
2807 #define AC97_ALC850_JACK_SELECT 0x76
2808 #define AC97_ALC850_MISC1 0x7a
2809 #define AC97_ALC850_MULTICH 0x6a
2811 static void alc850_update_jacks(struct snd_ac97 *ac97)
2814 int aux_is_back_surround;
2816 /* shared Line-In / Surround Out */
2817 shared = is_shared_surrout(ac97);
2818 /* SURR 1kOhm (bit4), Amp (bit5) */
2819 snd_ac97_update_bits(ac97, AC97_ALC850_MISC1, (1<<4)|(1<<5),
2820 shared ? (1<<5) : (1<<4));
2821 /* LINE-IN = 0, SURROUND = 2 */
2822 snd_ac97_update_bits(ac97, AC97_ALC850_JACK_SELECT, 7 << 12,
2823 shared ? (2<<12) : (0<<12));
2824 /* update shared Mic In / Center/LFE Out */
2825 shared = is_shared_clfeout(ac97);
2826 /* Vref disable (bit12), 1kOhm (bit13) */
2827 snd_ac97_update_bits(ac97, AC97_ALC850_MISC1, (1<<12)|(1<<13),
2828 shared ? (1<<12) : (1<<13));
2829 /* MIC-IN = 1, CENTER-LFE = 5 */
2830 snd_ac97_update_bits(ac97, AC97_ALC850_JACK_SELECT, 7 << 4,
2831 shared ? (5<<4) : (1<<4));
2833 aux_is_back_surround = alc850_is_aux_back_surround(ac97);
2834 /* Aux is Back Surround */
2835 snd_ac97_update_bits(ac97, AC97_ALC850_MULTICH, 1 << 10,
2836 aux_is_back_surround ? (1<<10) : (0<<10));
2839 static const struct snd_kcontrol_new snd_ac97_controls_alc850[] = {
2840 AC97_PAGE_SINGLE("Duplicate Front", AC97_ALC650_MULTICH, 0, 1, 0, 0),
2841 AC97_SINGLE("Mic Front Input Switch", AC97_ALC850_JACK_SELECT, 15, 1, 1),
2842 AC97_SURROUND_JACK_MODE_CTL,
2843 AC97_CHANNEL_MODE_8CH_CTL,
2846 static int patch_alc850_specific(struct snd_ac97 *ac97)
2850 if ((err = patch_build_controls(ac97, snd_ac97_controls_alc850, ARRAY_SIZE(snd_ac97_controls_alc850))) < 0)
2852 if (ac97->ext_id & AC97_EI_SPDIF) {
2853 if ((err = patch_build_controls(ac97, snd_ac97_spdif_controls_alc655, ARRAY_SIZE(snd_ac97_spdif_controls_alc655))) < 0)
2859 static const struct snd_ac97_build_ops patch_alc850_ops = {
2860 .build_specific = patch_alc850_specific,
2861 .update_jacks = alc850_update_jacks
2864 static int patch_alc850(struct snd_ac97 *ac97)
2866 ac97->build_ops = &patch_alc850_ops;
2868 ac97->spec.dev_flags = 0; /* for IEC958 playback route - ALC655 compatible */
2869 ac97->flags |= AC97_HAS_8CH;
2871 /* assume only page 0 for writing cache */
2872 snd_ac97_update_bits(ac97, AC97_INT_PAGING, AC97_PAGE_MASK, AC97_PAGE_VENDOR);
2874 /* adjust default values */
2875 /* set default: spdif-in enabled,
2876 spdif-in monitor off, spdif-in PCM off
2877 center on mic off, surround on line-in off
2879 NB default bit 10=0 = Aux is Capture, not Back Surround
2881 snd_ac97_write_cache(ac97, AC97_ALC650_MULTICH, 1<<15);
2882 /* SURR_OUT: on, Surr 1kOhm: on, Surr Amp: off, Front 1kOhm: off
2883 * Front Amp: on, Vref: enable, Center 1kOhm: on, Mix: on
2885 snd_ac97_write_cache(ac97, 0x7a, (1<<1)|(1<<4)|(0<<5)|(1<<6)|
2886 (1<<7)|(0<<12)|(1<<13)|(0<<14));
2887 /* detection UIO2,3: all path floating, UIO3: MIC, Vref2: disable,
2888 * UIO1: FRONT, Vref3: disable, UIO3: LINE, Front-Mic: mute
2890 snd_ac97_write_cache(ac97, 0x76, (0<<0)|(0<<2)|(1<<4)|(1<<7)|(2<<8)|
2891 (1<<11)|(0<<12)|(1<<15));
2893 /* full DAC volume */
2894 snd_ac97_write_cache(ac97, AC97_ALC650_SURR_DAC_VOL, 0x0808);
2895 snd_ac97_write_cache(ac97, AC97_ALC650_LFE_DAC_VOL, 0x0808);
2899 static int patch_aztech_azf3328_specific(struct snd_ac97 *ac97)
2901 struct snd_kcontrol *kctl_3d_center =
2902 snd_ac97_find_mixer_ctl(ac97, "3D Control - Center");
2903 struct snd_kcontrol *kctl_3d_depth =
2904 snd_ac97_find_mixer_ctl(ac97, "3D Control - Depth");
2907 * 3D register is different from AC97 standard layout
2908 * (also do some renaming, to resemble Windows driver naming)
2910 if (kctl_3d_center) {
2911 kctl_3d_center->private_value =
2912 AC97_SINGLE_VALUE(AC97_3D_CONTROL, 1, 0x07, 0);
2913 snd_ac97_rename_vol_ctl(ac97,
2914 "3D Control - Center", "3D Control - Width"
2918 kctl_3d_depth->private_value =
2919 AC97_SINGLE_VALUE(AC97_3D_CONTROL, 8, 0x03, 0);
2921 /* Aztech Windows driver calls the
2922 equivalent control "Modem Playback", thus rename it: */
2923 snd_ac97_rename_vol_ctl(ac97,
2924 "Master Mono Playback", "Modem Playback"
2926 snd_ac97_rename_vol_ctl(ac97,
2927 "Headphone Playback", "FM Synth Playback"
2933 static const struct snd_ac97_build_ops patch_aztech_azf3328_ops = {
2934 .build_specific = patch_aztech_azf3328_specific
2937 static int patch_aztech_azf3328(struct snd_ac97 *ac97)
2939 ac97->build_ops = &patch_aztech_azf3328_ops;
2944 * C-Media CM97xx codecs
2946 static void cm9738_update_jacks(struct snd_ac97 *ac97)
2948 /* shared Line-In / Surround Out */
2949 snd_ac97_update_bits(ac97, AC97_CM9738_VENDOR_CTRL, 1 << 10,
2950 is_shared_surrout(ac97) ? (1 << 10) : 0);
2953 static const struct snd_kcontrol_new snd_ac97_cm9738_controls[] = {
2954 AC97_SINGLE("Duplicate Front", AC97_CM9738_VENDOR_CTRL, 13, 1, 0),
2955 AC97_SURROUND_JACK_MODE_CTL,
2956 AC97_CHANNEL_MODE_4CH_CTL,
2959 static int patch_cm9738_specific(struct snd_ac97 * ac97)
2961 return patch_build_controls(ac97, snd_ac97_cm9738_controls, ARRAY_SIZE(snd_ac97_cm9738_controls));
2964 static const struct snd_ac97_build_ops patch_cm9738_ops = {
2965 .build_specific = patch_cm9738_specific,
2966 .update_jacks = cm9738_update_jacks
2969 static int patch_cm9738(struct snd_ac97 * ac97)
2971 ac97->build_ops = &patch_cm9738_ops;
2972 /* FIXME: can anyone confirm below? */
2973 /* CM9738 has no PCM volume although the register reacts */
2974 ac97->flags |= AC97_HAS_NO_PCM_VOL;
2975 snd_ac97_write_cache(ac97, AC97_PCM, 0x8000);
2980 static int snd_ac97_cmedia_spdif_playback_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2982 static const char * const texts[] = { "Analog", "Digital" };
2984 return snd_ctl_enum_info(uinfo, 1, 2, texts);
2987 static int snd_ac97_cmedia_spdif_playback_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2989 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
2992 val = ac97->regs[AC97_CM9739_SPDIF_CTRL];
2993 ucontrol->value.enumerated.item[0] = (val >> 1) & 0x01;
2997 static int snd_ac97_cmedia_spdif_playback_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2999 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
3001 return snd_ac97_update_bits(ac97, AC97_CM9739_SPDIF_CTRL,
3003 (ucontrol->value.enumerated.item[0] & 0x01) << 1);
3006 static const struct snd_kcontrol_new snd_ac97_cm9739_controls_spdif[] = {
3007 /* BIT 0: SPDI_EN - always true */
3008 { /* BIT 1: SPDIFS */
3009 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3010 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3011 .info = snd_ac97_cmedia_spdif_playback_source_info,
3012 .get = snd_ac97_cmedia_spdif_playback_source_get,
3013 .put = snd_ac97_cmedia_spdif_playback_source_put,
3015 /* BIT 2: IG_SPIV */
3016 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,NONE) "Valid Switch", AC97_CM9739_SPDIF_CTRL, 2, 1, 0),
3018 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,NONE) "Monitor", AC97_CM9739_SPDIF_CTRL, 3, 1, 0),
3019 /* BIT 4: SPI2SDI */
3020 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), AC97_CM9739_SPDIF_CTRL, 4, 1, 0),
3021 /* BIT 8: SPD32 - 32bit SPDIF - not supported yet */
3024 static void cm9739_update_jacks(struct snd_ac97 *ac97)
3026 /* shared Line-In / Surround Out */
3027 snd_ac97_update_bits(ac97, AC97_CM9739_MULTI_CHAN, 1 << 10,
3028 is_shared_surrout(ac97) ? (1 << 10) : 0);
3029 /* shared Mic In / Center/LFE Out **/
3030 snd_ac97_update_bits(ac97, AC97_CM9739_MULTI_CHAN, 0x3000,
3031 is_shared_clfeout(ac97) ? 0x1000 : 0x2000);
3034 static const struct snd_kcontrol_new snd_ac97_cm9739_controls[] = {
3035 AC97_SURROUND_JACK_MODE_CTL,
3036 AC97_CHANNEL_MODE_CTL,
3039 static int patch_cm9739_specific(struct snd_ac97 * ac97)
3041 return patch_build_controls(ac97, snd_ac97_cm9739_controls, ARRAY_SIZE(snd_ac97_cm9739_controls));
3044 static int patch_cm9739_post_spdif(struct snd_ac97 * ac97)
3046 return patch_build_controls(ac97, snd_ac97_cm9739_controls_spdif, ARRAY_SIZE(snd_ac97_cm9739_controls_spdif));
3049 static const struct snd_ac97_build_ops patch_cm9739_ops = {
3050 .build_specific = patch_cm9739_specific,
3051 .build_post_spdif = patch_cm9739_post_spdif,
3052 .update_jacks = cm9739_update_jacks
3055 static int patch_cm9739(struct snd_ac97 * ac97)
3059 ac97->build_ops = &patch_cm9739_ops;
3061 /* CM9739/A has no Master and PCM volume although the register reacts */
3062 ac97->flags |= AC97_HAS_NO_MASTER_VOL | AC97_HAS_NO_PCM_VOL;
3063 snd_ac97_write_cache(ac97, AC97_MASTER, 0x8000);
3064 snd_ac97_write_cache(ac97, AC97_PCM, 0x8000);
3067 val = snd_ac97_read(ac97, AC97_EXTENDED_STATUS);
3068 if (val & AC97_EA_SPCV) {
3069 /* enable spdif in */
3070 snd_ac97_write_cache(ac97, AC97_CM9739_SPDIF_CTRL,
3071 snd_ac97_read(ac97, AC97_CM9739_SPDIF_CTRL) | 0x01);
3072 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000; /* 48k only */
3074 ac97->ext_id &= ~AC97_EI_SPDIF; /* disable extended-id */
3075 ac97->rates[AC97_RATES_SPDIF] = 0;
3078 /* set-up multi channel */
3079 /* bit 14: 0 = SPDIF, 1 = EAPD */
3080 /* bit 13: enable internal vref output for mic */
3081 /* bit 12: disable center/lfe (switchable) */
3082 /* bit 10: disable surround/line (switchable) */
3083 /* bit 9: mix 2 surround off */
3084 /* bit 4: undocumented; 0 mutes the CM9739A, which defaults to 1 */
3085 /* bit 3: undocumented; surround? */
3087 val = snd_ac97_read(ac97, AC97_CM9739_MULTI_CHAN) & (1 << 4);
3090 if (! (ac97->ext_id & AC97_EI_SPDIF))
3092 snd_ac97_write_cache(ac97, AC97_CM9739_MULTI_CHAN, val);
3094 /* FIXME: set up GPIO */
3095 snd_ac97_write_cache(ac97, 0x70, 0x0100);
3096 snd_ac97_write_cache(ac97, 0x72, 0x0020);
3097 /* Special exception for ASUS W1000/CMI9739. It does not have an SPDIF in. */
3099 ac97->subsystem_vendor == 0x1043 &&
3100 ac97->subsystem_device == 0x1843) {
3101 snd_ac97_write_cache(ac97, AC97_CM9739_SPDIF_CTRL,
3102 snd_ac97_read(ac97, AC97_CM9739_SPDIF_CTRL) & ~0x01);
3103 snd_ac97_write_cache(ac97, AC97_CM9739_MULTI_CHAN,
3104 snd_ac97_read(ac97, AC97_CM9739_MULTI_CHAN) | (1 << 14));
3110 #define AC97_CM9761_MULTI_CHAN 0x64
3111 #define AC97_CM9761_FUNC 0x66
3112 #define AC97_CM9761_SPDIF_CTRL 0x6c
3114 static void cm9761_update_jacks(struct snd_ac97 *ac97)
3116 /* FIXME: check the bits for each model
3117 * model 83 is confirmed to work
3119 static const unsigned short surr_on[3][2] = {
3120 { 0x0008, 0x0000 }, /* 9761-78 & 82 */
3121 { 0x0000, 0x0008 }, /* 9761-82 rev.B */
3122 { 0x0000, 0x0008 }, /* 9761-83 */
3124 static const unsigned short clfe_on[3][2] = {
3125 { 0x0000, 0x1000 }, /* 9761-78 & 82 */
3126 { 0x1000, 0x0000 }, /* 9761-82 rev.B */
3127 { 0x0000, 0x1000 }, /* 9761-83 */
3129 static const unsigned short surr_shared[3][2] = {
3130 { 0x0000, 0x0400 }, /* 9761-78 & 82 */
3131 { 0x0000, 0x0400 }, /* 9761-82 rev.B */
3132 { 0x0000, 0x0400 }, /* 9761-83 */
3134 static const unsigned short clfe_shared[3][2] = {
3135 { 0x2000, 0x0880 }, /* 9761-78 & 82 */
3136 { 0x0000, 0x2880 }, /* 9761-82 rev.B */
3137 { 0x2000, 0x0800 }, /* 9761-83 */
3139 unsigned short val = 0;
3141 val |= surr_on[ac97->spec.dev_flags][is_surround_on(ac97)];
3142 val |= clfe_on[ac97->spec.dev_flags][is_clfe_on(ac97)];
3143 val |= surr_shared[ac97->spec.dev_flags][is_shared_surrout(ac97)];
3144 val |= clfe_shared[ac97->spec.dev_flags][is_shared_clfeout(ac97)];
3146 snd_ac97_update_bits(ac97, AC97_CM9761_MULTI_CHAN, 0x3c88, val);
3149 static const struct snd_kcontrol_new snd_ac97_cm9761_controls[] = {
3150 AC97_SURROUND_JACK_MODE_CTL,
3151 AC97_CHANNEL_MODE_CTL,
3154 static int cm9761_spdif_out_source_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
3156 static const char * const texts[] = { "AC-Link", "ADC", "SPDIF-In" };
3158 return snd_ctl_enum_info(uinfo, 1, 3, texts);
3161 static int cm9761_spdif_out_source_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
3163 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
3165 if (ac97->regs[AC97_CM9761_FUNC] & 0x1)
3166 ucontrol->value.enumerated.item[0] = 2; /* SPDIF-loopback */
3167 else if (ac97->regs[AC97_CM9761_SPDIF_CTRL] & 0x2)
3168 ucontrol->value.enumerated.item[0] = 1; /* ADC loopback */
3170 ucontrol->value.enumerated.item[0] = 0; /* AC-link */
3174 static int cm9761_spdif_out_source_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
3176 struct snd_ac97 *ac97 = snd_kcontrol_chip(kcontrol);
3178 if (ucontrol->value.enumerated.item[0] == 2)
3179 return snd_ac97_update_bits(ac97, AC97_CM9761_FUNC, 0x1, 0x1);
3180 snd_ac97_update_bits(ac97, AC97_CM9761_FUNC, 0x1, 0);
3181 return snd_ac97_update_bits(ac97, AC97_CM9761_SPDIF_CTRL, 0x2,
3182 ucontrol->value.enumerated.item[0] == 1 ? 0x2 : 0);
3185 static const char * const cm9761_dac_clock[] = {
3186 "AC-Link", "SPDIF-In", "Both"
3188 static const struct ac97_enum cm9761_dac_clock_enum =
3189 AC97_ENUM_SINGLE(AC97_CM9761_SPDIF_CTRL, 9, 3, cm9761_dac_clock);
3191 static const struct snd_kcontrol_new snd_ac97_cm9761_controls_spdif[] = {
3192 { /* BIT 1: SPDIFS */
3193 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3194 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3195 .info = cm9761_spdif_out_source_info,
3196 .get = cm9761_spdif_out_source_get,
3197 .put = cm9761_spdif_out_source_put,
3199 /* BIT 2: IG_SPIV */
3200 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,NONE) "Valid Switch", AC97_CM9761_SPDIF_CTRL, 2, 1, 0),
3202 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,NONE) "Monitor", AC97_CM9761_SPDIF_CTRL, 3, 1, 0),
3203 /* BIT 4: SPI2SDI */
3204 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), AC97_CM9761_SPDIF_CTRL, 4, 1, 0),
3205 /* BIT 9-10: DAC_CTL */
3206 AC97_ENUM("DAC Clock Source", cm9761_dac_clock_enum),
3209 static int patch_cm9761_post_spdif(struct snd_ac97 * ac97)
3211 return patch_build_controls(ac97, snd_ac97_cm9761_controls_spdif, ARRAY_SIZE(snd_ac97_cm9761_controls_spdif));
3214 static int patch_cm9761_specific(struct snd_ac97 * ac97)
3216 return patch_build_controls(ac97, snd_ac97_cm9761_controls, ARRAY_SIZE(snd_ac97_cm9761_controls));
3219 static const struct snd_ac97_build_ops patch_cm9761_ops = {
3220 .build_specific = patch_cm9761_specific,
3221 .build_post_spdif = patch_cm9761_post_spdif,
3222 .update_jacks = cm9761_update_jacks
3225 static int patch_cm9761(struct snd_ac97 *ac97)
3229 /* CM9761 has no PCM volume although the register reacts */
3230 /* Master volume seems to have _some_ influence on the analog
3233 ac97->flags |= /*AC97_HAS_NO_MASTER_VOL |*/ AC97_HAS_NO_PCM_VOL;
3234 snd_ac97_write_cache(ac97, AC97_MASTER, 0x8808);
3235 snd_ac97_write_cache(ac97, AC97_PCM, 0x8808);
3237 ac97->spec.dev_flags = 0; /* 1 = model 82 revision B, 2 = model 83 */
3238 if (ac97->id == AC97_ID_CM9761_82) {
3240 /* check page 1, reg 0x60 */
3241 val = snd_ac97_read(ac97, AC97_INT_PAGING);
3242 snd_ac97_write_cache(ac97, AC97_INT_PAGING, (val & ~0x0f) | 0x01);
3243 tmp = snd_ac97_read(ac97, 0x60);
3244 ac97->spec.dev_flags = tmp & 1; /* revision B? */
3245 snd_ac97_write_cache(ac97, AC97_INT_PAGING, val);
3246 } else if (ac97->id == AC97_ID_CM9761_83)
3247 ac97->spec.dev_flags = 2;
3249 ac97->build_ops = &patch_cm9761_ops;
3252 /* force the SPDIF bit in ext_id - codec doesn't set this bit! */
3253 ac97->ext_id |= AC97_EI_SPDIF;
3254 /* to be sure: we overwrite the ext status bits */
3255 snd_ac97_write_cache(ac97, AC97_EXTENDED_STATUS, 0x05c0);
3256 /* Don't set 0x0200 here. This results in the silent analog output */
3257 snd_ac97_write_cache(ac97, AC97_CM9761_SPDIF_CTRL, 0x0001); /* enable spdif-in */
3258 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000; /* 48k only */
3260 /* set-up multi channel */
3261 /* bit 15: pc master beep off
3262 * bit 14: pin47 = EAPD/SPDIF
3263 * bit 13: vref ctl [= cm9739]
3264 * bit 12: CLFE control (reverted on rev B)
3265 * bit 11: Mic/center share (reverted on rev B)
3266 * bit 10: suddound/line share
3267 * bit 9: Analog-in mix -> surround
3268 * bit 8: Analog-in mix -> CLFE
3269 * bit 7: Mic/LFE share (mic/center/lfe)
3270 * bit 5: vref select (9761A)
3271 * bit 4: front control
3272 * bit 3: surround control (revereted with rev B)
3275 * bit 0: mic boost level (0=20dB, 1=30dB)
3279 if (ac97->spec.dev_flags)
3284 val = snd_ac97_read(ac97, AC97_CM9761_MULTI_CHAN);
3285 val |= (1 << 4); /* front on */
3286 snd_ac97_write_cache(ac97, AC97_CM9761_MULTI_CHAN, val);
3288 /* FIXME: set up GPIO */
3289 snd_ac97_write_cache(ac97, 0x70, 0x0100);
3290 snd_ac97_write_cache(ac97, 0x72, 0x0020);
3295 #define AC97_CM9780_SIDE 0x60
3296 #define AC97_CM9780_JACK 0x62
3297 #define AC97_CM9780_MIXER 0x64
3298 #define AC97_CM9780_MULTI_CHAN 0x66
3299 #define AC97_CM9780_SPDIF 0x6c
3301 static const char * const cm9780_ch_select[] = {
3302 "Front", "Side", "Center/LFE", "Rear"
3304 static const struct ac97_enum cm9780_ch_select_enum =
3305 AC97_ENUM_SINGLE(AC97_CM9780_MULTI_CHAN, 6, 4, cm9780_ch_select);
3306 static const struct snd_kcontrol_new cm9780_controls[] = {
3307 AC97_DOUBLE("Side Playback Switch", AC97_CM9780_SIDE, 15, 7, 1, 1),
3308 AC97_DOUBLE("Side Playback Volume", AC97_CM9780_SIDE, 8, 0, 31, 0),
3309 AC97_ENUM("Side Playback Route", cm9780_ch_select_enum),
3312 static int patch_cm9780_specific(struct snd_ac97 *ac97)
3314 return patch_build_controls(ac97, cm9780_controls, ARRAY_SIZE(cm9780_controls));
3317 static const struct snd_ac97_build_ops patch_cm9780_ops = {
3318 .build_specific = patch_cm9780_specific,
3319 .build_post_spdif = patch_cm9761_post_spdif /* identical with CM9761 */
3322 static int patch_cm9780(struct snd_ac97 *ac97)
3326 ac97->build_ops = &patch_cm9780_ops;
3329 if (ac97->ext_id & AC97_EI_SPDIF) {
3330 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_48000; /* 48k only */
3331 val = snd_ac97_read(ac97, AC97_CM9780_SPDIF);
3332 val |= 0x1; /* SPDI_EN */
3333 snd_ac97_write_cache(ac97, AC97_CM9780_SPDIF, val);
3342 static const struct snd_kcontrol_new snd_ac97_controls_vt1613[] = {
3343 AC97_SINGLE("DC Offset removal", 0x5a, 10, 1, 0),
3346 static int patch_vt1613_specific(struct snd_ac97 *ac97)
3348 return patch_build_controls(ac97, &snd_ac97_controls_vt1613[0],
3349 ARRAY_SIZE(snd_ac97_controls_vt1613));
3352 static const struct snd_ac97_build_ops patch_vt1613_ops = {
3353 .build_specific = patch_vt1613_specific
3356 static int patch_vt1613(struct snd_ac97 *ac97)
3358 ac97->build_ops = &patch_vt1613_ops;
3360 ac97->flags |= AC97_HAS_NO_VIDEO;
3361 ac97->caps |= AC97_BC_HEADPHONE;
3369 static const struct snd_kcontrol_new snd_ac97_controls_vt1616[] = {
3370 AC97_SINGLE("DC Offset removal", 0x5a, 10, 1, 0),
3371 AC97_SINGLE("Alternate Level to Surround Out", 0x5a, 15, 1, 0),
3372 AC97_SINGLE("Downmix LFE and Center to Front", 0x5a, 12, 1, 0),
3373 AC97_SINGLE("Downmix Surround to Front", 0x5a, 11, 1, 0),
3376 static const char * const follower_vols_vt1616[] = {
3377 "Front Playback Volume",
3378 "Surround Playback Volume",
3379 "Center Playback Volume",
3380 "LFE Playback Volume",
3384 static const char * const follower_sws_vt1616[] = {
3385 "Front Playback Switch",
3386 "Surround Playback Switch",
3387 "Center Playback Switch",
3388 "LFE Playback Switch",
3392 /* find a mixer control element with the given name */
3393 static struct snd_kcontrol *snd_ac97_find_mixer_ctl(struct snd_ac97 *ac97,
3396 struct snd_ctl_elem_id id;
3397 memset(&id, 0, sizeof(id));
3398 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
3399 strcpy(id.name, name);
3400 return snd_ctl_find_id(ac97->bus->card, &id);
3403 /* create a virtual master control and add followers */
3404 static int snd_ac97_add_vmaster(struct snd_ac97 *ac97, char *name,
3405 const unsigned int *tlv,
3406 const char * const *followers)
3408 struct snd_kcontrol *kctl;
3409 const char * const *s;
3412 kctl = snd_ctl_make_virtual_master(name, tlv);
3415 err = snd_ctl_add(ac97->bus->card, kctl);
3419 for (s = followers; *s; s++) {
3420 struct snd_kcontrol *sctl;
3422 sctl = snd_ac97_find_mixer_ctl(ac97, *s);
3424 dev_dbg(ac97->bus->card->dev,
3425 "Cannot find follower %s, skipped\n", *s);
3428 err = snd_ctl_add_follower(kctl, sctl);
3435 static int patch_vt1616_specific(struct snd_ac97 * ac97)
3437 struct snd_kcontrol *kctl;
3440 if (snd_ac97_try_bit(ac97, 0x5a, 9))
3441 if ((err = patch_build_controls(ac97, &snd_ac97_controls_vt1616[0], 1)) < 0)
3443 if ((err = patch_build_controls(ac97, &snd_ac97_controls_vt1616[1], ARRAY_SIZE(snd_ac97_controls_vt1616) - 1)) < 0)
3446 /* There is already a misnamed master switch. Rename it. */
3447 kctl = snd_ac97_find_mixer_ctl(ac97, "Master Playback Volume");
3451 snd_ac97_rename_vol_ctl(ac97, "Master Playback", "Front Playback");
3453 err = snd_ac97_add_vmaster(ac97, "Master Playback Volume",
3454 kctl->tlv.p, follower_vols_vt1616);
3458 err = snd_ac97_add_vmaster(ac97, "Master Playback Switch",
3459 NULL, follower_sws_vt1616);
3466 static const struct snd_ac97_build_ops patch_vt1616_ops = {
3467 .build_specific = patch_vt1616_specific
3470 static int patch_vt1616(struct snd_ac97 * ac97)
3472 ac97->build_ops = &patch_vt1616_ops;
3481 * unfortunately, the vt1617a stashes the twiddlers required for
3482 * noodling the i/o jacks on 2 different regs. that means that we can't
3483 * use the easy way provided by AC97_ENUM_DOUBLE() we have to write
3486 * NB: this is absolutely and utterly different from the vt1618. dunno
3490 /* copied from ac97_surround_jack_mode_info() */
3491 static int snd_ac97_vt1617a_smart51_info(struct snd_kcontrol *kcontrol,
3492 struct snd_ctl_elem_info *uinfo)
3494 /* ordering in this list reflects vt1617a docs for Reg 20 and
3495 * 7a and Table 6 that lays out the matrix NB WRT Table6: SM51
3496 * is SM51EN *AND* it's Bit14, not Bit15 so the table is very
3497 * counter-intuitive */
3499 static const char * const texts[] = {"LineIn Mic1", "LineIn Mic1 Mic3",
3500 "Surr LFE/C Mic3", "LineIn LFE/C Mic3",
3501 "LineIn Mic2", "LineIn Mic2 Mic1",
3502 "Surr LFE Mic1", "Surr LFE Mic1 Mic2"};
3504 return snd_ctl_enum_info(uinfo, 1, 8, texts);
3507 static int snd_ac97_vt1617a_smart51_get(struct snd_kcontrol *kcontrol,
3508 struct snd_ctl_elem_value *ucontrol)
3510 ushort usSM51, usMS;
3512 struct snd_ac97 *pac97;
3514 pac97 = snd_kcontrol_chip(kcontrol); /* grab codec handle */
3516 /* grab our desired bits, then mash them together in a manner
3517 * consistent with Table 6 on page 17 in the 1617a docs */
3519 usSM51 = snd_ac97_read(pac97, 0x7a) >> 14;
3520 usMS = snd_ac97_read(pac97, 0x20) >> 8;
3522 ucontrol->value.enumerated.item[0] = (usSM51 << 1) + usMS;
3527 static int snd_ac97_vt1617a_smart51_put(struct snd_kcontrol *kcontrol,
3528 struct snd_ctl_elem_value *ucontrol)
3530 ushort usSM51, usMS, usReg;
3532 struct snd_ac97 *pac97;
3534 pac97 = snd_kcontrol_chip(kcontrol); /* grab codec handle */
3536 usSM51 = ucontrol->value.enumerated.item[0] >> 1;
3537 usMS = ucontrol->value.enumerated.item[0] & 1;
3539 /* push our values into the register - consider that things will be left
3540 * in a funky state if the write fails */
3542 usReg = snd_ac97_read(pac97, 0x7a);
3543 snd_ac97_write_cache(pac97, 0x7a, (usReg & 0x3FFF) + (usSM51 << 14));
3544 usReg = snd_ac97_read(pac97, 0x20);
3545 snd_ac97_write_cache(pac97, 0x20, (usReg & 0xFEFF) + (usMS << 8));
3550 static const struct snd_kcontrol_new snd_ac97_controls_vt1617a[] = {
3552 AC97_SINGLE("Center/LFE Exchange", 0x5a, 8, 1, 0),
3554 * These are used to enable/disable surround sound on motherboards
3555 * that have 3 bidirectional analog jacks
3558 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3559 .name = "Smart 5.1 Select",
3560 .info = snd_ac97_vt1617a_smart51_info,
3561 .get = snd_ac97_vt1617a_smart51_get,
3562 .put = snd_ac97_vt1617a_smart51_put,
3566 static int patch_vt1617a(struct snd_ac97 * ac97)
3571 /* we choose to not fail out at this point, but we tell the
3572 caller when we return */
3574 err = patch_build_controls(ac97, &snd_ac97_controls_vt1617a[0],
3575 ARRAY_SIZE(snd_ac97_controls_vt1617a));
3577 /* bring analog power consumption to normal by turning off the
3578 * headphone amplifier, like WinXP driver for EPIA SP
3580 /* We need to check the bit before writing it.
3581 * On some (many?) hardwares, setting bit actually clears it!
3583 val = snd_ac97_read(ac97, 0x5c);
3585 snd_ac97_write_cache(ac97, 0x5c, 0x20);
3587 ac97->ext_id |= AC97_EI_SPDIF; /* force the detection of spdif */
3588 ac97->rates[AC97_RATES_SPDIF] = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000;
3589 ac97->build_ops = &patch_vt1616_ops;
3594 /* VIA VT1618 8 CHANNEL AC97 CODEC
3596 * VIA implements 'Smart 5.1' completely differently on the 1618 than
3597 * it does on the 1617a. awesome! They seem to have sourced this
3598 * particular revision of the technology from somebody else, it's
3599 * called Universal Audio Jack and it shows up on some other folk's chips
3602 * ordering in this list reflects vt1618 docs for Reg 60h and
3603 * the block diagram, DACs are as follows:
3606 * OUT_1 -> Surround,
3609 * Unlike the 1617a, each OUT has a consistent set of mappings
3610 * for all bitpatterns other than 00:
3616 * Special Case of 00:
3618 * OUT_0 Mixed Output
3622 * I have no idea what the hell Reserved does, but on an MSI
3623 * CN700T, i have to set it to get 5.1 output - YMMV, bad
3626 * If other chips use Universal Audio Jack, then this code might be applicable
3630 struct vt1618_uaj_item {
3631 unsigned short mask;
3632 unsigned short shift;
3633 const char * const items[4];
3636 /* This list reflects the vt1618 docs for Vendor Defined Register 0x60. */
3638 static const struct vt1618_uaj_item vt1618_uaj[3] = {
3644 "Speaker Out", "DAC Unmixed Out", "Line In", "Mic In"
3652 "Surround Out", "DAC Unmixed Out", "Line In", "Mic In"
3660 "Center LFE Out", "DAC Unmixed Out", "Line In", "Mic In"
3665 static int snd_ac97_vt1618_UAJ_info(struct snd_kcontrol *kcontrol,
3666 struct snd_ctl_elem_info *uinfo)
3668 return snd_ctl_enum_info(uinfo, 1, 4,
3669 vt1618_uaj[kcontrol->private_value].items);
3672 /* All of the vt1618 Universal Audio Jack twiddlers are on
3673 * Vendor Defined Register 0x60, page 0. The bits, and thus
3674 * the mask, are the only thing that changes
3676 static int snd_ac97_vt1618_UAJ_get(struct snd_kcontrol *kcontrol,
3677 struct snd_ctl_elem_value *ucontrol)
3679 unsigned short datpag, uaj;
3680 struct snd_ac97 *pac97 = snd_kcontrol_chip(kcontrol);
3682 mutex_lock(&pac97->page_mutex);
3684 datpag = snd_ac97_read(pac97, AC97_INT_PAGING) & AC97_PAGE_MASK;
3685 snd_ac97_update_bits(pac97, AC97_INT_PAGING, AC97_PAGE_MASK, 0);
3687 uaj = snd_ac97_read(pac97, 0x60) &
3688 vt1618_uaj[kcontrol->private_value].mask;
3690 snd_ac97_update_bits(pac97, AC97_INT_PAGING, AC97_PAGE_MASK, datpag);
3691 mutex_unlock(&pac97->page_mutex);
3693 ucontrol->value.enumerated.item[0] = uaj >>
3694 vt1618_uaj[kcontrol->private_value].shift;
3699 static int snd_ac97_vt1618_UAJ_put(struct snd_kcontrol *kcontrol,
3700 struct snd_ctl_elem_value *ucontrol)
3702 return ac97_update_bits_page(snd_kcontrol_chip(kcontrol), 0x60,
3703 vt1618_uaj[kcontrol->private_value].mask,
3704 ucontrol->value.enumerated.item[0]<<
3705 vt1618_uaj[kcontrol->private_value].shift,
3709 /* config aux in jack - not found on 3 jack motherboards or soundcards */
3711 static int snd_ac97_vt1618_aux_info(struct snd_kcontrol *kcontrol,
3712 struct snd_ctl_elem_info *uinfo)
3714 static const char * const txt_aux[] = {"Aux In", "Back Surr Out"};
3716 return snd_ctl_enum_info(uinfo, 1, 2, txt_aux);
3719 static int snd_ac97_vt1618_aux_get(struct snd_kcontrol *kcontrol,
3720 struct snd_ctl_elem_value *ucontrol)
3722 ucontrol->value.enumerated.item[0] =
3723 (snd_ac97_read(snd_kcontrol_chip(kcontrol), 0x5c) & 0x0008)>>3;
3727 static int snd_ac97_vt1618_aux_put(struct snd_kcontrol *kcontrol,
3728 struct snd_ctl_elem_value *ucontrol)
3730 /* toggle surround rear dac power */
3732 snd_ac97_update_bits(snd_kcontrol_chip(kcontrol), 0x5c, 0x0008,
3733 ucontrol->value.enumerated.item[0] << 3);
3735 /* toggle aux in surround rear out jack */
3737 return snd_ac97_update_bits(snd_kcontrol_chip(kcontrol), 0x76, 0x0008,
3738 ucontrol->value.enumerated.item[0] << 3);
3741 static const struct snd_kcontrol_new snd_ac97_controls_vt1618[] = {
3742 AC97_SINGLE("Exchange Center/LFE", 0x5a, 8, 1, 0),
3743 AC97_SINGLE("DC Offset", 0x5a, 10, 1, 0),
3744 AC97_SINGLE("Soft Mute", 0x5c, 0, 1, 1),
3745 AC97_SINGLE("Headphone Amp", 0x5c, 5, 1, 1),
3746 AC97_DOUBLE("Back Surr Volume", 0x5e, 8, 0, 31, 1),
3747 AC97_SINGLE("Back Surr Switch", 0x5e, 15, 1, 1),
3749 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3750 .name = "Speaker Jack Mode",
3751 .info = snd_ac97_vt1618_UAJ_info,
3752 .get = snd_ac97_vt1618_UAJ_get,
3753 .put = snd_ac97_vt1618_UAJ_put,
3757 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3758 .name = "Line Jack Mode",
3759 .info = snd_ac97_vt1618_UAJ_info,
3760 .get = snd_ac97_vt1618_UAJ_get,
3761 .put = snd_ac97_vt1618_UAJ_put,
3765 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3766 .name = "Mic Jack Mode",
3767 .info = snd_ac97_vt1618_UAJ_info,
3768 .get = snd_ac97_vt1618_UAJ_get,
3769 .put = snd_ac97_vt1618_UAJ_put,
3773 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3774 .name = "Aux Jack Mode",
3775 .info = snd_ac97_vt1618_aux_info,
3776 .get = snd_ac97_vt1618_aux_get,
3777 .put = snd_ac97_vt1618_aux_put,
3781 static int patch_vt1618(struct snd_ac97 *ac97)
3783 return patch_build_controls(ac97, snd_ac97_controls_vt1618,
3784 ARRAY_SIZE(snd_ac97_controls_vt1618));
3789 static void it2646_update_jacks(struct snd_ac97 *ac97)
3791 /* shared Line-In / Surround Out */
3792 snd_ac97_update_bits(ac97, 0x76, 1 << 9,
3793 is_shared_surrout(ac97) ? (1<<9) : 0);
3794 /* shared Mic / Center/LFE Out */
3795 snd_ac97_update_bits(ac97, 0x76, 1 << 10,
3796 is_shared_clfeout(ac97) ? (1<<10) : 0);
3799 static const struct snd_kcontrol_new snd_ac97_controls_it2646[] = {
3800 AC97_SURROUND_JACK_MODE_CTL,
3801 AC97_CHANNEL_MODE_CTL,
3804 static const struct snd_kcontrol_new snd_ac97_spdif_controls_it2646[] = {
3805 AC97_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), 0x76, 11, 1, 0),
3806 AC97_SINGLE("Analog to IEC958 Output", 0x76, 12, 1, 0),
3807 AC97_SINGLE("IEC958 Input Monitor", 0x76, 13, 1, 0),
3810 static int patch_it2646_specific(struct snd_ac97 * ac97)
3813 if ((err = patch_build_controls(ac97, snd_ac97_controls_it2646, ARRAY_SIZE(snd_ac97_controls_it2646))) < 0)
3815 if ((err = patch_build_controls(ac97, snd_ac97_spdif_controls_it2646, ARRAY_SIZE(snd_ac97_spdif_controls_it2646))) < 0)
3820 static const struct snd_ac97_build_ops patch_it2646_ops = {
3821 .build_specific = patch_it2646_specific,
3822 .update_jacks = it2646_update_jacks
3825 static int patch_it2646(struct snd_ac97 * ac97)
3827 ac97->build_ops = &patch_it2646_ops;
3828 /* full DAC volume */
3829 snd_ac97_write_cache(ac97, 0x5E, 0x0808);
3830 snd_ac97_write_cache(ac97, 0x7A, 0x0808);
3838 #define AC97_SI3036_CHIP_ID 0x5a
3839 #define AC97_SI3036_LINE_CFG 0x5c
3841 static const struct snd_kcontrol_new snd_ac97_controls_si3036[] = {
3842 AC97_DOUBLE("Modem Speaker Volume", 0x5c, 14, 12, 3, 1)
3845 static int patch_si3036_specific(struct snd_ac97 * ac97)
3848 for (idx = 0; idx < ARRAY_SIZE(snd_ac97_controls_si3036); idx++)
3849 if ((err = snd_ctl_add(ac97->bus->card, snd_ctl_new1(&snd_ac97_controls_si3036[idx], ac97))) < 0)
3854 static const struct snd_ac97_build_ops patch_si3036_ops = {
3855 .build_specific = patch_si3036_specific,
3858 static int mpatch_si3036(struct snd_ac97 * ac97)
3860 ac97->build_ops = &patch_si3036_ops;
3861 snd_ac97_write_cache(ac97, 0x5c, 0xf210 );
3862 snd_ac97_write_cache(ac97, 0x68, 0);
3869 * We use a static resolution table since LM4550 codec cannot be
3870 * properly autoprobed to determine the resolution via
3871 * check_volume_resolution().
3874 static const struct snd_ac97_res_table lm4550_restbl[] = {
3875 { AC97_MASTER, 0x1f1f },
3876 { AC97_HEADPHONE, 0x1f1f },
3877 { AC97_MASTER_MONO, 0x001f },
3878 { AC97_PC_BEEP, 0x001f }, /* LSB is ignored */
3879 { AC97_PHONE, 0x001f },
3880 { AC97_MIC, 0x001f },
3881 { AC97_LINE, 0x1f1f },
3882 { AC97_CD, 0x1f1f },
3883 { AC97_VIDEO, 0x1f1f },
3884 { AC97_AUX, 0x1f1f },
3885 { AC97_PCM, 0x1f1f },
3886 { AC97_REC_GAIN, 0x0f0f },
3887 { } /* terminator */
3890 static int patch_lm4550(struct snd_ac97 *ac97)
3892 ac97->res_table = lm4550_restbl;
3897 * UCB1400 codec (http://www.semiconductors.philips.com/acrobat_download/datasheets/UCB1400-02.pdf)
3899 static const struct snd_kcontrol_new snd_ac97_controls_ucb1400[] = {
3900 /* enable/disable headphone driver which allows direct connection to
3901 stereo headphone without the use of external DC blocking
3903 AC97_SINGLE("Headphone Driver", 0x6a, 6, 1, 0),
3904 /* Filter used to compensate the DC offset is added in the ADC to remove idle
3905 tones from the audio band. */
3906 AC97_SINGLE("DC Filter", 0x6a, 4, 1, 0),
3907 /* Control smart-low-power mode feature. Allows automatic power down
3908 of unused blocks in the ADC analog front end and the PLL. */
3909 AC97_SINGLE("Smart Low Power Mode", 0x6c, 4, 3, 0),
3912 static int patch_ucb1400_specific(struct snd_ac97 * ac97)
3915 for (idx = 0; idx < ARRAY_SIZE(snd_ac97_controls_ucb1400); idx++)
3916 if ((err = snd_ctl_add(ac97->bus->card, snd_ctl_new1(&snd_ac97_controls_ucb1400[idx], ac97))) < 0)
3921 static const struct snd_ac97_build_ops patch_ucb1400_ops = {
3922 .build_specific = patch_ucb1400_specific,
3925 static int patch_ucb1400(struct snd_ac97 * ac97)
3927 ac97->build_ops = &patch_ucb1400_ops;
3928 /* enable headphone driver and smart low power mode by default */
3929 snd_ac97_write_cache(ac97, 0x6a, 0x0050);
3930 snd_ac97_write_cache(ac97, 0x6c, 0x0030);