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 <linux/init.h>
28 #include <linux/delay.h>
29 #include <linux/slab.h>
30 #include <linux/pci.h>
31 #include <sound/core.h>
32 #include <sound/asoundef.h>
33 #include <sound/jack.h>
34 #include "hda_codec.h"
35 #include "hda_local.h"
73 STAC_92HD73XX_NO_JD, /* no jack-detection */
118 STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
119 * is given, one of the above models will be
120 * chosen according to the subsystem id. */
121 /* for backward compatibility */
137 STAC_D965_REF_NO_JD, /* no jack-detection */
146 struct sigmatel_event {
153 struct sigmatel_jack {
156 struct snd_jack *jack;
159 struct sigmatel_spec {
160 struct snd_kcontrol_new *mixers[4];
161 unsigned int num_mixers;
164 unsigned int eapd_switch: 1;
165 unsigned int surr_switch: 1;
166 unsigned int alt_switch: 1;
167 unsigned int hp_detect: 1;
168 unsigned int spdif_mute: 1;
171 unsigned int eapd_mask;
172 unsigned int gpio_mask;
173 unsigned int gpio_dir;
174 unsigned int gpio_data;
175 unsigned int gpio_mute;
178 unsigned int stream_delay;
180 /* analog loopback */
181 unsigned char aloopback_mask;
182 unsigned char aloopback_shift;
184 /* power management */
185 unsigned int num_pwrs;
186 unsigned int *pwr_mapping;
191 struct snd_array jacks;
194 struct snd_array events;
197 struct hda_input_mux *mono_mux;
198 struct hda_input_mux *amp_mux;
199 unsigned int cur_mmux;
200 struct hda_multi_out multiout;
201 hda_nid_t dac_nids[5];
202 hda_nid_t hp_dacs[5];
203 hda_nid_t speaker_dacs[5];
207 unsigned int num_adcs;
209 unsigned int num_muxes;
210 hda_nid_t *dmic_nids;
211 unsigned int num_dmics;
212 hda_nid_t *dmux_nids;
213 unsigned int num_dmuxes;
214 hda_nid_t *smux_nids;
215 unsigned int num_smuxes;
216 const char **spdif_labels;
218 hda_nid_t dig_in_nid;
220 hda_nid_t anabeep_nid;
221 hda_nid_t digbeep_nid;
225 unsigned int num_pins;
226 unsigned int *pin_configs;
228 /* codec specific stuff */
229 struct hda_verb *init;
230 struct snd_kcontrol_new *mixer;
233 struct hda_input_mux *dinput_mux;
234 unsigned int cur_dmux[2];
235 struct hda_input_mux *input_mux;
236 unsigned int cur_mux[3];
237 struct hda_input_mux *sinput_mux;
238 unsigned int cur_smux[2];
239 unsigned int cur_amux;
241 unsigned int num_amps;
242 unsigned int powerdown_adcs;
245 unsigned int io_switch[2];
246 unsigned int clfe_swap;
247 hda_nid_t line_switch; /* shared line-in for input and output */
248 hda_nid_t mic_switch; /* shared mic-in for input and output */
249 hda_nid_t hp_switch; /* NID of HP as line-out */
250 unsigned int aloopback;
252 struct hda_pcm pcm_rec[2]; /* PCM information */
254 /* dynamic controls and input_mux */
255 struct auto_pin_cfg autocfg;
256 struct snd_array kctls;
257 struct hda_input_mux private_dimux;
258 struct hda_input_mux private_imux;
259 struct hda_input_mux private_smux;
260 struct hda_input_mux private_amp_mux;
261 struct hda_input_mux private_mono_mux;
264 static hda_nid_t stac9200_adc_nids[1] = {
268 static hda_nid_t stac9200_mux_nids[1] = {
272 static hda_nid_t stac9200_dac_nids[1] = {
276 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
277 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
281 static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
285 static hda_nid_t stac92hd73xx_adc_nids[2] = {
289 #define DELL_M6_AMP 2
290 static hda_nid_t stac92hd73xx_amp_nids[3] = {
294 #define STAC92HD73XX_NUM_DMICS 2
295 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
299 #define STAC92HD73_DAC_COUNT 5
301 static hda_nid_t stac92hd73xx_mux_nids[4] = {
302 0x28, 0x29, 0x2a, 0x2b,
305 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
309 static hda_nid_t stac92hd73xx_smux_nids[2] = {
313 #define STAC92HD83XXX_NUM_DMICS 2
314 static hda_nid_t stac92hd83xxx_dmic_nids[STAC92HD83XXX_NUM_DMICS + 1] = {
318 #define STAC92HD83_DAC_COUNT 3
320 static hda_nid_t stac92hd83xxx_dmux_nids[2] = {
324 static hda_nid_t stac92hd83xxx_adc_nids[2] = {
328 static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
332 static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
336 static unsigned int stac92hd83xxx_pwr_mapping[4] = {
337 0x03, 0x0c, 0x10, 0x40,
340 static hda_nid_t stac92hd83xxx_amp_nids[1] = {
344 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
348 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
352 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
356 static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
360 static hda_nid_t stac92hd71bxx_smux_nids[2] = {
364 #define STAC92HD71BXX_NUM_DMICS 2
365 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
369 static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
373 static hda_nid_t stac925x_adc_nids[1] = {
377 static hda_nid_t stac925x_mux_nids[1] = {
381 static hda_nid_t stac925x_dac_nids[1] = {
385 #define STAC925X_NUM_DMICS 1
386 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
390 static hda_nid_t stac925x_dmux_nids[1] = {
394 static hda_nid_t stac922x_adc_nids[2] = {
398 static hda_nid_t stac922x_mux_nids[2] = {
402 static hda_nid_t stac927x_adc_nids[3] = {
406 static hda_nid_t stac927x_mux_nids[3] = {
410 static hda_nid_t stac927x_smux_nids[1] = {
414 static hda_nid_t stac927x_dac_nids[6] = {
415 0x02, 0x03, 0x04, 0x05, 0x06, 0
418 static hda_nid_t stac927x_dmux_nids[1] = {
422 #define STAC927X_NUM_DMICS 2
423 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
427 static const char *stac927x_spdif_labels[5] = {
428 "Digital Playback", "ADAT", "Analog Mux 1",
429 "Analog Mux 2", "Analog Mux 3"
432 static hda_nid_t stac9205_adc_nids[2] = {
436 static hda_nid_t stac9205_mux_nids[2] = {
440 static hda_nid_t stac9205_dmux_nids[1] = {
444 static hda_nid_t stac9205_smux_nids[1] = {
448 #define STAC9205_NUM_DMICS 2
449 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
453 static hda_nid_t stac9200_pin_nids[8] = {
454 0x08, 0x09, 0x0d, 0x0e,
455 0x0f, 0x10, 0x11, 0x12,
458 static hda_nid_t stac925x_pin_nids[8] = {
459 0x07, 0x08, 0x0a, 0x0b,
460 0x0c, 0x0d, 0x10, 0x11,
463 static hda_nid_t stac922x_pin_nids[10] = {
464 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
465 0x0f, 0x10, 0x11, 0x15, 0x1b,
468 static hda_nid_t stac92hd73xx_pin_nids[13] = {
469 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
470 0x0f, 0x10, 0x11, 0x12, 0x13,
474 static hda_nid_t stac92hd83xxx_pin_nids[14] = {
475 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
476 0x0f, 0x10, 0x11, 0x12, 0x13,
477 0x1d, 0x1e, 0x1f, 0x20
479 static hda_nid_t stac92hd71bxx_pin_nids[11] = {
480 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
481 0x0f, 0x14, 0x18, 0x19, 0x1e,
485 static hda_nid_t stac927x_pin_nids[14] = {
486 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
487 0x0f, 0x10, 0x11, 0x12, 0x13,
488 0x14, 0x21, 0x22, 0x23,
491 static hda_nid_t stac9205_pin_nids[12] = {
492 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
493 0x0f, 0x14, 0x16, 0x17, 0x18,
497 #define stac92xx_amp_volume_info snd_hda_mixer_amp_volume_info
499 static int stac92xx_amp_volume_get(struct snd_kcontrol *kcontrol,
500 struct snd_ctl_elem_value *ucontrol)
502 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
503 struct sigmatel_spec *spec = codec->spec;
504 hda_nid_t nid = spec->amp_nids[spec->cur_amux];
506 kcontrol->private_value ^= get_amp_nid(kcontrol);
507 kcontrol->private_value |= nid;
509 return snd_hda_mixer_amp_volume_get(kcontrol, ucontrol);
512 static int stac92xx_amp_volume_put(struct snd_kcontrol *kcontrol,
513 struct snd_ctl_elem_value *ucontrol)
515 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
516 struct sigmatel_spec *spec = codec->spec;
517 hda_nid_t nid = spec->amp_nids[spec->cur_amux];
519 kcontrol->private_value ^= get_amp_nid(kcontrol);
520 kcontrol->private_value |= nid;
522 return snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
525 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
526 struct snd_ctl_elem_info *uinfo)
528 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
529 struct sigmatel_spec *spec = codec->spec;
530 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
533 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
534 struct snd_ctl_elem_value *ucontrol)
536 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
537 struct sigmatel_spec *spec = codec->spec;
538 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
540 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
544 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
545 struct snd_ctl_elem_value *ucontrol)
547 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
548 struct sigmatel_spec *spec = codec->spec;
549 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
551 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
552 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
555 static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
556 struct snd_ctl_elem_info *uinfo)
558 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
559 struct sigmatel_spec *spec = codec->spec;
560 return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
563 static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
564 struct snd_ctl_elem_value *ucontrol)
566 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
567 struct sigmatel_spec *spec = codec->spec;
568 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
570 ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
574 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
575 struct snd_ctl_elem_value *ucontrol)
577 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
578 struct sigmatel_spec *spec = codec->spec;
579 struct hda_input_mux *smux = &spec->private_smux;
580 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
584 err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
585 spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
589 if (spec->spdif_mute) {
591 nid = spec->multiout.dig_out_nid;
593 nid = codec->slave_dig_outs[smux_idx - 1];
594 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
598 /* un/mute SPDIF out */
599 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
605 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
607 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
608 struct sigmatel_spec *spec = codec->spec;
609 return snd_hda_input_mux_info(spec->input_mux, uinfo);
612 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
614 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
615 struct sigmatel_spec *spec = codec->spec;
616 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
618 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
622 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
624 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
625 struct sigmatel_spec *spec = codec->spec;
626 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
628 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
629 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
632 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
633 struct snd_ctl_elem_info *uinfo)
635 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
636 struct sigmatel_spec *spec = codec->spec;
637 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
640 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
641 struct snd_ctl_elem_value *ucontrol)
643 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
644 struct sigmatel_spec *spec = codec->spec;
646 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
650 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
651 struct snd_ctl_elem_value *ucontrol)
653 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
654 struct sigmatel_spec *spec = codec->spec;
656 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
657 spec->mono_nid, &spec->cur_mmux);
660 static int stac92xx_amp_mux_enum_info(struct snd_kcontrol *kcontrol,
661 struct snd_ctl_elem_info *uinfo)
663 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
664 struct sigmatel_spec *spec = codec->spec;
665 return snd_hda_input_mux_info(spec->amp_mux, uinfo);
668 static int stac92xx_amp_mux_enum_get(struct snd_kcontrol *kcontrol,
669 struct snd_ctl_elem_value *ucontrol)
671 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
672 struct sigmatel_spec *spec = codec->spec;
674 ucontrol->value.enumerated.item[0] = spec->cur_amux;
678 static int stac92xx_amp_mux_enum_put(struct snd_kcontrol *kcontrol,
679 struct snd_ctl_elem_value *ucontrol)
681 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
682 struct sigmatel_spec *spec = codec->spec;
683 struct snd_kcontrol *ctl =
684 snd_hda_find_mixer_ctl(codec, "Amp Capture Volume");
688 snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE |
689 SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
691 return snd_hda_input_mux_put(codec, spec->amp_mux, ucontrol,
695 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
697 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
698 struct snd_ctl_elem_value *ucontrol)
700 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
701 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
702 struct sigmatel_spec *spec = codec->spec;
704 ucontrol->value.integer.value[0] = !!(spec->aloopback &
705 (spec->aloopback_mask << idx));
709 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
710 struct snd_ctl_elem_value *ucontrol)
712 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
713 struct sigmatel_spec *spec = codec->spec;
714 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
715 unsigned int dac_mode;
716 unsigned int val, idx_val;
718 idx_val = spec->aloopback_mask << idx;
719 if (ucontrol->value.integer.value[0])
720 val = spec->aloopback | idx_val;
722 val = spec->aloopback & ~idx_val;
723 if (spec->aloopback == val)
726 spec->aloopback = val;
728 /* Only return the bits defined by the shift value of the
729 * first two bytes of the mask
731 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
732 kcontrol->private_value & 0xFFFF, 0x0);
733 dac_mode >>= spec->aloopback_shift;
735 if (spec->aloopback & idx_val) {
736 snd_hda_power_up(codec);
739 snd_hda_power_down(codec);
740 dac_mode &= ~idx_val;
743 snd_hda_codec_write_cache(codec, codec->afg, 0,
744 kcontrol->private_value >> 16, dac_mode);
749 static struct hda_verb stac9200_core_init[] = {
750 /* set dac0mux for dac converter */
751 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
755 static struct hda_verb stac9200_eapd_init[] = {
756 /* set dac0mux for dac converter */
757 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
758 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
762 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
763 /* set master volume and direct control */
764 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
765 /* setup adcs to point to mixer */
766 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
767 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
768 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
769 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
770 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
771 /* setup import muxs */
772 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
773 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
774 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
775 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
779 static struct hda_verb dell_eq_core_init[] = {
780 /* set master volume to max value without distortion
781 * and direct control */
782 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
783 /* setup adcs to point to mixer */
784 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
785 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
786 /* setup import muxs */
787 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
788 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
789 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
790 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
794 static struct hda_verb dell_m6_core_init[] = {
795 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
796 /* setup adcs to point to mixer */
797 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
798 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
799 /* setup import muxs */
800 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
801 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
802 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
803 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
807 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
808 /* set master volume and direct control */
809 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
810 /* setup adcs to point to mixer */
811 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
812 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
813 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
814 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
815 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
816 /* setup import muxs */
817 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
818 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
819 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
820 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
824 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
825 /* set master volume and direct control */
826 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
827 /* dac3 is connected to import3 mux */
828 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
829 /* setup adcs to point to mixer */
830 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
831 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
832 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
833 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
834 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
835 /* setup import muxs */
836 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
837 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
838 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
839 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
843 static struct hda_verb stac92hd83xxx_core_init[] = {
844 /* start of config #1 */
845 { 0xe, AC_VERB_SET_CONNECT_SEL, 0x3},
847 /* start of config #2 */
848 { 0xa, AC_VERB_SET_CONNECT_SEL, 0x0},
849 { 0xb, AC_VERB_SET_CONNECT_SEL, 0x0},
850 { 0xd, AC_VERB_SET_CONNECT_SEL, 0x1},
852 /* power state controls amps */
853 { 0x01, AC_VERB_SET_EAPD, 1 << 2},
857 static struct hda_verb stac92hd71bxx_core_init[] = {
858 /* set master volume and direct control */
859 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
860 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
861 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
862 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
863 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
867 #define HD_DISABLE_PORTF 2
868 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
869 /* start of config #1 */
871 /* connect port 0f to audio mixer */
872 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
873 /* unmute right and left channels for node 0x0f */
874 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
875 /* start of config #2 */
877 /* set master volume and direct control */
878 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
879 /* unmute right and left channels for nodes 0x0a, 0xd */
880 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
881 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
885 static struct hda_verb stac925x_core_init[] = {
886 /* set dac0mux for dac converter */
887 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
888 /* mute the master volume */
889 { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
893 static struct hda_verb stac922x_core_init[] = {
894 /* set master volume and direct control */
895 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
899 static struct hda_verb d965_core_init[] = {
900 /* set master volume and direct control */
901 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
902 /* unmute node 0x1b */
903 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
904 /* select node 0x03 as DAC */
905 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
909 static struct hda_verb stac927x_core_init[] = {
910 /* set master volume and direct control */
911 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
912 /* enable analog pc beep path */
913 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
917 static struct hda_verb stac9205_core_init[] = {
918 /* set master volume and direct control */
919 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
920 /* enable analog pc beep path */
921 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
925 #define STAC_MONO_MUX \
927 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
928 .name = "Mono Mux", \
930 .info = stac92xx_mono_mux_enum_info, \
931 .get = stac92xx_mono_mux_enum_get, \
932 .put = stac92xx_mono_mux_enum_put, \
935 #define STAC_AMP_MUX \
937 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
938 .name = "Amp Selector Capture Switch", \
940 .info = stac92xx_amp_mux_enum_info, \
941 .get = stac92xx_amp_mux_enum_get, \
942 .put = stac92xx_amp_mux_enum_put, \
945 #define STAC_AMP_VOL(xname, nid, chs, idx, dir) \
947 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
950 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
951 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
952 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
953 .info = stac92xx_amp_volume_info, \
954 .get = stac92xx_amp_volume_get, \
955 .put = stac92xx_amp_volume_put, \
956 .tlv = { .c = snd_hda_mixer_amp_tlv }, \
957 .private_value = HDA_COMPOSE_AMP_VAL(nid, chs, idx, dir) \
960 #define STAC_INPUT_SOURCE(cnt) \
962 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
963 .name = "Input Source", \
965 .info = stac92xx_mux_enum_info, \
966 .get = stac92xx_mux_enum_get, \
967 .put = stac92xx_mux_enum_put, \
970 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
972 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
973 .name = "Analog Loopback", \
975 .info = stac92xx_aloopback_info, \
976 .get = stac92xx_aloopback_get, \
977 .put = stac92xx_aloopback_put, \
978 .private_value = verb_read | (verb_write << 16), \
981 static struct snd_kcontrol_new stac9200_mixer[] = {
982 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
983 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
984 STAC_INPUT_SOURCE(1),
985 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
986 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
990 #define DELL_M6_MIXER 6
991 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
992 /* start of config #1 */
993 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
994 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
996 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
997 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
999 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1000 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1002 /* start of config #2 */
1003 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1004 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1006 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1007 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1009 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
1011 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1012 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1014 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1015 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1020 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
1021 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1023 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1024 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1026 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1027 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1029 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1030 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1032 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1033 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1035 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1036 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1038 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1039 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1041 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1042 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1046 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
1047 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1049 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1050 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1052 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1053 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1055 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1056 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1058 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1059 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1061 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1062 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1064 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1065 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1067 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1068 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1073 static struct snd_kcontrol_new stac92hd83xxx_mixer[] = {
1074 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_OUTPUT),
1075 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_OUTPUT),
1077 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_OUTPUT),
1078 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_OUTPUT),
1080 HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x1b, 0x3, HDA_INPUT),
1081 HDA_CODEC_MUTE("DAC0 Capture Switch", 0x1b, 0x3, HDA_INPUT),
1083 HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x1b, 0x4, HDA_INPUT),
1084 HDA_CODEC_MUTE("DAC1 Capture Switch", 0x1b, 0x4, HDA_INPUT),
1086 HDA_CODEC_VOLUME("Front Mic Capture Volume", 0x1b, 0x0, HDA_INPUT),
1087 HDA_CODEC_MUTE("Front Mic Capture Switch", 0x1b, 0x0, HDA_INPUT),
1089 HDA_CODEC_VOLUME("Line In Capture Volume", 0x1b, 0x2, HDA_INPUT),
1090 HDA_CODEC_MUTE("Line In Capture Switch", 0x1b, 0x2, HDA_INPUT),
1093 HDA_CODEC_VOLUME("Mic Capture Volume", 0x1b, 0x1, HDA_INPUT),
1094 HDA_CODEC_MUTE("Mic Capture Switch", 0x1b 0x1, HDA_INPUT),
1099 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
1100 STAC_INPUT_SOURCE(2),
1101 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
1103 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1104 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1106 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1107 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1108 /* analog pc-beep replaced with digital beep support */
1110 HDA_CODEC_VOLUME("PC Beep Volume", 0x17, 0x2, HDA_INPUT),
1111 HDA_CODEC_MUTE("PC Beep Switch", 0x17, 0x2, HDA_INPUT),
1114 HDA_CODEC_MUTE("Import0 Mux Capture Switch", 0x17, 0x0, HDA_INPUT),
1115 HDA_CODEC_VOLUME("Import0 Mux Capture Volume", 0x17, 0x0, HDA_INPUT),
1117 HDA_CODEC_MUTE("Import1 Mux Capture Switch", 0x17, 0x1, HDA_INPUT),
1118 HDA_CODEC_VOLUME("Import1 Mux Capture Volume", 0x17, 0x1, HDA_INPUT),
1120 HDA_CODEC_MUTE("DAC0 Capture Switch", 0x17, 0x3, HDA_INPUT),
1121 HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x17, 0x3, HDA_INPUT),
1123 HDA_CODEC_MUTE("DAC1 Capture Switch", 0x17, 0x4, HDA_INPUT),
1124 HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x17, 0x4, HDA_INPUT),
1128 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
1129 STAC_INPUT_SOURCE(2),
1130 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
1132 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1133 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1135 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1136 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1140 static struct snd_kcontrol_new stac925x_mixer[] = {
1141 HDA_CODEC_VOLUME("Master Playback Volume", 0x0e, 0, HDA_OUTPUT),
1142 HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
1143 STAC_INPUT_SOURCE(1),
1144 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
1145 HDA_CODEC_MUTE("Capture Switch", 0x14, 0, HDA_OUTPUT),
1149 static struct snd_kcontrol_new stac9205_mixer[] = {
1150 STAC_INPUT_SOURCE(2),
1151 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1153 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
1154 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
1156 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
1157 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
1161 /* This needs to be generated dynamically based on sequence */
1162 static struct snd_kcontrol_new stac922x_mixer[] = {
1163 STAC_INPUT_SOURCE(2),
1164 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
1165 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
1167 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
1168 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
1173 static struct snd_kcontrol_new stac927x_mixer[] = {
1174 STAC_INPUT_SOURCE(3),
1175 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1177 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
1178 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
1180 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
1181 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
1183 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
1184 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
1188 static struct snd_kcontrol_new stac_dmux_mixer = {
1189 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1190 .name = "Digital Input Source",
1191 /* count set later */
1192 .info = stac92xx_dmux_enum_info,
1193 .get = stac92xx_dmux_enum_get,
1194 .put = stac92xx_dmux_enum_put,
1197 static struct snd_kcontrol_new stac_smux_mixer = {
1198 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1199 .name = "IEC958 Playback Source",
1200 /* count set later */
1201 .info = stac92xx_smux_enum_info,
1202 .get = stac92xx_smux_enum_get,
1203 .put = stac92xx_smux_enum_put,
1206 static const char *slave_vols[] = {
1207 "Front Playback Volume",
1208 "Surround Playback Volume",
1209 "Center Playback Volume",
1210 "LFE Playback Volume",
1211 "Side Playback Volume",
1212 "Headphone Playback Volume",
1213 "Headphone Playback Volume",
1214 "Speaker Playback Volume",
1215 "External Speaker Playback Volume",
1216 "Speaker2 Playback Volume",
1220 static const char *slave_sws[] = {
1221 "Front Playback Switch",
1222 "Surround Playback Switch",
1223 "Center Playback Switch",
1224 "LFE Playback Switch",
1225 "Side Playback Switch",
1226 "Headphone Playback Switch",
1227 "Headphone Playback Switch",
1228 "Speaker Playback Switch",
1229 "External Speaker Playback Switch",
1230 "Speaker2 Playback Switch",
1231 "IEC958 Playback Switch",
1235 static void stac92xx_free_kctls(struct hda_codec *codec);
1236 static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
1238 static int stac92xx_build_controls(struct hda_codec *codec)
1240 struct sigmatel_spec *spec = codec->spec;
1241 struct auto_pin_cfg *cfg = &spec->autocfg;
1246 err = snd_hda_add_new_ctls(codec, spec->mixer);
1250 for (i = 0; i < spec->num_mixers; i++) {
1251 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1255 if (spec->num_dmuxes > 0) {
1256 stac_dmux_mixer.count = spec->num_dmuxes;
1257 err = snd_hda_ctl_add(codec,
1258 snd_ctl_new1(&stac_dmux_mixer, codec));
1262 if (spec->num_smuxes > 0) {
1263 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1264 struct hda_input_mux *smux = &spec->private_smux;
1265 /* check for mute support on SPDIF out */
1266 if (wcaps & AC_WCAP_OUT_AMP) {
1267 smux->items[smux->num_items].label = "Off";
1268 smux->items[smux->num_items].index = 0;
1270 spec->spdif_mute = 1;
1272 stac_smux_mixer.count = spec->num_smuxes;
1273 err = snd_hda_ctl_add(codec,
1274 snd_ctl_new1(&stac_smux_mixer, codec));
1279 if (spec->multiout.dig_out_nid) {
1280 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1283 err = snd_hda_create_spdif_share_sw(codec,
1287 spec->multiout.share_spdif = 1;
1289 if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1290 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1295 /* if we have no master control, let's create it */
1296 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1297 unsigned int vmaster_tlv[4];
1298 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1299 HDA_OUTPUT, vmaster_tlv);
1300 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1301 vmaster_tlv, slave_vols);
1305 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1306 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1312 stac92xx_free_kctls(codec); /* no longer needed */
1314 /* create jack input elements */
1315 if (spec->hp_detect) {
1316 for (i = 0; i < cfg->hp_outs; i++) {
1317 int type = SND_JACK_HEADPHONE;
1318 nid = cfg->hp_pins[i];
1319 /* jack detection */
1320 if (cfg->hp_outs == i)
1321 type |= SND_JACK_LINEOUT;
1322 err = stac92xx_add_jack(codec, nid, type);
1327 for (i = 0; i < cfg->line_outs; i++) {
1328 err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
1333 for (i = 0; i < AUTO_PIN_LAST; i++) {
1334 nid = cfg->input_pins[i];
1336 err = stac92xx_add_jack(codec, nid,
1337 SND_JACK_MICROPHONE);
1346 static unsigned int ref9200_pin_configs[8] = {
1347 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1348 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1351 static unsigned int gateway9200_m4_pin_configs[8] = {
1352 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1353 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1355 static unsigned int gateway9200_m4_2_pin_configs[8] = {
1356 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1357 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1361 STAC 9200 pin configs for
1366 static unsigned int dell9200_d21_pin_configs[8] = {
1367 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
1368 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1372 STAC 9200 pin configs for
1376 static unsigned int dell9200_d22_pin_configs[8] = {
1377 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1378 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1382 STAC 9200 pin configs for
1383 102801C4 (Dell Dimension E310)
1390 static unsigned int dell9200_d23_pin_configs[8] = {
1391 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1392 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
1397 STAC 9200-32 pin configs for
1398 102801B5 (Dell Inspiron 630m)
1399 102801D8 (Dell Inspiron 640m)
1401 static unsigned int dell9200_m21_pin_configs[8] = {
1402 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1403 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1407 STAC 9200-32 pin configs for
1408 102801C2 (Dell Latitude D620)
1410 102801CC (Dell Latitude D820)
1414 static unsigned int dell9200_m22_pin_configs[8] = {
1415 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1416 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1420 STAC 9200-32 pin configs for
1421 102801CE (Dell XPS M1710)
1422 102801CF (Dell Precision M90)
1424 static unsigned int dell9200_m23_pin_configs[8] = {
1425 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1426 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1430 STAC 9200-32 pin configs for
1433 102801CB (Dell Latitude 120L)
1436 static unsigned int dell9200_m24_pin_configs[8] = {
1437 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1438 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1442 STAC 9200-32 pin configs for
1443 102801BD (Dell Inspiron E1505n)
1447 static unsigned int dell9200_m25_pin_configs[8] = {
1448 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1449 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1453 STAC 9200-32 pin configs for
1454 102801F5 (Dell Inspiron 1501)
1457 static unsigned int dell9200_m26_pin_configs[8] = {
1458 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1459 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1464 102801CD (Dell Inspiron E1705/9400)
1466 static unsigned int dell9200_m27_pin_configs[8] = {
1467 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1468 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1471 static unsigned int oqo9200_pin_configs[8] = {
1472 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1473 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1477 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1478 [STAC_REF] = ref9200_pin_configs,
1479 [STAC_9200_OQO] = oqo9200_pin_configs,
1480 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1481 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1482 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1483 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1484 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1485 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1486 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1487 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1488 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1489 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1490 [STAC_9200_M4] = gateway9200_m4_pin_configs,
1491 [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1492 [STAC_9200_PANASONIC] = ref9200_pin_configs,
1495 static const char *stac9200_models[STAC_9200_MODELS] = {
1497 [STAC_9200_OQO] = "oqo",
1498 [STAC_9200_DELL_D21] = "dell-d21",
1499 [STAC_9200_DELL_D22] = "dell-d22",
1500 [STAC_9200_DELL_D23] = "dell-d23",
1501 [STAC_9200_DELL_M21] = "dell-m21",
1502 [STAC_9200_DELL_M22] = "dell-m22",
1503 [STAC_9200_DELL_M23] = "dell-m23",
1504 [STAC_9200_DELL_M24] = "dell-m24",
1505 [STAC_9200_DELL_M25] = "dell-m25",
1506 [STAC_9200_DELL_M26] = "dell-m26",
1507 [STAC_9200_DELL_M27] = "dell-m27",
1508 [STAC_9200_M4] = "gateway-m4",
1509 [STAC_9200_M4_2] = "gateway-m4-2",
1510 [STAC_9200_PANASONIC] = "panasonic",
1513 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1514 /* SigmaTel reference board */
1515 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1516 "DFI LanParty", STAC_REF),
1517 /* Dell laptops have BIOS problem */
1518 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1519 "unknown Dell", STAC_9200_DELL_D21),
1520 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1521 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1522 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1523 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1524 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1525 "unknown Dell", STAC_9200_DELL_D22),
1526 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1527 "unknown Dell", STAC_9200_DELL_D22),
1528 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1529 "Dell Latitude D620", STAC_9200_DELL_M22),
1530 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1531 "unknown Dell", STAC_9200_DELL_D23),
1532 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1533 "unknown Dell", STAC_9200_DELL_D23),
1534 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1535 "unknown Dell", STAC_9200_DELL_M22),
1536 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1537 "unknown Dell", STAC_9200_DELL_M24),
1538 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1539 "unknown Dell", STAC_9200_DELL_M24),
1540 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1541 "Dell Latitude 120L", STAC_9200_DELL_M24),
1542 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1543 "Dell Latitude D820", STAC_9200_DELL_M22),
1544 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1545 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1546 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1547 "Dell XPS M1710", STAC_9200_DELL_M23),
1548 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1549 "Dell Precision M90", STAC_9200_DELL_M23),
1550 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1551 "unknown Dell", STAC_9200_DELL_M22),
1552 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1553 "unknown Dell", STAC_9200_DELL_M22),
1554 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1555 "unknown Dell", STAC_9200_DELL_M22),
1556 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1557 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1558 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1559 "unknown Dell", STAC_9200_DELL_D23),
1560 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1561 "unknown Dell", STAC_9200_DELL_D23),
1562 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1563 "unknown Dell", STAC_9200_DELL_D21),
1564 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1565 "unknown Dell", STAC_9200_DELL_D23),
1566 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1567 "unknown Dell", STAC_9200_DELL_D21),
1568 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1569 "unknown Dell", STAC_9200_DELL_M25),
1570 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1571 "unknown Dell", STAC_9200_DELL_M25),
1572 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1573 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1574 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1575 "unknown Dell", STAC_9200_DELL_M26),
1577 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1578 /* Gateway machines needs EAPD to be set on resume */
1579 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1580 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1581 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1583 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1587 static unsigned int ref925x_pin_configs[8] = {
1588 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1589 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1592 static unsigned int stac925xM1_pin_configs[8] = {
1593 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1594 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1597 static unsigned int stac925xM1_2_pin_configs[8] = {
1598 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1599 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1602 static unsigned int stac925xM2_pin_configs[8] = {
1603 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1604 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1607 static unsigned int stac925xM2_2_pin_configs[8] = {
1608 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1609 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1612 static unsigned int stac925xM3_pin_configs[8] = {
1613 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1614 0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1617 static unsigned int stac925xM5_pin_configs[8] = {
1618 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1619 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1622 static unsigned int stac925xM6_pin_configs[8] = {
1623 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1624 0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1627 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1628 [STAC_REF] = ref925x_pin_configs,
1629 [STAC_M1] = stac925xM1_pin_configs,
1630 [STAC_M1_2] = stac925xM1_2_pin_configs,
1631 [STAC_M2] = stac925xM2_pin_configs,
1632 [STAC_M2_2] = stac925xM2_2_pin_configs,
1633 [STAC_M3] = stac925xM3_pin_configs,
1634 [STAC_M5] = stac925xM5_pin_configs,
1635 [STAC_M6] = stac925xM6_pin_configs,
1638 static const char *stac925x_models[STAC_925x_MODELS] = {
1641 [STAC_M1_2] = "m1-2",
1643 [STAC_M2_2] = "m2-2",
1649 static struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1650 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1651 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1652 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1653 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1654 SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1655 /* Not sure about the brand name for those */
1656 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1657 SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1658 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1659 SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1663 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1664 /* SigmaTel reference board */
1665 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1666 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1668 /* Default table for unknown ID */
1669 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1674 static unsigned int ref92hd73xx_pin_configs[13] = {
1675 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1676 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1677 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1681 static unsigned int dell_m6_pin_configs[13] = {
1682 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1683 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1684 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1688 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1689 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1690 [STAC_DELL_M6_AMIC] = dell_m6_pin_configs,
1691 [STAC_DELL_M6_DMIC] = dell_m6_pin_configs,
1692 [STAC_DELL_M6_BOTH] = dell_m6_pin_configs,
1693 [STAC_DELL_EQ] = dell_m6_pin_configs,
1696 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1697 [STAC_92HD73XX_NO_JD] = "no-jd",
1698 [STAC_92HD73XX_REF] = "ref",
1699 [STAC_DELL_M6_AMIC] = "dell-m6-amic",
1700 [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1701 [STAC_DELL_M6_BOTH] = "dell-m6",
1702 [STAC_DELL_EQ] = "dell-eq",
1705 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1706 /* SigmaTel reference board */
1707 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1708 "DFI LanParty", STAC_92HD73XX_REF),
1709 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1710 "Dell Studio 1535", STAC_DELL_M6_DMIC),
1711 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1712 "unknown Dell", STAC_DELL_M6_DMIC),
1713 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1714 "unknown Dell", STAC_DELL_M6_BOTH),
1715 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1716 "unknown Dell", STAC_DELL_M6_BOTH),
1717 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1718 "unknown Dell", STAC_DELL_M6_AMIC),
1719 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1720 "unknown Dell", STAC_DELL_M6_AMIC),
1721 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1722 "unknown Dell", STAC_DELL_M6_DMIC),
1723 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1724 "unknown Dell", STAC_DELL_M6_DMIC),
1725 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1726 "Dell Studio 1537", STAC_DELL_M6_DMIC),
1727 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1728 "Dell Studio 17", STAC_DELL_M6_DMIC),
1732 static unsigned int ref92hd83xxx_pin_configs[14] = {
1733 0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1734 0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1735 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x40f000f0,
1736 0x01451160, 0x98560170,
1739 static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1740 [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1743 static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1744 [STAC_92HD83XXX_REF] = "ref",
1747 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1748 /* SigmaTel reference board */
1749 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1750 "DFI LanParty", STAC_92HD83XXX_REF),
1754 static unsigned int ref92hd71bxx_pin_configs[11] = {
1755 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1756 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1757 0x90a000f0, 0x01452050, 0x01452050,
1760 static unsigned int dell_m4_1_pin_configs[11] = {
1761 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1762 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1763 0x40f000f0, 0x4f0000f0, 0x4f0000f0,
1766 static unsigned int dell_m4_2_pin_configs[11] = {
1767 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1768 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1769 0x40f000f0, 0x044413b0, 0x044413b0,
1772 static unsigned int dell_m4_3_pin_configs[11] = {
1773 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1774 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1775 0x40f000f0, 0x044413b0, 0x044413b0,
1778 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1779 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1780 [STAC_DELL_M4_1] = dell_m4_1_pin_configs,
1781 [STAC_DELL_M4_2] = dell_m4_2_pin_configs,
1782 [STAC_DELL_M4_3] = dell_m4_3_pin_configs,
1783 [STAC_HP_M4] = NULL,
1784 [STAC_HP_DV5] = NULL,
1787 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1788 [STAC_92HD71BXX_REF] = "ref",
1789 [STAC_DELL_M4_1] = "dell-m4-1",
1790 [STAC_DELL_M4_2] = "dell-m4-2",
1791 [STAC_DELL_M4_3] = "dell-m4-3",
1792 [STAC_HP_M4] = "hp-m4",
1793 [STAC_HP_DV5] = "hp-dv5",
1796 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1797 /* SigmaTel reference board */
1798 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1799 "DFI LanParty", STAC_92HD71BXX_REF),
1800 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f2,
1801 "HP dv5", STAC_HP_M4),
1802 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f4,
1803 "HP dv7", STAC_HP_M4),
1804 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fc,
1805 "HP dv7", STAC_HP_M4),
1806 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3603,
1807 "HP dv5", STAC_HP_DV5),
1808 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1809 "unknown HP", STAC_HP_M4),
1810 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1811 "unknown Dell", STAC_DELL_M4_1),
1812 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1813 "unknown Dell", STAC_DELL_M4_1),
1814 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1815 "unknown Dell", STAC_DELL_M4_1),
1816 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1817 "unknown Dell", STAC_DELL_M4_1),
1818 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1819 "unknown Dell", STAC_DELL_M4_1),
1820 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1821 "unknown Dell", STAC_DELL_M4_1),
1822 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1823 "unknown Dell", STAC_DELL_M4_1),
1824 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1825 "unknown Dell", STAC_DELL_M4_2),
1826 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1827 "unknown Dell", STAC_DELL_M4_2),
1828 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1829 "unknown Dell", STAC_DELL_M4_2),
1830 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1831 "unknown Dell", STAC_DELL_M4_2),
1832 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1833 "unknown Dell", STAC_DELL_M4_3),
1837 static unsigned int ref922x_pin_configs[10] = {
1838 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1839 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1840 0x40000100, 0x40000100,
1844 STAC 922X pin configs for
1851 static unsigned int dell_922x_d81_pin_configs[10] = {
1852 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1853 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1854 0x01813122, 0x400001f2,
1858 STAC 922X pin configs for
1862 static unsigned int dell_922x_d82_pin_configs[10] = {
1863 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1864 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1865 0x01813122, 0x400001f1,
1869 STAC 922X pin configs for
1872 static unsigned int dell_922x_m81_pin_configs[10] = {
1873 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1874 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1875 0x40C003f1, 0x405003f0,
1879 STAC 9221 A1 pin configs for
1880 102801D7 (Dell XPS M1210)
1882 static unsigned int dell_922x_m82_pin_configs[10] = {
1883 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1884 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1885 0x508003f3, 0x405003f4,
1888 static unsigned int d945gtp3_pin_configs[10] = {
1889 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1890 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1891 0x02a19120, 0x40000100,
1894 static unsigned int d945gtp5_pin_configs[10] = {
1895 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1896 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1897 0x02a19320, 0x40000100,
1900 static unsigned int intel_mac_v1_pin_configs[10] = {
1901 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1902 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1903 0x400000fc, 0x400000fb,
1906 static unsigned int intel_mac_v2_pin_configs[10] = {
1907 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1908 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1909 0x400000fc, 0x400000fb,
1912 static unsigned int intel_mac_v3_pin_configs[10] = {
1913 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1914 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1915 0x400000fc, 0x400000fb,
1918 static unsigned int intel_mac_v4_pin_configs[10] = {
1919 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1920 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1921 0x400000fc, 0x400000fb,
1924 static unsigned int intel_mac_v5_pin_configs[10] = {
1925 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1926 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1927 0x400000fc, 0x400000fb,
1930 static unsigned int ecs202_pin_configs[10] = {
1931 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1932 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1933 0x9037012e, 0x40e000f2,
1936 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1937 [STAC_D945_REF] = ref922x_pin_configs,
1938 [STAC_D945GTP3] = d945gtp3_pin_configs,
1939 [STAC_D945GTP5] = d945gtp5_pin_configs,
1940 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1941 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1942 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1943 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1944 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1945 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1946 /* for backward compatibility */
1947 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1948 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1949 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1950 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1951 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1952 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1953 [STAC_ECS_202] = ecs202_pin_configs,
1954 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1955 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1956 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1957 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1960 static const char *stac922x_models[STAC_922X_MODELS] = {
1961 [STAC_D945_REF] = "ref",
1962 [STAC_D945GTP5] = "5stack",
1963 [STAC_D945GTP3] = "3stack",
1964 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1965 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1966 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1967 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1968 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1969 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1970 /* for backward compatibility */
1971 [STAC_MACMINI] = "macmini",
1972 [STAC_MACBOOK] = "macbook",
1973 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1974 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1975 [STAC_IMAC_INTEL] = "imac-intel",
1976 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1977 [STAC_ECS_202] = "ecs202",
1978 [STAC_922X_DELL_D81] = "dell-d81",
1979 [STAC_922X_DELL_D82] = "dell-d82",
1980 [STAC_922X_DELL_M81] = "dell-m81",
1981 [STAC_922X_DELL_M82] = "dell-m82",
1984 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1985 /* SigmaTel reference board */
1986 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1987 "DFI LanParty", STAC_D945_REF),
1988 /* Intel 945G based systems */
1989 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1990 "Intel D945G", STAC_D945GTP3),
1991 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1992 "Intel D945G", STAC_D945GTP3),
1993 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1994 "Intel D945G", STAC_D945GTP3),
1995 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1996 "Intel D945G", STAC_D945GTP3),
1997 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1998 "Intel D945G", STAC_D945GTP3),
1999 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
2000 "Intel D945G", STAC_D945GTP3),
2001 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
2002 "Intel D945G", STAC_D945GTP3),
2003 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
2004 "Intel D945G", STAC_D945GTP3),
2005 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
2006 "Intel D945G", STAC_D945GTP3),
2007 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
2008 "Intel D945G", STAC_D945GTP3),
2009 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
2010 "Intel D945G", STAC_D945GTP3),
2011 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
2012 "Intel D945G", STAC_D945GTP3),
2013 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
2014 "Intel D945G", STAC_D945GTP3),
2015 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
2016 "Intel D945G", STAC_D945GTP3),
2017 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
2018 "Intel D945G", STAC_D945GTP3),
2019 /* Intel D945G 5-stack systems */
2020 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
2021 "Intel D945G", STAC_D945GTP5),
2022 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
2023 "Intel D945G", STAC_D945GTP5),
2024 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
2025 "Intel D945G", STAC_D945GTP5),
2026 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
2027 "Intel D945G", STAC_D945GTP5),
2028 /* Intel 945P based systems */
2029 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
2030 "Intel D945P", STAC_D945GTP3),
2031 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
2032 "Intel D945P", STAC_D945GTP3),
2033 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
2034 "Intel D945P", STAC_D945GTP3),
2035 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
2036 "Intel D945P", STAC_D945GTP3),
2037 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
2038 "Intel D945P", STAC_D945GTP3),
2039 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
2040 "Intel D945P", STAC_D945GTP5),
2042 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
2043 SND_PCI_QUIRK(0x8384, 0x7680,
2044 "Mac", STAC_INTEL_MAC_AUTO),
2046 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
2047 "unknown Dell", STAC_922X_DELL_D81),
2048 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
2049 "unknown Dell", STAC_922X_DELL_D81),
2050 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
2051 "unknown Dell", STAC_922X_DELL_D81),
2052 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
2053 "unknown Dell", STAC_922X_DELL_D82),
2054 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
2055 "unknown Dell", STAC_922X_DELL_M81),
2056 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
2057 "unknown Dell", STAC_922X_DELL_D82),
2058 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
2059 "unknown Dell", STAC_922X_DELL_D81),
2060 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
2061 "unknown Dell", STAC_922X_DELL_D81),
2062 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
2063 "Dell XPS M1210", STAC_922X_DELL_M82),
2064 /* ECS/PC Chips boards */
2065 SND_PCI_QUIRK(0x1019, 0x2144,
2066 "ECS/PC chips", STAC_ECS_202),
2067 SND_PCI_QUIRK(0x1019, 0x2608,
2068 "ECS/PC chips", STAC_ECS_202),
2069 SND_PCI_QUIRK(0x1019, 0x2633,
2070 "ECS/PC chips P17G/1333", STAC_ECS_202),
2071 SND_PCI_QUIRK(0x1019, 0x2811,
2072 "ECS/PC chips", STAC_ECS_202),
2073 SND_PCI_QUIRK(0x1019, 0x2812,
2074 "ECS/PC chips", STAC_ECS_202),
2075 SND_PCI_QUIRK(0x1019, 0x2813,
2076 "ECS/PC chips", STAC_ECS_202),
2077 SND_PCI_QUIRK(0x1019, 0x2814,
2078 "ECS/PC chips", STAC_ECS_202),
2079 SND_PCI_QUIRK(0x1019, 0x2815,
2080 "ECS/PC chips", STAC_ECS_202),
2081 SND_PCI_QUIRK(0x1019, 0x2816,
2082 "ECS/PC chips", STAC_ECS_202),
2083 SND_PCI_QUIRK(0x1019, 0x2817,
2084 "ECS/PC chips", STAC_ECS_202),
2085 SND_PCI_QUIRK(0x1019, 0x2818,
2086 "ECS/PC chips", STAC_ECS_202),
2087 SND_PCI_QUIRK(0x1019, 0x2819,
2088 "ECS/PC chips", STAC_ECS_202),
2089 SND_PCI_QUIRK(0x1019, 0x2820,
2090 "ECS/PC chips", STAC_ECS_202),
2094 static unsigned int ref927x_pin_configs[14] = {
2095 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2096 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
2097 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2098 0x01c42190, 0x40000100,
2101 static unsigned int d965_3st_pin_configs[14] = {
2102 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2103 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2104 0x40000100, 0x40000100, 0x40000100, 0x40000100,
2105 0x40000100, 0x40000100
2108 static unsigned int d965_5st_pin_configs[14] = {
2109 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2110 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2111 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2112 0x40000100, 0x40000100
2115 static unsigned int dell_3st_pin_configs[14] = {
2116 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2117 0x01111212, 0x01116211, 0x01813050, 0x01112214,
2118 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2119 0x40c003fc, 0x40000100
2122 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2123 [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2124 [STAC_D965_REF] = ref927x_pin_configs,
2125 [STAC_D965_3ST] = d965_3st_pin_configs,
2126 [STAC_D965_5ST] = d965_5st_pin_configs,
2127 [STAC_DELL_3ST] = dell_3st_pin_configs,
2128 [STAC_DELL_BIOS] = NULL,
2131 static const char *stac927x_models[STAC_927X_MODELS] = {
2132 [STAC_D965_REF_NO_JD] = "ref-no-jd",
2133 [STAC_D965_REF] = "ref",
2134 [STAC_D965_3ST] = "3stack",
2135 [STAC_D965_5ST] = "5stack",
2136 [STAC_DELL_3ST] = "dell-3stack",
2137 [STAC_DELL_BIOS] = "dell-bios",
2140 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2141 /* SigmaTel reference board */
2142 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2143 "DFI LanParty", STAC_D965_REF),
2144 /* Intel 946 based systems */
2145 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2146 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2147 /* 965 based 3 stack systems */
2148 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
2149 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
2150 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
2151 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
2152 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
2153 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
2154 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
2155 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
2156 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
2157 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
2158 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
2159 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
2160 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
2161 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
2162 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
2163 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
2164 /* Dell 3 stack systems */
2165 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
2166 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2167 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
2168 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
2169 /* Dell 3 stack systems with verb table in BIOS */
2170 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2171 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
2172 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
2173 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_3ST),
2174 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
2175 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
2176 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
2177 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2178 /* 965 based 5 stack systems */
2179 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
2180 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
2181 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
2182 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
2183 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
2184 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
2185 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
2186 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
2187 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
2191 static unsigned int ref9205_pin_configs[12] = {
2192 0x40000100, 0x40000100, 0x01016011, 0x01014010,
2193 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2194 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2198 STAC 9205 pin configs for
2205 10280228 (Dell Vostro 1500)
2207 static unsigned int dell_9205_m42_pin_configs[12] = {
2208 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2209 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2210 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2214 STAC 9205 pin configs for
2218 102801FF (Dell Precision M4300)
2223 static unsigned int dell_9205_m43_pin_configs[12] = {
2224 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2225 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2226 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2229 static unsigned int dell_9205_m44_pin_configs[12] = {
2230 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2231 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2232 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2235 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2236 [STAC_9205_REF] = ref9205_pin_configs,
2237 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2238 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2239 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2242 static const char *stac9205_models[STAC_9205_MODELS] = {
2243 [STAC_9205_REF] = "ref",
2244 [STAC_9205_DELL_M42] = "dell-m42",
2245 [STAC_9205_DELL_M43] = "dell-m43",
2246 [STAC_9205_DELL_M44] = "dell-m44",
2249 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
2250 /* SigmaTel reference board */
2251 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2252 "DFI LanParty", STAC_9205_REF),
2253 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2254 "unknown Dell", STAC_9205_DELL_M42),
2255 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2256 "unknown Dell", STAC_9205_DELL_M42),
2257 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2258 "Dell Precision", STAC_9205_DELL_M43),
2259 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2260 "Dell Precision", STAC_9205_DELL_M43),
2261 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2262 "Dell Precision", STAC_9205_DELL_M43),
2263 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2264 "unknown Dell", STAC_9205_DELL_M42),
2265 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2266 "unknown Dell", STAC_9205_DELL_M42),
2267 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2268 "Dell Precision", STAC_9205_DELL_M43),
2269 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2270 "Dell Precision M4300", STAC_9205_DELL_M43),
2271 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2272 "unknown Dell", STAC_9205_DELL_M42),
2273 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2274 "Dell Precision", STAC_9205_DELL_M43),
2275 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2276 "Dell Precision", STAC_9205_DELL_M43),
2277 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2278 "Dell Precision", STAC_9205_DELL_M43),
2279 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2280 "Dell Inspiron", STAC_9205_DELL_M44),
2281 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2282 "Dell Vostro 1500", STAC_9205_DELL_M42),
2286 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
2289 struct sigmatel_spec *spec = codec->spec;
2291 kfree(spec->pin_configs);
2292 spec->pin_configs = kcalloc(spec->num_pins, sizeof(*spec->pin_configs),
2294 if (!spec->pin_configs)
2297 for (i = 0; i < spec->num_pins; i++) {
2298 hda_nid_t nid = spec->pin_nids[i];
2299 unsigned int pin_cfg;
2301 pin_cfg = snd_hda_codec_read(codec, nid, 0,
2302 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
2303 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
2305 spec->pin_configs[i] = pin_cfg;
2311 static void stac92xx_set_config_reg(struct hda_codec *codec,
2312 hda_nid_t pin_nid, unsigned int pin_config)
2315 snd_hda_codec_write(codec, pin_nid, 0,
2316 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
2317 pin_config & 0x000000ff);
2318 snd_hda_codec_write(codec, pin_nid, 0,
2319 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
2320 (pin_config & 0x0000ff00) >> 8);
2321 snd_hda_codec_write(codec, pin_nid, 0,
2322 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
2323 (pin_config & 0x00ff0000) >> 16);
2324 snd_hda_codec_write(codec, pin_nid, 0,
2325 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
2327 i = snd_hda_codec_read(codec, pin_nid, 0,
2328 AC_VERB_GET_CONFIG_DEFAULT,
2330 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
2334 static void stac92xx_set_config_regs(struct hda_codec *codec)
2337 struct sigmatel_spec *spec = codec->spec;
2339 if (!spec->pin_configs)
2342 for (i = 0; i < spec->num_pins; i++)
2343 stac92xx_set_config_reg(codec, spec->pin_nids[i],
2344 spec->pin_configs[i]);
2347 static int stac_save_pin_cfgs(struct hda_codec *codec, unsigned int *pins)
2349 struct sigmatel_spec *spec = codec->spec;
2352 return stac92xx_save_bios_config_regs(codec);
2354 kfree(spec->pin_configs);
2355 spec->pin_configs = kmemdup(pins,
2356 spec->num_pins * sizeof(*pins),
2358 if (!spec->pin_configs)
2361 stac92xx_set_config_regs(codec);
2365 static void stac_change_pin_config(struct hda_codec *codec, hda_nid_t nid,
2368 struct sigmatel_spec *spec = codec->spec;
2371 for (i = 0; i < spec->num_pins; i++) {
2372 if (spec->pin_nids[i] == nid) {
2373 spec->pin_configs[i] = cfg;
2374 stac92xx_set_config_reg(codec, nid, cfg);
2381 * Analog playback callbacks
2383 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2384 struct hda_codec *codec,
2385 struct snd_pcm_substream *substream)
2387 struct sigmatel_spec *spec = codec->spec;
2388 if (spec->stream_delay)
2389 msleep(spec->stream_delay);
2390 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2394 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2395 struct hda_codec *codec,
2396 unsigned int stream_tag,
2397 unsigned int format,
2398 struct snd_pcm_substream *substream)
2400 struct sigmatel_spec *spec = codec->spec;
2401 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2404 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2405 struct hda_codec *codec,
2406 struct snd_pcm_substream *substream)
2408 struct sigmatel_spec *spec = codec->spec;
2409 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2413 * Digital playback callbacks
2415 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2416 struct hda_codec *codec,
2417 struct snd_pcm_substream *substream)
2419 struct sigmatel_spec *spec = codec->spec;
2420 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2423 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2424 struct hda_codec *codec,
2425 struct snd_pcm_substream *substream)
2427 struct sigmatel_spec *spec = codec->spec;
2428 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2431 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2432 struct hda_codec *codec,
2433 unsigned int stream_tag,
2434 unsigned int format,
2435 struct snd_pcm_substream *substream)
2437 struct sigmatel_spec *spec = codec->spec;
2438 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2439 stream_tag, format, substream);
2444 * Analog capture callbacks
2446 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2447 struct hda_codec *codec,
2448 unsigned int stream_tag,
2449 unsigned int format,
2450 struct snd_pcm_substream *substream)
2452 struct sigmatel_spec *spec = codec->spec;
2453 hda_nid_t nid = spec->adc_nids[substream->number];
2455 if (spec->powerdown_adcs) {
2457 snd_hda_codec_write(codec, nid, 0,
2458 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2460 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2464 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2465 struct hda_codec *codec,
2466 struct snd_pcm_substream *substream)
2468 struct sigmatel_spec *spec = codec->spec;
2469 hda_nid_t nid = spec->adc_nids[substream->number];
2471 snd_hda_codec_cleanup_stream(codec, nid);
2472 if (spec->powerdown_adcs)
2473 snd_hda_codec_write(codec, nid, 0,
2474 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2478 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2482 /* NID is set in stac92xx_build_pcms */
2484 .open = stac92xx_dig_playback_pcm_open,
2485 .close = stac92xx_dig_playback_pcm_close,
2486 .prepare = stac92xx_dig_playback_pcm_prepare
2490 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2494 /* NID is set in stac92xx_build_pcms */
2497 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2501 .nid = 0x02, /* NID to query formats and rates */
2503 .open = stac92xx_playback_pcm_open,
2504 .prepare = stac92xx_playback_pcm_prepare,
2505 .cleanup = stac92xx_playback_pcm_cleanup
2509 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2513 .nid = 0x06, /* NID to query formats and rates */
2515 .open = stac92xx_playback_pcm_open,
2516 .prepare = stac92xx_playback_pcm_prepare,
2517 .cleanup = stac92xx_playback_pcm_cleanup
2521 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2524 /* NID + .substreams is set in stac92xx_build_pcms */
2526 .prepare = stac92xx_capture_pcm_prepare,
2527 .cleanup = stac92xx_capture_pcm_cleanup
2531 static int stac92xx_build_pcms(struct hda_codec *codec)
2533 struct sigmatel_spec *spec = codec->spec;
2534 struct hda_pcm *info = spec->pcm_rec;
2536 codec->num_pcms = 1;
2537 codec->pcm_info = info;
2539 info->name = "STAC92xx Analog";
2540 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2541 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2542 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2543 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2545 if (spec->alt_switch) {
2548 info->name = "STAC92xx Analog Alt";
2549 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2552 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2555 info->name = "STAC92xx Digital";
2556 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2557 if (spec->multiout.dig_out_nid) {
2558 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2559 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2561 if (spec->dig_in_nid) {
2562 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2563 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2570 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
2572 unsigned int pincap = snd_hda_param_read(codec, nid,
2574 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2575 if (pincap & AC_PINCAP_VREF_100)
2576 return AC_PINCTL_VREF_100;
2577 if (pincap & AC_PINCAP_VREF_80)
2578 return AC_PINCTL_VREF_80;
2579 if (pincap & AC_PINCAP_VREF_50)
2580 return AC_PINCTL_VREF_50;
2581 if (pincap & AC_PINCAP_VREF_GRD)
2582 return AC_PINCTL_VREF_GRD;
2586 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2589 snd_hda_codec_write_cache(codec, nid, 0,
2590 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2593 #define stac92xx_hp_switch_info snd_ctl_boolean_mono_info
2595 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2596 struct snd_ctl_elem_value *ucontrol)
2598 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2599 struct sigmatel_spec *spec = codec->spec;
2601 ucontrol->value.integer.value[0] = !!spec->hp_switch;
2605 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
2606 unsigned char type);
2608 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2609 struct snd_ctl_elem_value *ucontrol)
2611 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2612 struct sigmatel_spec *spec = codec->spec;
2613 int nid = kcontrol->private_value;
2615 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2617 /* check to be sure that the ports are upto date with
2620 stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
2625 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
2627 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2629 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2630 struct sigmatel_spec *spec = codec->spec;
2631 int io_idx = kcontrol-> private_value & 0xff;
2633 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
2637 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2639 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2640 struct sigmatel_spec *spec = codec->spec;
2641 hda_nid_t nid = kcontrol->private_value >> 8;
2642 int io_idx = kcontrol-> private_value & 0xff;
2643 unsigned short val = !!ucontrol->value.integer.value[0];
2645 spec->io_switch[io_idx] = val;
2648 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2650 unsigned int pinctl = AC_PINCTL_IN_EN;
2651 if (io_idx) /* set VREF for mic */
2652 pinctl |= stac92xx_get_vref(codec, nid);
2653 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2656 /* check the auto-mute again: we need to mute/unmute the speaker
2657 * appropriately according to the pin direction
2659 if (spec->hp_detect)
2660 stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
2665 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2667 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2668 struct snd_ctl_elem_value *ucontrol)
2670 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2671 struct sigmatel_spec *spec = codec->spec;
2673 ucontrol->value.integer.value[0] = spec->clfe_swap;
2677 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2678 struct snd_ctl_elem_value *ucontrol)
2680 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2681 struct sigmatel_spec *spec = codec->spec;
2682 hda_nid_t nid = kcontrol->private_value & 0xff;
2683 unsigned int val = !!ucontrol->value.integer.value[0];
2685 if (spec->clfe_swap == val)
2688 spec->clfe_swap = val;
2690 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2691 spec->clfe_swap ? 0x4 : 0x0);
2696 #define STAC_CODEC_HP_SWITCH(xname) \
2697 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2700 .info = stac92xx_hp_switch_info, \
2701 .get = stac92xx_hp_switch_get, \
2702 .put = stac92xx_hp_switch_put, \
2705 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2706 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2709 .info = stac92xx_io_switch_info, \
2710 .get = stac92xx_io_switch_get, \
2711 .put = stac92xx_io_switch_put, \
2712 .private_value = xpval, \
2715 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2716 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2719 .info = stac92xx_clfe_switch_info, \
2720 .get = stac92xx_clfe_switch_get, \
2721 .put = stac92xx_clfe_switch_put, \
2722 .private_value = xpval, \
2726 STAC_CTL_WIDGET_VOL,
2727 STAC_CTL_WIDGET_MUTE,
2728 STAC_CTL_WIDGET_MONO_MUX,
2729 STAC_CTL_WIDGET_AMP_MUX,
2730 STAC_CTL_WIDGET_AMP_VOL,
2731 STAC_CTL_WIDGET_HP_SWITCH,
2732 STAC_CTL_WIDGET_IO_SWITCH,
2733 STAC_CTL_WIDGET_CLFE_SWITCH
2736 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2737 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2738 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2741 STAC_AMP_VOL(NULL, 0, 0, 0, 0),
2742 STAC_CODEC_HP_SWITCH(NULL),
2743 STAC_CODEC_IO_SWITCH(NULL, 0),
2744 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2747 /* add dynamic controls */
2748 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2749 struct snd_kcontrol_new *ktemp,
2750 int idx, const char *name,
2753 struct snd_kcontrol_new *knew;
2755 snd_array_init(&spec->kctls, sizeof(*knew), 32);
2756 knew = snd_array_new(&spec->kctls);
2761 knew->name = kstrdup(name, GFP_KERNEL);
2764 knew->private_value = val;
2768 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2769 int type, int idx, const char *name,
2772 return stac92xx_add_control_temp(spec,
2773 &stac92xx_control_templates[type],
2778 /* add dynamic controls */
2779 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2780 const char *name, unsigned long val)
2782 return stac92xx_add_control_idx(spec, type, 0, name, val);
2785 /* check whether the line-input can be used as line-out */
2786 static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2788 struct sigmatel_spec *spec = codec->spec;
2789 struct auto_pin_cfg *cfg = &spec->autocfg;
2791 unsigned int pincap;
2793 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2795 nid = cfg->input_pins[AUTO_PIN_LINE];
2796 pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
2797 if (pincap & AC_PINCAP_OUT)
2802 /* check whether the mic-input can be used as line-out */
2803 static hda_nid_t check_mic_out_switch(struct hda_codec *codec)
2805 struct sigmatel_spec *spec = codec->spec;
2806 struct auto_pin_cfg *cfg = &spec->autocfg;
2807 unsigned int def_conf, pincap;
2808 unsigned int mic_pin;
2810 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2812 mic_pin = AUTO_PIN_MIC;
2814 hda_nid_t nid = cfg->input_pins[mic_pin];
2815 def_conf = snd_hda_codec_read(codec, nid, 0,
2816 AC_VERB_GET_CONFIG_DEFAULT, 0);
2817 /* some laptops have an internal analog microphone
2818 * which can't be used as a output */
2819 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2820 pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
2821 if (pincap & AC_PINCAP_OUT)
2824 if (mic_pin == AUTO_PIN_MIC)
2825 mic_pin = AUTO_PIN_FRONT_MIC;
2832 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2836 for (i = 0; i < spec->multiout.num_dacs; i++) {
2837 if (spec->multiout.dac_nids[i] == nid)
2844 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2847 if (is_in_dac_nids(spec, nid))
2849 for (i = 0; i < spec->autocfg.hp_outs; i++)
2850 if (spec->hp_dacs[i] == nid)
2852 for (i = 0; i < spec->autocfg.speaker_outs; i++)
2853 if (spec->speaker_dacs[i] == nid)
2858 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2860 struct sigmatel_spec *spec = codec->spec;
2862 hda_nid_t conn[HDA_MAX_CONNECTIONS];
2863 unsigned int wcaps, wtype;
2865 conn_len = snd_hda_get_connections(codec, nid, conn,
2866 HDA_MAX_CONNECTIONS);
2867 for (j = 0; j < conn_len; j++) {
2868 wcaps = snd_hda_param_read(codec, conn[j],
2869 AC_PAR_AUDIO_WIDGET_CAP);
2870 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2871 /* we check only analog outputs */
2872 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2874 /* if this route has a free DAC, assign it */
2875 if (!check_all_dac_nids(spec, conn[j])) {
2877 /* select this DAC in the pin's input mux */
2878 snd_hda_codec_write_cache(codec, nid, 0,
2879 AC_VERB_SET_CONNECT_SEL, j);
2887 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2888 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2891 * Fill in the dac_nids table from the parsed pin configuration
2892 * This function only works when every pin in line_out_pins[]
2893 * contains atleast one DAC in its connection list. Some 92xx
2894 * codecs are not connected directly to a DAC, such as the 9200
2895 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2897 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2899 struct sigmatel_spec *spec = codec->spec;
2900 struct auto_pin_cfg *cfg = &spec->autocfg;
2904 for (i = 0; i < cfg->line_outs; i++) {
2905 nid = cfg->line_out_pins[i];
2906 dac = get_unassigned_dac(codec, nid);
2908 if (spec->multiout.num_dacs > 0) {
2909 /* we have already working output pins,
2910 * so let's drop the broken ones again
2912 cfg->line_outs = spec->multiout.num_dacs;
2915 /* error out, no available DAC found */
2917 "%s: No available DAC for pin 0x%x\n",
2921 add_spec_dacs(spec, dac);
2924 /* add line-in as output */
2925 nid = check_line_out_switch(codec);
2927 dac = get_unassigned_dac(codec, nid);
2929 snd_printdd("STAC: Add line-in 0x%x as output %d\n",
2930 nid, cfg->line_outs);
2931 cfg->line_out_pins[cfg->line_outs] = nid;
2933 spec->line_switch = nid;
2934 add_spec_dacs(spec, dac);
2937 /* add mic as output */
2938 nid = check_mic_out_switch(codec);
2940 dac = get_unassigned_dac(codec, nid);
2942 snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
2943 nid, cfg->line_outs);
2944 cfg->line_out_pins[cfg->line_outs] = nid;
2946 spec->mic_switch = nid;
2947 add_spec_dacs(spec, dac);
2951 for (i = 0; i < cfg->hp_outs; i++) {
2952 nid = cfg->hp_pins[i];
2953 dac = get_unassigned_dac(codec, nid);
2955 if (!spec->multiout.hp_nid)
2956 spec->multiout.hp_nid = dac;
2958 add_spec_extra_dacs(spec, dac);
2960 spec->hp_dacs[i] = dac;
2963 for (i = 0; i < cfg->speaker_outs; i++) {
2964 nid = cfg->speaker_pins[i];
2965 dac = get_unassigned_dac(codec, nid);
2967 add_spec_extra_dacs(spec, dac);
2968 spec->speaker_dacs[i] = dac;
2971 snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2972 spec->multiout.num_dacs,
2973 spec->multiout.dac_nids[0],
2974 spec->multiout.dac_nids[1],
2975 spec->multiout.dac_nids[2],
2976 spec->multiout.dac_nids[3],
2977 spec->multiout.dac_nids[4]);
2982 /* create volume control/switch for the given prefx type */
2983 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
2988 sprintf(name, "%s Playback Volume", pfx);
2989 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
2990 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2993 sprintf(name, "%s Playback Switch", pfx);
2994 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
2995 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3001 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3003 if (spec->multiout.num_dacs > 4) {
3004 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3007 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
3008 spec->multiout.num_dacs++;
3013 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3016 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3017 if (!spec->multiout.extra_out_nid[i]) {
3018 spec->multiout.extra_out_nid[i] = nid;
3022 printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3026 static int is_unique_dac(struct sigmatel_spec *spec, hda_nid_t nid)
3030 if (spec->autocfg.line_outs != 1)
3032 if (spec->multiout.hp_nid == nid)
3034 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++)
3035 if (spec->multiout.extra_out_nid[i] == nid)
3040 /* add playback controls from the parsed DAC table */
3041 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3042 const struct auto_pin_cfg *cfg)
3044 struct sigmatel_spec *spec = codec->spec;
3045 static const char *chname[4] = {
3046 "Front", "Surround", NULL /*CLFE*/, "Side"
3050 unsigned int wid_caps;
3052 for (i = 0; i < cfg->line_outs && spec->multiout.dac_nids[i]; i++) {
3053 nid = spec->multiout.dac_nids[i];
3056 err = create_controls(spec, "Center", nid, 1);
3059 err = create_controls(spec, "LFE", nid, 2);
3063 wid_caps = get_wcaps(codec, nid);
3065 if (wid_caps & AC_WCAP_LR_SWAP) {
3066 err = stac92xx_add_control(spec,
3067 STAC_CTL_WIDGET_CLFE_SWITCH,
3068 "Swap Center/LFE Playback Switch", nid);
3075 const char *name = chname[i];
3076 /* if it's a single DAC, assign a better name */
3077 if (!i && is_unique_dac(spec, nid)) {
3078 switch (cfg->line_out_type) {
3079 case AUTO_PIN_HP_OUT:
3082 case AUTO_PIN_SPEAKER_OUT:
3087 err = create_controls(spec, name, nid, 3);
3093 if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3094 err = stac92xx_add_control(spec,
3095 STAC_CTL_WIDGET_HP_SWITCH,
3096 "Headphone as Line Out Switch",
3097 cfg->hp_pins[cfg->hp_outs - 1]);
3102 if (spec->line_switch) {
3103 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
3104 "Line In as Output Switch",
3105 spec->line_switch << 8);
3110 if (spec->mic_switch) {
3111 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
3112 "Mic as Output Switch",
3113 (spec->mic_switch << 8) | 1);
3121 /* add playback controls for Speaker and HP outputs */
3122 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3123 struct auto_pin_cfg *cfg)
3125 struct sigmatel_spec *spec = codec->spec;
3130 for (i = 0; i < cfg->hp_outs; i++) {
3131 static const char *pfxs[] = {
3132 "Headphone", "Headphone2", "Headphone3",
3134 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
3135 if (wid_caps & AC_WCAP_UNSOL_CAP)
3136 spec->hp_detect = 1;
3137 if (nums >= ARRAY_SIZE(pfxs))
3139 nid = spec->hp_dacs[i];
3142 err = create_controls(spec, pfxs[nums++], nid, 3);
3147 for (i = 0; i < cfg->speaker_outs; i++) {
3148 static const char *pfxs[] = {
3149 "Speaker", "External Speaker", "Speaker2",
3151 if (nums >= ARRAY_SIZE(pfxs))
3153 nid = spec->speaker_dacs[i];
3156 err = create_controls(spec, pfxs[nums++], nid, 3);
3163 /* labels for mono mux outputs */
3164 static const char *stac92xx_mono_labels[4] = {
3165 "DAC0", "DAC1", "Mixer", "DAC2"
3168 /* create mono mux for mono out on capable codecs */
3169 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3171 struct sigmatel_spec *spec = codec->spec;
3172 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3174 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3176 num_cons = snd_hda_get_connections(codec,
3179 HDA_MAX_NUM_INPUTS);
3180 if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3183 for (i = 0; i < num_cons; i++) {
3184 mono_mux->items[mono_mux->num_items].label =
3185 stac92xx_mono_labels[i];
3186 mono_mux->items[mono_mux->num_items].index = i;
3187 mono_mux->num_items++;
3190 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3191 "Mono Mux", spec->mono_nid);
3194 /* labels for amp mux outputs */
3195 static const char *stac92xx_amp_labels[3] = {
3196 "Front Microphone", "Microphone", "Line In",
3199 /* create amp out controls mux on capable codecs */
3200 static int stac92xx_auto_create_amp_output_ctls(struct hda_codec *codec)
3202 struct sigmatel_spec *spec = codec->spec;
3203 struct hda_input_mux *amp_mux = &spec->private_amp_mux;
3206 for (i = 0; i < spec->num_amps; i++) {
3207 amp_mux->items[amp_mux->num_items].label =
3208 stac92xx_amp_labels[i];
3209 amp_mux->items[amp_mux->num_items].index = i;
3210 amp_mux->num_items++;
3213 if (spec->num_amps > 1) {
3214 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_MUX,
3215 "Amp Selector Capture Switch", 0);
3219 return stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_VOL,
3220 "Amp Capture Volume",
3221 HDA_COMPOSE_AMP_VAL(spec->amp_nids[0], 3, 0, HDA_INPUT));
3225 /* create PC beep volume controls */
3226 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3229 struct sigmatel_spec *spec = codec->spec;
3230 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3233 /* check for mute support for the the amp */
3234 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3235 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3236 "PC Beep Playback Switch",
3237 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3242 /* check to see if there is volume support for the amp */
3243 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3244 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3245 "PC Beep Playback Volume",
3246 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3253 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3254 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3256 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3257 struct snd_ctl_elem_value *ucontrol)
3259 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3260 ucontrol->value.integer.value[0] = codec->beep->enabled;
3264 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3265 struct snd_ctl_elem_value *ucontrol)
3267 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3268 int enabled = !!ucontrol->value.integer.value[0];
3269 if (codec->beep->enabled != enabled) {
3270 codec->beep->enabled = enabled;
3276 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3277 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3278 .info = stac92xx_dig_beep_switch_info,
3279 .get = stac92xx_dig_beep_switch_get,
3280 .put = stac92xx_dig_beep_switch_put,
3283 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3285 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3286 0, "PC Beep Playback Switch", 0);
3290 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3292 struct sigmatel_spec *spec = codec->spec;
3293 int wcaps, nid, i, err = 0;
3295 for (i = 0; i < spec->num_muxes; i++) {
3296 nid = spec->mux_nids[i];
3297 wcaps = get_wcaps(codec, nid);
3299 if (wcaps & AC_WCAP_OUT_AMP) {
3300 err = stac92xx_add_control_idx(spec,
3301 STAC_CTL_WIDGET_VOL, i, "Mux Capture Volume",
3302 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3310 static const char *stac92xx_spdif_labels[3] = {
3311 "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3314 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3316 struct sigmatel_spec *spec = codec->spec;
3317 struct hda_input_mux *spdif_mux = &spec->private_smux;
3318 const char **labels = spec->spdif_labels;
3320 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3322 num_cons = snd_hda_get_connections(codec,
3325 HDA_MAX_NUM_INPUTS);
3330 labels = stac92xx_spdif_labels;
3332 for (i = 0; i < num_cons; i++) {
3333 spdif_mux->items[spdif_mux->num_items].label = labels[i];
3334 spdif_mux->items[spdif_mux->num_items].index = i;
3335 spdif_mux->num_items++;
3341 /* labels for dmic mux inputs */
3342 static const char *stac92xx_dmic_labels[5] = {
3343 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3344 "Digital Mic 3", "Digital Mic 4"
3347 /* create playback/capture controls for input pins on dmic capable codecs */
3348 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3349 const struct auto_pin_cfg *cfg)
3351 struct sigmatel_spec *spec = codec->spec;
3352 struct hda_input_mux *dimux = &spec->private_dimux;
3353 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3357 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
3358 dimux->items[dimux->num_items].index = 0;
3361 for (i = 0; i < spec->num_dmics; i++) {
3366 unsigned int def_conf;
3368 def_conf = snd_hda_codec_read(codec,
3371 AC_VERB_GET_CONFIG_DEFAULT,
3373 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3376 nid = spec->dmic_nids[i];
3377 num_cons = snd_hda_get_connections(codec,
3380 HDA_MAX_NUM_INPUTS);
3381 for (j = 0; j < num_cons; j++)
3382 if (con_lst[j] == nid) {
3388 wcaps = get_wcaps(codec, nid) &
3389 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3392 sprintf(name, "%s Capture Volume",
3393 stac92xx_dmic_labels[dimux->num_items]);
3395 err = stac92xx_add_control(spec,
3396 STAC_CTL_WIDGET_VOL,
3398 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3399 (wcaps & AC_WCAP_OUT_AMP) ?
3400 HDA_OUTPUT : HDA_INPUT));
3405 dimux->items[dimux->num_items].label =
3406 stac92xx_dmic_labels[dimux->num_items];
3407 dimux->items[dimux->num_items].index = index;
3414 /* create playback/capture controls for input pins */
3415 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3417 struct sigmatel_spec *spec = codec->spec;
3418 struct hda_input_mux *imux = &spec->private_imux;
3419 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3422 for (i = 0; i < AUTO_PIN_LAST; i++) {
3425 if (!cfg->input_pins[i])
3428 for (j = 0; j < spec->num_muxes; j++) {
3430 num_cons = snd_hda_get_connections(codec,
3433 HDA_MAX_NUM_INPUTS);
3434 for (k = 0; k < num_cons; k++)
3435 if (con_lst[k] == cfg->input_pins[i]) {
3442 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3443 imux->items[imux->num_items].index = index;
3447 if (imux->num_items) {
3449 * Set the current input for the muxes.
3450 * The STAC9221 has two input muxes with identical source
3451 * NID lists. Hopefully this won't get confused.
3453 for (i = 0; i < spec->num_muxes; i++) {
3454 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3455 AC_VERB_SET_CONNECT_SEL,
3456 imux->items[0].index);
3463 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3465 struct sigmatel_spec *spec = codec->spec;
3468 for (i = 0; i < spec->autocfg.line_outs; i++) {
3469 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3470 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3474 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3476 struct sigmatel_spec *spec = codec->spec;
3479 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3481 pin = spec->autocfg.hp_pins[i];
3482 if (pin) /* connect to front */
3483 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3485 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3487 pin = spec->autocfg.speaker_pins[i];
3488 if (pin) /* connect to front */
3489 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3493 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3495 struct sigmatel_spec *spec = codec->spec;
3498 if ((err = snd_hda_parse_pin_def_config(codec,
3500 spec->dmic_nids)) < 0)
3502 if (! spec->autocfg.line_outs)
3503 return 0; /* can't find valid pin config */
3505 /* If we have no real line-out pin and multiple hp-outs, HPs should
3506 * be set up as multi-channel outputs.
3508 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
3509 spec->autocfg.hp_outs > 1) {
3510 /* Copy hp_outs to line_outs, backup line_outs in
3511 * speaker_outs so that the following routines can handle
3512 * HP pins as primary outputs.
3514 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3515 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3516 sizeof(spec->autocfg.line_out_pins));
3517 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3518 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3519 sizeof(spec->autocfg.hp_pins));
3520 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3521 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3522 spec->autocfg.hp_outs = 0;
3524 if (spec->autocfg.mono_out_pin) {
3525 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3526 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3527 u32 caps = query_amp_caps(codec,
3528 spec->autocfg.mono_out_pin, dir);
3529 hda_nid_t conn_list[1];
3531 /* get the mixer node and then the mono mux if it exists */
3532 if (snd_hda_get_connections(codec,
3533 spec->autocfg.mono_out_pin, conn_list, 1) &&
3534 snd_hda_get_connections(codec, conn_list[0],
3537 int wcaps = get_wcaps(codec, conn_list[0]);
3538 int wid_type = (wcaps & AC_WCAP_TYPE)
3539 >> AC_WCAP_TYPE_SHIFT;
3540 /* LR swap check, some stac925x have a mux that
3541 * changes the DACs output path instead of the
3544 if (wid_type == AC_WID_AUD_SEL &&
3545 !(wcaps & AC_WCAP_LR_SWAP))
3546 spec->mono_nid = conn_list[0];
3549 hda_nid_t nid = spec->autocfg.mono_out_pin;
3551 /* most mono outs have a least a mute/unmute switch */
3552 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3553 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3554 "Mono Playback Switch",
3555 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3558 /* check for volume support for the amp */
3559 if ((caps & AC_AMPCAP_NUM_STEPS)
3560 >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3561 err = stac92xx_add_control(spec,
3562 STAC_CTL_WIDGET_VOL,
3563 "Mono Playback Volume",
3564 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3570 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3574 if (!spec->multiout.num_dacs) {
3575 err = stac92xx_auto_fill_dac_nids(codec);
3578 err = stac92xx_auto_create_multi_out_ctls(codec,
3584 /* setup analog beep controls */
3585 if (spec->anabeep_nid > 0) {
3586 err = stac92xx_auto_create_beep_ctls(codec,
3592 /* setup digital beep controls and input device */
3593 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3594 if (spec->digbeep_nid > 0) {
3595 hda_nid_t nid = spec->digbeep_nid;
3598 err = stac92xx_auto_create_beep_ctls(codec, nid);
3601 err = snd_hda_attach_beep_device(codec, nid);
3604 /* if no beep switch is available, make its own one */
3605 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3607 !((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT)) {
3608 err = stac92xx_beep_switch_ctl(codec);
3615 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3620 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3625 if (spec->mono_nid > 0) {
3626 err = stac92xx_auto_create_mono_output_ctls(codec);
3630 if (spec->num_amps > 0) {
3631 err = stac92xx_auto_create_amp_output_ctls(codec);
3635 if (spec->num_dmics > 0 && !spec->dinput_mux)
3636 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3637 &spec->autocfg)) < 0)
3639 if (spec->num_muxes > 0) {
3640 err = stac92xx_auto_create_mux_input_ctls(codec);
3644 if (spec->num_smuxes > 0) {
3645 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3650 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3651 if (spec->multiout.max_channels > 2)
3652 spec->surr_switch = 1;
3654 if (spec->autocfg.dig_out_pin)
3655 spec->multiout.dig_out_nid = dig_out;
3656 if (dig_in && spec->autocfg.dig_in_pin)
3657 spec->dig_in_nid = dig_in;
3659 if (spec->kctls.list)
3660 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3662 spec->input_mux = &spec->private_imux;
3663 if (!spec->dinput_mux)
3664 spec->dinput_mux = &spec->private_dimux;
3665 spec->sinput_mux = &spec->private_smux;
3666 spec->mono_mux = &spec->private_mono_mux;
3667 spec->amp_mux = &spec->private_amp_mux;
3671 /* add playback controls for HP output */
3672 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3673 struct auto_pin_cfg *cfg)
3675 struct sigmatel_spec *spec = codec->spec;
3676 hda_nid_t pin = cfg->hp_pins[0];
3677 unsigned int wid_caps;
3682 wid_caps = get_wcaps(codec, pin);
3683 if (wid_caps & AC_WCAP_UNSOL_CAP)
3684 spec->hp_detect = 1;
3689 /* add playback controls for LFE output */
3690 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3691 struct auto_pin_cfg *cfg)
3693 struct sigmatel_spec *spec = codec->spec;
3695 hda_nid_t lfe_pin = 0x0;
3699 * search speaker outs and line outs for a mono speaker pin
3700 * with an amp. If one is found, add LFE controls
3703 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3704 hda_nid_t pin = spec->autocfg.speaker_pins[i];
3705 unsigned int wcaps = get_wcaps(codec, pin);
3706 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3707 if (wcaps == AC_WCAP_OUT_AMP)
3708 /* found a mono speaker with an amp, must be lfe */
3712 /* if speaker_outs is 0, then speakers may be in line_outs */
3713 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3714 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3715 hda_nid_t pin = spec->autocfg.line_out_pins[i];
3716 unsigned int defcfg;
3717 defcfg = snd_hda_codec_read(codec, pin, 0,
3718 AC_VERB_GET_CONFIG_DEFAULT,
3720 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3721 unsigned int wcaps = get_wcaps(codec, pin);
3722 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3723 if (wcaps == AC_WCAP_OUT_AMP)
3724 /* found a mono speaker with an amp,
3732 err = create_controls(spec, "LFE", lfe_pin, 1);
3740 static int stac9200_parse_auto_config(struct hda_codec *codec)
3742 struct sigmatel_spec *spec = codec->spec;
3745 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3748 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3751 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
3754 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
3757 if (spec->num_muxes > 0) {
3758 err = stac92xx_auto_create_mux_input_ctls(codec);
3763 if (spec->autocfg.dig_out_pin)
3764 spec->multiout.dig_out_nid = 0x05;
3765 if (spec->autocfg.dig_in_pin)
3766 spec->dig_in_nid = 0x04;
3768 if (spec->kctls.list)
3769 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3771 spec->input_mux = &spec->private_imux;
3772 spec->dinput_mux = &spec->private_dimux;
3778 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
3779 * funky external mute control using GPIO pins.
3782 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
3783 unsigned int dir_mask, unsigned int data)
3785 unsigned int gpiostate, gpiomask, gpiodir;
3787 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
3788 AC_VERB_GET_GPIO_DATA, 0);
3789 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
3791 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
3792 AC_VERB_GET_GPIO_MASK, 0);
3795 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
3796 AC_VERB_GET_GPIO_DIRECTION, 0);
3797 gpiodir |= dir_mask;
3799 /* Configure GPIOx as CMOS */
3800 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
3802 snd_hda_codec_write(codec, codec->afg, 0,
3803 AC_VERB_SET_GPIO_MASK, gpiomask);
3804 snd_hda_codec_read(codec, codec->afg, 0,
3805 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
3809 snd_hda_codec_read(codec, codec->afg, 0,
3810 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
3813 static int stac92xx_add_jack(struct hda_codec *codec,
3814 hda_nid_t nid, int type)
3816 #ifdef CONFIG_SND_JACK
3817 struct sigmatel_spec *spec = codec->spec;
3818 struct sigmatel_jack *jack;
3819 int def_conf = snd_hda_codec_read(codec, nid,
3820 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
3821 int connectivity = get_defcfg_connect(def_conf);
3824 if (connectivity && connectivity != AC_JACK_PORT_FIXED)
3827 snd_array_init(&spec->jacks, sizeof(*jack), 32);
3828 jack = snd_array_new(&spec->jacks);
3834 sprintf(name, "%s at %s %s Jack",
3835 snd_hda_get_jack_type(def_conf),
3836 snd_hda_get_jack_connectivity(def_conf),
3837 snd_hda_get_jack_location(def_conf));
3839 return snd_jack_new(codec->bus->card, name, type, &jack->jack);
3845 static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
3846 unsigned char type, int data)
3848 struct sigmatel_event *event;
3850 snd_array_init(&spec->events, sizeof(*event), 32);
3851 event = snd_array_new(&spec->events);
3856 event->tag = spec->events.used;
3862 static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
3863 hda_nid_t nid, unsigned char type)
3865 struct sigmatel_spec *spec = codec->spec;
3866 struct sigmatel_event *event = spec->events.list;
3869 for (i = 0; i < spec->events.used; i++, event++) {
3870 if (event->nid == nid && event->type == type)
3876 static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
3879 struct sigmatel_spec *spec = codec->spec;
3880 struct sigmatel_event *event = spec->events.list;
3883 for (i = 0; i < spec->events.used; i++, event++) {
3884 if (event->tag == tag)
3890 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
3893 struct sigmatel_event *event;
3896 if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
3898 event = stac_get_event(codec, nid, type);
3902 tag = stac_add_event(codec->spec, nid, type, 0);
3905 snd_hda_codec_write_cache(codec, nid, 0,
3906 AC_VERB_SET_UNSOLICITED_ENABLE,
3910 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
3913 for (i = 0; i < cfg->hp_outs; i++)
3914 if (cfg->hp_pins[i] == nid)
3915 return 1; /* nid is a HP-Out */
3917 return 0; /* nid is not a HP-Out */
3920 static void stac92xx_power_down(struct hda_codec *codec)
3922 struct sigmatel_spec *spec = codec->spec;
3924 /* power down inactive DACs */
3926 for (dac = spec->dac_list; *dac; dac++)
3927 if (!check_all_dac_nids(spec, *dac))
3928 snd_hda_codec_write(codec, *dac, 0,
3929 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3932 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
3935 static int stac92xx_init(struct hda_codec *codec)
3937 struct sigmatel_spec *spec = codec->spec;
3938 struct auto_pin_cfg *cfg = &spec->autocfg;
3942 snd_hda_sequence_write(codec, spec->init);
3944 /* power down adcs initially */
3945 if (spec->powerdown_adcs)
3946 for (i = 0; i < spec->num_adcs; i++)
3947 snd_hda_codec_write(codec,
3948 spec->adc_nids[i], 0,
3949 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3952 gpio = spec->gpio_data;
3953 /* turn on EAPD statically when spec->eapd_switch isn't set.
3954 * otherwise, unsol event will turn it on/off dynamically
3956 if (!spec->eapd_switch)
3957 gpio |= spec->eapd_mask;
3958 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
3961 if (spec->hp_detect) {
3962 /* Enable unsolicited responses on the HP widget */
3963 for (i = 0; i < cfg->hp_outs; i++) {
3964 hda_nid_t nid = cfg->hp_pins[i];
3965 enable_pin_detect(codec, nid, STAC_HP_EVENT);
3967 /* force to enable the first line-out; the others are set up
3970 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
3972 /* fake event to set up pins */
3973 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
3976 stac92xx_auto_init_multi_out(codec);
3977 stac92xx_auto_init_hp_out(codec);
3978 for (i = 0; i < cfg->hp_outs; i++)
3979 stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
3981 for (i = 0; i < AUTO_PIN_LAST; i++) {
3982 hda_nid_t nid = cfg->input_pins[i];
3984 unsigned int pinctl, conf;
3985 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
3986 /* for mic pins, force to initialize */
3987 pinctl = stac92xx_get_vref(codec, nid);
3988 pinctl |= AC_PINCTL_IN_EN;
3989 stac92xx_auto_set_pinctl(codec, nid, pinctl);
3991 pinctl = snd_hda_codec_read(codec, nid, 0,
3992 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3993 /* if PINCTL already set then skip */
3994 if (!(pinctl & AC_PINCTL_IN_EN)) {
3995 pinctl |= AC_PINCTL_IN_EN;
3996 stac92xx_auto_set_pinctl(codec, nid,
4000 conf = snd_hda_codec_read(codec, nid, 0,
4001 AC_VERB_GET_CONFIG_DEFAULT, 0);
4002 if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
4003 enable_pin_detect(codec, nid,
4005 stac_issue_unsol_event(codec, nid,
4010 for (i = 0; i < spec->num_dmics; i++)
4011 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4013 if (cfg->dig_out_pin)
4014 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
4016 if (cfg->dig_in_pin)
4017 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4019 for (i = 0; i < spec->num_pwrs; i++) {
4020 hda_nid_t nid = spec->pwr_nids[i];
4021 int pinctl, def_conf;
4023 /* power on when no jack detection is available */
4024 if (!spec->hp_detect) {
4025 stac_toggle_power_map(codec, nid, 1);
4029 if (is_nid_hp_pin(cfg, nid))
4030 continue; /* already has an unsol event */
4032 pinctl = snd_hda_codec_read(codec, nid, 0,
4033 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4034 /* outputs are only ports capable of power management
4035 * any attempts on powering down a input port cause the
4036 * referenced VREF to act quirky.
4038 if (pinctl & AC_PINCTL_IN_EN) {
4039 stac_toggle_power_map(codec, nid, 1);
4042 def_conf = snd_hda_codec_read(codec, nid, 0,
4043 AC_VERB_GET_CONFIG_DEFAULT, 0);
4044 def_conf = get_defcfg_connect(def_conf);
4045 /* skip any ports that don't have jacks since presence
4046 * detection is useless */
4047 if (def_conf != AC_JACK_PORT_COMPLEX) {
4048 if (def_conf != AC_JACK_PORT_NONE)
4049 stac_toggle_power_map(codec, nid, 1);
4052 if (!stac_get_event(codec, nid, STAC_INSERT_EVENT)) {
4053 enable_pin_detect(codec, nid, STAC_PWR_EVENT);
4054 stac_issue_unsol_event(codec, nid, STAC_PWR_EVENT);
4058 stac92xx_power_down(codec);
4062 static void stac92xx_free_jacks(struct hda_codec *codec)
4064 #ifdef CONFIG_SND_JACK
4065 /* free jack instances manually when clearing/reconfiguring */
4066 struct sigmatel_spec *spec = codec->spec;
4067 if (!codec->bus->shutdown && spec->jacks.list) {
4068 struct sigmatel_jack *jacks = spec->jacks.list;
4070 for (i = 0; i < spec->jacks.used; i++)
4071 snd_device_free(codec->bus->card, &jacks[i].jack);
4073 snd_array_free(&spec->jacks);
4077 static void stac92xx_free_kctls(struct hda_codec *codec)
4079 struct sigmatel_spec *spec = codec->spec;
4081 if (spec->kctls.list) {
4082 struct snd_kcontrol_new *kctl = spec->kctls.list;
4084 for (i = 0; i < spec->kctls.used; i++)
4085 kfree(kctl[i].name);
4087 snd_array_free(&spec->kctls);
4090 static void stac92xx_free(struct hda_codec *codec)
4092 struct sigmatel_spec *spec = codec->spec;
4097 kfree(spec->pin_configs);
4098 stac92xx_free_jacks(codec);
4099 snd_array_free(&spec->events);
4102 snd_hda_detach_beep_device(codec);
4105 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4108 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4109 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4111 if (pin_ctl & AC_PINCTL_IN_EN) {
4113 * we need to check the current set-up direction of
4114 * shared input pins since they can be switched via
4115 * "xxx as Output" mixer switch
4117 struct sigmatel_spec *spec = codec->spec;
4118 if (nid == spec->line_switch || nid == spec->mic_switch)
4122 /* if setting pin direction bits, clear the current
4123 direction bits first */
4124 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4125 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4127 snd_hda_codec_write_cache(codec, nid, 0,
4128 AC_VERB_SET_PIN_WIDGET_CONTROL,
4132 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4135 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4136 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4137 snd_hda_codec_write_cache(codec, nid, 0,
4138 AC_VERB_SET_PIN_WIDGET_CONTROL,
4142 static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4146 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
4152 /* return non-zero if the hp-pin of the given array index isn't
4153 * a jack-detection target
4155 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4157 struct auto_pin_cfg *cfg = &spec->autocfg;
4159 /* ignore sensing of shared line and mic jacks */
4160 if (cfg->hp_pins[i] == spec->line_switch)
4162 if (cfg->hp_pins[i] == spec->mic_switch)
4164 /* ignore if the pin is set as line-out */
4165 if (cfg->hp_pins[i] == spec->hp_switch)
4170 static void stac92xx_hp_detect(struct hda_codec *codec)
4172 struct sigmatel_spec *spec = codec->spec;
4173 struct auto_pin_cfg *cfg = &spec->autocfg;
4177 if (spec->gpio_mute)
4178 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4179 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4181 for (i = 0; i < cfg->hp_outs; i++) {
4184 if (no_hp_sensing(spec, i))
4186 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4188 unsigned int pinctl;
4189 pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4190 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4191 if (pinctl & AC_PINCTL_IN_EN)
4192 presence = 0; /* mic- or line-input */
4197 /* disable lineouts */
4198 if (spec->hp_switch)
4199 stac92xx_reset_pinctl(codec, spec->hp_switch,
4201 for (i = 0; i < cfg->line_outs; i++)
4202 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4204 for (i = 0; i < cfg->speaker_outs; i++)
4205 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4207 if (spec->eapd_mask && spec->eapd_switch)
4208 stac_gpio_set(codec, spec->gpio_mask,
4209 spec->gpio_dir, spec->gpio_data &
4212 /* enable lineouts */
4213 if (spec->hp_switch)
4214 stac92xx_set_pinctl(codec, spec->hp_switch,
4216 for (i = 0; i < cfg->line_outs; i++)
4217 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4219 for (i = 0; i < cfg->speaker_outs; i++)
4220 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4222 if (spec->eapd_mask && spec->eapd_switch)
4223 stac_gpio_set(codec, spec->gpio_mask,
4224 spec->gpio_dir, spec->gpio_data |
4227 /* toggle hp outs */
4228 for (i = 0; i < cfg->hp_outs; i++) {
4229 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4230 if (no_hp_sensing(spec, i))
4233 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4235 /* Resetting the pinctl like below may lead to (a sort of) regressions
4236 * on some devices since they use the HP pin actually for line/speaker
4237 * outs although the default pin config shows a different pin (that is
4238 * wrong and useless).
4240 * So, it's basically a problem of default pin configs, likely a BIOS issue.
4241 * But, disabling the code below just works around it, and I'm too tired of
4242 * bug reports with such devices...
4245 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4250 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4253 struct sigmatel_spec *spec = codec->spec;
4254 unsigned int idx, val;
4256 for (idx = 0; idx < spec->num_pwrs; idx++) {
4257 if (spec->pwr_nids[idx] == nid)
4260 if (idx >= spec->num_pwrs)
4263 /* several codecs have two power down bits */
4264 if (spec->pwr_mapping)
4265 idx = spec->pwr_mapping[idx];
4269 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
4275 /* power down unused output ports */
4276 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4279 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4281 stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4284 static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
4286 struct sigmatel_spec *spec = codec->spec;
4287 struct sigmatel_jack *jacks = spec->jacks.list;
4291 for (i = 0; i < spec->jacks.used; i++) {
4292 if (jacks->nid == nid) {
4293 unsigned int pin_ctl =
4294 snd_hda_codec_read(codec, nid,
4295 0, AC_VERB_GET_PIN_WIDGET_CONTROL,
4297 int type = jacks->type;
4298 if (type == (SND_JACK_LINEOUT
4299 | SND_JACK_HEADPHONE))
4300 type = (pin_ctl & AC_PINCTL_HP_EN)
4301 ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
4302 snd_jack_report(jacks->jack,
4303 get_pin_presence(codec, nid)
4311 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
4314 struct sigmatel_event *event = stac_get_event(codec, nid, type);
4317 codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
4320 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4322 struct sigmatel_spec *spec = codec->spec;
4323 struct sigmatel_event *event;
4326 tag = (res >> 26) & 0x7f;
4327 event = stac_get_event_from_tag(codec, tag);
4331 switch (event->type) {
4333 stac92xx_hp_detect(codec);
4335 case STAC_INSERT_EVENT:
4336 case STAC_PWR_EVENT:
4337 if (spec->num_pwrs > 0)
4338 stac92xx_pin_sense(codec, event->nid);
4339 stac92xx_report_jack(codec, event->nid);
4341 case STAC_VREF_EVENT:
4342 data = snd_hda_codec_read(codec, codec->afg, 0,
4343 AC_VERB_GET_GPIO_DATA, 0);
4344 /* toggle VREF state based on GPIOx status */
4345 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4346 !!(data & (1 << event->data)));
4351 #ifdef CONFIG_PROC_FS
4352 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4353 struct hda_codec *codec, hda_nid_t nid)
4355 if (nid == codec->afg)
4356 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4357 snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
4360 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4361 struct hda_codec *codec,
4364 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4365 snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
4368 /* stac92hd71bxx, stac92hd73xx */
4369 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4370 struct hda_codec *codec, hda_nid_t nid)
4372 stac92hd_proc_hook(buffer, codec, nid);
4373 if (nid == codec->afg)
4374 analog_loop_proc_hook(buffer, codec, 0xfa0);
4377 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4378 struct hda_codec *codec, hda_nid_t nid)
4380 if (nid == codec->afg)
4381 analog_loop_proc_hook(buffer, codec, 0xfe0);
4384 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4385 struct hda_codec *codec, hda_nid_t nid)
4387 if (nid == codec->afg)
4388 analog_loop_proc_hook(buffer, codec, 0xfeb);
4391 #define stac92hd_proc_hook NULL
4392 #define stac92hd7x_proc_hook NULL
4393 #define stac9205_proc_hook NULL
4394 #define stac927x_proc_hook NULL
4397 #ifdef SND_HDA_NEEDS_RESUME
4398 static int stac92xx_resume(struct hda_codec *codec)
4400 struct sigmatel_spec *spec = codec->spec;
4402 stac92xx_set_config_regs(codec);
4403 stac92xx_init(codec);
4404 snd_hda_codec_resume_amp(codec);
4405 snd_hda_codec_resume_cache(codec);
4406 /* fake event to set up pins again to override cached values */
4407 if (spec->hp_detect)
4408 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
4413 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
4415 struct sigmatel_spec *spec = codec->spec;
4416 if (spec->eapd_mask)
4417 stac_gpio_set(codec, spec->gpio_mask,
4418 spec->gpio_dir, spec->gpio_data &
4424 static struct hda_codec_ops stac92xx_patch_ops = {
4425 .build_controls = stac92xx_build_controls,
4426 .build_pcms = stac92xx_build_pcms,
4427 .init = stac92xx_init,
4428 .free = stac92xx_free,
4429 .unsol_event = stac92xx_unsol_event,
4430 #ifdef SND_HDA_NEEDS_RESUME
4431 .suspend = stac92xx_suspend,
4432 .resume = stac92xx_resume,
4436 static int patch_stac9200(struct hda_codec *codec)
4438 struct sigmatel_spec *spec;
4441 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4446 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
4447 spec->pin_nids = stac9200_pin_nids;
4448 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
4451 if (spec->board_config < 0) {
4452 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
4453 err = stac92xx_save_bios_config_regs(codec);
4455 err = stac_save_pin_cfgs(codec,
4456 stac9200_brd_tbl[spec->board_config]);
4458 stac92xx_free(codec);
4462 spec->multiout.max_channels = 2;
4463 spec->multiout.num_dacs = 1;
4464 spec->multiout.dac_nids = stac9200_dac_nids;
4465 spec->adc_nids = stac9200_adc_nids;
4466 spec->mux_nids = stac9200_mux_nids;
4467 spec->num_muxes = 1;
4468 spec->num_dmics = 0;
4472 if (spec->board_config == STAC_9200_M4 ||
4473 spec->board_config == STAC_9200_M4_2 ||
4474 spec->board_config == STAC_9200_OQO)
4475 spec->init = stac9200_eapd_init;
4477 spec->init = stac9200_core_init;
4478 spec->mixer = stac9200_mixer;
4480 if (spec->board_config == STAC_9200_PANASONIC) {
4481 spec->gpio_mask = spec->gpio_dir = 0x09;
4482 spec->gpio_data = 0x00;
4485 err = stac9200_parse_auto_config(codec);
4487 stac92xx_free(codec);
4491 /* CF-74 has no headphone detection, and the driver should *NOT*
4492 * do detection and HP/speaker toggle because the hardware does it.
4494 if (spec->board_config == STAC_9200_PANASONIC)
4495 spec->hp_detect = 0;
4497 codec->patch_ops = stac92xx_patch_ops;
4502 static int patch_stac925x(struct hda_codec *codec)
4504 struct sigmatel_spec *spec;
4507 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4512 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
4513 spec->pin_nids = stac925x_pin_nids;
4515 /* Check first for codec ID */
4516 spec->board_config = snd_hda_check_board_codec_sid_config(codec,
4519 stac925x_codec_id_cfg_tbl);
4521 /* Now checks for PCI ID, if codec ID is not found */
4522 if (spec->board_config < 0)
4523 spec->board_config = snd_hda_check_board_config(codec,
4528 if (spec->board_config < 0) {
4529 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
4530 "using BIOS defaults\n");
4531 err = stac92xx_save_bios_config_regs(codec);
4533 err = stac_save_pin_cfgs(codec,
4534 stac925x_brd_tbl[spec->board_config]);
4536 stac92xx_free(codec);
4540 spec->multiout.max_channels = 2;
4541 spec->multiout.num_dacs = 1;
4542 spec->multiout.dac_nids = stac925x_dac_nids;
4543 spec->adc_nids = stac925x_adc_nids;
4544 spec->mux_nids = stac925x_mux_nids;
4545 spec->num_muxes = 1;
4548 switch (codec->vendor_id) {
4549 case 0x83847632: /* STAC9202 */
4550 case 0x83847633: /* STAC9202D */
4551 case 0x83847636: /* STAC9251 */
4552 case 0x83847637: /* STAC9251D */
4553 spec->num_dmics = STAC925X_NUM_DMICS;
4554 spec->dmic_nids = stac925x_dmic_nids;
4555 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
4556 spec->dmux_nids = stac925x_dmux_nids;
4559 spec->num_dmics = 0;
4563 spec->init = stac925x_core_init;
4564 spec->mixer = stac925x_mixer;
4566 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
4568 if (spec->board_config < 0) {
4569 printk(KERN_WARNING "hda_codec: No auto-config is "
4570 "available, default to model=ref\n");
4571 spec->board_config = STAC_925x_REF;
4577 stac92xx_free(codec);
4581 codec->patch_ops = stac92xx_patch_ops;
4586 static struct hda_input_mux stac92hd73xx_dmux = {
4589 { "Analog Inputs", 0x0b },
4590 { "Digital Mic 1", 0x09 },
4591 { "Digital Mic 2", 0x0a },
4596 static int patch_stac92hd73xx(struct hda_codec *codec)
4598 struct sigmatel_spec *spec;
4599 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
4603 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4608 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
4609 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
4610 spec->pin_nids = stac92hd73xx_pin_nids;
4611 spec->board_config = snd_hda_check_board_config(codec,
4612 STAC_92HD73XX_MODELS,
4613 stac92hd73xx_models,
4614 stac92hd73xx_cfg_tbl);
4616 if (spec->board_config < 0) {
4617 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4618 " STAC92HD73XX, using BIOS defaults\n");
4619 err = stac92xx_save_bios_config_regs(codec);
4621 err = stac_save_pin_cfgs(codec,
4622 stac92hd73xx_brd_tbl[spec->board_config]);
4624 stac92xx_free(codec);
4628 num_dacs = snd_hda_get_connections(codec, 0x0a,
4629 conn, STAC92HD73_DAC_COUNT + 2) - 1;
4631 if (num_dacs < 3 || num_dacs > 5) {
4632 printk(KERN_WARNING "hda_codec: Could not determine "
4633 "number of channels defaulting to DAC count\n");
4634 num_dacs = STAC92HD73_DAC_COUNT;
4637 case 0x3: /* 6 Channel */
4638 spec->mixer = stac92hd73xx_6ch_mixer;
4639 spec->init = stac92hd73xx_6ch_core_init;
4641 case 0x4: /* 8 Channel */
4642 spec->mixer = stac92hd73xx_8ch_mixer;
4643 spec->init = stac92hd73xx_8ch_core_init;
4645 case 0x5: /* 10 Channel */
4646 spec->mixer = stac92hd73xx_10ch_mixer;
4647 spec->init = stac92hd73xx_10ch_core_init;
4649 spec->multiout.dac_nids = spec->dac_nids;
4651 spec->aloopback_mask = 0x01;
4652 spec->aloopback_shift = 8;
4654 spec->digbeep_nid = 0x1c;
4655 spec->mux_nids = stac92hd73xx_mux_nids;
4656 spec->adc_nids = stac92hd73xx_adc_nids;
4657 spec->dmic_nids = stac92hd73xx_dmic_nids;
4658 spec->dmux_nids = stac92hd73xx_dmux_nids;
4659 spec->smux_nids = stac92hd73xx_smux_nids;
4660 spec->amp_nids = stac92hd73xx_amp_nids;
4661 spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
4663 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
4664 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
4665 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
4666 memcpy(&spec->private_dimux, &stac92hd73xx_dmux,
4667 sizeof(stac92hd73xx_dmux));
4669 switch (spec->board_config) {
4671 spec->init = dell_eq_core_init;
4673 case STAC_DELL_M6_AMIC:
4674 case STAC_DELL_M6_DMIC:
4675 case STAC_DELL_M6_BOTH:
4676 spec->num_smuxes = 0;
4677 spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
4678 spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
4679 spec->eapd_switch = 0;
4682 if (spec->board_config != STAC_DELL_EQ)
4683 spec->init = dell_m6_core_init;
4684 switch (spec->board_config) {
4685 case STAC_DELL_M6_AMIC: /* Analog Mics */
4686 stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
4687 spec->num_dmics = 0;
4688 spec->private_dimux.num_items = 1;
4690 case STAC_DELL_M6_DMIC: /* Digital Mics */
4691 stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
4692 spec->num_dmics = 1;
4693 spec->private_dimux.num_items = 2;
4695 case STAC_DELL_M6_BOTH: /* Both */
4696 stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
4697 stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
4698 spec->num_dmics = 1;
4699 spec->private_dimux.num_items = 2;
4704 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
4705 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
4706 spec->eapd_switch = 1;
4708 if (spec->board_config > STAC_92HD73XX_REF) {
4709 /* GPIO0 High = Enable EAPD */
4710 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4711 spec->gpio_data = 0x01;
4713 spec->dinput_mux = &spec->private_dimux;
4715 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
4716 spec->pwr_nids = stac92hd73xx_pwr_nids;
4718 err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
4721 if (spec->board_config < 0) {
4722 printk(KERN_WARNING "hda_codec: No auto-config is "
4723 "available, default to model=ref\n");
4724 spec->board_config = STAC_92HD73XX_REF;
4731 stac92xx_free(codec);
4735 if (spec->board_config == STAC_92HD73XX_NO_JD)
4736 spec->hp_detect = 0;
4738 codec->patch_ops = stac92xx_patch_ops;
4740 codec->proc_widget_hook = stac92hd7x_proc_hook;
4745 static struct hda_input_mux stac92hd83xxx_dmux = {
4748 { "Analog Inputs", 0x03 },
4749 { "Digital Mic 1", 0x04 },
4750 { "Digital Mic 2", 0x05 },
4754 static int patch_stac92hd83xxx(struct hda_codec *codec)
4756 struct sigmatel_spec *spec;
4759 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4764 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
4765 spec->mono_nid = 0x19;
4766 spec->digbeep_nid = 0x21;
4767 spec->dmic_nids = stac92hd83xxx_dmic_nids;
4768 spec->dmux_nids = stac92hd83xxx_dmux_nids;
4769 spec->adc_nids = stac92hd83xxx_adc_nids;
4770 spec->pwr_nids = stac92hd83xxx_pwr_nids;
4771 spec->amp_nids = stac92hd83xxx_amp_nids;
4772 spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
4773 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
4774 spec->multiout.dac_nids = spec->dac_nids;
4776 spec->init = stac92hd83xxx_core_init;
4777 switch (codec->vendor_id) {
4782 spec->init++; /* switch to config #2 */
4785 spec->mixer = stac92hd83xxx_mixer;
4786 spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
4787 spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
4788 spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
4789 spec->num_amps = ARRAY_SIZE(stac92hd83xxx_amp_nids);
4790 spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
4791 spec->dinput_mux = &stac92hd83xxx_dmux;
4792 spec->pin_nids = stac92hd83xxx_pin_nids;
4793 spec->board_config = snd_hda_check_board_config(codec,
4794 STAC_92HD83XXX_MODELS,
4795 stac92hd83xxx_models,
4796 stac92hd83xxx_cfg_tbl);
4798 if (spec->board_config < 0) {
4799 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4800 " STAC92HD83XXX, using BIOS defaults\n");
4801 err = stac92xx_save_bios_config_regs(codec);
4803 err = stac_save_pin_cfgs(codec,
4804 stac92hd83xxx_brd_tbl[spec->board_config]);
4806 stac92xx_free(codec);
4810 err = stac92xx_parse_auto_config(codec, 0x1d, 0);
4812 if (spec->board_config < 0) {
4813 printk(KERN_WARNING "hda_codec: No auto-config is "
4814 "available, default to model=ref\n");
4815 spec->board_config = STAC_92HD83XXX_REF;
4822 stac92xx_free(codec);
4826 codec->patch_ops = stac92xx_patch_ops;
4828 codec->proc_widget_hook = stac92hd_proc_hook;
4833 static struct hda_input_mux stac92hd71bxx_dmux = {
4836 { "Analog Inputs", 0x00 },
4838 { "Digital Mic 1", 0x02 },
4839 { "Digital Mic 2", 0x03 },
4843 static int patch_stac92hd71bxx(struct hda_codec *codec)
4845 struct sigmatel_spec *spec;
4848 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4853 codec->patch_ops = stac92xx_patch_ops;
4854 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
4855 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
4856 spec->pin_nids = stac92hd71bxx_pin_nids;
4857 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux,
4858 sizeof(stac92hd71bxx_dmux));
4859 spec->board_config = snd_hda_check_board_config(codec,
4860 STAC_92HD71BXX_MODELS,
4861 stac92hd71bxx_models,
4862 stac92hd71bxx_cfg_tbl);
4864 if (spec->board_config < 0) {
4865 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4866 " STAC92HD71BXX, using BIOS defaults\n");
4867 err = stac92xx_save_bios_config_regs(codec);
4869 err = stac_save_pin_cfgs(codec,
4870 stac92hd71bxx_brd_tbl[spec->board_config]);
4872 stac92xx_free(codec);
4876 if (spec->board_config > STAC_92HD71BXX_REF) {
4878 spec->gpio_mask = 0x01;
4879 spec->gpio_dir = 0x01;
4880 spec->gpio_data = 0x01;
4883 switch (codec->vendor_id) {
4884 case 0x111d76b6: /* 4 Port without Analog Mixer */
4886 case 0x111d76b4: /* 6 Port without Analog Mixer */
4888 spec->mixer = stac92hd71bxx_mixer;
4889 spec->init = stac92hd71bxx_core_init;
4890 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4892 case 0x111d7608: /* 5 Port with Analog Mixer */
4893 switch (spec->board_config) {
4895 /* Enable VREF power saving on GPIO1 detect */
4896 err = stac_add_event(spec, codec->afg,
4897 STAC_VREF_EVENT, 0x02);
4900 snd_hda_codec_write_cache(codec, codec->afg, 0,
4901 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
4902 snd_hda_codec_write_cache(codec, codec->afg, 0,
4903 AC_VERB_SET_UNSOLICITED_ENABLE,
4905 spec->gpio_mask |= 0x02;
4908 if ((codec->revision_id & 0xf) == 0 ||
4909 (codec->revision_id & 0xf) == 1)
4910 spec->stream_delay = 40; /* 40 milliseconds */
4912 /* no output amps */
4914 spec->mixer = stac92hd71bxx_analog_mixer;
4915 spec->dinput_mux = &spec->private_dimux;
4918 spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
4919 stac_change_pin_config(codec, 0xf, 0x40f000f0);
4921 case 0x111d7603: /* 6 Port with Analog Mixer */
4922 if ((codec->revision_id & 0xf) == 1)
4923 spec->stream_delay = 40; /* 40 milliseconds */
4925 /* no output amps */
4929 spec->dinput_mux = &spec->private_dimux;
4930 spec->mixer = stac92hd71bxx_analog_mixer;
4931 spec->init = stac92hd71bxx_analog_core_init;
4932 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4935 spec->aloopback_mask = 0x50;
4936 spec->aloopback_shift = 0;
4938 spec->powerdown_adcs = 1;
4939 spec->digbeep_nid = 0x26;
4940 spec->mux_nids = stac92hd71bxx_mux_nids;
4941 spec->adc_nids = stac92hd71bxx_adc_nids;
4942 spec->dmic_nids = stac92hd71bxx_dmic_nids;
4943 spec->dmux_nids = stac92hd71bxx_dmux_nids;
4944 spec->smux_nids = stac92hd71bxx_smux_nids;
4945 spec->pwr_nids = stac92hd71bxx_pwr_nids;
4947 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
4948 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
4950 switch (spec->board_config) {
4952 /* enable internal microphone */
4953 stac_change_pin_config(codec, 0x0e, 0x01813040);
4954 stac92xx_auto_set_pinctl(codec, 0x0e,
4955 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
4957 case STAC_DELL_M4_2:
4958 spec->num_dmics = 0;
4959 spec->num_smuxes = 0;
4960 spec->num_dmuxes = 0;
4962 case STAC_DELL_M4_1:
4963 case STAC_DELL_M4_3:
4964 spec->num_dmics = 1;
4965 spec->num_smuxes = 0;
4966 spec->num_dmuxes = 0;
4969 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
4970 spec->num_smuxes = ARRAY_SIZE(stac92hd71bxx_smux_nids);
4971 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
4974 spec->multiout.dac_nids = spec->dac_nids;
4975 if (spec->dinput_mux)
4976 spec->private_dimux.num_items +=
4978 (ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1);
4980 err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
4982 if (spec->board_config < 0) {
4983 printk(KERN_WARNING "hda_codec: No auto-config is "
4984 "available, default to model=ref\n");
4985 spec->board_config = STAC_92HD71BXX_REF;
4992 stac92xx_free(codec);
4996 codec->proc_widget_hook = stac92hd7x_proc_hook;
5001 static int patch_stac922x(struct hda_codec *codec)
5003 struct sigmatel_spec *spec;
5006 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5011 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
5012 spec->pin_nids = stac922x_pin_nids;
5013 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
5016 if (spec->board_config == STAC_INTEL_MAC_AUTO) {
5017 spec->gpio_mask = spec->gpio_dir = 0x03;
5018 spec->gpio_data = 0x03;
5019 /* Intel Macs have all same PCI SSID, so we need to check
5020 * codec SSID to distinguish the exact models
5022 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
5023 switch (codec->subsystem_id) {
5026 spec->board_config = STAC_INTEL_MAC_V1;
5030 spec->board_config = STAC_INTEL_MAC_V2;
5038 spec->board_config = STAC_INTEL_MAC_V3;
5042 spec->board_config = STAC_INTEL_MAC_V4;
5046 spec->board_config = STAC_INTEL_MAC_V5;
5049 spec->board_config = STAC_INTEL_MAC_V3;
5055 if (spec->board_config < 0) {
5056 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
5057 "using BIOS defaults\n");
5058 err = stac92xx_save_bios_config_regs(codec);
5060 err = stac_save_pin_cfgs(codec,
5061 stac922x_brd_tbl[spec->board_config]);
5063 stac92xx_free(codec);
5067 spec->adc_nids = stac922x_adc_nids;
5068 spec->mux_nids = stac922x_mux_nids;
5069 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
5070 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
5071 spec->num_dmics = 0;
5074 spec->init = stac922x_core_init;
5075 spec->mixer = stac922x_mixer;
5077 spec->multiout.dac_nids = spec->dac_nids;
5079 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
5081 if (spec->board_config < 0) {
5082 printk(KERN_WARNING "hda_codec: No auto-config is "
5083 "available, default to model=ref\n");
5084 spec->board_config = STAC_D945_REF;
5090 stac92xx_free(codec);
5094 codec->patch_ops = stac92xx_patch_ops;
5096 /* Fix Mux capture level; max to 2 */
5097 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
5098 (0 << AC_AMPCAP_OFFSET_SHIFT) |
5099 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5100 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5101 (0 << AC_AMPCAP_MUTE_SHIFT));
5106 static int patch_stac927x(struct hda_codec *codec)
5108 struct sigmatel_spec *spec;
5111 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5116 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
5117 spec->pin_nids = stac927x_pin_nids;
5118 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
5122 if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
5123 if (spec->board_config < 0)
5124 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
5125 "STAC927x, using BIOS defaults\n");
5126 err = stac92xx_save_bios_config_regs(codec);
5128 err = stac_save_pin_cfgs(codec,
5129 stac927x_brd_tbl[spec->board_config]);
5131 stac92xx_free(codec);
5135 spec->digbeep_nid = 0x23;
5136 spec->adc_nids = stac927x_adc_nids;
5137 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
5138 spec->mux_nids = stac927x_mux_nids;
5139 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
5140 spec->smux_nids = stac927x_smux_nids;
5141 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
5142 spec->spdif_labels = stac927x_spdif_labels;
5143 spec->dac_list = stac927x_dac_nids;
5144 spec->multiout.dac_nids = spec->dac_nids;
5146 switch (spec->board_config) {
5149 /* GPIO0 High = Enable EAPD */
5150 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01;
5151 spec->gpio_data = 0x01;
5152 spec->num_dmics = 0;
5154 spec->init = d965_core_init;
5155 spec->mixer = stac927x_mixer;
5157 case STAC_DELL_BIOS:
5158 switch (codec->subsystem_id) {
5161 /* correct the device field to SPDIF out */
5162 stac_change_pin_config(codec, 0x21, 0x01442070);
5165 /* configure the analog microphone on some laptops */
5166 stac_change_pin_config(codec, 0x0c, 0x90a79130);
5167 /* correct the front output jack as a hp out */
5168 stac_change_pin_config(codec, 0x0f, 0x0227011f);
5169 /* correct the front input jack as a mic */
5170 stac_change_pin_config(codec, 0x0e, 0x02a79130);
5173 /* GPIO2 High = Enable EAPD */
5174 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
5175 spec->gpio_data = 0x04;
5176 spec->dmic_nids = stac927x_dmic_nids;
5177 spec->num_dmics = STAC927X_NUM_DMICS;
5179 spec->init = d965_core_init;
5180 spec->mixer = stac927x_mixer;
5181 spec->dmux_nids = stac927x_dmux_nids;
5182 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
5185 if (spec->board_config > STAC_D965_REF) {
5186 /* GPIO0 High = Enable EAPD */
5187 spec->eapd_mask = spec->gpio_mask = 0x01;
5188 spec->gpio_dir = spec->gpio_data = 0x01;
5190 spec->num_dmics = 0;
5192 spec->init = stac927x_core_init;
5193 spec->mixer = stac927x_mixer;
5197 spec->aloopback_mask = 0x40;
5198 spec->aloopback_shift = 0;
5199 spec->eapd_switch = 1;
5201 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
5203 if (spec->board_config < 0) {
5204 printk(KERN_WARNING "hda_codec: No auto-config is "
5205 "available, default to model=ref\n");
5206 spec->board_config = STAC_D965_REF;
5212 stac92xx_free(codec);
5216 codec->patch_ops = stac92xx_patch_ops;
5218 codec->proc_widget_hook = stac927x_proc_hook;
5222 * The STAC927x seem to require fairly long delays for certain
5223 * command sequences. With too short delays (even if the answer
5224 * is set to RIRB properly), it results in the silence output
5225 * on some hardwares like Dell.
5227 * The below flag enables the longer delay (see get_response
5230 codec->bus->needs_damn_long_delay = 1;
5232 /* no jack detecion for ref-no-jd model */
5233 if (spec->board_config == STAC_D965_REF_NO_JD)
5234 spec->hp_detect = 0;
5239 static int patch_stac9205(struct hda_codec *codec)
5241 struct sigmatel_spec *spec;
5244 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5249 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
5250 spec->pin_nids = stac9205_pin_nids;
5251 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
5255 if (spec->board_config < 0) {
5256 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
5257 err = stac92xx_save_bios_config_regs(codec);
5259 err = stac_save_pin_cfgs(codec,
5260 stac9205_brd_tbl[spec->board_config]);
5262 stac92xx_free(codec);
5266 spec->digbeep_nid = 0x23;
5267 spec->adc_nids = stac9205_adc_nids;
5268 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
5269 spec->mux_nids = stac9205_mux_nids;
5270 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
5271 spec->smux_nids = stac9205_smux_nids;
5272 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
5273 spec->dmic_nids = stac9205_dmic_nids;
5274 spec->num_dmics = STAC9205_NUM_DMICS;
5275 spec->dmux_nids = stac9205_dmux_nids;
5276 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
5279 spec->init = stac9205_core_init;
5280 spec->mixer = stac9205_mixer;
5282 spec->aloopback_mask = 0x40;
5283 spec->aloopback_shift = 0;
5284 spec->eapd_switch = 1;
5285 spec->multiout.dac_nids = spec->dac_nids;
5287 switch (spec->board_config){
5288 case STAC_9205_DELL_M43:
5289 /* Enable SPDIF in/out */
5290 stac_change_pin_config(codec, 0x1f, 0x01441030);
5291 stac_change_pin_config(codec, 0x20, 0x1c410030);
5293 /* Enable unsol response for GPIO4/Dock HP connection */
5294 err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
5297 snd_hda_codec_write_cache(codec, codec->afg, 0,
5298 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
5299 snd_hda_codec_write_cache(codec, codec->afg, 0,
5300 AC_VERB_SET_UNSOLICITED_ENABLE,
5303 spec->gpio_dir = 0x0b;
5304 spec->eapd_mask = 0x01;
5305 spec->gpio_mask = 0x1b;
5306 spec->gpio_mute = 0x10;
5307 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
5310 spec->gpio_data = 0x01;
5313 /* SPDIF-In enabled */
5316 /* GPIO0 High = EAPD */
5317 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5318 spec->gpio_data = 0x01;
5322 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
5324 if (spec->board_config < 0) {
5325 printk(KERN_WARNING "hda_codec: No auto-config is "
5326 "available, default to model=ref\n");
5327 spec->board_config = STAC_9205_REF;
5333 stac92xx_free(codec);
5337 codec->patch_ops = stac92xx_patch_ops;
5339 codec->proc_widget_hook = stac9205_proc_hook;
5348 /* static config for Sony VAIO FE550G and Sony VAIO AR */
5349 static hda_nid_t vaio_dacs[] = { 0x2 };
5350 #define VAIO_HP_DAC 0x5
5351 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
5352 static hda_nid_t vaio_mux_nids[] = { 0x15 };
5354 static struct hda_input_mux vaio_mux = {
5357 /* { "HP", 0x0 }, */
5358 { "Mic Jack", 0x1 },
5359 { "Internal Mic", 0x2 },
5364 static struct hda_verb vaio_init[] = {
5365 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
5366 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
5367 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
5368 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
5369 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
5370 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
5371 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5372 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
5373 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
5374 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
5375 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
5376 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5380 static struct hda_verb vaio_ar_init[] = {
5381 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
5382 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
5383 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
5384 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
5385 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
5386 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
5387 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5388 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
5389 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
5390 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
5391 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
5392 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
5393 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5397 static struct snd_kcontrol_new vaio_mixer[] = {
5398 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x02, 0, HDA_OUTPUT),
5399 HDA_CODEC_MUTE("Headphone Playback Switch", 0x02, 0, HDA_OUTPUT),
5400 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x05, 0, HDA_OUTPUT),
5401 HDA_CODEC_MUTE("Speaker Playback Switch", 0x05, 0, HDA_OUTPUT),
5402 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
5403 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5404 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5406 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5407 .name = "Capture Source",
5409 .info = stac92xx_mux_enum_info,
5410 .get = stac92xx_mux_enum_get,
5411 .put = stac92xx_mux_enum_put,
5416 static struct snd_kcontrol_new vaio_ar_mixer[] = {
5417 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x02, 0, HDA_OUTPUT),
5418 HDA_CODEC_MUTE("Headphone Playback Switch", 0x02, 0, HDA_OUTPUT),
5419 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x05, 0, HDA_OUTPUT),
5420 HDA_CODEC_MUTE("Speaker Playback Switch", 0x05, 0, HDA_OUTPUT),
5421 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
5422 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5423 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5424 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
5425 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
5427 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5428 .name = "Capture Source",
5430 .info = stac92xx_mux_enum_info,
5431 .get = stac92xx_mux_enum_get,
5432 .put = stac92xx_mux_enum_put,
5437 static struct hda_codec_ops stac9872_patch_ops = {
5438 .build_controls = stac92xx_build_controls,
5439 .build_pcms = stac92xx_build_pcms,
5440 .init = stac92xx_init,
5441 .free = stac92xx_free,
5442 #ifdef SND_HDA_NEEDS_RESUME
5443 .resume = stac92xx_resume,
5447 static int stac9872_vaio_init(struct hda_codec *codec)
5451 err = stac92xx_init(codec);
5454 if (codec->patch_ops.unsol_event)
5455 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
5459 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
5461 if (get_pin_presence(codec, 0x0a)) {
5462 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
5463 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
5465 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
5466 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
5470 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
5472 switch (res >> 26) {
5474 stac9872_vaio_hp_detect(codec, res);
5479 static struct hda_codec_ops stac9872_vaio_patch_ops = {
5480 .build_controls = stac92xx_build_controls,
5481 .build_pcms = stac92xx_build_pcms,
5482 .init = stac9872_vaio_init,
5483 .free = stac92xx_free,
5484 .unsol_event = stac9872_vaio_unsol_event,
5486 .resume = stac92xx_resume,
5490 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
5492 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
5494 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
5496 /* AR Series. id=0x83847664 and subsys=104D1300 */
5501 static const char *stac9872_models[STAC_9872_MODELS] = {
5502 [CXD9872RD_VAIO] = "vaio",
5503 [CXD9872AKD_VAIO] = "vaio-ar",
5506 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
5507 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
5508 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
5509 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
5510 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
5514 static int patch_stac9872(struct hda_codec *codec)
5516 struct sigmatel_spec *spec;
5519 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
5522 if (board_config < 0)
5523 /* unknown config, let generic-parser do its job... */
5524 return snd_hda_parse_generic_codec(codec);
5526 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5531 switch (board_config) {
5532 case CXD9872RD_VAIO:
5533 case STAC9872AK_VAIO:
5534 case STAC9872K_VAIO:
5535 spec->mixer = vaio_mixer;
5536 spec->init = vaio_init;
5537 spec->multiout.max_channels = 2;
5538 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
5539 spec->multiout.dac_nids = vaio_dacs;
5540 spec->multiout.hp_nid = VAIO_HP_DAC;
5541 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
5542 spec->adc_nids = vaio_adcs;
5544 spec->input_mux = &vaio_mux;
5545 spec->mux_nids = vaio_mux_nids;
5546 codec->patch_ops = stac9872_vaio_patch_ops;
5549 case CXD9872AKD_VAIO:
5550 spec->mixer = vaio_ar_mixer;
5551 spec->init = vaio_ar_init;
5552 spec->multiout.max_channels = 2;
5553 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
5554 spec->multiout.dac_nids = vaio_dacs;
5555 spec->multiout.hp_nid = VAIO_HP_DAC;
5556 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
5558 spec->adc_nids = vaio_adcs;
5559 spec->input_mux = &vaio_mux;
5560 spec->mux_nids = vaio_mux_nids;
5561 codec->patch_ops = stac9872_patch_ops;
5572 static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
5573 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
5574 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
5575 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
5576 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
5577 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
5578 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
5579 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
5580 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
5581 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
5582 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
5583 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
5584 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
5585 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
5586 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
5587 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
5588 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
5589 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
5590 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
5591 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
5592 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
5593 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
5594 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
5595 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
5596 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
5597 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
5598 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
5599 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
5600 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
5601 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
5602 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
5603 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
5604 /* The following does not take into account .id=0x83847661 when subsys =
5605 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
5606 * currently not fully supported.
5608 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
5609 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
5610 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
5611 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
5612 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
5613 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
5614 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
5615 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
5616 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
5617 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
5618 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
5619 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
5620 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
5621 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
5622 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
5623 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
5624 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
5625 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
5626 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5627 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5628 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5629 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5630 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5631 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5632 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5633 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5637 MODULE_ALIAS("snd-hda-codec-id:8384*");
5638 MODULE_ALIAS("snd-hda-codec-id:111d*");
5640 MODULE_LICENSE("GPL");
5641 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
5643 static struct hda_codec_preset_list sigmatel_list = {
5644 .preset = snd_hda_preset_sigmatel,
5645 .owner = THIS_MODULE,
5648 static int __init patch_sigmatel_init(void)
5650 return snd_hda_add_codec_preset(&sigmatel_list);
5653 static void __exit patch_sigmatel_exit(void)
5655 snd_hda_delete_codec_preset(&sigmatel_list);
5658 module_init(patch_sigmatel_init)
5659 module_exit(patch_sigmatel_exit)