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 stac9200_eapd_init[] = {
383 /* set dac0mux for dac converter */
384 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
385 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
389 static struct hda_verb stac925x_core_init[] = {
390 /* set dac0mux for dac converter */
391 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
395 static struct hda_verb stac922x_core_init[] = {
396 /* set master volume and direct control */
397 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
401 static struct hda_verb d965_core_init[] = {
402 /* set master volume and direct control */
403 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
404 /* unmute node 0x1b */
405 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
406 /* select node 0x03 as DAC */
407 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
411 static struct hda_verb stac927x_core_init[] = {
412 /* set master volume and direct control */
413 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
417 static struct hda_verb stac9205_core_init[] = {
418 /* set master volume and direct control */
419 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
423 #define STAC_INPUT_SOURCE(cnt) \
425 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
426 .name = "Input Source", \
428 .info = stac92xx_mux_enum_info, \
429 .get = stac92xx_mux_enum_get, \
430 .put = stac92xx_mux_enum_put, \
433 #define STAC_ANALOG_LOOPBACK(verb_read,verb_write) \
435 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
436 .name = "Analog Loopback", \
438 .info = stac92xx_aloopback_info, \
439 .get = stac92xx_aloopback_get, \
440 .put = stac92xx_aloopback_put, \
441 .private_value = verb_read | (verb_write << 16), \
444 #define STAC_VOLKNOB \
446 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
447 .name = "Master Playback Volume", \
449 .info = stac92xx_volknob_info, \
450 .get = stac92xx_volknob_get, \
451 .put = stac92xx_volknob_put, \
452 .private_value = 127, \
456 static struct snd_kcontrol_new stac9200_mixer[] = {
457 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
458 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
459 STAC_INPUT_SOURCE(1),
460 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
461 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
462 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT),
466 static struct snd_kcontrol_new stac925x_mixer[] = {
467 STAC_INPUT_SOURCE(1),
468 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
469 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_OUTPUT),
470 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT),
474 static struct snd_kcontrol_new stac9205_mixer[] = {
476 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
477 .name = "Digital Input Source",
479 .info = stac92xx_dmux_enum_info,
480 .get = stac92xx_dmux_enum_get,
481 .put = stac92xx_dmux_enum_put,
483 STAC_INPUT_SOURCE(2),
484 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0),
487 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
488 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
489 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT),
491 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
492 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
493 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT),
498 /* This needs to be generated dynamically based on sequence */
499 static struct snd_kcontrol_new stac922x_mixer[] = {
500 STAC_INPUT_SOURCE(2),
502 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
503 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
504 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT),
506 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
507 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
508 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT),
513 static struct snd_kcontrol_new stac927x_mixer[] = {
514 STAC_INPUT_SOURCE(3),
516 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB),
518 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
519 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
520 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT),
522 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
523 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
524 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT),
526 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
527 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
528 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT),
532 static int stac92xx_build_controls(struct hda_codec *codec)
534 struct sigmatel_spec *spec = codec->spec;
538 err = snd_hda_add_new_ctls(codec, spec->mixer);
542 for (i = 0; i < spec->num_mixers; i++) {
543 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
548 if (spec->multiout.dig_out_nid) {
549 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
553 if (spec->dig_in_nid) {
554 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
561 static unsigned int ref9200_pin_configs[8] = {
562 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
563 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
567 STAC 9200 pin configs for
572 static unsigned int dell9200_d21_pin_configs[8] = {
573 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
574 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
578 STAC 9200 pin configs for
582 static unsigned int dell9200_d22_pin_configs[8] = {
583 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
584 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
588 STAC 9200 pin configs for
589 102801C4 (Dell Dimension E310)
596 static unsigned int dell9200_d23_pin_configs[8] = {
597 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
598 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
603 STAC 9200-32 pin configs for
604 102801B5 (Dell Inspiron 630m)
605 102801D8 (Dell Inspiron 640m)
607 static unsigned int dell9200_m21_pin_configs[8] = {
608 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
609 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
613 STAC 9200-32 pin configs for
614 102801C2 (Dell Latitude D620)
616 102801CC (Dell Latitude D820)
620 static unsigned int dell9200_m22_pin_configs[8] = {
621 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
622 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
626 STAC 9200-32 pin configs for
627 102801CE (Dell XPS M1710)
628 102801CF (Dell Precision M90)
630 static unsigned int dell9200_m23_pin_configs[8] = {
631 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
632 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
636 STAC 9200-32 pin configs for
639 102801CB (Dell Latitude 120L)
642 static unsigned int dell9200_m24_pin_configs[8] = {
643 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
644 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
648 STAC 9200-32 pin configs for
649 102801BD (Dell Inspiron E1505n)
653 static unsigned int dell9200_m25_pin_configs[8] = {
654 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
655 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
659 STAC 9200-32 pin configs for
660 102801F5 (Dell Inspiron 1501)
663 static unsigned int dell9200_m26_pin_configs[8] = {
664 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
665 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
670 102801CD (Dell Inspiron E1705/9400)
672 static unsigned int dell9200_m27_pin_configs[8] = {
673 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
674 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
678 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
679 [STAC_REF] = ref9200_pin_configs,
680 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
681 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
682 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
683 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
684 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
685 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
686 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
687 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
688 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
689 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
692 static const char *stac9200_models[STAC_9200_MODELS] = {
694 [STAC_9200_DELL_D21] = "dell-d21",
695 [STAC_9200_DELL_D22] = "dell-d22",
696 [STAC_9200_DELL_D23] = "dell-d23",
697 [STAC_9200_DELL_M21] = "dell-m21",
698 [STAC_9200_DELL_M22] = "dell-m22",
699 [STAC_9200_DELL_M23] = "dell-m23",
700 [STAC_9200_DELL_M24] = "dell-m24",
701 [STAC_9200_DELL_M25] = "dell-m25",
702 [STAC_9200_DELL_M26] = "dell-m26",
703 [STAC_9200_DELL_M27] = "dell-m27",
704 [STAC_9200_GATEWAY] = "gateway",
707 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
708 /* SigmaTel reference board */
709 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
710 "DFI LanParty", STAC_REF),
711 /* Dell laptops have BIOS problem */
712 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
713 "unknown Dell", STAC_9200_DELL_D21),
714 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
715 "Dell Inspiron 630m", STAC_9200_DELL_M21),
716 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
717 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
718 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
719 "unknown Dell", STAC_9200_DELL_D22),
720 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
721 "unknown Dell", STAC_9200_DELL_D22),
722 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
723 "Dell Latitude D620", STAC_9200_DELL_M22),
724 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
725 "unknown Dell", STAC_9200_DELL_D23),
726 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
727 "unknown Dell", STAC_9200_DELL_D23),
728 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
729 "unknown Dell", STAC_9200_DELL_M22),
730 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
731 "unknown Dell", STAC_9200_DELL_M24),
732 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
733 "unknown Dell", STAC_9200_DELL_M24),
734 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
735 "Dell Latitude 120L", STAC_9200_DELL_M24),
736 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
737 "Dell Latitude D820", STAC_9200_DELL_M22),
738 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
739 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
740 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
741 "Dell XPS M1710", STAC_9200_DELL_M23),
742 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
743 "Dell Precision M90", STAC_9200_DELL_M23),
744 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
745 "unknown Dell", STAC_9200_DELL_M22),
746 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
747 "unknown Dell", STAC_9200_DELL_M22),
748 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
749 "unknown Dell", STAC_9200_DELL_M22),
750 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
751 "Dell Inspiron 640m", STAC_9200_DELL_M21),
752 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
753 "unknown Dell", STAC_9200_DELL_D23),
754 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
755 "unknown Dell", STAC_9200_DELL_D23),
756 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
757 "unknown Dell", STAC_9200_DELL_D21),
758 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
759 "unknown Dell", STAC_9200_DELL_D23),
760 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
761 "unknown Dell", STAC_9200_DELL_D21),
762 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
763 "unknown Dell", STAC_9200_DELL_M25),
764 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
765 "unknown Dell", STAC_9200_DELL_M25),
766 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
767 "Dell Inspiron 1501", STAC_9200_DELL_M26),
768 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
769 "unknown Dell", STAC_9200_DELL_M26),
771 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_REF),
772 /* Gateway machines needs EAPD to be set on resume */
773 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
774 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
776 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
781 static unsigned int ref925x_pin_configs[8] = {
782 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
783 0x90a70320, 0x02214210, 0x400003f1, 0x9033032e,
786 static unsigned int stac925x_MA6_pin_configs[8] = {
787 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
788 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
791 static unsigned int stac925x_PA6_pin_configs[8] = {
792 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
793 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
796 static unsigned int stac925xM2_2_pin_configs[8] = {
797 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
798 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
801 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
802 [STAC_REF] = ref925x_pin_configs,
803 [STAC_M2_2] = stac925xM2_2_pin_configs,
804 [STAC_MA6] = stac925x_MA6_pin_configs,
805 [STAC_PA6] = stac925x_PA6_pin_configs,
808 static const char *stac925x_models[STAC_925x_MODELS] = {
810 [STAC_M2_2] = "m2-2",
815 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
816 /* SigmaTel reference board */
817 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
818 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
819 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
820 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
821 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
822 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
823 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
827 static unsigned int ref922x_pin_configs[10] = {
828 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
829 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
830 0x40000100, 0x40000100,
834 STAC 922X pin configs for
841 static unsigned int dell_922x_d81_pin_configs[10] = {
842 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
843 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
844 0x01813122, 0x400001f2,
848 STAC 922X pin configs for
852 static unsigned int dell_922x_d82_pin_configs[10] = {
853 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
854 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
855 0x01813122, 0x400001f1,
859 STAC 922X pin configs for
862 static unsigned int dell_922x_m81_pin_configs[10] = {
863 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
864 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
865 0x40C003f1, 0x405003f0,
869 STAC 9221 A1 pin configs for
870 102801D7 (Dell XPS M1210)
872 static unsigned int dell_922x_m82_pin_configs[10] = {
873 0x0221121f, 0x408103ff, 0x02111212, 0x90100310,
874 0x408003f1, 0x02111211, 0x03451340, 0x40c003f2,
875 0x508003f3, 0x405003f4,
878 static unsigned int d945gtp3_pin_configs[10] = {
879 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
880 0x40000100, 0x40000100, 0x40000100, 0x40000100,
881 0x02a19120, 0x40000100,
884 static unsigned int d945gtp5_pin_configs[10] = {
885 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
886 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
887 0x02a19320, 0x40000100,
890 static unsigned int intel_mac_v1_pin_configs[10] = {
891 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
892 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
893 0x400000fc, 0x400000fb,
896 static unsigned int intel_mac_v2_pin_configs[10] = {
897 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
898 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
899 0x400000fc, 0x400000fb,
902 static unsigned int intel_mac_v3_pin_configs[10] = {
903 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
904 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
905 0x400000fc, 0x400000fb,
908 static unsigned int intel_mac_v4_pin_configs[10] = {
909 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
910 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
911 0x400000fc, 0x400000fb,
914 static unsigned int intel_mac_v5_pin_configs[10] = {
915 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
916 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
917 0x400000fc, 0x400000fb,
921 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
922 [STAC_D945_REF] = ref922x_pin_configs,
923 [STAC_D945GTP3] = d945gtp3_pin_configs,
924 [STAC_D945GTP5] = d945gtp5_pin_configs,
925 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
926 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
927 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
928 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
929 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
930 /* for backward compatibility */
931 [STAC_MACMINI] = intel_mac_v3_pin_configs,
932 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
933 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
934 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
935 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
936 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
937 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
938 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
939 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
940 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
943 static const char *stac922x_models[STAC_922X_MODELS] = {
944 [STAC_D945_REF] = "ref",
945 [STAC_D945GTP5] = "5stack",
946 [STAC_D945GTP3] = "3stack",
947 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
948 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
949 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
950 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
951 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
952 /* for backward compatibility */
953 [STAC_MACMINI] = "macmini",
954 [STAC_MACBOOK] = "macbook",
955 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
956 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
957 [STAC_IMAC_INTEL] = "imac-intel",
958 [STAC_IMAC_INTEL_20] = "imac-intel-20",
959 [STAC_922X_DELL_D81] = "dell-d81",
960 [STAC_922X_DELL_D82] = "dell-d82",
961 [STAC_922X_DELL_M81] = "dell-m81",
962 [STAC_922X_DELL_M82] = "dell-m82",
965 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
966 /* SigmaTel reference board */
967 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
968 "DFI LanParty", STAC_D945_REF),
969 /* Intel 945G based systems */
970 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
971 "Intel D945G", STAC_D945GTP3),
972 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
973 "Intel D945G", STAC_D945GTP3),
974 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
975 "Intel D945G", STAC_D945GTP3),
976 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
977 "Intel D945G", STAC_D945GTP3),
978 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
979 "Intel D945G", STAC_D945GTP3),
980 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
981 "Intel D945G", STAC_D945GTP3),
982 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
983 "Intel D945G", STAC_D945GTP3),
984 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
985 "Intel D945G", STAC_D945GTP3),
986 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
987 "Intel D945G", STAC_D945GTP3),
988 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
989 "Intel D945G", STAC_D945GTP3),
990 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
991 "Intel D945G", STAC_D945GTP3),
992 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
993 "Intel D945G", STAC_D945GTP3),
994 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
995 "Intel D945G", STAC_D945GTP3),
996 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
997 "Intel D945G", STAC_D945GTP3),
998 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
999 "Intel D945G", STAC_D945GTP3),
1000 /* Intel D945G 5-stack systems */
1001 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1002 "Intel D945G", STAC_D945GTP5),
1003 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1004 "Intel D945G", STAC_D945GTP5),
1005 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1006 "Intel D945G", STAC_D945GTP5),
1007 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1008 "Intel D945G", STAC_D945GTP5),
1009 /* Intel 945P based systems */
1010 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1011 "Intel D945P", STAC_D945GTP3),
1012 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1013 "Intel D945P", STAC_D945GTP3),
1014 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1015 "Intel D945P", STAC_D945GTP3),
1016 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1017 "Intel D945P", STAC_D945GTP3),
1018 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1019 "Intel D945P", STAC_D945GTP3),
1020 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1021 "Intel D945P", STAC_D945GTP5),
1023 /* Apple Mac Mini (early 2006) */
1024 SND_PCI_QUIRK(0x8384, 0x7680,
1025 "Mac Mini", STAC_INTEL_MAC_V3),
1027 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1028 "unknown Dell", STAC_922X_DELL_D81),
1029 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1030 "unknown Dell", STAC_922X_DELL_D81),
1031 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1032 "unknown Dell", STAC_922X_DELL_D81),
1033 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1034 "unknown Dell", STAC_922X_DELL_D82),
1035 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1036 "unknown Dell", STAC_922X_DELL_M81),
1037 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1038 "unknown Dell", STAC_922X_DELL_D82),
1039 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1040 "unknown Dell", STAC_922X_DELL_D81),
1041 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1042 "unknown Dell", STAC_922X_DELL_D81),
1043 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1044 "Dell XPS M1210", STAC_922X_DELL_M82),
1048 static unsigned int ref927x_pin_configs[14] = {
1049 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1050 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1051 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1052 0x01c42190, 0x40000100,
1055 static unsigned int d965_3st_pin_configs[14] = {
1056 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
1057 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
1058 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1059 0x40000100, 0x40000100
1062 static unsigned int d965_5st_pin_configs[14] = {
1063 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1064 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
1065 0x40000100, 0x40000100, 0x40000100, 0x01442070,
1066 0x40000100, 0x40000100
1069 static unsigned int dell_3st_pin_configs[14] = {
1070 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
1071 0x01111212, 0x01116211, 0x01813050, 0x01112214,
1072 0x403003fa, 0x40000100, 0x40000100, 0x404003fb,
1073 0x40c003fc, 0x40000100
1076 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
1077 [STAC_D965_REF] = ref927x_pin_configs,
1078 [STAC_D965_3ST] = d965_3st_pin_configs,
1079 [STAC_D965_5ST] = d965_5st_pin_configs,
1080 [STAC_DELL_3ST] = dell_3st_pin_configs,
1083 static const char *stac927x_models[STAC_927X_MODELS] = {
1084 [STAC_D965_REF] = "ref",
1085 [STAC_D965_3ST] = "3stack",
1086 [STAC_D965_5ST] = "5stack",
1087 [STAC_DELL_3ST] = "dell-3stack",
1090 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
1091 /* SigmaTel reference board */
1092 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1093 "DFI LanParty", STAC_D965_REF),
1094 /* Intel 946 based systems */
1095 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
1096 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
1097 /* 965 based 3 stack systems */
1098 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
1099 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
1100 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
1101 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
1102 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
1103 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
1104 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
1105 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
1106 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
1107 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
1108 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
1109 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
1110 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
1111 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
1112 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
1113 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
1114 /* Dell 3 stack systems */
1115 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
1116 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
1117 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
1118 /* 965 based 5 stack systems */
1119 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
1120 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
1121 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
1122 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
1123 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
1124 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
1125 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
1126 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
1127 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
1131 static unsigned int ref9205_pin_configs[12] = {
1132 0x40000100, 0x40000100, 0x01016011, 0x01014010,
1133 0x01813122, 0x01a19021, 0x40000100, 0x40000100,
1134 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
1138 STAC 9205 pin configs for
1146 static unsigned int dell_9205_m42_pin_configs[12] = {
1147 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
1148 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
1149 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
1153 STAC 9205 pin configs for
1157 102801FF (Dell Precision M4300)
1162 static unsigned int dell_9205_m43_pin_configs[12] = {
1163 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
1164 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
1165 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
1168 static unsigned int dell_9205_m44_pin_configs[12] = {
1169 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
1170 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
1171 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
1174 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
1175 [STAC_9205_REF] = ref9205_pin_configs,
1176 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
1177 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
1178 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
1181 static const char *stac9205_models[STAC_9205_MODELS] = {
1182 [STAC_9205_REF] = "ref",
1183 [STAC_9205_DELL_M42] = "dell-m42",
1184 [STAC_9205_DELL_M43] = "dell-m43",
1185 [STAC_9205_DELL_M44] = "dell-m44",
1188 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
1189 /* SigmaTel reference board */
1190 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1191 "DFI LanParty", STAC_9205_REF),
1192 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1193 "unknown Dell", STAC_9205_DELL_M42),
1194 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1195 "unknown Dell", STAC_9205_DELL_M42),
1196 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
1197 "Dell Precision", STAC_9205_DELL_M43),
1198 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
1199 "Dell Precision", STAC_9205_DELL_M43),
1200 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
1201 "Dell Precision", STAC_9205_DELL_M43),
1202 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
1203 "Dell Precision", STAC_9205_DELL_M43),
1204 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
1205 "Dell Precision", STAC_9205_DELL_M43),
1206 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1207 "unknown Dell", STAC_9205_DELL_M42),
1208 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1209 "unknown Dell", STAC_9205_DELL_M42),
1210 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
1211 "Dell Precision", STAC_9205_DELL_M43),
1212 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
1213 "Dell Precision M4300", STAC_9205_DELL_M43),
1214 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
1215 "Dell Precision", STAC_9205_DELL_M43),
1216 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1217 "Dell Inspiron", STAC_9205_DELL_M44),
1218 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1219 "Dell Inspiron", STAC_9205_DELL_M44),
1220 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1221 "Dell Inspiron", STAC_9205_DELL_M44),
1222 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1223 "Dell Inspiron", STAC_9205_DELL_M44),
1224 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
1225 "unknown Dell", STAC_9205_DELL_M42),
1226 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
1227 "Dell Inspiron", STAC_9205_DELL_M44),
1231 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
1234 struct sigmatel_spec *spec = codec->spec;
1236 if (! spec->bios_pin_configs) {
1237 spec->bios_pin_configs = kcalloc(spec->num_pins,
1238 sizeof(*spec->bios_pin_configs), GFP_KERNEL);
1239 if (! spec->bios_pin_configs)
1243 for (i = 0; i < spec->num_pins; i++) {
1244 hda_nid_t nid = spec->pin_nids[i];
1245 unsigned int pin_cfg;
1247 pin_cfg = snd_hda_codec_read(codec, nid, 0,
1248 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
1249 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
1251 spec->bios_pin_configs[i] = pin_cfg;
1257 static void stac92xx_set_config_reg(struct hda_codec *codec,
1258 hda_nid_t pin_nid, unsigned int pin_config)
1261 snd_hda_codec_write(codec, pin_nid, 0,
1262 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
1263 pin_config & 0x000000ff);
1264 snd_hda_codec_write(codec, pin_nid, 0,
1265 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
1266 (pin_config & 0x0000ff00) >> 8);
1267 snd_hda_codec_write(codec, pin_nid, 0,
1268 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
1269 (pin_config & 0x00ff0000) >> 16);
1270 snd_hda_codec_write(codec, pin_nid, 0,
1271 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
1273 i = snd_hda_codec_read(codec, pin_nid, 0,
1274 AC_VERB_GET_CONFIG_DEFAULT,
1276 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
1280 static void stac92xx_set_config_regs(struct hda_codec *codec)
1283 struct sigmatel_spec *spec = codec->spec;
1285 if (!spec->pin_configs)
1288 for (i = 0; i < spec->num_pins; i++)
1289 stac92xx_set_config_reg(codec, spec->pin_nids[i],
1290 spec->pin_configs[i]);
1293 static void stac92xx_enable_gpio_mask(struct hda_codec *codec)
1295 struct sigmatel_spec *spec = codec->spec;
1296 /* Configure GPIOx as output */
1297 snd_hda_codec_write_cache(codec, codec->afg, 0,
1298 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_mask);
1299 /* Configure GPIOx as CMOS */
1300 snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7e7, 0x00000000);
1302 snd_hda_codec_write_cache(codec, codec->afg, 0,
1303 AC_VERB_SET_GPIO_DATA, spec->gpio_data);
1305 snd_hda_codec_write_cache(codec, codec->afg, 0,
1306 AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
1310 * Analog playback callbacks
1312 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
1313 struct hda_codec *codec,
1314 struct snd_pcm_substream *substream)
1316 struct sigmatel_spec *spec = codec->spec;
1317 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
1320 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1321 struct hda_codec *codec,
1322 unsigned int stream_tag,
1323 unsigned int format,
1324 struct snd_pcm_substream *substream)
1326 struct sigmatel_spec *spec = codec->spec;
1327 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
1330 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1331 struct hda_codec *codec,
1332 struct snd_pcm_substream *substream)
1334 struct sigmatel_spec *spec = codec->spec;
1335 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1339 * Digital playback callbacks
1341 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1342 struct hda_codec *codec,
1343 struct snd_pcm_substream *substream)
1345 struct sigmatel_spec *spec = codec->spec;
1346 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1349 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1350 struct hda_codec *codec,
1351 struct snd_pcm_substream *substream)
1353 struct sigmatel_spec *spec = codec->spec;
1354 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1357 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1358 struct hda_codec *codec,
1359 unsigned int stream_tag,
1360 unsigned int format,
1361 struct snd_pcm_substream *substream)
1363 struct sigmatel_spec *spec = codec->spec;
1364 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1365 stream_tag, format, substream);
1370 * Analog capture callbacks
1372 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1373 struct hda_codec *codec,
1374 unsigned int stream_tag,
1375 unsigned int format,
1376 struct snd_pcm_substream *substream)
1378 struct sigmatel_spec *spec = codec->spec;
1380 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1381 stream_tag, 0, format);
1385 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1386 struct hda_codec *codec,
1387 struct snd_pcm_substream *substream)
1389 struct sigmatel_spec *spec = codec->spec;
1391 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
1395 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
1399 /* NID is set in stac92xx_build_pcms */
1401 .open = stac92xx_dig_playback_pcm_open,
1402 .close = stac92xx_dig_playback_pcm_close,
1403 .prepare = stac92xx_dig_playback_pcm_prepare
1407 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
1411 /* NID is set in stac92xx_build_pcms */
1414 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
1418 .nid = 0x02, /* NID to query formats and rates */
1420 .open = stac92xx_playback_pcm_open,
1421 .prepare = stac92xx_playback_pcm_prepare,
1422 .cleanup = stac92xx_playback_pcm_cleanup
1426 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
1430 .nid = 0x06, /* NID to query formats and rates */
1432 .open = stac92xx_playback_pcm_open,
1433 .prepare = stac92xx_playback_pcm_prepare,
1434 .cleanup = stac92xx_playback_pcm_cleanup
1438 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
1441 /* NID + .substreams is set in stac92xx_build_pcms */
1443 .prepare = stac92xx_capture_pcm_prepare,
1444 .cleanup = stac92xx_capture_pcm_cleanup
1448 static int stac92xx_build_pcms(struct hda_codec *codec)
1450 struct sigmatel_spec *spec = codec->spec;
1451 struct hda_pcm *info = spec->pcm_rec;
1453 codec->num_pcms = 1;
1454 codec->pcm_info = info;
1456 info->name = "STAC92xx Analog";
1457 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
1458 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
1459 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1460 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
1462 if (spec->alt_switch) {
1465 info->name = "STAC92xx Analog Alt";
1466 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
1469 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1472 info->name = "STAC92xx Digital";
1473 if (spec->multiout.dig_out_nid) {
1474 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
1475 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
1477 if (spec->dig_in_nid) {
1478 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
1479 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
1486 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
1488 unsigned int pincap = snd_hda_param_read(codec, nid,
1490 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
1491 if (pincap & AC_PINCAP_VREF_100)
1492 return AC_PINCTL_VREF_100;
1493 if (pincap & AC_PINCAP_VREF_80)
1494 return AC_PINCTL_VREF_80;
1495 if (pincap & AC_PINCAP_VREF_50)
1496 return AC_PINCTL_VREF_50;
1497 if (pincap & AC_PINCAP_VREF_GRD)
1498 return AC_PINCTL_VREF_GRD;
1502 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
1505 snd_hda_codec_write_cache(codec, nid, 0,
1506 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
1509 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
1511 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1513 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1514 struct sigmatel_spec *spec = codec->spec;
1515 int io_idx = kcontrol-> private_value & 0xff;
1517 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
1521 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1523 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1524 struct sigmatel_spec *spec = codec->spec;
1525 hda_nid_t nid = kcontrol->private_value >> 8;
1526 int io_idx = kcontrol-> private_value & 0xff;
1527 unsigned short val = ucontrol->value.integer.value[0];
1529 spec->io_switch[io_idx] = val;
1532 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
1534 unsigned int pinctl = AC_PINCTL_IN_EN;
1535 if (io_idx) /* set VREF for mic */
1536 pinctl |= stac92xx_get_vref(codec, nid);
1537 stac92xx_auto_set_pinctl(codec, nid, pinctl);
1542 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
1544 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
1545 struct snd_ctl_elem_value *ucontrol)
1547 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1548 struct sigmatel_spec *spec = codec->spec;
1550 ucontrol->value.integer.value[0] = spec->clfe_swap;
1554 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
1555 struct snd_ctl_elem_value *ucontrol)
1557 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1558 struct sigmatel_spec *spec = codec->spec;
1559 hda_nid_t nid = kcontrol->private_value & 0xff;
1561 if (spec->clfe_swap == ucontrol->value.integer.value[0])
1564 spec->clfe_swap = ucontrol->value.integer.value[0];
1566 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1567 spec->clfe_swap ? 0x4 : 0x0);
1572 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
1573 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1576 .info = stac92xx_io_switch_info, \
1577 .get = stac92xx_io_switch_get, \
1578 .put = stac92xx_io_switch_put, \
1579 .private_value = xpval, \
1582 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
1583 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1586 .info = stac92xx_clfe_switch_info, \
1587 .get = stac92xx_clfe_switch_get, \
1588 .put = stac92xx_clfe_switch_put, \
1589 .private_value = xpval, \
1593 STAC_CTL_WIDGET_VOL,
1594 STAC_CTL_WIDGET_MUTE,
1595 STAC_CTL_WIDGET_IO_SWITCH,
1596 STAC_CTL_WIDGET_CLFE_SWITCH
1599 static struct snd_kcontrol_new stac92xx_control_templates[] = {
1600 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
1601 HDA_CODEC_MUTE(NULL, 0, 0, 0),
1602 STAC_CODEC_IO_SWITCH(NULL, 0),
1603 STAC_CODEC_CLFE_SWITCH(NULL, 0),
1606 /* add dynamic controls */
1607 static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val)
1609 struct snd_kcontrol_new *knew;
1611 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
1612 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
1614 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
1617 if (spec->kctl_alloc) {
1618 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
1619 kfree(spec->kctl_alloc);
1621 spec->kctl_alloc = knew;
1622 spec->num_kctl_alloc = num;
1625 knew = &spec->kctl_alloc[spec->num_kctl_used];
1626 *knew = stac92xx_control_templates[type];
1627 knew->name = kstrdup(name, GFP_KERNEL);
1630 knew->private_value = val;
1631 spec->num_kctl_used++;
1635 /* flag inputs as additional dynamic lineouts */
1636 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
1638 struct sigmatel_spec *spec = codec->spec;
1639 unsigned int wcaps, wtype;
1640 int i, num_dacs = 0;
1642 /* use the wcaps cache to count all DACs available for line-outs */
1643 for (i = 0; i < codec->num_nodes; i++) {
1644 wcaps = codec->wcaps[i];
1645 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
1646 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
1650 snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
1652 switch (cfg->line_outs) {
1654 /* add line-in as side */
1655 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
1656 cfg->line_out_pins[cfg->line_outs] =
1657 cfg->input_pins[AUTO_PIN_LINE];
1658 spec->line_switch = 1;
1663 /* add line-in as clfe and mic as side */
1664 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
1665 cfg->line_out_pins[cfg->line_outs] =
1666 cfg->input_pins[AUTO_PIN_LINE];
1667 spec->line_switch = 1;
1670 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
1671 cfg->line_out_pins[cfg->line_outs] =
1672 cfg->input_pins[AUTO_PIN_MIC];
1673 spec->mic_switch = 1;
1678 /* add line-in as surr and mic as clfe */
1679 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
1680 cfg->line_out_pins[cfg->line_outs] =
1681 cfg->input_pins[AUTO_PIN_LINE];
1682 spec->line_switch = 1;
1685 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
1686 cfg->line_out_pins[cfg->line_outs] =
1687 cfg->input_pins[AUTO_PIN_MIC];
1688 spec->mic_switch = 1;
1698 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
1702 for (i = 0; i < spec->multiout.num_dacs; i++) {
1703 if (spec->multiout.dac_nids[i] == nid)
1711 * Fill in the dac_nids table from the parsed pin configuration
1712 * This function only works when every pin in line_out_pins[]
1713 * contains atleast one DAC in its connection list. Some 92xx
1714 * codecs are not connected directly to a DAC, such as the 9200
1715 * and 9202/925x. For those, dac_nids[] must be hard-coded.
1717 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
1718 struct auto_pin_cfg *cfg)
1720 struct sigmatel_spec *spec = codec->spec;
1721 int i, j, conn_len = 0;
1722 hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
1723 unsigned int wcaps, wtype;
1725 for (i = 0; i < cfg->line_outs; i++) {
1726 nid = cfg->line_out_pins[i];
1727 conn_len = snd_hda_get_connections(codec, nid, conn,
1728 HDA_MAX_CONNECTIONS);
1729 for (j = 0; j < conn_len; j++) {
1730 wcaps = snd_hda_param_read(codec, conn[j],
1731 AC_PAR_AUDIO_WIDGET_CAP);
1732 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
1734 if (wtype != AC_WID_AUD_OUT ||
1735 (wcaps & AC_WCAP_DIGITAL))
1737 /* conn[j] is a DAC routed to this line-out */
1738 if (!is_in_dac_nids(spec, conn[j]))
1742 if (j == conn_len) {
1743 if (spec->multiout.num_dacs > 0) {
1744 /* we have already working output pins,
1745 * so let's drop the broken ones again
1747 cfg->line_outs = spec->multiout.num_dacs;
1750 /* error out, no available DAC found */
1752 "%s: No available DAC for pin 0x%x\n",
1757 spec->multiout.dac_nids[i] = conn[j];
1758 spec->multiout.num_dacs++;
1760 /* select this DAC in the pin's input mux */
1761 snd_hda_codec_write_cache(codec, nid, 0,
1762 AC_VERB_SET_CONNECT_SEL, j);
1767 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
1768 spec->multiout.num_dacs,
1769 spec->multiout.dac_nids[0],
1770 spec->multiout.dac_nids[1],
1771 spec->multiout.dac_nids[2],
1772 spec->multiout.dac_nids[3],
1773 spec->multiout.dac_nids[4]);
1777 /* create volume control/switch for the given prefx type */
1778 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
1783 sprintf(name, "%s Playback Volume", pfx);
1784 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
1785 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1788 sprintf(name, "%s Playback Switch", pfx);
1789 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
1790 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1796 /* add playback controls from the parsed DAC table */
1797 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
1798 const struct auto_pin_cfg *cfg)
1800 static const char *chname[4] = {
1801 "Front", "Surround", NULL /*CLFE*/, "Side"
1806 struct sigmatel_spec *spec = codec->spec;
1807 unsigned int wid_caps;
1810 for (i = 0; i < cfg->line_outs; i++) {
1811 if (!spec->multiout.dac_nids[i])
1814 nid = spec->multiout.dac_nids[i];
1818 err = create_controls(spec, "Center", nid, 1);
1821 err = create_controls(spec, "LFE", nid, 2);
1825 wid_caps = get_wcaps(codec, nid);
1827 if (wid_caps & AC_WCAP_LR_SWAP) {
1828 err = stac92xx_add_control(spec,
1829 STAC_CTL_WIDGET_CLFE_SWITCH,
1830 "Swap Center/LFE Playback Switch", nid);
1837 err = create_controls(spec, chname[i], nid, 3);
1843 if (spec->line_switch)
1844 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Line In as Output Switch", cfg->input_pins[AUTO_PIN_LINE] << 8)) < 0)
1847 if (spec->mic_switch)
1848 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Mic as Output Switch", (cfg->input_pins[AUTO_PIN_MIC] << 8) | 1)) < 0)
1854 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
1856 if (is_in_dac_nids(spec, nid))
1858 if (spec->multiout.hp_nid == nid)
1863 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
1865 if (!spec->multiout.hp_nid)
1866 spec->multiout.hp_nid = nid;
1867 else if (spec->multiout.num_dacs > 4) {
1868 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
1871 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
1872 spec->multiout.num_dacs++;
1877 /* add playback controls for Speaker and HP outputs */
1878 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
1879 struct auto_pin_cfg *cfg)
1881 struct sigmatel_spec *spec = codec->spec;
1883 int i, old_num_dacs, err;
1885 old_num_dacs = spec->multiout.num_dacs;
1886 for (i = 0; i < cfg->hp_outs; i++) {
1887 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
1888 if (wid_caps & AC_WCAP_UNSOL_CAP)
1889 spec->hp_detect = 1;
1890 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
1891 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
1892 if (check_in_dac_nids(spec, nid))
1896 add_spec_dacs(spec, nid);
1898 for (i = 0; i < cfg->speaker_outs; i++) {
1899 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
1900 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
1901 if (check_in_dac_nids(spec, nid))
1905 add_spec_dacs(spec, nid);
1907 for (i = 0; i < cfg->line_outs; i++) {
1908 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
1909 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
1910 if (check_in_dac_nids(spec, nid))
1914 add_spec_dacs(spec, nid);
1916 for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
1917 static const char *pfxs[] = {
1918 "Speaker", "External Speaker", "Speaker2",
1920 err = create_controls(spec, pfxs[i - old_num_dacs],
1921 spec->multiout.dac_nids[i], 3);
1925 if (spec->multiout.hp_nid) {
1927 if (old_num_dacs == spec->multiout.num_dacs)
1931 err = create_controls(spec, pfx, spec->multiout.hp_nid, 3);
1939 /* labels for dmic mux inputs */
1940 static const char *stac92xx_dmic_labels[5] = {
1941 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
1942 "Digital Mic 3", "Digital Mic 4"
1945 /* create playback/capture controls for input pins on dmic capable codecs */
1946 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
1947 const struct auto_pin_cfg *cfg)
1949 struct sigmatel_spec *spec = codec->spec;
1950 struct hda_input_mux *dimux = &spec->private_dimux;
1951 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
1954 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
1955 dimux->items[dimux->num_items].index = 0;
1958 for (i = 0; i < spec->num_dmics; i++) {
1961 unsigned int def_conf;
1963 def_conf = snd_hda_codec_read(codec,
1966 AC_VERB_GET_CONFIG_DEFAULT,
1968 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
1971 num_cons = snd_hda_get_connections(codec,
1974 HDA_MAX_NUM_INPUTS);
1975 for (j = 0; j < num_cons; j++)
1976 if (con_lst[j] == spec->dmic_nids[i]) {
1982 dimux->items[dimux->num_items].label =
1983 stac92xx_dmic_labels[dimux->num_items];
1984 dimux->items[dimux->num_items].index = index;
1991 /* create playback/capture controls for input pins */
1992 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
1994 struct sigmatel_spec *spec = codec->spec;
1995 struct hda_input_mux *imux = &spec->private_imux;
1996 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
1999 for (i = 0; i < AUTO_PIN_LAST; i++) {
2002 if (!cfg->input_pins[i])
2005 for (j = 0; j < spec->num_muxes; j++) {
2007 num_cons = snd_hda_get_connections(codec,
2010 HDA_MAX_NUM_INPUTS);
2011 for (k = 0; k < num_cons; k++)
2012 if (con_lst[k] == cfg->input_pins[i]) {
2019 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2020 imux->items[imux->num_items].index = index;
2024 if (imux->num_items) {
2026 * Set the current input for the muxes.
2027 * The STAC9221 has two input muxes with identical source
2028 * NID lists. Hopefully this won't get confused.
2030 for (i = 0; i < spec->num_muxes; i++) {
2031 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
2032 AC_VERB_SET_CONNECT_SEL,
2033 imux->items[0].index);
2040 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
2042 struct sigmatel_spec *spec = codec->spec;
2045 for (i = 0; i < spec->autocfg.line_outs; i++) {
2046 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2047 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2051 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
2053 struct sigmatel_spec *spec = codec->spec;
2056 for (i = 0; i < spec->autocfg.hp_outs; i++) {
2058 pin = spec->autocfg.hp_pins[i];
2059 if (pin) /* connect to front */
2060 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
2062 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
2064 pin = spec->autocfg.speaker_pins[i];
2065 if (pin) /* connect to front */
2066 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
2070 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
2072 struct sigmatel_spec *spec = codec->spec;
2075 if ((err = snd_hda_parse_pin_def_config(codec,
2077 spec->dmic_nids)) < 0)
2079 if (! spec->autocfg.line_outs)
2080 return 0; /* can't find valid pin config */
2082 if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
2084 if (spec->multiout.num_dacs == 0)
2085 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2088 err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
2093 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
2098 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
2103 if (spec->num_dmics > 0)
2104 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
2105 &spec->autocfg)) < 0)
2108 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2109 if (spec->multiout.max_channels > 2)
2110 spec->surr_switch = 1;
2112 if (spec->autocfg.dig_out_pin)
2113 spec->multiout.dig_out_nid = dig_out;
2114 if (spec->autocfg.dig_in_pin)
2115 spec->dig_in_nid = dig_in;
2117 if (spec->kctl_alloc)
2118 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2120 spec->input_mux = &spec->private_imux;
2121 spec->dinput_mux = &spec->private_dimux;
2126 /* add playback controls for HP output */
2127 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
2128 struct auto_pin_cfg *cfg)
2130 struct sigmatel_spec *spec = codec->spec;
2131 hda_nid_t pin = cfg->hp_pins[0];
2132 unsigned int wid_caps;
2137 wid_caps = get_wcaps(codec, pin);
2138 if (wid_caps & AC_WCAP_UNSOL_CAP)
2139 spec->hp_detect = 1;
2144 /* add playback controls for LFE output */
2145 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
2146 struct auto_pin_cfg *cfg)
2148 struct sigmatel_spec *spec = codec->spec;
2150 hda_nid_t lfe_pin = 0x0;
2154 * search speaker outs and line outs for a mono speaker pin
2155 * with an amp. If one is found, add LFE controls
2158 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
2159 hda_nid_t pin = spec->autocfg.speaker_pins[i];
2160 unsigned long wcaps = get_wcaps(codec, pin);
2161 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2162 if (wcaps == AC_WCAP_OUT_AMP)
2163 /* found a mono speaker with an amp, must be lfe */
2167 /* if speaker_outs is 0, then speakers may be in line_outs */
2168 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
2169 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
2170 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2172 cfg = snd_hda_codec_read(codec, pin, 0,
2173 AC_VERB_GET_CONFIG_DEFAULT,
2175 if (get_defcfg_device(cfg) == AC_JACK_SPEAKER) {
2176 unsigned long wcaps = get_wcaps(codec, pin);
2177 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2178 if (wcaps == AC_WCAP_OUT_AMP)
2179 /* found a mono speaker with an amp,
2187 err = create_controls(spec, "LFE", lfe_pin, 1);
2195 static int stac9200_parse_auto_config(struct hda_codec *codec)
2197 struct sigmatel_spec *spec = codec->spec;
2200 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2203 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
2206 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
2209 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
2212 if (spec->autocfg.dig_out_pin)
2213 spec->multiout.dig_out_nid = 0x05;
2214 if (spec->autocfg.dig_in_pin)
2215 spec->dig_in_nid = 0x04;
2217 if (spec->kctl_alloc)
2218 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2220 spec->input_mux = &spec->private_imux;
2221 spec->dinput_mux = &spec->private_dimux;
2227 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
2228 * funky external mute control using GPIO pins.
2231 static void stac922x_gpio_mute(struct hda_codec *codec, int pin, int muted)
2233 unsigned int gpiostate, gpiomask, gpiodir;
2235 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
2236 AC_VERB_GET_GPIO_DATA, 0);
2239 gpiostate |= (1 << pin);
2241 gpiostate &= ~(1 << pin);
2243 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
2244 AC_VERB_GET_GPIO_MASK, 0);
2245 gpiomask |= (1 << pin);
2247 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
2248 AC_VERB_GET_GPIO_DIRECTION, 0);
2249 gpiodir |= (1 << pin);
2251 /* AppleHDA seems to do this -- WTF is this verb?? */
2252 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
2254 snd_hda_codec_write(codec, codec->afg, 0,
2255 AC_VERB_SET_GPIO_MASK, gpiomask);
2256 snd_hda_codec_write(codec, codec->afg, 0,
2257 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
2261 snd_hda_codec_write(codec, codec->afg, 0,
2262 AC_VERB_SET_GPIO_DATA, gpiostate);
2265 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
2268 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
2269 snd_hda_codec_write_cache(codec, nid, 0,
2270 AC_VERB_SET_UNSOLICITED_ENABLE,
2271 (AC_USRSP_EN | event));
2274 static int stac92xx_init(struct hda_codec *codec)
2276 struct sigmatel_spec *spec = codec->spec;
2277 struct auto_pin_cfg *cfg = &spec->autocfg;
2280 snd_hda_sequence_write(codec, spec->init);
2283 if (spec->hp_detect) {
2284 /* Enable unsolicited responses on the HP widget */
2285 for (i = 0; i < cfg->hp_outs; i++)
2286 enable_pin_detect(codec, cfg->hp_pins[i],
2288 /* force to enable the first line-out; the others are set up
2291 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
2293 stac92xx_auto_init_hp_out(codec);
2294 /* fake event to set up pins */
2295 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2297 stac92xx_auto_init_multi_out(codec);
2298 stac92xx_auto_init_hp_out(codec);
2300 for (i = 0; i < AUTO_PIN_LAST; i++) {
2301 hda_nid_t nid = cfg->input_pins[i];
2303 unsigned int pinctl = AC_PINCTL_IN_EN;
2304 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
2305 pinctl |= stac92xx_get_vref(codec, nid);
2306 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2309 if (spec->num_dmics > 0)
2310 for (i = 0; i < spec->num_dmics; i++)
2311 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
2314 if (cfg->dig_out_pin)
2315 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
2317 if (cfg->dig_in_pin)
2318 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
2321 if (spec->gpio_mute) {
2322 stac922x_gpio_mute(codec, 0, 0);
2323 stac922x_gpio_mute(codec, 1, 0);
2329 static void stac92xx_free(struct hda_codec *codec)
2331 struct sigmatel_spec *spec = codec->spec;
2337 if (spec->kctl_alloc) {
2338 for (i = 0; i < spec->num_kctl_used; i++)
2339 kfree(spec->kctl_alloc[i].name);
2340 kfree(spec->kctl_alloc);
2343 if (spec->bios_pin_configs)
2344 kfree(spec->bios_pin_configs);
2349 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
2352 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2353 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2355 if (pin_ctl & AC_PINCTL_IN_EN) {
2357 * we need to check the current set-up direction of
2358 * shared input pins since they can be switched via
2359 * "xxx as Output" mixer switch
2361 struct sigmatel_spec *spec = codec->spec;
2362 struct auto_pin_cfg *cfg = &spec->autocfg;
2363 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
2364 spec->line_switch) ||
2365 (nid == cfg->input_pins[AUTO_PIN_MIC] &&
2370 /* if setting pin direction bits, clear the current
2371 direction bits first */
2372 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
2373 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
2375 snd_hda_codec_write_cache(codec, nid, 0,
2376 AC_VERB_SET_PIN_WIDGET_CONTROL,
2380 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
2383 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2384 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2385 snd_hda_codec_write_cache(codec, nid, 0,
2386 AC_VERB_SET_PIN_WIDGET_CONTROL,
2390 static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
2394 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
2400 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
2402 struct sigmatel_spec *spec = codec->spec;
2403 struct auto_pin_cfg *cfg = &spec->autocfg;
2407 for (i = 0; i < cfg->hp_outs; i++) {
2408 presence = get_pin_presence(codec, cfg->hp_pins[i]);
2414 /* disable lineouts, enable hp */
2415 for (i = 0; i < cfg->line_outs; i++)
2416 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
2418 for (i = 0; i < cfg->speaker_outs; i++)
2419 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
2422 /* enable lineouts, disable hp */
2423 for (i = 0; i < cfg->line_outs; i++)
2424 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
2426 for (i = 0; i < cfg->speaker_outs; i++)
2427 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
2432 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
2434 switch (res >> 26) {
2436 stac92xx_hp_detect(codec, res);
2441 #ifdef SND_HDA_NEEDS_RESUME
2442 static int stac92xx_resume(struct hda_codec *codec)
2444 struct sigmatel_spec *spec = codec->spec;
2446 stac92xx_set_config_regs(codec);
2447 snd_hda_sequence_write(codec, spec->init);
2448 if (spec->gpio_mute) {
2449 stac922x_gpio_mute(codec, 0, 0);
2450 stac922x_gpio_mute(codec, 1, 0);
2452 snd_hda_codec_resume_amp(codec);
2453 snd_hda_codec_resume_cache(codec);
2454 /* invoke unsolicited event to reset the HP state */
2455 if (spec->hp_detect)
2456 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2461 static struct hda_codec_ops stac92xx_patch_ops = {
2462 .build_controls = stac92xx_build_controls,
2463 .build_pcms = stac92xx_build_pcms,
2464 .init = stac92xx_init,
2465 .free = stac92xx_free,
2466 .unsol_event = stac92xx_unsol_event,
2467 #ifdef SND_HDA_NEEDS_RESUME
2468 .resume = stac92xx_resume,
2472 static int patch_stac9200(struct hda_codec *codec)
2474 struct sigmatel_spec *spec;
2477 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2482 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
2483 spec->pin_nids = stac9200_pin_nids;
2484 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
2487 if (spec->board_config < 0) {
2488 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
2489 err = stac92xx_save_bios_config_regs(codec);
2491 stac92xx_free(codec);
2494 spec->pin_configs = spec->bios_pin_configs;
2496 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
2497 stac92xx_set_config_regs(codec);
2500 spec->multiout.max_channels = 2;
2501 spec->multiout.num_dacs = 1;
2502 spec->multiout.dac_nids = stac9200_dac_nids;
2503 spec->adc_nids = stac9200_adc_nids;
2504 spec->mux_nids = stac9200_mux_nids;
2505 spec->num_muxes = 1;
2506 spec->num_dmics = 0;
2509 if (spec->board_config == STAC_9200_GATEWAY)
2510 spec->init = stac9200_eapd_init;
2512 spec->init = stac9200_core_init;
2513 spec->mixer = stac9200_mixer;
2515 err = stac9200_parse_auto_config(codec);
2517 stac92xx_free(codec);
2521 codec->patch_ops = stac92xx_patch_ops;
2526 static int patch_stac925x(struct hda_codec *codec)
2528 struct sigmatel_spec *spec;
2531 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2536 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
2537 spec->pin_nids = stac925x_pin_nids;
2538 spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
2542 if (spec->board_config < 0) {
2543 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
2544 "using BIOS defaults\n");
2545 err = stac92xx_save_bios_config_regs(codec);
2547 stac92xx_free(codec);
2550 spec->pin_configs = spec->bios_pin_configs;
2551 } else if (stac925x_brd_tbl[spec->board_config] != NULL){
2552 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
2553 stac92xx_set_config_regs(codec);
2556 spec->multiout.max_channels = 2;
2557 spec->multiout.num_dacs = 1;
2558 spec->multiout.dac_nids = stac925x_dac_nids;
2559 spec->adc_nids = stac925x_adc_nids;
2560 spec->mux_nids = stac925x_mux_nids;
2561 spec->num_muxes = 1;
2563 switch (codec->vendor_id) {
2564 case 0x83847632: /* STAC9202 */
2565 case 0x83847633: /* STAC9202D */
2566 case 0x83847636: /* STAC9251 */
2567 case 0x83847637: /* STAC9251D */
2568 spec->num_dmics = 1;
2569 spec->dmic_nids = stac925x_dmic_nids;
2572 spec->num_dmics = 0;
2576 spec->init = stac925x_core_init;
2577 spec->mixer = stac925x_mixer;
2579 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
2581 if (spec->board_config < 0) {
2582 printk(KERN_WARNING "hda_codec: No auto-config is "
2583 "available, default to model=ref\n");
2584 spec->board_config = STAC_925x_REF;
2590 stac92xx_free(codec);
2594 codec->patch_ops = stac92xx_patch_ops;
2599 static int patch_stac922x(struct hda_codec *codec)
2601 struct sigmatel_spec *spec;
2604 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2609 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
2610 spec->pin_nids = stac922x_pin_nids;
2611 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
2614 if (spec->board_config == STAC_INTEL_MAC_V3) {
2615 spec->gpio_mute = 1;
2616 /* Intel Macs have all same PCI SSID, so we need to check
2617 * codec SSID to distinguish the exact models
2619 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
2620 switch (codec->subsystem_id) {
2623 spec->board_config = STAC_INTEL_MAC_V1;
2627 spec->board_config = STAC_INTEL_MAC_V2;
2635 spec->board_config = STAC_INTEL_MAC_V3;
2639 spec->board_config = STAC_INTEL_MAC_V4;
2643 spec->board_config = STAC_INTEL_MAC_V5;
2649 if (spec->board_config < 0) {
2650 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
2651 "using BIOS defaults\n");
2652 err = stac92xx_save_bios_config_regs(codec);
2654 stac92xx_free(codec);
2657 spec->pin_configs = spec->bios_pin_configs;
2658 } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
2659 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
2660 stac92xx_set_config_regs(codec);
2663 spec->adc_nids = stac922x_adc_nids;
2664 spec->mux_nids = stac922x_mux_nids;
2665 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
2666 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
2667 spec->num_dmics = 0;
2669 spec->init = stac922x_core_init;
2670 spec->mixer = stac922x_mixer;
2672 spec->multiout.dac_nids = spec->dac_nids;
2674 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
2676 if (spec->board_config < 0) {
2677 printk(KERN_WARNING "hda_codec: No auto-config is "
2678 "available, default to model=ref\n");
2679 spec->board_config = STAC_D945_REF;
2685 stac92xx_free(codec);
2689 codec->patch_ops = stac92xx_patch_ops;
2691 /* Fix Mux capture level; max to 2 */
2692 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
2693 (0 << AC_AMPCAP_OFFSET_SHIFT) |
2694 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
2695 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2696 (0 << AC_AMPCAP_MUTE_SHIFT));
2701 static int patch_stac927x(struct hda_codec *codec)
2703 struct sigmatel_spec *spec;
2706 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2711 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
2712 spec->pin_nids = stac927x_pin_nids;
2713 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
2717 if (spec->board_config < 0) {
2718 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC927x, using BIOS defaults\n");
2719 err = stac92xx_save_bios_config_regs(codec);
2721 stac92xx_free(codec);
2724 spec->pin_configs = spec->bios_pin_configs;
2725 } else if (stac927x_brd_tbl[spec->board_config] != NULL) {
2726 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
2727 stac92xx_set_config_regs(codec);
2730 switch (spec->board_config) {
2732 spec->adc_nids = stac927x_adc_nids;
2733 spec->mux_nids = stac927x_mux_nids;
2734 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
2735 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
2736 spec->num_dmics = 0;
2737 spec->init = d965_core_init;
2738 spec->mixer = stac927x_mixer;
2741 spec->adc_nids = stac927x_adc_nids;
2742 spec->mux_nids = stac927x_mux_nids;
2743 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
2744 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
2745 spec->num_dmics = 0;
2746 spec->init = d965_core_init;
2747 spec->mixer = stac927x_mixer;
2750 spec->adc_nids = stac927x_adc_nids;
2751 spec->mux_nids = stac927x_mux_nids;
2752 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
2753 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
2754 spec->num_dmics = 0;
2755 spec->init = stac927x_core_init;
2756 spec->mixer = stac927x_mixer;
2759 spec->multiout.dac_nids = spec->dac_nids;
2760 /* GPIO0 High = Enable EAPD */
2761 spec->gpio_mask = spec->gpio_data = 0x00000001;
2762 stac92xx_enable_gpio_mask(codec);
2764 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
2766 if (spec->board_config < 0) {
2767 printk(KERN_WARNING "hda_codec: No auto-config is "
2768 "available, default to model=ref\n");
2769 spec->board_config = STAC_D965_REF;
2775 stac92xx_free(codec);
2779 codec->patch_ops = stac92xx_patch_ops;
2784 static int patch_stac9205(struct hda_codec *codec)
2786 struct sigmatel_spec *spec;
2789 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2794 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
2795 spec->pin_nids = stac9205_pin_nids;
2796 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
2800 if (spec->board_config < 0) {
2801 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
2802 err = stac92xx_save_bios_config_regs(codec);
2804 stac92xx_free(codec);
2807 spec->pin_configs = spec->bios_pin_configs;
2809 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
2810 stac92xx_set_config_regs(codec);
2813 spec->adc_nids = stac9205_adc_nids;
2814 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
2815 spec->mux_nids = stac9205_mux_nids;
2816 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
2817 spec->dmic_nids = stac9205_dmic_nids;
2818 spec->num_dmics = ARRAY_SIZE(stac9205_dmic_nids);
2819 spec->dmux_nid = 0x1d;
2821 spec->init = stac9205_core_init;
2822 spec->mixer = stac9205_mixer;
2824 spec->multiout.dac_nids = spec->dac_nids;
2826 switch (spec->board_config){
2827 case STAC_9205_DELL_M43:
2828 /* Enable SPDIF in/out */
2829 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
2830 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
2832 spec->gpio_mask = 0x00000007; /* GPIO0-2 */
2833 /* GPIO0 High = EAPD, GPIO1 Low = DRM,
2834 * GPIO2 High = Headphone Mute
2836 spec->gpio_data = 0x00000005;
2839 /* GPIO0 High = EAPD */
2840 spec->gpio_mask = spec->gpio_data = 0x00000001;
2844 stac92xx_enable_gpio_mask(codec);
2845 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
2847 if (spec->board_config < 0) {
2848 printk(KERN_WARNING "hda_codec: No auto-config is "
2849 "available, default to model=ref\n");
2850 spec->board_config = STAC_9205_REF;
2856 stac92xx_free(codec);
2860 codec->patch_ops = stac92xx_patch_ops;
2869 /* static config for Sony VAIO FE550G and Sony VAIO AR */
2870 static hda_nid_t vaio_dacs[] = { 0x2 };
2871 #define VAIO_HP_DAC 0x5
2872 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
2873 static hda_nid_t vaio_mux_nids[] = { 0x15 };
2875 static struct hda_input_mux vaio_mux = {
2878 /* { "HP", 0x0 }, */
2879 { "Mic Jack", 0x1 },
2880 { "Internal Mic", 0x2 },
2885 static struct hda_verb vaio_init[] = {
2886 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
2887 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
2888 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
2889 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
2890 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
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 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
2896 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
2897 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
2901 static struct hda_verb vaio_ar_init[] = {
2902 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
2903 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
2904 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
2905 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
2906 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
2907 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
2908 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
2909 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
2910 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
2911 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
2912 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
2913 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
2914 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
2918 /* bind volumes of both NID 0x02 and 0x05 */
2919 static struct hda_bind_ctls vaio_bind_master_vol = {
2920 .ops = &snd_hda_bind_vol,
2922 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
2923 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
2928 /* bind volumes of both NID 0x02 and 0x05 */
2929 static struct hda_bind_ctls vaio_bind_master_sw = {
2930 .ops = &snd_hda_bind_sw,
2932 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
2933 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
2938 static struct snd_kcontrol_new vaio_mixer[] = {
2939 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
2940 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
2941 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
2942 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
2943 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
2945 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2946 .name = "Capture Source",
2948 .info = stac92xx_mux_enum_info,
2949 .get = stac92xx_mux_enum_get,
2950 .put = stac92xx_mux_enum_put,
2955 static struct snd_kcontrol_new vaio_ar_mixer[] = {
2956 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
2957 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
2958 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
2959 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
2960 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
2961 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
2962 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
2964 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2965 .name = "Capture Source",
2967 .info = stac92xx_mux_enum_info,
2968 .get = stac92xx_mux_enum_get,
2969 .put = stac92xx_mux_enum_put,
2974 static struct hda_codec_ops stac9872_patch_ops = {
2975 .build_controls = stac92xx_build_controls,
2976 .build_pcms = stac92xx_build_pcms,
2977 .init = stac92xx_init,
2978 .free = stac92xx_free,
2979 #ifdef SND_HDA_NEEDS_RESUME
2980 .resume = stac92xx_resume,
2984 static int stac9872_vaio_init(struct hda_codec *codec)
2988 err = stac92xx_init(codec);
2991 if (codec->patch_ops.unsol_event)
2992 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2996 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
2998 if (get_pin_presence(codec, 0x0a)) {
2999 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3000 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3002 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3003 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3007 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
3009 switch (res >> 26) {
3011 stac9872_vaio_hp_detect(codec, res);
3016 static struct hda_codec_ops stac9872_vaio_patch_ops = {
3017 .build_controls = stac92xx_build_controls,
3018 .build_pcms = stac92xx_build_pcms,
3019 .init = stac9872_vaio_init,
3020 .free = stac92xx_free,
3021 .unsol_event = stac9872_vaio_unsol_event,
3023 .resume = stac92xx_resume,
3027 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
3029 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
3031 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
3033 /* AR Series. id=0x83847664 and subsys=104D1300 */
3038 static const char *stac9872_models[STAC_9872_MODELS] = {
3039 [CXD9872RD_VAIO] = "vaio",
3040 [CXD9872AKD_VAIO] = "vaio-ar",
3043 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
3044 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
3045 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
3046 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
3047 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
3051 static int patch_stac9872(struct hda_codec *codec)
3053 struct sigmatel_spec *spec;
3056 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
3059 if (board_config < 0)
3060 /* unknown config, let generic-parser do its job... */
3061 return snd_hda_parse_generic_codec(codec);
3063 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3068 switch (board_config) {
3069 case CXD9872RD_VAIO:
3070 case STAC9872AK_VAIO:
3071 case STAC9872K_VAIO:
3072 spec->mixer = vaio_mixer;
3073 spec->init = vaio_init;
3074 spec->multiout.max_channels = 2;
3075 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3076 spec->multiout.dac_nids = vaio_dacs;
3077 spec->multiout.hp_nid = VAIO_HP_DAC;
3078 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3079 spec->adc_nids = vaio_adcs;
3080 spec->input_mux = &vaio_mux;
3081 spec->mux_nids = vaio_mux_nids;
3082 codec->patch_ops = stac9872_vaio_patch_ops;
3085 case CXD9872AKD_VAIO:
3086 spec->mixer = vaio_ar_mixer;
3087 spec->init = vaio_ar_init;
3088 spec->multiout.max_channels = 2;
3089 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3090 spec->multiout.dac_nids = vaio_dacs;
3091 spec->multiout.hp_nid = VAIO_HP_DAC;
3092 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3093 spec->adc_nids = vaio_adcs;
3094 spec->input_mux = &vaio_mux;
3095 spec->mux_nids = vaio_mux_nids;
3096 codec->patch_ops = stac9872_patch_ops;
3107 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
3108 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
3109 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
3110 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
3111 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
3112 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
3113 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
3114 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
3115 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
3116 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
3117 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
3118 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
3119 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
3120 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
3121 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
3122 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
3123 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
3124 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
3125 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
3126 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
3127 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
3128 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
3129 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
3130 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
3131 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
3132 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
3133 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
3134 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
3135 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
3136 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
3137 /* The following does not take into account .id=0x83847661 when subsys =
3138 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
3139 * currently not fully supported.
3141 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
3142 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
3143 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
3144 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
3145 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
3146 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
3147 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
3148 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
3149 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
3150 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
3151 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },