2 * Universal Interface for Intel High Definition Audio Codec
4 * HD audio interface patch for SigmaTel STAC92xx
6 * Copyright (c) 2005 Embedded Alley Solutions, Inc.
7 * Matt Porter <mporter@embeddedalley.com>
9 * Based on patch_cmedia.c and patch_realtek.c
10 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
12 * This driver is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This driver is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include <sound/driver.h>
28 #include <linux/init.h>
29 #include <linux/delay.h>
30 #include <linux/slab.h>
31 #include <linux/pci.h>
32 #include <sound/core.h>
33 #include <sound/asoundef.h>
34 #include "hda_codec.h"
35 #include "hda_local.h"
37 #define NUM_CONTROL_ALLOC 32
38 #define STAC_HP_EVENT 0x37
81 /* for backward compatibility */
103 struct sigmatel_spec {
104 struct snd_kcontrol_new *mixers[4];
105 unsigned int num_mixers;
108 unsigned int surr_switch: 1;
109 unsigned int line_switch: 1;
110 unsigned int mic_switch: 1;
111 unsigned int alt_switch: 1;
112 unsigned int hp_detect: 1;
113 unsigned int gpio_mute: 1;
115 unsigned int gpio_mask, gpio_data;
118 struct hda_multi_out multiout;
119 hda_nid_t dac_nids[5];
123 unsigned int num_adcs;
125 unsigned int num_muxes;
126 hda_nid_t *dmic_nids;
127 unsigned int num_dmics;
129 hda_nid_t dig_in_nid;
133 unsigned int num_pins;
134 unsigned int *pin_configs;
135 unsigned int *bios_pin_configs;
137 /* codec specific stuff */
138 struct hda_verb *init;
139 struct snd_kcontrol_new *mixer;
142 struct hda_input_mux *dinput_mux;
143 unsigned int cur_dmux;
144 struct hda_input_mux *input_mux;
145 unsigned int cur_mux[3];
148 unsigned int io_switch[2];
149 unsigned int clfe_swap;
150 unsigned int aloopback;
152 struct hda_pcm pcm_rec[2]; /* PCM information */
154 /* dynamic controls and input_mux */
155 struct auto_pin_cfg autocfg;
156 unsigned int num_kctl_alloc, num_kctl_used;
157 struct snd_kcontrol_new *kctl_alloc;
158 struct hda_input_mux private_dimux;
159 struct hda_input_mux private_imux;
162 static hda_nid_t stac9200_adc_nids[1] = {
166 static hda_nid_t stac9200_mux_nids[1] = {
170 static hda_nid_t stac9200_dac_nids[1] = {
174 static hda_nid_t stac925x_adc_nids[1] = {
178 static hda_nid_t stac925x_mux_nids[1] = {
182 static hda_nid_t stac925x_dac_nids[1] = {
186 static hda_nid_t stac925x_dmic_nids[1] = {
190 static hda_nid_t stac922x_adc_nids[2] = {
194 static hda_nid_t stac922x_mux_nids[2] = {
198 static hda_nid_t stac927x_adc_nids[3] = {
202 static hda_nid_t stac927x_mux_nids[3] = {
206 static hda_nid_t stac9205_adc_nids[2] = {
210 static hda_nid_t stac9205_mux_nids[2] = {
214 static hda_nid_t stac9205_dmic_nids[2] = {
218 static hda_nid_t stac9200_pin_nids[8] = {
219 0x08, 0x09, 0x0d, 0x0e,
220 0x0f, 0x10, 0x11, 0x12,
223 static hda_nid_t stac925x_pin_nids[8] = {
224 0x07, 0x08, 0x0a, 0x0b,
225 0x0c, 0x0d, 0x10, 0x11,
228 static hda_nid_t stac922x_pin_nids[10] = {
229 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
230 0x0f, 0x10, 0x11, 0x15, 0x1b,
233 static hda_nid_t stac927x_pin_nids[14] = {
234 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
235 0x0f, 0x10, 0x11, 0x12, 0x13,
236 0x14, 0x21, 0x22, 0x23,
239 static hda_nid_t stac9205_pin_nids[12] = {
240 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
241 0x0f, 0x14, 0x16, 0x17, 0x18,
245 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
246 struct snd_ctl_elem_info *uinfo)
248 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
249 struct sigmatel_spec *spec = codec->spec;
250 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
253 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
254 struct snd_ctl_elem_value *ucontrol)
256 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
257 struct sigmatel_spec *spec = codec->spec;
259 ucontrol->value.enumerated.item[0] = spec->cur_dmux;
263 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
264 struct snd_ctl_elem_value *ucontrol)
266 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
267 struct sigmatel_spec *spec = codec->spec;
269 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
270 spec->dmux_nid, &spec->cur_dmux);
273 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
275 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
276 struct sigmatel_spec *spec = codec->spec;
277 return snd_hda_input_mux_info(spec->input_mux, uinfo);
280 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
282 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
283 struct sigmatel_spec *spec = codec->spec;
284 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
286 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
290 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
292 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
293 struct sigmatel_spec *spec = codec->spec;
294 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
296 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
297 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
300 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
302 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
303 struct snd_ctl_elem_value *ucontrol)
305 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
306 struct sigmatel_spec *spec = codec->spec;
308 ucontrol->value.integer.value[0] = spec->aloopback;
312 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
313 struct snd_ctl_elem_value *ucontrol)
315 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
316 struct sigmatel_spec *spec = codec->spec;
317 unsigned int dac_mode;
319 if (spec->aloopback == ucontrol->value.integer.value[0])
322 spec->aloopback = ucontrol->value.integer.value[0];
325 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
326 kcontrol->private_value & 0xFFFF, 0x0);
328 if (spec->aloopback) {
329 snd_hda_power_up(codec);
332 snd_hda_power_down(codec);
336 snd_hda_codec_write_cache(codec, codec->afg, 0,
337 kcontrol->private_value >> 16, dac_mode);
342 static int stac92xx_volknob_info(struct snd_kcontrol *kcontrol,
343 struct snd_ctl_elem_info *uinfo)
345 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
347 uinfo->value.integer.min = 0;
348 uinfo->value.integer.max = 127;
352 static int stac92xx_volknob_get(struct snd_kcontrol *kcontrol,
353 struct snd_ctl_elem_value *ucontrol)
355 ucontrol->value.integer.value[0] = kcontrol->private_value;
359 static int stac92xx_volknob_put(struct snd_kcontrol *kcontrol,
360 struct snd_ctl_elem_value *ucontrol)
362 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
364 if (kcontrol->private_value == ucontrol->value.integer.value[0])
367 kcontrol->private_value = ucontrol->value.integer.value[0];
369 snd_hda_codec_write_cache(codec, 0x24, 0,
370 AC_VERB_SET_VOLUME_KNOB_CONTROL,
371 kcontrol->private_value | 0x80);
376 static struct hda_verb stac9200_core_init[] = {
377 /* set dac0mux for dac converter */
378 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
382 static struct hda_verb stac925x_core_init[] = {
383 /* set dac0mux for dac converter */
384 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
388 static struct hda_verb stac922x_core_init[] = {
389 /* set master volume and direct control */
390 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
394 static struct hda_verb d965_core_init[] = {
395 /* set master volume and direct control */
396 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
397 /* unmute node 0x1b */
398 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
399 /* select node 0x03 as DAC */
400 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
404 static struct hda_verb stac927x_core_init[] = {
405 /* set master volume and direct control */
406 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
410 static struct hda_verb stac9205_core_init[] = {
411 /* set master volume and direct control */
412 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
416 #define STAC_INPUT_SOURCE(cnt) \
418 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
419 .name = "Input Source", \
421 .info = stac92xx_mux_enum_info, \
422 .get = stac92xx_mux_enum_get, \
423 .put = stac92xx_mux_enum_put, \
426 #define STAC_ANALOG_LOOPBACK(verb_read,verb_write) \
428 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
429 .name = "Analog Loopback", \
431 .info = stac92xx_aloopback_info, \
432 .get = stac92xx_aloopback_get, \
433 .put = stac92xx_aloopback_put, \
434 .private_value = verb_read | (verb_write << 16), \
437 #define STAC_VOLKNOB \
439 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
440 .name = "Master Playback Volume", \
442 .info = stac92xx_volknob_info, \
443 .get = stac92xx_volknob_get, \
444 .put = stac92xx_volknob_put, \
445 .private_value = 127, \
449 static struct snd_kcontrol_new stac9200_mixer[] = {
450 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
451 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
452 STAC_INPUT_SOURCE(1),
453 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
454 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
455 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT),
459 static struct snd_kcontrol_new stac925x_mixer[] = {
460 STAC_INPUT_SOURCE(1),
461 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
462 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_OUTPUT),
463 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT),
467 static struct snd_kcontrol_new stac9205_mixer[] = {
469 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
470 .name = "Digital Input Source",
472 .info = stac92xx_dmux_enum_info,
473 .get = stac92xx_dmux_enum_get,
474 .put = stac92xx_dmux_enum_put,
476 STAC_INPUT_SOURCE(2),
477 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0),
480 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
481 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
482 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT),
484 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
485 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
486 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT),
491 /* This needs to be generated dynamically based on sequence */
492 static struct snd_kcontrol_new stac922x_mixer[] = {
493 STAC_INPUT_SOURCE(2),
495 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
496 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
497 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT),
499 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
500 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
501 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT),
506 static struct snd_kcontrol_new stac927x_mixer[] = {
507 STAC_INPUT_SOURCE(3),
509 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB),
511 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
512 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
513 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT),
515 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
516 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
517 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT),
519 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
520 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
521 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT),
525 static int stac92xx_build_controls(struct hda_codec *codec)
527 struct sigmatel_spec *spec = codec->spec;
531 err = snd_hda_add_new_ctls(codec, spec->mixer);
535 for (i = 0; i < spec->num_mixers; i++) {
536 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
541 if (spec->multiout.dig_out_nid) {
542 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
546 if (spec->dig_in_nid) {
547 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
554 static unsigned int ref9200_pin_configs[8] = {
555 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
556 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
560 STAC 9200 pin configs for
565 static unsigned int dell9200_d21_pin_configs[8] = {
566 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
567 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
571 STAC 9200 pin configs for
575 static unsigned int dell9200_d22_pin_configs[8] = {
576 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
577 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
581 STAC 9200 pin configs for
582 102801C4 (Dell Dimension E310)
589 static unsigned int dell9200_d23_pin_configs[8] = {
590 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
591 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
596 STAC 9200-32 pin configs for
597 102801B5 (Dell Inspiron 630m)
598 102801D8 (Dell Inspiron 640m)
600 static unsigned int dell9200_m21_pin_configs[8] = {
601 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
602 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
606 STAC 9200-32 pin configs for
607 102801C2 (Dell Latitude D620)
609 102801CC (Dell Latitude D820)
613 static unsigned int dell9200_m22_pin_configs[8] = {
614 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
615 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
619 STAC 9200-32 pin configs for
620 102801CE (Dell XPS M1710)
621 102801CF (Dell Precision M90)
623 static unsigned int dell9200_m23_pin_configs[8] = {
624 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
625 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
629 STAC 9200-32 pin configs for
632 102801CB (Dell Latitude 120L)
635 static unsigned int dell9200_m24_pin_configs[8] = {
636 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
637 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
641 STAC 9200-32 pin configs for
642 102801BD (Dell Inspiron E1505n)
646 static unsigned int dell9200_m25_pin_configs[8] = {
647 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
648 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
652 STAC 9200-32 pin configs for
653 102801F5 (Dell Inspiron 1501)
656 static unsigned int dell9200_m26_pin_configs[8] = {
657 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
658 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
663 102801CD (Dell Inspiron E1705/9400)
665 static unsigned int dell9200_m27_pin_configs[8] = {
666 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
667 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
671 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
672 [STAC_REF] = ref9200_pin_configs,
673 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
674 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
675 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
676 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
677 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
678 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
679 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
680 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
681 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
682 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
685 static const char *stac9200_models[STAC_9200_MODELS] = {
687 [STAC_9200_DELL_D21] = "dell-d21",
688 [STAC_9200_DELL_D22] = "dell-d22",
689 [STAC_9200_DELL_D23] = "dell-d23",
690 [STAC_9200_DELL_M21] = "dell-m21",
691 [STAC_9200_DELL_M22] = "dell-m22",
692 [STAC_9200_DELL_M23] = "dell-m23",
693 [STAC_9200_DELL_M24] = "dell-m24",
694 [STAC_9200_DELL_M25] = "dell-m25",
695 [STAC_9200_DELL_M26] = "dell-m26",
696 [STAC_9200_DELL_M27] = "dell-m27",
699 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
700 /* SigmaTel reference board */
701 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
702 "DFI LanParty", STAC_REF),
703 /* Dell laptops have BIOS problem */
704 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
705 "unknown Dell", STAC_9200_DELL_D21),
706 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
707 "Dell Inspiron 630m", STAC_9200_DELL_M21),
708 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
709 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
710 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
711 "unknown Dell", STAC_9200_DELL_D22),
712 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
713 "unknown Dell", STAC_9200_DELL_D22),
714 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
715 "Dell Latitude D620", STAC_9200_DELL_M22),
716 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
717 "unknown Dell", STAC_9200_DELL_D23),
718 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
719 "unknown Dell", STAC_9200_DELL_D23),
720 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
721 "unknown Dell", STAC_9200_DELL_M22),
722 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
723 "unknown Dell", STAC_9200_DELL_M24),
724 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
725 "unknown Dell", STAC_9200_DELL_M24),
726 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
727 "Dell Latitude 120L", STAC_9200_DELL_M24),
728 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
729 "Dell Latitude D820", STAC_9200_DELL_M22),
730 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
731 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
732 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
733 "Dell XPS M1710", STAC_9200_DELL_M23),
734 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
735 "Dell Precision M90", STAC_9200_DELL_M23),
736 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
737 "unknown Dell", STAC_9200_DELL_M22),
738 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
739 "unknown Dell", STAC_9200_DELL_M22),
740 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
741 "unknown Dell", STAC_9200_DELL_M22),
742 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
743 "Dell Inspiron 640m", STAC_9200_DELL_M21),
744 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
745 "unknown Dell", STAC_9200_DELL_D23),
746 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
747 "unknown Dell", STAC_9200_DELL_D23),
748 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
749 "unknown Dell", STAC_9200_DELL_D21),
750 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
751 "unknown Dell", STAC_9200_DELL_D23),
752 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
753 "unknown Dell", STAC_9200_DELL_D21),
754 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
755 "unknown Dell", STAC_9200_DELL_M25),
756 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
757 "unknown Dell", STAC_9200_DELL_M25),
758 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
759 "Dell Inspiron 1501", STAC_9200_DELL_M26),
760 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
761 "unknown Dell", STAC_9200_DELL_M26),
763 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_REF),
768 static unsigned int ref925x_pin_configs[8] = {
769 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
770 0x90a70320, 0x02214210, 0x400003f1, 0x9033032e,
773 static unsigned int stac925x_MA6_pin_configs[8] = {
774 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
775 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
778 static unsigned int stac925x_PA6_pin_configs[8] = {
779 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
780 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
783 static unsigned int stac925xM2_2_pin_configs[8] = {
784 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
785 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
788 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
789 [STAC_REF] = ref925x_pin_configs,
790 [STAC_M2_2] = stac925xM2_2_pin_configs,
791 [STAC_MA6] = stac925x_MA6_pin_configs,
792 [STAC_PA6] = stac925x_PA6_pin_configs,
795 static const char *stac925x_models[STAC_925x_MODELS] = {
797 [STAC_M2_2] = "m2-2",
802 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
803 /* SigmaTel reference board */
804 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
805 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
806 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
807 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
808 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
809 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
810 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
814 static unsigned int ref922x_pin_configs[10] = {
815 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
816 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
817 0x40000100, 0x40000100,
821 STAC 922X pin configs for
828 static unsigned int dell_922x_d81_pin_configs[10] = {
829 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
830 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
831 0x01813122, 0x400001f2,
835 STAC 922X pin configs for
839 static unsigned int dell_922x_d82_pin_configs[10] = {
840 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
841 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
842 0x01813122, 0x400001f1,
846 STAC 922X pin configs for
849 static unsigned int dell_922x_m81_pin_configs[10] = {
850 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
851 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
852 0x40C003f1, 0x405003f0,
856 STAC 9221 A1 pin configs for
857 102801D7 (Dell XPS M1210)
859 static unsigned int dell_922x_m82_pin_configs[10] = {
860 0x0221121f, 0x408103ff, 0x02111212, 0x90100310,
861 0x408003f1, 0x02111211, 0x03451340, 0x40c003f2,
862 0x508003f3, 0x405003f4,
865 static unsigned int d945gtp3_pin_configs[10] = {
866 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
867 0x40000100, 0x40000100, 0x40000100, 0x40000100,
868 0x02a19120, 0x40000100,
871 static unsigned int d945gtp5_pin_configs[10] = {
872 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
873 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
874 0x02a19320, 0x40000100,
877 static unsigned int intel_mac_v1_pin_configs[10] = {
878 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
879 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
880 0x400000fc, 0x400000fb,
883 static unsigned int intel_mac_v2_pin_configs[10] = {
884 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
885 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
886 0x400000fc, 0x400000fb,
889 static unsigned int intel_mac_v3_pin_configs[10] = {
890 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
891 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
892 0x400000fc, 0x400000fb,
895 static unsigned int intel_mac_v4_pin_configs[10] = {
896 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
897 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
898 0x400000fc, 0x400000fb,
901 static unsigned int intel_mac_v5_pin_configs[10] = {
902 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
903 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
904 0x400000fc, 0x400000fb,
908 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
909 [STAC_D945_REF] = ref922x_pin_configs,
910 [STAC_D945GTP3] = d945gtp3_pin_configs,
911 [STAC_D945GTP5] = d945gtp5_pin_configs,
912 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
913 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
914 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
915 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
916 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
917 /* for backward compatibility */
918 [STAC_MACMINI] = intel_mac_v3_pin_configs,
919 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
920 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
921 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
922 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
923 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
924 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
925 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
926 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
927 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
930 static const char *stac922x_models[STAC_922X_MODELS] = {
931 [STAC_D945_REF] = "ref",
932 [STAC_D945GTP5] = "5stack",
933 [STAC_D945GTP3] = "3stack",
934 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
935 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
936 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
937 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
938 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
939 /* for backward compatibility */
940 [STAC_MACMINI] = "macmini",
941 [STAC_MACBOOK] = "macbook",
942 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
943 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
944 [STAC_IMAC_INTEL] = "imac-intel",
945 [STAC_IMAC_INTEL_20] = "imac-intel-20",
946 [STAC_922X_DELL_D81] = "dell-d81",
947 [STAC_922X_DELL_D82] = "dell-d82",
948 [STAC_922X_DELL_M81] = "dell-m81",
949 [STAC_922X_DELL_M82] = "dell-m82",
952 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
953 /* SigmaTel reference board */
954 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
955 "DFI LanParty", STAC_D945_REF),
956 /* Intel 945G based systems */
957 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
958 "Intel D945G", STAC_D945GTP3),
959 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
960 "Intel D945G", STAC_D945GTP3),
961 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
962 "Intel D945G", STAC_D945GTP3),
963 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
964 "Intel D945G", STAC_D945GTP3),
965 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
966 "Intel D945G", STAC_D945GTP3),
967 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
968 "Intel D945G", STAC_D945GTP3),
969 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
970 "Intel D945G", STAC_D945GTP3),
971 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
972 "Intel D945G", STAC_D945GTP3),
973 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
974 "Intel D945G", STAC_D945GTP3),
975 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
976 "Intel D945G", STAC_D945GTP3),
977 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
978 "Intel D945G", STAC_D945GTP3),
979 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
980 "Intel D945G", STAC_D945GTP3),
981 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
982 "Intel D945G", STAC_D945GTP3),
983 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
984 "Intel D945G", STAC_D945GTP3),
985 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
986 "Intel D945G", STAC_D945GTP3),
987 /* Intel D945G 5-stack systems */
988 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
989 "Intel D945G", STAC_D945GTP5),
990 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
991 "Intel D945G", STAC_D945GTP5),
992 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
993 "Intel D945G", STAC_D945GTP5),
994 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
995 "Intel D945G", STAC_D945GTP5),
996 /* Intel 945P based systems */
997 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
998 "Intel D945P", STAC_D945GTP3),
999 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1000 "Intel D945P", STAC_D945GTP3),
1001 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1002 "Intel D945P", STAC_D945GTP3),
1003 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1004 "Intel D945P", STAC_D945GTP3),
1005 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1006 "Intel D945P", STAC_D945GTP3),
1007 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1008 "Intel D945P", STAC_D945GTP5),
1010 /* Apple Mac Mini (early 2006) */
1011 SND_PCI_QUIRK(0x8384, 0x7680,
1012 "Mac Mini", STAC_INTEL_MAC_V3),
1014 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1015 "unknown Dell", STAC_922X_DELL_D81),
1016 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1017 "unknown Dell", STAC_922X_DELL_D81),
1018 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1019 "unknown Dell", STAC_922X_DELL_D81),
1020 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1021 "unknown Dell", STAC_922X_DELL_D82),
1022 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1023 "unknown Dell", STAC_922X_DELL_M81),
1024 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1025 "unknown Dell", STAC_922X_DELL_D82),
1026 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1027 "unknown Dell", STAC_922X_DELL_D81),
1028 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1029 "unknown Dell", STAC_922X_DELL_D81),
1030 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1031 "Dell XPS M1210", STAC_922X_DELL_M82),
1035 static unsigned int ref927x_pin_configs[14] = {
1036 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1037 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1038 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1039 0x01c42190, 0x40000100,
1042 static unsigned int d965_3st_pin_configs[14] = {
1043 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
1044 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
1045 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1046 0x40000100, 0x40000100
1049 static unsigned int d965_5st_pin_configs[14] = {
1050 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1051 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
1052 0x40000100, 0x40000100, 0x40000100, 0x01442070,
1053 0x40000100, 0x40000100
1056 static unsigned int dell_3st_pin_configs[14] = {
1057 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
1058 0x01111212, 0x01116211, 0x01813050, 0x01112214,
1059 0x403003fa, 0x40000100, 0x40000100, 0x404003fb,
1060 0x40c003fc, 0x40000100
1063 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
1064 [STAC_D965_REF] = ref927x_pin_configs,
1065 [STAC_D965_3ST] = d965_3st_pin_configs,
1066 [STAC_D965_5ST] = d965_5st_pin_configs,
1067 [STAC_DELL_3ST] = dell_3st_pin_configs,
1070 static const char *stac927x_models[STAC_927X_MODELS] = {
1071 [STAC_D965_REF] = "ref",
1072 [STAC_D965_3ST] = "3stack",
1073 [STAC_D965_5ST] = "5stack",
1074 [STAC_DELL_3ST] = "dell-3stack",
1077 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
1078 /* SigmaTel reference board */
1079 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1080 "DFI LanParty", STAC_D965_REF),
1081 /* Intel 946 based systems */
1082 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
1083 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
1084 /* 965 based 3 stack systems */
1085 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
1086 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
1087 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
1088 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
1089 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
1090 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
1091 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
1092 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
1093 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
1094 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
1095 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
1096 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
1097 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
1098 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
1099 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
1100 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
1101 /* Dell 3 stack systems */
1102 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
1103 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
1104 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
1105 /* 965 based 5 stack systems */
1106 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
1107 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
1108 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
1109 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
1110 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
1111 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
1112 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
1113 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
1114 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
1118 static unsigned int ref9205_pin_configs[12] = {
1119 0x40000100, 0x40000100, 0x01016011, 0x01014010,
1120 0x01813122, 0x01a19021, 0x40000100, 0x40000100,
1121 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
1125 STAC 9205 pin configs for
1133 static unsigned int dell_9205_m42_pin_configs[12] = {
1134 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
1135 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
1136 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
1140 STAC 9205 pin configs for
1144 102801FF (Dell Precision M4300)
1149 static unsigned int dell_9205_m43_pin_configs[12] = {
1150 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
1151 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
1152 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
1155 static unsigned int dell_9205_m44_pin_configs[12] = {
1156 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
1157 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
1158 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
1161 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
1162 [STAC_9205_REF] = ref9205_pin_configs,
1163 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
1164 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
1165 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
1166 [STAC_9205_M43xx] = NULL,
1169 static const char *stac9205_models[STAC_9205_MODELS] = {
1170 [STAC_9205_REF] = "ref",
1171 [STAC_9205_DELL_M42] = "dell-m42",
1172 [STAC_9205_DELL_M43] = "dell-m43",
1173 [STAC_9205_DELL_M44] = "dell-m44",
1176 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
1177 /* SigmaTel reference board */
1178 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1179 "DFI LanParty", STAC_9205_REF),
1180 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1181 "unknown Dell", STAC_9205_DELL_M42),
1182 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1183 "unknown Dell", STAC_9205_DELL_M42),
1184 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
1185 "Dell Precision", STAC_9205_M43xx),
1186 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
1187 "Dell Precision", STAC_9205_DELL_M43),
1188 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
1189 "Dell Precision", STAC_9205_DELL_M43),
1190 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
1191 "Dell Precision", STAC_9205_DELL_M43),
1192 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1193 "unknown Dell", STAC_9205_DELL_M42),
1194 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1195 "unknown Dell", STAC_9205_DELL_M42),
1196 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
1197 "Dell Precision", STAC_9205_DELL_M43),
1198 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
1199 "Dell Precision M4300", STAC_9205_DELL_M43),
1200 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
1201 "Dell Precision", STAC_9205_DELL_M43),
1202 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1203 "Dell Inspiron", STAC_9205_DELL_M44),
1204 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1205 "Dell Inspiron", STAC_9205_DELL_M44),
1206 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1207 "Dell Inspiron", STAC_9205_DELL_M44),
1208 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1209 "Dell Inspiron", STAC_9205_DELL_M44),
1210 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
1211 "unknown Dell", STAC_9205_DELL_M42),
1212 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
1213 "Dell Inspiron", STAC_9205_DELL_M44),
1217 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
1220 struct sigmatel_spec *spec = codec->spec;
1222 if (! spec->bios_pin_configs) {
1223 spec->bios_pin_configs = kcalloc(spec->num_pins,
1224 sizeof(*spec->bios_pin_configs), GFP_KERNEL);
1225 if (! spec->bios_pin_configs)
1229 for (i = 0; i < spec->num_pins; i++) {
1230 hda_nid_t nid = spec->pin_nids[i];
1231 unsigned int pin_cfg;
1233 pin_cfg = snd_hda_codec_read(codec, nid, 0,
1234 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
1235 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
1237 spec->bios_pin_configs[i] = pin_cfg;
1243 static void stac92xx_set_config_reg(struct hda_codec *codec,
1244 hda_nid_t pin_nid, unsigned int pin_config)
1247 snd_hda_codec_write(codec, pin_nid, 0,
1248 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
1249 pin_config & 0x000000ff);
1250 snd_hda_codec_write(codec, pin_nid, 0,
1251 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
1252 (pin_config & 0x0000ff00) >> 8);
1253 snd_hda_codec_write(codec, pin_nid, 0,
1254 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
1255 (pin_config & 0x00ff0000) >> 16);
1256 snd_hda_codec_write(codec, pin_nid, 0,
1257 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
1259 i = snd_hda_codec_read(codec, pin_nid, 0,
1260 AC_VERB_GET_CONFIG_DEFAULT,
1262 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
1266 static void stac92xx_set_config_regs(struct hda_codec *codec)
1269 struct sigmatel_spec *spec = codec->spec;
1271 if (!spec->pin_configs)
1274 for (i = 0; i < spec->num_pins; i++)
1275 stac92xx_set_config_reg(codec, spec->pin_nids[i],
1276 spec->pin_configs[i]);
1279 static void stac92xx_enable_gpio_mask(struct hda_codec *codec)
1281 struct sigmatel_spec *spec = codec->spec;
1282 /* Configure GPIOx as output */
1283 snd_hda_codec_write_cache(codec, codec->afg, 0,
1284 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_mask);
1285 /* Configure GPIOx as CMOS */
1286 snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7e7, 0x00000000);
1288 snd_hda_codec_write_cache(codec, codec->afg, 0,
1289 AC_VERB_SET_GPIO_DATA, spec->gpio_data);
1291 snd_hda_codec_write_cache(codec, codec->afg, 0,
1292 AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
1296 * Analog playback callbacks
1298 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
1299 struct hda_codec *codec,
1300 struct snd_pcm_substream *substream)
1302 struct sigmatel_spec *spec = codec->spec;
1303 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
1306 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1307 struct hda_codec *codec,
1308 unsigned int stream_tag,
1309 unsigned int format,
1310 struct snd_pcm_substream *substream)
1312 struct sigmatel_spec *spec = codec->spec;
1313 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
1316 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1317 struct hda_codec *codec,
1318 struct snd_pcm_substream *substream)
1320 struct sigmatel_spec *spec = codec->spec;
1321 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1325 * Digital playback callbacks
1327 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1328 struct hda_codec *codec,
1329 struct snd_pcm_substream *substream)
1331 struct sigmatel_spec *spec = codec->spec;
1332 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1335 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1336 struct hda_codec *codec,
1337 struct snd_pcm_substream *substream)
1339 struct sigmatel_spec *spec = codec->spec;
1340 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1343 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1344 struct hda_codec *codec,
1345 unsigned int stream_tag,
1346 unsigned int format,
1347 struct snd_pcm_substream *substream)
1349 struct sigmatel_spec *spec = codec->spec;
1350 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1351 stream_tag, format, substream);
1356 * Analog capture callbacks
1358 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1359 struct hda_codec *codec,
1360 unsigned int stream_tag,
1361 unsigned int format,
1362 struct snd_pcm_substream *substream)
1364 struct sigmatel_spec *spec = codec->spec;
1366 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1367 stream_tag, 0, format);
1371 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1372 struct hda_codec *codec,
1373 struct snd_pcm_substream *substream)
1375 struct sigmatel_spec *spec = codec->spec;
1377 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
1381 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
1385 /* NID is set in stac92xx_build_pcms */
1387 .open = stac92xx_dig_playback_pcm_open,
1388 .close = stac92xx_dig_playback_pcm_close,
1389 .prepare = stac92xx_dig_playback_pcm_prepare
1393 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
1397 /* NID is set in stac92xx_build_pcms */
1400 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
1404 .nid = 0x02, /* NID to query formats and rates */
1406 .open = stac92xx_playback_pcm_open,
1407 .prepare = stac92xx_playback_pcm_prepare,
1408 .cleanup = stac92xx_playback_pcm_cleanup
1412 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
1416 .nid = 0x06, /* NID to query formats and rates */
1418 .open = stac92xx_playback_pcm_open,
1419 .prepare = stac92xx_playback_pcm_prepare,
1420 .cleanup = stac92xx_playback_pcm_cleanup
1424 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
1427 /* NID + .substreams is set in stac92xx_build_pcms */
1429 .prepare = stac92xx_capture_pcm_prepare,
1430 .cleanup = stac92xx_capture_pcm_cleanup
1434 static int stac92xx_build_pcms(struct hda_codec *codec)
1436 struct sigmatel_spec *spec = codec->spec;
1437 struct hda_pcm *info = spec->pcm_rec;
1439 codec->num_pcms = 1;
1440 codec->pcm_info = info;
1442 info->name = "STAC92xx Analog";
1443 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
1444 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
1445 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1446 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
1448 if (spec->alt_switch) {
1451 info->name = "STAC92xx Analog Alt";
1452 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
1455 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1458 info->name = "STAC92xx Digital";
1459 if (spec->multiout.dig_out_nid) {
1460 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
1461 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
1463 if (spec->dig_in_nid) {
1464 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
1465 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
1472 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
1474 unsigned int pincap = snd_hda_param_read(codec, nid,
1476 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
1477 if (pincap & AC_PINCAP_VREF_100)
1478 return AC_PINCTL_VREF_100;
1479 if (pincap & AC_PINCAP_VREF_80)
1480 return AC_PINCTL_VREF_80;
1481 if (pincap & AC_PINCAP_VREF_50)
1482 return AC_PINCTL_VREF_50;
1483 if (pincap & AC_PINCAP_VREF_GRD)
1484 return AC_PINCTL_VREF_GRD;
1488 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
1491 snd_hda_codec_write_cache(codec, nid, 0,
1492 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
1495 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
1497 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1499 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1500 struct sigmatel_spec *spec = codec->spec;
1501 int io_idx = kcontrol-> private_value & 0xff;
1503 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
1507 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1509 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1510 struct sigmatel_spec *spec = codec->spec;
1511 hda_nid_t nid = kcontrol->private_value >> 8;
1512 int io_idx = kcontrol-> private_value & 0xff;
1513 unsigned short val = ucontrol->value.integer.value[0];
1515 spec->io_switch[io_idx] = val;
1518 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
1520 unsigned int pinctl = AC_PINCTL_IN_EN;
1521 if (io_idx) /* set VREF for mic */
1522 pinctl |= stac92xx_get_vref(codec, nid);
1523 stac92xx_auto_set_pinctl(codec, nid, pinctl);
1528 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
1530 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
1531 struct snd_ctl_elem_value *ucontrol)
1533 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1534 struct sigmatel_spec *spec = codec->spec;
1536 ucontrol->value.integer.value[0] = spec->clfe_swap;
1540 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
1541 struct snd_ctl_elem_value *ucontrol)
1543 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1544 struct sigmatel_spec *spec = codec->spec;
1545 hda_nid_t nid = kcontrol->private_value & 0xff;
1547 if (spec->clfe_swap == ucontrol->value.integer.value[0])
1550 spec->clfe_swap = ucontrol->value.integer.value[0];
1552 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1553 spec->clfe_swap ? 0x4 : 0x0);
1558 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
1559 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1562 .info = stac92xx_io_switch_info, \
1563 .get = stac92xx_io_switch_get, \
1564 .put = stac92xx_io_switch_put, \
1565 .private_value = xpval, \
1568 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
1569 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1572 .info = stac92xx_clfe_switch_info, \
1573 .get = stac92xx_clfe_switch_get, \
1574 .put = stac92xx_clfe_switch_put, \
1575 .private_value = xpval, \
1579 STAC_CTL_WIDGET_VOL,
1580 STAC_CTL_WIDGET_MUTE,
1581 STAC_CTL_WIDGET_IO_SWITCH,
1582 STAC_CTL_WIDGET_CLFE_SWITCH
1585 static struct snd_kcontrol_new stac92xx_control_templates[] = {
1586 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
1587 HDA_CODEC_MUTE(NULL, 0, 0, 0),
1588 STAC_CODEC_IO_SWITCH(NULL, 0),
1589 STAC_CODEC_CLFE_SWITCH(NULL, 0),
1592 /* add dynamic controls */
1593 static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val)
1595 struct snd_kcontrol_new *knew;
1597 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
1598 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
1600 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
1603 if (spec->kctl_alloc) {
1604 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
1605 kfree(spec->kctl_alloc);
1607 spec->kctl_alloc = knew;
1608 spec->num_kctl_alloc = num;
1611 knew = &spec->kctl_alloc[spec->num_kctl_used];
1612 *knew = stac92xx_control_templates[type];
1613 knew->name = kstrdup(name, GFP_KERNEL);
1616 knew->private_value = val;
1617 spec->num_kctl_used++;
1621 /* flag inputs as additional dynamic lineouts */
1622 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
1624 struct sigmatel_spec *spec = codec->spec;
1625 unsigned int wcaps, wtype;
1626 int i, num_dacs = 0;
1628 /* use the wcaps cache to count all DACs available for line-outs */
1629 for (i = 0; i < codec->num_nodes; i++) {
1630 wcaps = codec->wcaps[i];
1631 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
1632 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
1636 snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
1638 switch (cfg->line_outs) {
1640 /* add line-in as side */
1641 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
1642 cfg->line_out_pins[cfg->line_outs] =
1643 cfg->input_pins[AUTO_PIN_LINE];
1644 spec->line_switch = 1;
1649 /* add line-in as clfe and mic as side */
1650 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
1651 cfg->line_out_pins[cfg->line_outs] =
1652 cfg->input_pins[AUTO_PIN_LINE];
1653 spec->line_switch = 1;
1656 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
1657 cfg->line_out_pins[cfg->line_outs] =
1658 cfg->input_pins[AUTO_PIN_MIC];
1659 spec->mic_switch = 1;
1664 /* add line-in as surr and mic as clfe */
1665 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
1666 cfg->line_out_pins[cfg->line_outs] =
1667 cfg->input_pins[AUTO_PIN_LINE];
1668 spec->line_switch = 1;
1671 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
1672 cfg->line_out_pins[cfg->line_outs] =
1673 cfg->input_pins[AUTO_PIN_MIC];
1674 spec->mic_switch = 1;
1684 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
1688 for (i = 0; i < spec->multiout.num_dacs; i++) {
1689 if (spec->multiout.dac_nids[i] == nid)
1697 * Fill in the dac_nids table from the parsed pin configuration
1698 * This function only works when every pin in line_out_pins[]
1699 * contains atleast one DAC in its connection list. Some 92xx
1700 * codecs are not connected directly to a DAC, such as the 9200
1701 * and 9202/925x. For those, dac_nids[] must be hard-coded.
1703 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
1704 struct auto_pin_cfg *cfg)
1706 struct sigmatel_spec *spec = codec->spec;
1707 int i, j, conn_len = 0;
1708 hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
1709 unsigned int wcaps, wtype;
1711 for (i = 0; i < cfg->line_outs; i++) {
1712 nid = cfg->line_out_pins[i];
1713 conn_len = snd_hda_get_connections(codec, nid, conn,
1714 HDA_MAX_CONNECTIONS);
1715 for (j = 0; j < conn_len; j++) {
1716 wcaps = snd_hda_param_read(codec, conn[j],
1717 AC_PAR_AUDIO_WIDGET_CAP);
1718 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
1720 if (wtype != AC_WID_AUD_OUT ||
1721 (wcaps & AC_WCAP_DIGITAL))
1723 /* conn[j] is a DAC routed to this line-out */
1724 if (!is_in_dac_nids(spec, conn[j]))
1728 if (j == conn_len) {
1729 if (spec->multiout.num_dacs > 0) {
1730 /* we have already working output pins,
1731 * so let's drop the broken ones again
1733 cfg->line_outs = spec->multiout.num_dacs;
1736 /* error out, no available DAC found */
1738 "%s: No available DAC for pin 0x%x\n",
1743 spec->multiout.dac_nids[i] = conn[j];
1744 spec->multiout.num_dacs++;
1746 /* select this DAC in the pin's input mux */
1747 snd_hda_codec_write_cache(codec, nid, 0,
1748 AC_VERB_SET_CONNECT_SEL, j);
1753 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
1754 spec->multiout.num_dacs,
1755 spec->multiout.dac_nids[0],
1756 spec->multiout.dac_nids[1],
1757 spec->multiout.dac_nids[2],
1758 spec->multiout.dac_nids[3],
1759 spec->multiout.dac_nids[4]);
1763 /* create volume control/switch for the given prefx type */
1764 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
1769 sprintf(name, "%s Playback Volume", pfx);
1770 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
1771 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1774 sprintf(name, "%s Playback Switch", pfx);
1775 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
1776 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1782 /* add playback controls from the parsed DAC table */
1783 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
1784 const struct auto_pin_cfg *cfg)
1786 static const char *chname[4] = {
1787 "Front", "Surround", NULL /*CLFE*/, "Side"
1792 struct sigmatel_spec *spec = codec->spec;
1793 unsigned int wid_caps;
1796 for (i = 0; i < cfg->line_outs; i++) {
1797 if (!spec->multiout.dac_nids[i])
1800 nid = spec->multiout.dac_nids[i];
1804 err = create_controls(spec, "Center", nid, 1);
1807 err = create_controls(spec, "LFE", nid, 2);
1811 wid_caps = get_wcaps(codec, nid);
1813 if (wid_caps & AC_WCAP_LR_SWAP) {
1814 err = stac92xx_add_control(spec,
1815 STAC_CTL_WIDGET_CLFE_SWITCH,
1816 "Swap Center/LFE Playback Switch", nid);
1823 err = create_controls(spec, chname[i], nid, 3);
1829 if (spec->line_switch)
1830 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Line In as Output Switch", cfg->input_pins[AUTO_PIN_LINE] << 8)) < 0)
1833 if (spec->mic_switch)
1834 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Mic as Output Switch", (cfg->input_pins[AUTO_PIN_MIC] << 8) | 1)) < 0)
1840 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
1842 if (is_in_dac_nids(spec, nid))
1844 if (spec->multiout.hp_nid == nid)
1849 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
1851 if (!spec->multiout.hp_nid)
1852 spec->multiout.hp_nid = nid;
1853 else if (spec->multiout.num_dacs > 4) {
1854 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
1857 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
1858 spec->multiout.num_dacs++;
1863 /* add playback controls for Speaker and HP outputs */
1864 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
1865 struct auto_pin_cfg *cfg)
1867 struct sigmatel_spec *spec = codec->spec;
1869 int i, old_num_dacs, err;
1871 old_num_dacs = spec->multiout.num_dacs;
1872 for (i = 0; i < cfg->hp_outs; i++) {
1873 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
1874 if (wid_caps & AC_WCAP_UNSOL_CAP)
1875 spec->hp_detect = 1;
1876 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
1877 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
1878 if (check_in_dac_nids(spec, nid))
1882 add_spec_dacs(spec, nid);
1884 for (i = 0; i < cfg->speaker_outs; i++) {
1885 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
1886 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
1887 if (check_in_dac_nids(spec, nid))
1891 add_spec_dacs(spec, nid);
1893 for (i = 0; i < cfg->line_outs; i++) {
1894 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
1895 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
1896 if (check_in_dac_nids(spec, nid))
1900 add_spec_dacs(spec, nid);
1902 for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
1903 static const char *pfxs[] = {
1904 "Speaker", "External Speaker", "Speaker2",
1906 err = create_controls(spec, pfxs[i - old_num_dacs],
1907 spec->multiout.dac_nids[i], 3);
1911 if (spec->multiout.hp_nid) {
1913 if (old_num_dacs == spec->multiout.num_dacs)
1917 err = create_controls(spec, pfx, spec->multiout.hp_nid, 3);
1925 /* labels for dmic mux inputs */
1926 static const char *stac92xx_dmic_labels[5] = {
1927 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
1928 "Digital Mic 3", "Digital Mic 4"
1931 /* create playback/capture controls for input pins on dmic capable codecs */
1932 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
1933 const struct auto_pin_cfg *cfg)
1935 struct sigmatel_spec *spec = codec->spec;
1936 struct hda_input_mux *dimux = &spec->private_dimux;
1937 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
1940 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
1941 dimux->items[dimux->num_items].index = 0;
1944 for (i = 0; i < spec->num_dmics; i++) {
1947 unsigned int def_conf;
1949 def_conf = snd_hda_codec_read(codec,
1952 AC_VERB_GET_CONFIG_DEFAULT,
1954 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
1957 num_cons = snd_hda_get_connections(codec,
1960 HDA_MAX_NUM_INPUTS);
1961 for (j = 0; j < num_cons; j++)
1962 if (con_lst[j] == spec->dmic_nids[i]) {
1968 dimux->items[dimux->num_items].label =
1969 stac92xx_dmic_labels[dimux->num_items];
1970 dimux->items[dimux->num_items].index = index;
1977 /* create playback/capture controls for input pins */
1978 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
1980 struct sigmatel_spec *spec = codec->spec;
1981 struct hda_input_mux *imux = &spec->private_imux;
1982 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
1985 for (i = 0; i < AUTO_PIN_LAST; i++) {
1988 if (!cfg->input_pins[i])
1991 for (j = 0; j < spec->num_muxes; j++) {
1993 num_cons = snd_hda_get_connections(codec,
1996 HDA_MAX_NUM_INPUTS);
1997 for (k = 0; k < num_cons; k++)
1998 if (con_lst[k] == cfg->input_pins[i]) {
2005 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2006 imux->items[imux->num_items].index = index;
2010 if (imux->num_items) {
2012 * Set the current input for the muxes.
2013 * The STAC9221 has two input muxes with identical source
2014 * NID lists. Hopefully this won't get confused.
2016 for (i = 0; i < spec->num_muxes; i++) {
2017 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
2018 AC_VERB_SET_CONNECT_SEL,
2019 imux->items[0].index);
2026 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
2028 struct sigmatel_spec *spec = codec->spec;
2031 for (i = 0; i < spec->autocfg.line_outs; i++) {
2032 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2033 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2037 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
2039 struct sigmatel_spec *spec = codec->spec;
2042 for (i = 0; i < spec->autocfg.hp_outs; i++) {
2044 pin = spec->autocfg.hp_pins[i];
2045 if (pin) /* connect to front */
2046 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
2048 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
2050 pin = spec->autocfg.speaker_pins[i];
2051 if (pin) /* connect to front */
2052 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
2056 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
2058 struct sigmatel_spec *spec = codec->spec;
2061 if ((err = snd_hda_parse_pin_def_config(codec,
2063 spec->dmic_nids)) < 0)
2065 if (! spec->autocfg.line_outs)
2066 return 0; /* can't find valid pin config */
2068 if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
2070 if (spec->multiout.num_dacs == 0)
2071 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2074 err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
2079 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
2084 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
2089 if (spec->num_dmics > 0)
2090 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
2091 &spec->autocfg)) < 0)
2094 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2095 if (spec->multiout.max_channels > 2)
2096 spec->surr_switch = 1;
2098 if (spec->autocfg.dig_out_pin)
2099 spec->multiout.dig_out_nid = dig_out;
2100 if (spec->autocfg.dig_in_pin)
2101 spec->dig_in_nid = dig_in;
2103 if (spec->kctl_alloc)
2104 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2106 spec->input_mux = &spec->private_imux;
2107 spec->dinput_mux = &spec->private_dimux;
2112 /* add playback controls for HP output */
2113 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
2114 struct auto_pin_cfg *cfg)
2116 struct sigmatel_spec *spec = codec->spec;
2117 hda_nid_t pin = cfg->hp_pins[0];
2118 unsigned int wid_caps;
2123 wid_caps = get_wcaps(codec, pin);
2124 if (wid_caps & AC_WCAP_UNSOL_CAP)
2125 spec->hp_detect = 1;
2130 /* add playback controls for LFE output */
2131 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
2132 struct auto_pin_cfg *cfg)
2134 struct sigmatel_spec *spec = codec->spec;
2136 hda_nid_t lfe_pin = 0x0;
2140 * search speaker outs and line outs for a mono speaker pin
2141 * with an amp. If one is found, add LFE controls
2144 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
2145 hda_nid_t pin = spec->autocfg.speaker_pins[i];
2146 unsigned long wcaps = get_wcaps(codec, pin);
2147 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2148 if (wcaps == AC_WCAP_OUT_AMP)
2149 /* found a mono speaker with an amp, must be lfe */
2153 /* if speaker_outs is 0, then speakers may be in line_outs */
2154 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
2155 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
2156 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2158 cfg = snd_hda_codec_read(codec, pin, 0,
2159 AC_VERB_GET_CONFIG_DEFAULT,
2161 if (get_defcfg_device(cfg) == AC_JACK_SPEAKER) {
2162 unsigned long wcaps = get_wcaps(codec, pin);
2163 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2164 if (wcaps == AC_WCAP_OUT_AMP)
2165 /* found a mono speaker with an amp,
2173 err = create_controls(spec, "LFE", lfe_pin, 1);
2181 static int stac9200_parse_auto_config(struct hda_codec *codec)
2183 struct sigmatel_spec *spec = codec->spec;
2186 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2189 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
2192 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
2195 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
2198 if (spec->autocfg.dig_out_pin)
2199 spec->multiout.dig_out_nid = 0x05;
2200 if (spec->autocfg.dig_in_pin)
2201 spec->dig_in_nid = 0x04;
2203 if (spec->kctl_alloc)
2204 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2206 spec->input_mux = &spec->private_imux;
2207 spec->dinput_mux = &spec->private_dimux;
2213 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
2214 * funky external mute control using GPIO pins.
2217 static void stac922x_gpio_mute(struct hda_codec *codec, int pin, int muted)
2219 unsigned int gpiostate, gpiomask, gpiodir;
2221 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
2222 AC_VERB_GET_GPIO_DATA, 0);
2225 gpiostate |= (1 << pin);
2227 gpiostate &= ~(1 << pin);
2229 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
2230 AC_VERB_GET_GPIO_MASK, 0);
2231 gpiomask |= (1 << pin);
2233 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
2234 AC_VERB_GET_GPIO_DIRECTION, 0);
2235 gpiodir |= (1 << pin);
2237 /* AppleHDA seems to do this -- WTF is this verb?? */
2238 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
2240 snd_hda_codec_write(codec, codec->afg, 0,
2241 AC_VERB_SET_GPIO_MASK, gpiomask);
2242 snd_hda_codec_write(codec, codec->afg, 0,
2243 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
2247 snd_hda_codec_write(codec, codec->afg, 0,
2248 AC_VERB_SET_GPIO_DATA, gpiostate);
2251 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
2254 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
2255 snd_hda_codec_write_cache(codec, nid, 0,
2256 AC_VERB_SET_UNSOLICITED_ENABLE,
2257 (AC_USRSP_EN | event));
2260 static int stac92xx_init(struct hda_codec *codec)
2262 struct sigmatel_spec *spec = codec->spec;
2263 struct auto_pin_cfg *cfg = &spec->autocfg;
2266 snd_hda_sequence_write(codec, spec->init);
2269 if (spec->hp_detect) {
2270 /* Enable unsolicited responses on the HP widget */
2271 for (i = 0; i < cfg->hp_outs; i++)
2272 enable_pin_detect(codec, cfg->hp_pins[i],
2274 /* force to enable the first line-out; the others are set up
2277 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
2279 stac92xx_auto_init_hp_out(codec);
2280 /* fake event to set up pins */
2281 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2283 stac92xx_auto_init_multi_out(codec);
2284 stac92xx_auto_init_hp_out(codec);
2286 for (i = 0; i < AUTO_PIN_LAST; i++) {
2287 hda_nid_t nid = cfg->input_pins[i];
2289 unsigned int pinctl = AC_PINCTL_IN_EN;
2290 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
2291 pinctl |= stac92xx_get_vref(codec, nid);
2292 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2295 if (spec->num_dmics > 0)
2296 for (i = 0; i < spec->num_dmics; i++)
2297 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
2300 if (cfg->dig_out_pin)
2301 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
2303 if (cfg->dig_in_pin)
2304 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
2307 if (spec->gpio_mute) {
2308 stac922x_gpio_mute(codec, 0, 0);
2309 stac922x_gpio_mute(codec, 1, 0);
2315 static void stac92xx_free(struct hda_codec *codec)
2317 struct sigmatel_spec *spec = codec->spec;
2323 if (spec->kctl_alloc) {
2324 for (i = 0; i < spec->num_kctl_used; i++)
2325 kfree(spec->kctl_alloc[i].name);
2326 kfree(spec->kctl_alloc);
2329 if (spec->bios_pin_configs)
2330 kfree(spec->bios_pin_configs);
2335 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
2338 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2339 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2341 if (pin_ctl & AC_PINCTL_IN_EN) {
2343 * we need to check the current set-up direction of
2344 * shared input pins since they can be switched via
2345 * "xxx as Output" mixer switch
2347 struct sigmatel_spec *spec = codec->spec;
2348 struct auto_pin_cfg *cfg = &spec->autocfg;
2349 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
2350 spec->line_switch) ||
2351 (nid == cfg->input_pins[AUTO_PIN_MIC] &&
2356 /* if setting pin direction bits, clear the current
2357 direction bits first */
2358 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
2359 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
2361 snd_hda_codec_write_cache(codec, nid, 0,
2362 AC_VERB_SET_PIN_WIDGET_CONTROL,
2366 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
2369 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2370 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2371 snd_hda_codec_write_cache(codec, nid, 0,
2372 AC_VERB_SET_PIN_WIDGET_CONTROL,
2376 static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
2380 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
2386 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
2388 struct sigmatel_spec *spec = codec->spec;
2389 struct auto_pin_cfg *cfg = &spec->autocfg;
2393 for (i = 0; i < cfg->hp_outs; i++) {
2394 presence = get_pin_presence(codec, cfg->hp_pins[i]);
2400 /* disable lineouts, enable hp */
2401 for (i = 0; i < cfg->line_outs; i++)
2402 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
2404 for (i = 0; i < cfg->speaker_outs; i++)
2405 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
2408 /* enable lineouts, disable hp */
2409 for (i = 0; i < cfg->line_outs; i++)
2410 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
2412 for (i = 0; i < cfg->speaker_outs; i++)
2413 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
2418 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
2420 switch (res >> 26) {
2422 stac92xx_hp_detect(codec, res);
2427 #ifdef SND_HDA_NEEDS_RESUME
2428 static int stac92xx_resume(struct hda_codec *codec)
2430 struct sigmatel_spec *spec = codec->spec;
2432 stac92xx_set_config_regs(codec);
2433 snd_hda_sequence_write(codec, spec->init);
2434 if (spec->gpio_mute) {
2435 stac922x_gpio_mute(codec, 0, 0);
2436 stac922x_gpio_mute(codec, 1, 0);
2438 snd_hda_codec_resume_amp(codec);
2439 snd_hda_codec_resume_cache(codec);
2440 /* invoke unsolicited event to reset the HP state */
2441 if (spec->hp_detect)
2442 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2447 static struct hda_codec_ops stac92xx_patch_ops = {
2448 .build_controls = stac92xx_build_controls,
2449 .build_pcms = stac92xx_build_pcms,
2450 .init = stac92xx_init,
2451 .free = stac92xx_free,
2452 .unsol_event = stac92xx_unsol_event,
2453 #ifdef SND_HDA_NEEDS_RESUME
2454 .resume = stac92xx_resume,
2458 static int patch_stac9200(struct hda_codec *codec)
2460 struct sigmatel_spec *spec;
2463 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2468 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
2469 spec->pin_nids = stac9200_pin_nids;
2470 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
2473 if (spec->board_config < 0) {
2474 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
2475 err = stac92xx_save_bios_config_regs(codec);
2477 stac92xx_free(codec);
2480 spec->pin_configs = spec->bios_pin_configs;
2482 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
2483 stac92xx_set_config_regs(codec);
2486 spec->multiout.max_channels = 2;
2487 spec->multiout.num_dacs = 1;
2488 spec->multiout.dac_nids = stac9200_dac_nids;
2489 spec->adc_nids = stac9200_adc_nids;
2490 spec->mux_nids = stac9200_mux_nids;
2491 spec->num_muxes = 1;
2492 spec->num_dmics = 0;
2495 spec->init = stac9200_core_init;
2496 spec->mixer = stac9200_mixer;
2498 err = stac9200_parse_auto_config(codec);
2500 stac92xx_free(codec);
2504 codec->patch_ops = stac92xx_patch_ops;
2509 static int patch_stac925x(struct hda_codec *codec)
2511 struct sigmatel_spec *spec;
2514 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2519 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
2520 spec->pin_nids = stac925x_pin_nids;
2521 spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
2525 if (spec->board_config < 0) {
2526 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
2527 "using BIOS defaults\n");
2528 err = stac92xx_save_bios_config_regs(codec);
2530 stac92xx_free(codec);
2533 spec->pin_configs = spec->bios_pin_configs;
2534 } else if (stac925x_brd_tbl[spec->board_config] != NULL){
2535 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
2536 stac92xx_set_config_regs(codec);
2539 spec->multiout.max_channels = 2;
2540 spec->multiout.num_dacs = 1;
2541 spec->multiout.dac_nids = stac925x_dac_nids;
2542 spec->adc_nids = stac925x_adc_nids;
2543 spec->mux_nids = stac925x_mux_nids;
2544 spec->num_muxes = 1;
2546 switch (codec->vendor_id) {
2547 case 0x83847632: /* STAC9202 */
2548 case 0x83847633: /* STAC9202D */
2549 case 0x83847636: /* STAC9251 */
2550 case 0x83847637: /* STAC9251D */
2551 spec->num_dmics = 1;
2552 spec->dmic_nids = stac925x_dmic_nids;
2555 spec->num_dmics = 0;
2559 spec->init = stac925x_core_init;
2560 spec->mixer = stac925x_mixer;
2562 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
2564 if (spec->board_config < 0) {
2565 printk(KERN_WARNING "hda_codec: No auto-config is "
2566 "available, default to model=ref\n");
2567 spec->board_config = STAC_925x_REF;
2573 stac92xx_free(codec);
2577 codec->patch_ops = stac92xx_patch_ops;
2582 static int patch_stac922x(struct hda_codec *codec)
2584 struct sigmatel_spec *spec;
2587 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2592 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
2593 spec->pin_nids = stac922x_pin_nids;
2594 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
2597 if (spec->board_config == STAC_INTEL_MAC_V3) {
2598 spec->gpio_mute = 1;
2599 /* Intel Macs have all same PCI SSID, so we need to check
2600 * codec SSID to distinguish the exact models
2602 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
2603 switch (codec->subsystem_id) {
2606 spec->board_config = STAC_INTEL_MAC_V1;
2610 spec->board_config = STAC_INTEL_MAC_V2;
2618 spec->board_config = STAC_INTEL_MAC_V3;
2622 spec->board_config = STAC_INTEL_MAC_V4;
2626 spec->board_config = STAC_INTEL_MAC_V5;
2632 if (spec->board_config < 0) {
2633 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
2634 "using BIOS defaults\n");
2635 err = stac92xx_save_bios_config_regs(codec);
2637 stac92xx_free(codec);
2640 spec->pin_configs = spec->bios_pin_configs;
2641 } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
2642 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
2643 stac92xx_set_config_regs(codec);
2646 spec->adc_nids = stac922x_adc_nids;
2647 spec->mux_nids = stac922x_mux_nids;
2648 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
2649 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
2650 spec->num_dmics = 0;
2652 spec->init = stac922x_core_init;
2653 spec->mixer = stac922x_mixer;
2655 spec->multiout.dac_nids = spec->dac_nids;
2657 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
2659 if (spec->board_config < 0) {
2660 printk(KERN_WARNING "hda_codec: No auto-config is "
2661 "available, default to model=ref\n");
2662 spec->board_config = STAC_D945_REF;
2668 stac92xx_free(codec);
2672 codec->patch_ops = stac92xx_patch_ops;
2674 /* Fix Mux capture level; max to 2 */
2675 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
2676 (0 << AC_AMPCAP_OFFSET_SHIFT) |
2677 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
2678 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2679 (0 << AC_AMPCAP_MUTE_SHIFT));
2684 static int patch_stac927x(struct hda_codec *codec)
2686 struct sigmatel_spec *spec;
2689 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2694 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
2695 spec->pin_nids = stac927x_pin_nids;
2696 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
2700 if (spec->board_config < 0) {
2701 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC927x, using BIOS defaults\n");
2702 err = stac92xx_save_bios_config_regs(codec);
2704 stac92xx_free(codec);
2707 spec->pin_configs = spec->bios_pin_configs;
2708 } else if (stac927x_brd_tbl[spec->board_config] != NULL) {
2709 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
2710 stac92xx_set_config_regs(codec);
2713 switch (spec->board_config) {
2715 spec->adc_nids = stac927x_adc_nids;
2716 spec->mux_nids = stac927x_mux_nids;
2717 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
2718 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
2719 spec->num_dmics = 0;
2720 spec->init = d965_core_init;
2721 spec->mixer = stac927x_mixer;
2724 spec->adc_nids = stac927x_adc_nids;
2725 spec->mux_nids = stac927x_mux_nids;
2726 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
2727 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
2728 spec->num_dmics = 0;
2729 spec->init = d965_core_init;
2730 spec->mixer = stac927x_mixer;
2733 spec->adc_nids = stac927x_adc_nids;
2734 spec->mux_nids = stac927x_mux_nids;
2735 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
2736 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
2737 spec->num_dmics = 0;
2738 spec->init = stac927x_core_init;
2739 spec->mixer = stac927x_mixer;
2742 spec->multiout.dac_nids = spec->dac_nids;
2743 /* GPIO0 High = Enable EAPD */
2744 spec->gpio_mask = spec->gpio_data = 0x00000001;
2745 stac92xx_enable_gpio_mask(codec);
2747 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
2749 if (spec->board_config < 0) {
2750 printk(KERN_WARNING "hda_codec: No auto-config is "
2751 "available, default to model=ref\n");
2752 spec->board_config = STAC_D965_REF;
2758 stac92xx_free(codec);
2762 codec->patch_ops = stac92xx_patch_ops;
2767 static int patch_stac9205(struct hda_codec *codec)
2769 struct sigmatel_spec *spec;
2772 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2777 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
2778 spec->pin_nids = stac9205_pin_nids;
2779 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
2783 if (spec->board_config < 0) {
2784 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
2785 err = stac92xx_save_bios_config_regs(codec);
2787 stac92xx_free(codec);
2790 spec->pin_configs = spec->bios_pin_configs;
2792 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
2793 stac92xx_set_config_regs(codec);
2796 spec->adc_nids = stac9205_adc_nids;
2797 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
2798 spec->mux_nids = stac9205_mux_nids;
2799 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
2800 spec->dmic_nids = stac9205_dmic_nids;
2801 spec->num_dmics = ARRAY_SIZE(stac9205_dmic_nids);
2802 spec->dmux_nid = 0x1d;
2804 spec->init = stac9205_core_init;
2805 spec->mixer = stac9205_mixer;
2807 spec->multiout.dac_nids = spec->dac_nids;
2809 switch (spec->board_config){
2810 case STAC_9205_M43xx:
2811 case STAC_9205_DELL_M43:
2812 /* Enable SPDIF in/out */
2813 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
2814 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
2816 spec->gpio_mask = 0x00000007; /* GPIO0-2 */
2817 /* GPIO0 High = EAPD, GPIO1 Low = DRM,
2818 * GPIO2 High = Headphone Mute
2820 spec->gpio_data = 0x00000005;
2823 /* GPIO0 High = EAPD */
2824 spec->gpio_mask = spec->gpio_data = 0x00000001;
2828 stac92xx_enable_gpio_mask(codec);
2829 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
2831 if (spec->board_config < 0) {
2832 printk(KERN_WARNING "hda_codec: No auto-config is "
2833 "available, default to model=ref\n");
2834 spec->board_config = STAC_9205_REF;
2840 stac92xx_free(codec);
2844 codec->patch_ops = stac92xx_patch_ops;
2853 /* static config for Sony VAIO FE550G and Sony VAIO AR */
2854 static hda_nid_t vaio_dacs[] = { 0x2 };
2855 #define VAIO_HP_DAC 0x5
2856 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
2857 static hda_nid_t vaio_mux_nids[] = { 0x15 };
2859 static struct hda_input_mux vaio_mux = {
2862 /* { "HP", 0x0 }, */
2863 { "Mic Jack", 0x1 },
2864 { "Internal Mic", 0x2 },
2869 static struct hda_verb vaio_init[] = {
2870 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
2871 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
2872 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
2873 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
2874 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
2875 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
2876 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
2877 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
2878 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
2879 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
2880 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
2881 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
2885 static struct hda_verb vaio_ar_init[] = {
2886 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
2887 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
2888 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
2889 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
2890 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
2891 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
2892 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
2893 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
2894 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
2895 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
2896 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
2897 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
2898 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
2902 /* bind volumes of both NID 0x02 and 0x05 */
2903 static struct hda_bind_ctls vaio_bind_master_vol = {
2904 .ops = &snd_hda_bind_vol,
2906 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
2907 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
2912 /* bind volumes of both NID 0x02 and 0x05 */
2913 static struct hda_bind_ctls vaio_bind_master_sw = {
2914 .ops = &snd_hda_bind_sw,
2916 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
2917 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
2922 static struct snd_kcontrol_new vaio_mixer[] = {
2923 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
2924 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
2925 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
2926 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
2927 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
2929 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2930 .name = "Capture Source",
2932 .info = stac92xx_mux_enum_info,
2933 .get = stac92xx_mux_enum_get,
2934 .put = stac92xx_mux_enum_put,
2939 static struct snd_kcontrol_new vaio_ar_mixer[] = {
2940 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
2941 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
2942 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
2943 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
2944 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
2945 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
2946 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
2948 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2949 .name = "Capture Source",
2951 .info = stac92xx_mux_enum_info,
2952 .get = stac92xx_mux_enum_get,
2953 .put = stac92xx_mux_enum_put,
2958 static struct hda_codec_ops stac9872_patch_ops = {
2959 .build_controls = stac92xx_build_controls,
2960 .build_pcms = stac92xx_build_pcms,
2961 .init = stac92xx_init,
2962 .free = stac92xx_free,
2963 #ifdef SND_HDA_NEEDS_RESUME
2964 .resume = stac92xx_resume,
2968 static int stac9872_vaio_init(struct hda_codec *codec)
2972 err = stac92xx_init(codec);
2975 if (codec->patch_ops.unsol_event)
2976 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2980 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
2982 if (get_pin_presence(codec, 0x0a)) {
2983 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
2984 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
2986 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
2987 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
2991 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
2993 switch (res >> 26) {
2995 stac9872_vaio_hp_detect(codec, res);
3000 static struct hda_codec_ops stac9872_vaio_patch_ops = {
3001 .build_controls = stac92xx_build_controls,
3002 .build_pcms = stac92xx_build_pcms,
3003 .init = stac9872_vaio_init,
3004 .free = stac92xx_free,
3005 .unsol_event = stac9872_vaio_unsol_event,
3007 .resume = stac92xx_resume,
3011 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
3013 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
3015 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
3017 /* AR Series. id=0x83847664 and subsys=104D1300 */
3022 static const char *stac9872_models[STAC_9872_MODELS] = {
3023 [CXD9872RD_VAIO] = "vaio",
3024 [CXD9872AKD_VAIO] = "vaio-ar",
3027 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
3028 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
3029 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
3030 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
3031 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
3035 static int patch_stac9872(struct hda_codec *codec)
3037 struct sigmatel_spec *spec;
3040 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
3043 if (board_config < 0)
3044 /* unknown config, let generic-parser do its job... */
3045 return snd_hda_parse_generic_codec(codec);
3047 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3052 switch (board_config) {
3053 case CXD9872RD_VAIO:
3054 case STAC9872AK_VAIO:
3055 case STAC9872K_VAIO:
3056 spec->mixer = vaio_mixer;
3057 spec->init = vaio_init;
3058 spec->multiout.max_channels = 2;
3059 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3060 spec->multiout.dac_nids = vaio_dacs;
3061 spec->multiout.hp_nid = VAIO_HP_DAC;
3062 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3063 spec->adc_nids = vaio_adcs;
3064 spec->input_mux = &vaio_mux;
3065 spec->mux_nids = vaio_mux_nids;
3066 codec->patch_ops = stac9872_vaio_patch_ops;
3069 case CXD9872AKD_VAIO:
3070 spec->mixer = vaio_ar_mixer;
3071 spec->init = vaio_ar_init;
3072 spec->multiout.max_channels = 2;
3073 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3074 spec->multiout.dac_nids = vaio_dacs;
3075 spec->multiout.hp_nid = VAIO_HP_DAC;
3076 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3077 spec->adc_nids = vaio_adcs;
3078 spec->input_mux = &vaio_mux;
3079 spec->mux_nids = vaio_mux_nids;
3080 codec->patch_ops = stac9872_patch_ops;
3091 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
3092 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
3093 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
3094 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
3095 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
3096 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
3097 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
3098 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
3099 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
3100 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
3101 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
3102 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
3103 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
3104 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
3105 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
3106 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
3107 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
3108 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
3109 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
3110 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
3111 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
3112 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
3113 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
3114 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
3115 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
3116 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
3117 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
3118 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
3119 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
3120 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
3121 /* The following does not take into account .id=0x83847661 when subsys =
3122 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
3123 * currently not fully supported.
3125 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
3126 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
3127 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
3128 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
3129 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
3130 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
3131 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
3132 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
3133 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
3134 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
3135 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },