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"
77 STAC_92HD73XX_NO_JD, /* no jack-detection */
89 STAC_92HD83XXX_PWR_REF,
102 STAC_92HD71BXX_MODELS
128 STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
129 * is given, one of the above models will be
130 * chosen according to the subsystem id. */
131 /* for backward compatibility */
148 STAC_D965_REF_NO_JD, /* no jack-detection */
157 struct sigmatel_event {
164 struct sigmatel_jack {
167 struct snd_jack *jack;
170 struct sigmatel_spec {
171 struct snd_kcontrol_new *mixers[4];
172 unsigned int num_mixers;
175 unsigned int eapd_switch: 1;
176 unsigned int surr_switch: 1;
177 unsigned int alt_switch: 1;
178 unsigned int hp_detect: 1;
179 unsigned int spdif_mute: 1;
180 unsigned int check_volume_offset:1;
183 unsigned int eapd_mask;
184 unsigned int gpio_mask;
185 unsigned int gpio_dir;
186 unsigned int gpio_data;
187 unsigned int gpio_mute;
190 unsigned int stream_delay;
192 /* analog loopback */
193 struct snd_kcontrol_new *aloopback_ctl;
194 unsigned char aloopback_mask;
195 unsigned char aloopback_shift;
197 /* power management */
198 unsigned int num_pwrs;
199 unsigned int *pwr_mapping;
204 struct snd_array jacks;
207 struct snd_array events;
210 struct hda_input_mux *mono_mux;
211 struct hda_input_mux *amp_mux;
212 unsigned int cur_mmux;
213 struct hda_multi_out multiout;
214 hda_nid_t dac_nids[5];
215 hda_nid_t hp_dacs[5];
216 hda_nid_t speaker_dacs[5];
222 unsigned int num_adcs;
224 unsigned int num_muxes;
225 hda_nid_t *dmic_nids;
226 unsigned int num_dmics;
227 hda_nid_t *dmux_nids;
228 unsigned int num_dmuxes;
229 hda_nid_t *smux_nids;
230 unsigned int num_smuxes;
231 const char **spdif_labels;
233 hda_nid_t dig_in_nid;
235 hda_nid_t anabeep_nid;
236 hda_nid_t digbeep_nid;
240 unsigned int num_pins;
242 /* codec specific stuff */
243 struct hda_verb *init;
244 struct snd_kcontrol_new *mixer;
247 struct hda_input_mux *dinput_mux;
248 unsigned int cur_dmux[2];
249 struct hda_input_mux *input_mux;
250 unsigned int cur_mux[3];
251 struct hda_input_mux *sinput_mux;
252 unsigned int cur_smux[2];
253 unsigned int cur_amux;
255 unsigned int num_amps;
256 unsigned int powerdown_adcs;
259 unsigned int io_switch[2];
260 unsigned int clfe_swap;
261 hda_nid_t line_switch; /* shared line-in for input and output */
262 hda_nid_t mic_switch; /* shared mic-in for input and output */
263 hda_nid_t hp_switch; /* NID of HP as line-out */
264 unsigned int aloopback;
266 struct hda_pcm pcm_rec[2]; /* PCM information */
268 /* dynamic controls and input_mux */
269 struct auto_pin_cfg autocfg;
270 struct snd_array kctls;
271 struct hda_input_mux private_dimux;
272 struct hda_input_mux private_imux;
273 struct hda_input_mux private_smux;
274 struct hda_input_mux private_amp_mux;
275 struct hda_input_mux private_mono_mux;
278 static hda_nid_t stac9200_adc_nids[1] = {
282 static hda_nid_t stac9200_mux_nids[1] = {
286 static hda_nid_t stac9200_dac_nids[1] = {
290 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
291 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
295 static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
299 static hda_nid_t stac92hd73xx_adc_nids[2] = {
303 #define DELL_M6_AMP 2
304 static hda_nid_t stac92hd73xx_amp_nids[3] = {
308 #define STAC92HD73XX_NUM_DMICS 2
309 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
313 #define STAC92HD73_DAC_COUNT 5
315 static hda_nid_t stac92hd73xx_mux_nids[4] = {
316 0x28, 0x29, 0x2a, 0x2b,
319 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
323 static hda_nid_t stac92hd73xx_smux_nids[2] = {
327 #define STAC92HD83XXX_NUM_DMICS 2
328 static hda_nid_t stac92hd83xxx_dmic_nids[STAC92HD83XXX_NUM_DMICS + 1] = {
332 #define STAC92HD83_DAC_COUNT 3
334 static hda_nid_t stac92hd83xxx_dmux_nids[2] = {
338 static hda_nid_t stac92hd83xxx_adc_nids[2] = {
342 static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
346 static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
350 static unsigned int stac92hd83xxx_pwr_mapping[4] = {
351 0x03, 0x0c, 0x20, 0x40,
354 static hda_nid_t stac92hd83xxx_amp_nids[1] = {
358 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
362 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
366 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
370 static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
374 static hda_nid_t stac92hd71bxx_smux_nids[2] = {
378 #define STAC92HD71BXX_NUM_DMICS 2
379 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
383 static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
387 static hda_nid_t stac925x_adc_nids[1] = {
391 static hda_nid_t stac925x_mux_nids[1] = {
395 static hda_nid_t stac925x_dac_nids[1] = {
399 #define STAC925X_NUM_DMICS 1
400 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
404 static hda_nid_t stac925x_dmux_nids[1] = {
408 static hda_nid_t stac922x_adc_nids[2] = {
412 static hda_nid_t stac922x_mux_nids[2] = {
416 static hda_nid_t stac927x_slave_dig_outs[2] = {
420 static hda_nid_t stac927x_adc_nids[3] = {
424 static hda_nid_t stac927x_mux_nids[3] = {
428 static hda_nid_t stac927x_smux_nids[1] = {
432 static hda_nid_t stac927x_dac_nids[6] = {
433 0x02, 0x03, 0x04, 0x05, 0x06, 0
436 static hda_nid_t stac927x_dmux_nids[1] = {
440 #define STAC927X_NUM_DMICS 2
441 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
445 static const char *stac927x_spdif_labels[5] = {
446 "Digital Playback", "ADAT", "Analog Mux 1",
447 "Analog Mux 2", "Analog Mux 3"
450 static hda_nid_t stac9205_adc_nids[2] = {
454 static hda_nid_t stac9205_mux_nids[2] = {
458 static hda_nid_t stac9205_dmux_nids[1] = {
462 static hda_nid_t stac9205_smux_nids[1] = {
466 #define STAC9205_NUM_DMICS 2
467 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
471 static hda_nid_t stac9200_pin_nids[8] = {
472 0x08, 0x09, 0x0d, 0x0e,
473 0x0f, 0x10, 0x11, 0x12,
476 static hda_nid_t stac925x_pin_nids[8] = {
477 0x07, 0x08, 0x0a, 0x0b,
478 0x0c, 0x0d, 0x10, 0x11,
481 static hda_nid_t stac922x_pin_nids[10] = {
482 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
483 0x0f, 0x10, 0x11, 0x15, 0x1b,
486 static hda_nid_t stac92hd73xx_pin_nids[13] = {
487 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
488 0x0f, 0x10, 0x11, 0x12, 0x13,
492 static hda_nid_t stac92hd83xxx_pin_nids[10] = {
493 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
494 0x0f, 0x10, 0x11, 0x1f, 0x20,
497 #define STAC92HD71BXX_NUM_PINS 13
498 static hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
499 0x0a, 0x0b, 0x0c, 0x0d, 0x00,
500 0x00, 0x14, 0x18, 0x19, 0x1e,
503 static hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
504 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
505 0x0f, 0x14, 0x18, 0x19, 0x1e,
509 static hda_nid_t stac927x_pin_nids[14] = {
510 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
511 0x0f, 0x10, 0x11, 0x12, 0x13,
512 0x14, 0x21, 0x22, 0x23,
515 static hda_nid_t stac9205_pin_nids[12] = {
516 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
517 0x0f, 0x14, 0x16, 0x17, 0x18,
521 #define stac92xx_amp_volume_info snd_hda_mixer_amp_volume_info
523 static int stac92xx_amp_volume_get(struct snd_kcontrol *kcontrol,
524 struct snd_ctl_elem_value *ucontrol)
526 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
527 struct sigmatel_spec *spec = codec->spec;
528 hda_nid_t nid = spec->amp_nids[spec->cur_amux];
530 kcontrol->private_value ^= get_amp_nid(kcontrol);
531 kcontrol->private_value |= nid;
533 return snd_hda_mixer_amp_volume_get(kcontrol, ucontrol);
536 static int stac92xx_amp_volume_put(struct snd_kcontrol *kcontrol,
537 struct snd_ctl_elem_value *ucontrol)
539 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
540 struct sigmatel_spec *spec = codec->spec;
541 hda_nid_t nid = spec->amp_nids[spec->cur_amux];
543 kcontrol->private_value ^= get_amp_nid(kcontrol);
544 kcontrol->private_value |= nid;
546 return snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
549 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
550 struct snd_ctl_elem_info *uinfo)
552 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
553 struct sigmatel_spec *spec = codec->spec;
554 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
557 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
558 struct snd_ctl_elem_value *ucontrol)
560 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
561 struct sigmatel_spec *spec = codec->spec;
562 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
564 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
568 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
569 struct snd_ctl_elem_value *ucontrol)
571 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
572 struct sigmatel_spec *spec = codec->spec;
573 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
575 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
576 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
579 static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
580 struct snd_ctl_elem_info *uinfo)
582 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
583 struct sigmatel_spec *spec = codec->spec;
584 return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
587 static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
588 struct snd_ctl_elem_value *ucontrol)
590 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
591 struct sigmatel_spec *spec = codec->spec;
592 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
594 ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
598 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
599 struct snd_ctl_elem_value *ucontrol)
601 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
602 struct sigmatel_spec *spec = codec->spec;
603 struct hda_input_mux *smux = &spec->private_smux;
604 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
608 err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
609 spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
613 if (spec->spdif_mute) {
615 nid = spec->multiout.dig_out_nid;
617 nid = codec->slave_dig_outs[smux_idx - 1];
618 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
622 /* un/mute SPDIF out */
623 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
629 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
631 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
632 struct sigmatel_spec *spec = codec->spec;
633 return snd_hda_input_mux_info(spec->input_mux, uinfo);
636 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
638 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
639 struct sigmatel_spec *spec = codec->spec;
640 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
642 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
646 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
648 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
649 struct sigmatel_spec *spec = codec->spec;
650 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
652 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
653 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
656 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
657 struct snd_ctl_elem_info *uinfo)
659 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
660 struct sigmatel_spec *spec = codec->spec;
661 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
664 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
665 struct snd_ctl_elem_value *ucontrol)
667 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
668 struct sigmatel_spec *spec = codec->spec;
670 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
674 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
675 struct snd_ctl_elem_value *ucontrol)
677 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
678 struct sigmatel_spec *spec = codec->spec;
680 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
681 spec->mono_nid, &spec->cur_mmux);
684 static int stac92xx_amp_mux_enum_info(struct snd_kcontrol *kcontrol,
685 struct snd_ctl_elem_info *uinfo)
687 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
688 struct sigmatel_spec *spec = codec->spec;
689 return snd_hda_input_mux_info(spec->amp_mux, uinfo);
692 static int stac92xx_amp_mux_enum_get(struct snd_kcontrol *kcontrol,
693 struct snd_ctl_elem_value *ucontrol)
695 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
696 struct sigmatel_spec *spec = codec->spec;
698 ucontrol->value.enumerated.item[0] = spec->cur_amux;
702 static int stac92xx_amp_mux_enum_put(struct snd_kcontrol *kcontrol,
703 struct snd_ctl_elem_value *ucontrol)
705 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
706 struct sigmatel_spec *spec = codec->spec;
707 struct snd_kcontrol *ctl =
708 snd_hda_find_mixer_ctl(codec, "Amp Capture Volume");
712 snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE |
713 SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
715 return snd_hda_input_mux_put(codec, spec->amp_mux, ucontrol,
719 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
721 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
722 struct snd_ctl_elem_value *ucontrol)
724 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
725 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
726 struct sigmatel_spec *spec = codec->spec;
728 ucontrol->value.integer.value[0] = !!(spec->aloopback &
729 (spec->aloopback_mask << idx));
733 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
734 struct snd_ctl_elem_value *ucontrol)
736 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
737 struct sigmatel_spec *spec = codec->spec;
738 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
739 unsigned int dac_mode;
740 unsigned int val, idx_val;
742 idx_val = spec->aloopback_mask << idx;
743 if (ucontrol->value.integer.value[0])
744 val = spec->aloopback | idx_val;
746 val = spec->aloopback & ~idx_val;
747 if (spec->aloopback == val)
750 spec->aloopback = val;
752 /* Only return the bits defined by the shift value of the
753 * first two bytes of the mask
755 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
756 kcontrol->private_value & 0xFFFF, 0x0);
757 dac_mode >>= spec->aloopback_shift;
759 if (spec->aloopback & idx_val) {
760 snd_hda_power_up(codec);
763 snd_hda_power_down(codec);
764 dac_mode &= ~idx_val;
767 snd_hda_codec_write_cache(codec, codec->afg, 0,
768 kcontrol->private_value >> 16, dac_mode);
773 static struct hda_verb stac9200_core_init[] = {
774 /* set dac0mux for dac converter */
775 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
779 static struct hda_verb stac9200_eapd_init[] = {
780 /* set dac0mux for dac converter */
781 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
782 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
786 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
787 /* set master volume and direct control */
788 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
789 /* setup adcs to point to mixer */
790 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
791 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
792 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
793 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
794 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
795 /* setup import muxs */
796 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
797 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
798 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
799 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
803 static struct hda_verb dell_eq_core_init[] = {
804 /* set master volume to max value without distortion
805 * and direct control */
806 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
807 /* setup adcs to point to mixer */
808 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
809 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
810 /* setup import muxs */
811 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
812 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
813 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
814 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
818 static struct hda_verb dell_m6_core_init[] = {
819 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
820 /* setup adcs to point to mixer */
821 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
822 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
823 /* setup import muxs */
824 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
825 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
826 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
827 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
831 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
832 /* set master volume and direct control */
833 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
834 /* setup adcs to point to mixer */
835 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
836 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
837 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
838 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
839 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
840 /* setup import muxs */
841 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
842 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
843 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
844 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
848 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
849 /* set master volume and direct control */
850 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
851 /* dac3 is connected to import3 mux */
852 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
853 /* setup adcs to point to mixer */
854 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
855 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
856 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
857 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
858 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
859 /* setup import muxs */
860 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
861 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
862 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
863 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
867 static struct hda_verb stac92hd83xxx_core_init[] = {
868 { 0xa, AC_VERB_SET_CONNECT_SEL, 0x1},
869 { 0xb, AC_VERB_SET_CONNECT_SEL, 0x1},
870 { 0xd, AC_VERB_SET_CONNECT_SEL, 0x0},
872 /* power state controls amps */
873 { 0x01, AC_VERB_SET_EAPD, 1 << 2},
877 static struct hda_verb stac92hd71bxx_core_init[] = {
878 /* set master volume and direct control */
879 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
883 #define HD_DISABLE_PORTF 1
884 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
885 /* start of config #1 */
887 /* connect port 0f to audio mixer */
888 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
889 /* start of config #2 */
891 /* set master volume and direct control */
892 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
896 static struct hda_verb stac92hd71bxx_unmute_core_init[] = {
897 /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
898 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
899 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
900 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
904 static struct hda_verb stac925x_core_init[] = {
905 /* set dac0mux for dac converter */
906 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
907 /* mute the master volume */
908 { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
912 static struct hda_verb stac922x_core_init[] = {
913 /* set master volume and direct control */
914 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
918 static struct hda_verb d965_core_init[] = {
919 /* set master volume and direct control */
920 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
921 /* unmute node 0x1b */
922 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
923 /* select node 0x03 as DAC */
924 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
928 static struct hda_verb stac927x_core_init[] = {
929 /* set master volume and direct control */
930 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
931 /* enable analog pc beep path */
932 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
936 static struct hda_verb stac9205_core_init[] = {
937 /* set master volume and direct control */
938 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
939 /* enable analog pc beep path */
940 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
944 #define STAC_MONO_MUX \
946 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
947 .name = "Mono Mux", \
949 .info = stac92xx_mono_mux_enum_info, \
950 .get = stac92xx_mono_mux_enum_get, \
951 .put = stac92xx_mono_mux_enum_put, \
954 #define STAC_AMP_MUX \
956 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
957 .name = "Amp Selector Capture Switch", \
959 .info = stac92xx_amp_mux_enum_info, \
960 .get = stac92xx_amp_mux_enum_get, \
961 .put = stac92xx_amp_mux_enum_put, \
964 #define STAC_AMP_VOL(xname, nid, chs, idx, dir) \
966 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
969 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
970 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
971 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
972 .info = stac92xx_amp_volume_info, \
973 .get = stac92xx_amp_volume_get, \
974 .put = stac92xx_amp_volume_put, \
975 .tlv = { .c = snd_hda_mixer_amp_tlv }, \
976 .private_value = HDA_COMPOSE_AMP_VAL(nid, chs, idx, dir) \
979 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
981 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
982 .name = "Analog Loopback", \
984 .info = stac92xx_aloopback_info, \
985 .get = stac92xx_aloopback_get, \
986 .put = stac92xx_aloopback_put, \
987 .private_value = verb_read | (verb_write << 16), \
990 static struct snd_kcontrol_new stac9200_mixer[] = {
991 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
992 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
993 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
994 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
998 #define DELL_M6_MIXER 6
999 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
1000 /* start of config #1 */
1001 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1002 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1004 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1005 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1007 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1008 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1010 /* start of config #2 */
1011 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1012 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1014 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1015 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1017 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1018 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1020 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1021 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1026 static struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
1027 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
1031 static struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = {
1032 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1036 static struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
1037 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1041 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
1042 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1043 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1045 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1046 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1048 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1049 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1051 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1052 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1054 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1055 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1057 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1058 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1060 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1061 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1065 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
1066 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1067 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1069 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1070 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1072 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1073 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1075 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1076 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1078 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1079 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1081 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1082 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1084 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1085 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1090 static struct snd_kcontrol_new stac92hd83xxx_mixer[] = {
1091 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_OUTPUT),
1092 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_OUTPUT),
1094 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_OUTPUT),
1095 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_OUTPUT),
1097 HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x1b, 0x3, HDA_INPUT),
1098 HDA_CODEC_MUTE("DAC0 Capture Switch", 0x1b, 0x3, HDA_INPUT),
1100 HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x1b, 0x4, HDA_INPUT),
1101 HDA_CODEC_MUTE("DAC1 Capture Switch", 0x1b, 0x4, HDA_INPUT),
1103 HDA_CODEC_VOLUME("Front Mic Capture Volume", 0x1b, 0x0, HDA_INPUT),
1104 HDA_CODEC_MUTE("Front Mic Capture Switch", 0x1b, 0x0, HDA_INPUT),
1106 HDA_CODEC_VOLUME("Line In Capture Volume", 0x1b, 0x2, HDA_INPUT),
1107 HDA_CODEC_MUTE("Line In Capture Switch", 0x1b, 0x2, HDA_INPUT),
1110 HDA_CODEC_VOLUME("Mic Capture Volume", 0x1b, 0x1, HDA_INPUT),
1111 HDA_CODEC_MUTE("Mic Capture Switch", 0x1b 0x1, HDA_INPUT),
1116 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
1117 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1118 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1120 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1121 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1122 /* analog pc-beep replaced with digital beep support */
1124 HDA_CODEC_VOLUME("PC Beep Volume", 0x17, 0x2, HDA_INPUT),
1125 HDA_CODEC_MUTE("PC Beep Switch", 0x17, 0x2, HDA_INPUT),
1128 HDA_CODEC_MUTE("Import0 Mux Capture Switch", 0x17, 0x0, HDA_INPUT),
1129 HDA_CODEC_VOLUME("Import0 Mux Capture Volume", 0x17, 0x0, HDA_INPUT),
1131 HDA_CODEC_MUTE("Import1 Mux Capture Switch", 0x17, 0x1, HDA_INPUT),
1132 HDA_CODEC_VOLUME("Import1 Mux Capture Volume", 0x17, 0x1, HDA_INPUT),
1134 HDA_CODEC_MUTE("DAC0 Capture Switch", 0x17, 0x3, HDA_INPUT),
1135 HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x17, 0x3, HDA_INPUT),
1137 HDA_CODEC_MUTE("DAC1 Capture Switch", 0x17, 0x4, HDA_INPUT),
1138 HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x17, 0x4, HDA_INPUT),
1142 static struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
1143 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
1146 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
1147 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1148 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1150 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1151 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1155 static struct snd_kcontrol_new stac925x_mixer[] = {
1156 HDA_CODEC_VOLUME("Master Playback Volume", 0x0e, 0, HDA_OUTPUT),
1157 HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
1158 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
1159 HDA_CODEC_MUTE("Capture Switch", 0x14, 0, HDA_OUTPUT),
1163 static struct snd_kcontrol_new stac9205_mixer[] = {
1164 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
1165 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
1167 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
1168 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
1172 static struct snd_kcontrol_new stac9205_loopback[] = {
1173 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1177 /* This needs to be generated dynamically based on sequence */
1178 static struct snd_kcontrol_new stac922x_mixer[] = {
1179 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
1180 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
1182 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
1183 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
1188 static struct snd_kcontrol_new stac927x_mixer[] = {
1189 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
1190 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
1192 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
1193 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
1195 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
1196 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
1200 static struct snd_kcontrol_new stac927x_loopback[] = {
1201 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1205 static struct snd_kcontrol_new stac_dmux_mixer = {
1206 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1207 .name = "Digital Input Source",
1208 /* count set later */
1209 .info = stac92xx_dmux_enum_info,
1210 .get = stac92xx_dmux_enum_get,
1211 .put = stac92xx_dmux_enum_put,
1214 static struct snd_kcontrol_new stac_smux_mixer = {
1215 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1216 .name = "IEC958 Playback Source",
1217 /* count set later */
1218 .info = stac92xx_smux_enum_info,
1219 .get = stac92xx_smux_enum_get,
1220 .put = stac92xx_smux_enum_put,
1223 static const char *slave_vols[] = {
1224 "Front Playback Volume",
1225 "Surround Playback Volume",
1226 "Center Playback Volume",
1227 "LFE Playback Volume",
1228 "Side Playback Volume",
1229 "Headphone Playback Volume",
1230 "Headphone Playback Volume",
1231 "Speaker Playback Volume",
1232 "External Speaker Playback Volume",
1233 "Speaker2 Playback Volume",
1237 static const char *slave_sws[] = {
1238 "Front Playback Switch",
1239 "Surround Playback Switch",
1240 "Center Playback Switch",
1241 "LFE Playback Switch",
1242 "Side Playback Switch",
1243 "Headphone Playback Switch",
1244 "Headphone Playback Switch",
1245 "Speaker Playback Switch",
1246 "External Speaker Playback Switch",
1247 "Speaker2 Playback Switch",
1248 "IEC958 Playback Switch",
1252 static void stac92xx_free_kctls(struct hda_codec *codec);
1253 static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
1255 static int stac92xx_build_controls(struct hda_codec *codec)
1257 struct sigmatel_spec *spec = codec->spec;
1258 struct auto_pin_cfg *cfg = &spec->autocfg;
1263 err = snd_hda_add_new_ctls(codec, spec->mixer);
1267 for (i = 0; i < spec->num_mixers; i++) {
1268 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1272 if (spec->num_dmuxes > 0) {
1273 stac_dmux_mixer.count = spec->num_dmuxes;
1274 err = snd_hda_ctl_add(codec,
1275 snd_ctl_new1(&stac_dmux_mixer, codec));
1279 if (spec->num_smuxes > 0) {
1280 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1281 struct hda_input_mux *smux = &spec->private_smux;
1282 /* check for mute support on SPDIF out */
1283 if (wcaps & AC_WCAP_OUT_AMP) {
1284 smux->items[smux->num_items].label = "Off";
1285 smux->items[smux->num_items].index = 0;
1287 spec->spdif_mute = 1;
1289 stac_smux_mixer.count = spec->num_smuxes;
1290 err = snd_hda_ctl_add(codec,
1291 snd_ctl_new1(&stac_smux_mixer, codec));
1296 if (spec->multiout.dig_out_nid) {
1297 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1300 err = snd_hda_create_spdif_share_sw(codec,
1304 spec->multiout.share_spdif = 1;
1306 if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1307 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1312 /* if we have no master control, let's create it */
1313 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1314 unsigned int vmaster_tlv[4];
1315 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1316 HDA_OUTPUT, vmaster_tlv);
1317 /* correct volume offset */
1318 vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
1319 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1320 vmaster_tlv, slave_vols);
1324 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1325 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1331 if (spec->aloopback_ctl &&
1332 snd_hda_get_bool_hint(codec, "loopback") == 1) {
1333 err = snd_hda_add_new_ctls(codec, spec->aloopback_ctl);
1338 stac92xx_free_kctls(codec); /* no longer needed */
1340 /* create jack input elements */
1341 if (spec->hp_detect) {
1342 for (i = 0; i < cfg->hp_outs; i++) {
1343 int type = SND_JACK_HEADPHONE;
1344 nid = cfg->hp_pins[i];
1345 /* jack detection */
1346 if (cfg->hp_outs == i)
1347 type |= SND_JACK_LINEOUT;
1348 err = stac92xx_add_jack(codec, nid, type);
1353 for (i = 0; i < cfg->line_outs; i++) {
1354 err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
1359 for (i = 0; i < AUTO_PIN_LAST; i++) {
1360 nid = cfg->input_pins[i];
1362 err = stac92xx_add_jack(codec, nid,
1363 SND_JACK_MICROPHONE);
1372 static unsigned int ref9200_pin_configs[8] = {
1373 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1374 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1377 static unsigned int gateway9200_m4_pin_configs[8] = {
1378 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1379 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1381 static unsigned int gateway9200_m4_2_pin_configs[8] = {
1382 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1383 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1387 STAC 9200 pin configs for
1392 static unsigned int dell9200_d21_pin_configs[8] = {
1393 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
1394 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1398 STAC 9200 pin configs for
1402 static unsigned int dell9200_d22_pin_configs[8] = {
1403 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1404 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1408 STAC 9200 pin configs for
1409 102801C4 (Dell Dimension E310)
1416 static unsigned int dell9200_d23_pin_configs[8] = {
1417 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1418 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
1423 STAC 9200-32 pin configs for
1424 102801B5 (Dell Inspiron 630m)
1425 102801D8 (Dell Inspiron 640m)
1427 static unsigned int dell9200_m21_pin_configs[8] = {
1428 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1429 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1433 STAC 9200-32 pin configs for
1434 102801C2 (Dell Latitude D620)
1436 102801CC (Dell Latitude D820)
1440 static unsigned int dell9200_m22_pin_configs[8] = {
1441 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1442 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1446 STAC 9200-32 pin configs for
1447 102801CE (Dell XPS M1710)
1448 102801CF (Dell Precision M90)
1450 static unsigned int dell9200_m23_pin_configs[8] = {
1451 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1452 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1456 STAC 9200-32 pin configs for
1459 102801CB (Dell Latitude 120L)
1462 static unsigned int dell9200_m24_pin_configs[8] = {
1463 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1464 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1468 STAC 9200-32 pin configs for
1469 102801BD (Dell Inspiron E1505n)
1473 static unsigned int dell9200_m25_pin_configs[8] = {
1474 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1475 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1479 STAC 9200-32 pin configs for
1480 102801F5 (Dell Inspiron 1501)
1483 static unsigned int dell9200_m26_pin_configs[8] = {
1484 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1485 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1490 102801CD (Dell Inspiron E1705/9400)
1492 static unsigned int dell9200_m27_pin_configs[8] = {
1493 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1494 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1497 static unsigned int oqo9200_pin_configs[8] = {
1498 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1499 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1503 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1504 [STAC_REF] = ref9200_pin_configs,
1505 [STAC_9200_OQO] = oqo9200_pin_configs,
1506 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1507 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1508 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1509 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1510 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1511 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1512 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1513 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1514 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1515 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1516 [STAC_9200_M4] = gateway9200_m4_pin_configs,
1517 [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1518 [STAC_9200_PANASONIC] = ref9200_pin_configs,
1521 static const char *stac9200_models[STAC_9200_MODELS] = {
1522 [STAC_AUTO] = "auto",
1524 [STAC_9200_OQO] = "oqo",
1525 [STAC_9200_DELL_D21] = "dell-d21",
1526 [STAC_9200_DELL_D22] = "dell-d22",
1527 [STAC_9200_DELL_D23] = "dell-d23",
1528 [STAC_9200_DELL_M21] = "dell-m21",
1529 [STAC_9200_DELL_M22] = "dell-m22",
1530 [STAC_9200_DELL_M23] = "dell-m23",
1531 [STAC_9200_DELL_M24] = "dell-m24",
1532 [STAC_9200_DELL_M25] = "dell-m25",
1533 [STAC_9200_DELL_M26] = "dell-m26",
1534 [STAC_9200_DELL_M27] = "dell-m27",
1535 [STAC_9200_M4] = "gateway-m4",
1536 [STAC_9200_M4_2] = "gateway-m4-2",
1537 [STAC_9200_PANASONIC] = "panasonic",
1540 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1541 /* SigmaTel reference board */
1542 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1543 "DFI LanParty", STAC_REF),
1544 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1545 "DFI LanParty", STAC_REF),
1546 /* Dell laptops have BIOS problem */
1547 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1548 "unknown Dell", STAC_9200_DELL_D21),
1549 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1550 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1551 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1552 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1553 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1554 "unknown Dell", STAC_9200_DELL_D22),
1555 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1556 "unknown Dell", STAC_9200_DELL_D22),
1557 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1558 "Dell Latitude D620", STAC_9200_DELL_M22),
1559 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1560 "unknown Dell", STAC_9200_DELL_D23),
1561 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1562 "unknown Dell", STAC_9200_DELL_D23),
1563 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1564 "unknown Dell", STAC_9200_DELL_M22),
1565 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1566 "unknown Dell", STAC_9200_DELL_M24),
1567 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1568 "unknown Dell", STAC_9200_DELL_M24),
1569 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1570 "Dell Latitude 120L", STAC_9200_DELL_M24),
1571 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1572 "Dell Latitude D820", STAC_9200_DELL_M22),
1573 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1574 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1575 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1576 "Dell XPS M1710", STAC_9200_DELL_M23),
1577 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1578 "Dell Precision M90", STAC_9200_DELL_M23),
1579 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1580 "unknown Dell", STAC_9200_DELL_M22),
1581 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1582 "unknown Dell", STAC_9200_DELL_M22),
1583 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1584 "unknown Dell", STAC_9200_DELL_M22),
1585 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1586 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1587 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1588 "unknown Dell", STAC_9200_DELL_D23),
1589 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1590 "unknown Dell", STAC_9200_DELL_D23),
1591 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1592 "unknown Dell", STAC_9200_DELL_D21),
1593 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1594 "unknown Dell", STAC_9200_DELL_D23),
1595 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1596 "unknown Dell", STAC_9200_DELL_D21),
1597 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1598 "unknown Dell", STAC_9200_DELL_M25),
1599 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1600 "unknown Dell", STAC_9200_DELL_M25),
1601 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1602 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1603 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1604 "unknown Dell", STAC_9200_DELL_M26),
1606 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1607 /* Gateway machines needs EAPD to be set on resume */
1608 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1609 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1610 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1612 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1616 static unsigned int ref925x_pin_configs[8] = {
1617 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1618 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1621 static unsigned int stac925xM1_pin_configs[8] = {
1622 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1623 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1626 static unsigned int stac925xM1_2_pin_configs[8] = {
1627 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1628 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1631 static unsigned int stac925xM2_pin_configs[8] = {
1632 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1633 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1636 static unsigned int stac925xM2_2_pin_configs[8] = {
1637 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1638 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1641 static unsigned int stac925xM3_pin_configs[8] = {
1642 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1643 0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1646 static unsigned int stac925xM5_pin_configs[8] = {
1647 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1648 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1651 static unsigned int stac925xM6_pin_configs[8] = {
1652 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1653 0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1656 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1657 [STAC_REF] = ref925x_pin_configs,
1658 [STAC_M1] = stac925xM1_pin_configs,
1659 [STAC_M1_2] = stac925xM1_2_pin_configs,
1660 [STAC_M2] = stac925xM2_pin_configs,
1661 [STAC_M2_2] = stac925xM2_2_pin_configs,
1662 [STAC_M3] = stac925xM3_pin_configs,
1663 [STAC_M5] = stac925xM5_pin_configs,
1664 [STAC_M6] = stac925xM6_pin_configs,
1667 static const char *stac925x_models[STAC_925x_MODELS] = {
1668 [STAC_925x_AUTO] = "auto",
1671 [STAC_M1_2] = "m1-2",
1673 [STAC_M2_2] = "m2-2",
1679 static struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1680 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1681 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1682 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1683 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1684 SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1685 /* Not sure about the brand name for those */
1686 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1687 SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1688 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1689 SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1693 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1694 /* SigmaTel reference board */
1695 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1696 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
1697 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1699 /* Default table for unknown ID */
1700 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1705 static unsigned int ref92hd73xx_pin_configs[13] = {
1706 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1707 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1708 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1712 static unsigned int dell_m6_pin_configs[13] = {
1713 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1714 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1715 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1719 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1720 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1721 [STAC_DELL_M6_AMIC] = dell_m6_pin_configs,
1722 [STAC_DELL_M6_DMIC] = dell_m6_pin_configs,
1723 [STAC_DELL_M6_BOTH] = dell_m6_pin_configs,
1724 [STAC_DELL_EQ] = dell_m6_pin_configs,
1727 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1728 [STAC_92HD73XX_AUTO] = "auto",
1729 [STAC_92HD73XX_NO_JD] = "no-jd",
1730 [STAC_92HD73XX_REF] = "ref",
1731 [STAC_DELL_M6_AMIC] = "dell-m6-amic",
1732 [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1733 [STAC_DELL_M6_BOTH] = "dell-m6",
1734 [STAC_DELL_EQ] = "dell-eq",
1737 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1738 /* SigmaTel reference board */
1739 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1740 "DFI LanParty", STAC_92HD73XX_REF),
1741 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1742 "DFI LanParty", STAC_92HD73XX_REF),
1743 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1744 "Dell Studio 1535", STAC_DELL_M6_DMIC),
1745 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1746 "unknown Dell", STAC_DELL_M6_DMIC),
1747 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1748 "unknown Dell", STAC_DELL_M6_BOTH),
1749 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1750 "unknown Dell", STAC_DELL_M6_BOTH),
1751 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1752 "unknown Dell", STAC_DELL_M6_AMIC),
1753 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1754 "unknown Dell", STAC_DELL_M6_AMIC),
1755 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1756 "unknown Dell", STAC_DELL_M6_DMIC),
1757 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1758 "unknown Dell", STAC_DELL_M6_DMIC),
1759 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1760 "Dell Studio 1537", STAC_DELL_M6_DMIC),
1761 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1762 "Dell Studio 17", STAC_DELL_M6_DMIC),
1766 static unsigned int ref92hd83xxx_pin_configs[10] = {
1767 0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1768 0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1769 0x01451160, 0x98560170,
1772 static unsigned int dell_s14_pin_configs[10] = {
1773 0x02214030, 0x02211010, 0x02a19020, 0x01014050,
1774 0x40f000f0, 0x01819040, 0x40f000f0, 0x90a60160,
1775 0x40f000f0, 0x40f000f0,
1778 static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1779 [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1780 [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
1781 [STAC_DELL_S14] = dell_s14_pin_configs,
1784 static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1785 [STAC_92HD83XXX_AUTO] = "auto",
1786 [STAC_92HD83XXX_REF] = "ref",
1787 [STAC_92HD83XXX_PWR_REF] = "mic-ref",
1788 [STAC_DELL_S14] = "dell-s14",
1791 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1792 /* SigmaTel reference board */
1793 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1794 "DFI LanParty", STAC_92HD83XXX_REF),
1795 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1796 "DFI LanParty", STAC_92HD83XXX_REF),
1797 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
1798 "unknown Dell", STAC_DELL_S14),
1802 static unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1803 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1804 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1805 0x90a000f0, 0x01452050, 0x01452050, 0x00000000,
1809 static unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1810 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1811 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1812 0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000,
1816 static unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1817 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1818 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1819 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1823 static unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1824 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1825 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1826 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1830 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1831 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1832 [STAC_DELL_M4_1] = dell_m4_1_pin_configs,
1833 [STAC_DELL_M4_2] = dell_m4_2_pin_configs,
1834 [STAC_DELL_M4_3] = dell_m4_3_pin_configs,
1835 [STAC_HP_M4] = NULL,
1836 [STAC_HP_DV5] = NULL,
1839 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1840 [STAC_92HD71BXX_AUTO] = "auto",
1841 [STAC_92HD71BXX_REF] = "ref",
1842 [STAC_DELL_M4_1] = "dell-m4-1",
1843 [STAC_DELL_M4_2] = "dell-m4-2",
1844 [STAC_DELL_M4_3] = "dell-m4-3",
1845 [STAC_HP_M4] = "hp-m4",
1846 [STAC_HP_DV5] = "hp-dv5",
1849 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1850 /* SigmaTel reference board */
1851 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1852 "DFI LanParty", STAC_92HD71BXX_REF),
1853 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1854 "DFI LanParty", STAC_92HD71BXX_REF),
1855 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
1856 "HP dv4-7", STAC_HP_DV5),
1857 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
1858 "HP dv4-7", STAC_HP_DV5),
1859 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1860 "HP mini 1000", STAC_HP_M4),
1861 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1862 "unknown Dell", STAC_DELL_M4_1),
1863 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1864 "unknown Dell", STAC_DELL_M4_1),
1865 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1866 "unknown Dell", STAC_DELL_M4_1),
1867 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1868 "unknown Dell", STAC_DELL_M4_1),
1869 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1870 "unknown Dell", STAC_DELL_M4_1),
1871 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1872 "unknown Dell", STAC_DELL_M4_1),
1873 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1874 "unknown Dell", STAC_DELL_M4_1),
1875 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1876 "unknown Dell", STAC_DELL_M4_2),
1877 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1878 "unknown Dell", STAC_DELL_M4_2),
1879 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1880 "unknown Dell", STAC_DELL_M4_2),
1881 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1882 "unknown Dell", STAC_DELL_M4_2),
1883 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1884 "unknown Dell", STAC_DELL_M4_3),
1888 static unsigned int ref922x_pin_configs[10] = {
1889 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1890 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1891 0x40000100, 0x40000100,
1895 STAC 922X pin configs for
1902 static unsigned int dell_922x_d81_pin_configs[10] = {
1903 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1904 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1905 0x01813122, 0x400001f2,
1909 STAC 922X pin configs for
1913 static unsigned int dell_922x_d82_pin_configs[10] = {
1914 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1915 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1916 0x01813122, 0x400001f1,
1920 STAC 922X pin configs for
1923 static unsigned int dell_922x_m81_pin_configs[10] = {
1924 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1925 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1926 0x40C003f1, 0x405003f0,
1930 STAC 9221 A1 pin configs for
1931 102801D7 (Dell XPS M1210)
1933 static unsigned int dell_922x_m82_pin_configs[10] = {
1934 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1935 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1936 0x508003f3, 0x405003f4,
1939 static unsigned int d945gtp3_pin_configs[10] = {
1940 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1941 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1942 0x02a19120, 0x40000100,
1945 static unsigned int d945gtp5_pin_configs[10] = {
1946 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1947 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1948 0x02a19320, 0x40000100,
1951 static unsigned int intel_mac_v1_pin_configs[10] = {
1952 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1953 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1954 0x400000fc, 0x400000fb,
1957 static unsigned int intel_mac_v2_pin_configs[10] = {
1958 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1959 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1960 0x400000fc, 0x400000fb,
1963 static unsigned int intel_mac_v3_pin_configs[10] = {
1964 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1965 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1966 0x400000fc, 0x400000fb,
1969 static unsigned int intel_mac_v4_pin_configs[10] = {
1970 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1971 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1972 0x400000fc, 0x400000fb,
1975 static unsigned int intel_mac_v5_pin_configs[10] = {
1976 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1977 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1978 0x400000fc, 0x400000fb,
1981 static unsigned int ecs202_pin_configs[10] = {
1982 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1983 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1984 0x9037012e, 0x40e000f2,
1987 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1988 [STAC_D945_REF] = ref922x_pin_configs,
1989 [STAC_D945GTP3] = d945gtp3_pin_configs,
1990 [STAC_D945GTP5] = d945gtp5_pin_configs,
1991 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1992 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1993 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1994 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1995 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1996 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1997 /* for backward compatibility */
1998 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1999 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
2000 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
2001 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
2002 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
2003 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
2004 [STAC_ECS_202] = ecs202_pin_configs,
2005 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
2006 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
2007 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
2008 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
2011 static const char *stac922x_models[STAC_922X_MODELS] = {
2012 [STAC_922X_AUTO] = "auto",
2013 [STAC_D945_REF] = "ref",
2014 [STAC_D945GTP5] = "5stack",
2015 [STAC_D945GTP3] = "3stack",
2016 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
2017 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
2018 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
2019 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
2020 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
2021 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
2022 /* for backward compatibility */
2023 [STAC_MACMINI] = "macmini",
2024 [STAC_MACBOOK] = "macbook",
2025 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
2026 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
2027 [STAC_IMAC_INTEL] = "imac-intel",
2028 [STAC_IMAC_INTEL_20] = "imac-intel-20",
2029 [STAC_ECS_202] = "ecs202",
2030 [STAC_922X_DELL_D81] = "dell-d81",
2031 [STAC_922X_DELL_D82] = "dell-d82",
2032 [STAC_922X_DELL_M81] = "dell-m81",
2033 [STAC_922X_DELL_M82] = "dell-m82",
2036 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
2037 /* SigmaTel reference board */
2038 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2039 "DFI LanParty", STAC_D945_REF),
2040 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2041 "DFI LanParty", STAC_D945_REF),
2042 /* Intel 945G based systems */
2043 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
2044 "Intel D945G", STAC_D945GTP3),
2045 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
2046 "Intel D945G", STAC_D945GTP3),
2047 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
2048 "Intel D945G", STAC_D945GTP3),
2049 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
2050 "Intel D945G", STAC_D945GTP3),
2051 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
2052 "Intel D945G", STAC_D945GTP3),
2053 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
2054 "Intel D945G", STAC_D945GTP3),
2055 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
2056 "Intel D945G", STAC_D945GTP3),
2057 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
2058 "Intel D945G", STAC_D945GTP3),
2059 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
2060 "Intel D945G", STAC_D945GTP3),
2061 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
2062 "Intel D945G", STAC_D945GTP3),
2063 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
2064 "Intel D945G", STAC_D945GTP3),
2065 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
2066 "Intel D945G", STAC_D945GTP3),
2067 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
2068 "Intel D945G", STAC_D945GTP3),
2069 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
2070 "Intel D945G", STAC_D945GTP3),
2071 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
2072 "Intel D945G", STAC_D945GTP3),
2073 /* Intel D945G 5-stack systems */
2074 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
2075 "Intel D945G", STAC_D945GTP5),
2076 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
2077 "Intel D945G", STAC_D945GTP5),
2078 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
2079 "Intel D945G", STAC_D945GTP5),
2080 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
2081 "Intel D945G", STAC_D945GTP5),
2082 /* Intel 945P based systems */
2083 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
2084 "Intel D945P", STAC_D945GTP3),
2085 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
2086 "Intel D945P", STAC_D945GTP3),
2087 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
2088 "Intel D945P", STAC_D945GTP3),
2089 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
2090 "Intel D945P", STAC_D945GTP3),
2091 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
2092 "Intel D945P", STAC_D945GTP3),
2093 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
2094 "Intel D945P", STAC_D945GTP5),
2096 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
2097 "Intel D945", STAC_D945_REF),
2099 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
2100 SND_PCI_QUIRK(0x8384, 0x7680,
2101 "Mac", STAC_INTEL_MAC_AUTO),
2103 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
2104 "unknown Dell", STAC_922X_DELL_D81),
2105 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
2106 "unknown Dell", STAC_922X_DELL_D81),
2107 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
2108 "unknown Dell", STAC_922X_DELL_D81),
2109 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
2110 "unknown Dell", STAC_922X_DELL_D82),
2111 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
2112 "unknown Dell", STAC_922X_DELL_M81),
2113 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
2114 "unknown Dell", STAC_922X_DELL_D82),
2115 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
2116 "unknown Dell", STAC_922X_DELL_D81),
2117 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
2118 "unknown Dell", STAC_922X_DELL_D81),
2119 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
2120 "Dell XPS M1210", STAC_922X_DELL_M82),
2121 /* ECS/PC Chips boards */
2122 SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
2123 "ECS/PC chips", STAC_ECS_202),
2127 static unsigned int ref927x_pin_configs[14] = {
2128 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2129 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
2130 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2131 0x01c42190, 0x40000100,
2134 static unsigned int d965_3st_pin_configs[14] = {
2135 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2136 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2137 0x40000100, 0x40000100, 0x40000100, 0x40000100,
2138 0x40000100, 0x40000100
2141 static unsigned int d965_5st_pin_configs[14] = {
2142 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2143 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2144 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2145 0x40000100, 0x40000100
2148 static unsigned int dell_3st_pin_configs[14] = {
2149 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2150 0x01111212, 0x01116211, 0x01813050, 0x01112214,
2151 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2152 0x40c003fc, 0x40000100
2155 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2156 [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2157 [STAC_D965_REF] = ref927x_pin_configs,
2158 [STAC_D965_3ST] = d965_3st_pin_configs,
2159 [STAC_D965_5ST] = d965_5st_pin_configs,
2160 [STAC_DELL_3ST] = dell_3st_pin_configs,
2161 [STAC_DELL_BIOS] = NULL,
2164 static const char *stac927x_models[STAC_927X_MODELS] = {
2165 [STAC_927X_AUTO] = "auto",
2166 [STAC_D965_REF_NO_JD] = "ref-no-jd",
2167 [STAC_D965_REF] = "ref",
2168 [STAC_D965_3ST] = "3stack",
2169 [STAC_D965_5ST] = "5stack",
2170 [STAC_DELL_3ST] = "dell-3stack",
2171 [STAC_DELL_BIOS] = "dell-bios",
2174 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2175 /* SigmaTel reference board */
2176 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2177 "DFI LanParty", STAC_D965_REF),
2178 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2179 "DFI LanParty", STAC_D965_REF),
2180 /* Intel 946 based systems */
2181 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2182 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2183 /* 965 based 3 stack systems */
2184 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
2185 "Intel D965", STAC_D965_3ST),
2186 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
2187 "Intel D965", STAC_D965_3ST),
2188 /* Dell 3 stack systems */
2189 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
2190 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2191 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
2192 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
2193 /* Dell 3 stack systems with verb table in BIOS */
2194 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2195 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
2196 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
2197 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_3ST),
2198 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
2199 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
2200 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
2201 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2202 /* 965 based 5 stack systems */
2203 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
2204 "Intel D965", STAC_D965_5ST),
2205 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
2206 "Intel D965", STAC_D965_5ST),
2210 static unsigned int ref9205_pin_configs[12] = {
2211 0x40000100, 0x40000100, 0x01016011, 0x01014010,
2212 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2213 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2217 STAC 9205 pin configs for
2224 10280228 (Dell Vostro 1500)
2226 static unsigned int dell_9205_m42_pin_configs[12] = {
2227 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2228 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2229 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2233 STAC 9205 pin configs for
2237 102801FF (Dell Precision M4300)
2242 static unsigned int dell_9205_m43_pin_configs[12] = {
2243 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2244 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2245 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2248 static unsigned int dell_9205_m44_pin_configs[12] = {
2249 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2250 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2251 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2254 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2255 [STAC_9205_REF] = ref9205_pin_configs,
2256 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2257 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2258 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2259 [STAC_9205_EAPD] = NULL,
2262 static const char *stac9205_models[STAC_9205_MODELS] = {
2263 [STAC_9205_AUTO] = "auto",
2264 [STAC_9205_REF] = "ref",
2265 [STAC_9205_DELL_M42] = "dell-m42",
2266 [STAC_9205_DELL_M43] = "dell-m43",
2267 [STAC_9205_DELL_M44] = "dell-m44",
2268 [STAC_9205_EAPD] = "eapd",
2271 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
2272 /* SigmaTel reference board */
2273 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2274 "DFI LanParty", STAC_9205_REF),
2275 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2276 "DFI LanParty", STAC_9205_REF),
2278 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2279 "unknown Dell", STAC_9205_DELL_M42),
2280 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2281 "unknown Dell", STAC_9205_DELL_M42),
2282 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2283 "Dell Precision", STAC_9205_DELL_M43),
2284 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2285 "Dell Precision", STAC_9205_DELL_M43),
2286 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2287 "Dell Precision", STAC_9205_DELL_M43),
2288 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2289 "unknown Dell", STAC_9205_DELL_M42),
2290 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2291 "unknown Dell", STAC_9205_DELL_M42),
2292 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2293 "Dell Precision", STAC_9205_DELL_M43),
2294 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2295 "Dell Precision M4300", STAC_9205_DELL_M43),
2296 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2297 "unknown Dell", STAC_9205_DELL_M42),
2298 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2299 "Dell Precision", STAC_9205_DELL_M43),
2300 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2301 "Dell Precision", STAC_9205_DELL_M43),
2302 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2303 "Dell Precision", STAC_9205_DELL_M43),
2304 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2305 "Dell Inspiron", STAC_9205_DELL_M44),
2306 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2307 "Dell Vostro 1500", STAC_9205_DELL_M42),
2309 SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
2313 static void stac92xx_set_config_regs(struct hda_codec *codec,
2314 unsigned int *pincfgs)
2317 struct sigmatel_spec *spec = codec->spec;
2322 for (i = 0; i < spec->num_pins; i++)
2323 if (spec->pin_nids[i] && pincfgs[i])
2324 snd_hda_codec_set_pincfg(codec, spec->pin_nids[i],
2329 * Analog playback callbacks
2331 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2332 struct hda_codec *codec,
2333 struct snd_pcm_substream *substream)
2335 struct sigmatel_spec *spec = codec->spec;
2336 if (spec->stream_delay)
2337 msleep(spec->stream_delay);
2338 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2342 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2343 struct hda_codec *codec,
2344 unsigned int stream_tag,
2345 unsigned int format,
2346 struct snd_pcm_substream *substream)
2348 struct sigmatel_spec *spec = codec->spec;
2349 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2352 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2353 struct hda_codec *codec,
2354 struct snd_pcm_substream *substream)
2356 struct sigmatel_spec *spec = codec->spec;
2357 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2361 * Digital playback callbacks
2363 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2364 struct hda_codec *codec,
2365 struct snd_pcm_substream *substream)
2367 struct sigmatel_spec *spec = codec->spec;
2368 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2371 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2372 struct hda_codec *codec,
2373 struct snd_pcm_substream *substream)
2375 struct sigmatel_spec *spec = codec->spec;
2376 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2379 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2380 struct hda_codec *codec,
2381 unsigned int stream_tag,
2382 unsigned int format,
2383 struct snd_pcm_substream *substream)
2385 struct sigmatel_spec *spec = codec->spec;
2386 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2387 stream_tag, format, substream);
2390 static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2391 struct hda_codec *codec,
2392 struct snd_pcm_substream *substream)
2394 struct sigmatel_spec *spec = codec->spec;
2395 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2400 * Analog capture callbacks
2402 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2403 struct hda_codec *codec,
2404 unsigned int stream_tag,
2405 unsigned int format,
2406 struct snd_pcm_substream *substream)
2408 struct sigmatel_spec *spec = codec->spec;
2409 hda_nid_t nid = spec->adc_nids[substream->number];
2411 if (spec->powerdown_adcs) {
2413 snd_hda_codec_write(codec, nid, 0,
2414 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2416 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2420 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2421 struct hda_codec *codec,
2422 struct snd_pcm_substream *substream)
2424 struct sigmatel_spec *spec = codec->spec;
2425 hda_nid_t nid = spec->adc_nids[substream->number];
2427 snd_hda_codec_cleanup_stream(codec, nid);
2428 if (spec->powerdown_adcs)
2429 snd_hda_codec_write(codec, nid, 0,
2430 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2434 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2438 /* NID is set in stac92xx_build_pcms */
2440 .open = stac92xx_dig_playback_pcm_open,
2441 .close = stac92xx_dig_playback_pcm_close,
2442 .prepare = stac92xx_dig_playback_pcm_prepare,
2443 .cleanup = stac92xx_dig_playback_pcm_cleanup
2447 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2451 /* NID is set in stac92xx_build_pcms */
2454 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2458 .nid = 0x02, /* NID to query formats and rates */
2460 .open = stac92xx_playback_pcm_open,
2461 .prepare = stac92xx_playback_pcm_prepare,
2462 .cleanup = stac92xx_playback_pcm_cleanup
2466 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2470 .nid = 0x06, /* NID to query formats and rates */
2472 .open = stac92xx_playback_pcm_open,
2473 .prepare = stac92xx_playback_pcm_prepare,
2474 .cleanup = stac92xx_playback_pcm_cleanup
2478 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2481 /* NID + .substreams is set in stac92xx_build_pcms */
2483 .prepare = stac92xx_capture_pcm_prepare,
2484 .cleanup = stac92xx_capture_pcm_cleanup
2488 static int stac92xx_build_pcms(struct hda_codec *codec)
2490 struct sigmatel_spec *spec = codec->spec;
2491 struct hda_pcm *info = spec->pcm_rec;
2493 codec->num_pcms = 1;
2494 codec->pcm_info = info;
2496 info->name = "STAC92xx Analog";
2497 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2498 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2499 spec->multiout.dac_nids[0];
2500 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2501 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2502 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2504 if (spec->alt_switch) {
2507 info->name = "STAC92xx Analog Alt";
2508 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2511 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2514 info->name = "STAC92xx Digital";
2515 info->pcm_type = spec->autocfg.dig_out_type[0];
2516 if (spec->multiout.dig_out_nid) {
2517 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2518 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2520 if (spec->dig_in_nid) {
2521 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2522 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2529 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
2531 unsigned int pincap = snd_hda_param_read(codec, nid,
2533 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2534 if (pincap & AC_PINCAP_VREF_100)
2535 return AC_PINCTL_VREF_100;
2536 if (pincap & AC_PINCAP_VREF_80)
2537 return AC_PINCTL_VREF_80;
2538 if (pincap & AC_PINCAP_VREF_50)
2539 return AC_PINCTL_VREF_50;
2540 if (pincap & AC_PINCAP_VREF_GRD)
2541 return AC_PINCTL_VREF_GRD;
2545 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2548 snd_hda_codec_write_cache(codec, nid, 0,
2549 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2552 #define stac92xx_hp_switch_info snd_ctl_boolean_mono_info
2554 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2555 struct snd_ctl_elem_value *ucontrol)
2557 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2558 struct sigmatel_spec *spec = codec->spec;
2560 ucontrol->value.integer.value[0] = !!spec->hp_switch;
2564 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
2565 unsigned char type);
2567 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2568 struct snd_ctl_elem_value *ucontrol)
2570 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2571 struct sigmatel_spec *spec = codec->spec;
2572 int nid = kcontrol->private_value;
2574 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2576 /* check to be sure that the ports are upto date with
2579 stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
2584 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
2586 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2588 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2589 struct sigmatel_spec *spec = codec->spec;
2590 int io_idx = kcontrol-> private_value & 0xff;
2592 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
2596 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2598 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2599 struct sigmatel_spec *spec = codec->spec;
2600 hda_nid_t nid = kcontrol->private_value >> 8;
2601 int io_idx = kcontrol-> private_value & 0xff;
2602 unsigned short val = !!ucontrol->value.integer.value[0];
2604 spec->io_switch[io_idx] = val;
2607 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2609 unsigned int pinctl = AC_PINCTL_IN_EN;
2610 if (io_idx) /* set VREF for mic */
2611 pinctl |= stac92xx_get_vref(codec, nid);
2612 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2615 /* check the auto-mute again: we need to mute/unmute the speaker
2616 * appropriately according to the pin direction
2618 if (spec->hp_detect)
2619 stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
2624 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2626 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2627 struct snd_ctl_elem_value *ucontrol)
2629 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2630 struct sigmatel_spec *spec = codec->spec;
2632 ucontrol->value.integer.value[0] = spec->clfe_swap;
2636 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2637 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 & 0xff;
2642 unsigned int val = !!ucontrol->value.integer.value[0];
2644 if (spec->clfe_swap == val)
2647 spec->clfe_swap = val;
2649 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2650 spec->clfe_swap ? 0x4 : 0x0);
2655 #define STAC_CODEC_HP_SWITCH(xname) \
2656 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2659 .info = stac92xx_hp_switch_info, \
2660 .get = stac92xx_hp_switch_get, \
2661 .put = stac92xx_hp_switch_put, \
2664 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2665 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2668 .info = stac92xx_io_switch_info, \
2669 .get = stac92xx_io_switch_get, \
2670 .put = stac92xx_io_switch_put, \
2671 .private_value = xpval, \
2674 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2675 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2678 .info = stac92xx_clfe_switch_info, \
2679 .get = stac92xx_clfe_switch_get, \
2680 .put = stac92xx_clfe_switch_put, \
2681 .private_value = xpval, \
2685 STAC_CTL_WIDGET_VOL,
2686 STAC_CTL_WIDGET_MUTE,
2687 STAC_CTL_WIDGET_MONO_MUX,
2688 STAC_CTL_WIDGET_AMP_MUX,
2689 STAC_CTL_WIDGET_AMP_VOL,
2690 STAC_CTL_WIDGET_HP_SWITCH,
2691 STAC_CTL_WIDGET_IO_SWITCH,
2692 STAC_CTL_WIDGET_CLFE_SWITCH
2695 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2696 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2697 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2700 STAC_AMP_VOL(NULL, 0, 0, 0, 0),
2701 STAC_CODEC_HP_SWITCH(NULL),
2702 STAC_CODEC_IO_SWITCH(NULL, 0),
2703 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2706 /* add dynamic controls */
2707 static struct snd_kcontrol_new *
2708 stac_control_new(struct sigmatel_spec *spec,
2709 struct snd_kcontrol_new *ktemp,
2712 struct snd_kcontrol_new *knew;
2714 snd_array_init(&spec->kctls, sizeof(*knew), 32);
2715 knew = snd_array_new(&spec->kctls);
2719 knew->name = kstrdup(name, GFP_KERNEL);
2722 memset(knew, 0, sizeof(*knew));
2723 spec->kctls.alloced--;
2729 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2730 struct snd_kcontrol_new *ktemp,
2731 int idx, const char *name,
2734 struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name);
2738 knew->private_value = val;
2742 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2743 int type, int idx, const char *name,
2746 return stac92xx_add_control_temp(spec,
2747 &stac92xx_control_templates[type],
2752 /* add dynamic controls */
2753 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2754 const char *name, unsigned long val)
2756 return stac92xx_add_control_idx(spec, type, 0, name, val);
2759 static struct snd_kcontrol_new stac_input_src_temp = {
2760 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2761 .name = "Input Source",
2762 .info = stac92xx_mux_enum_info,
2763 .get = stac92xx_mux_enum_get,
2764 .put = stac92xx_mux_enum_put,
2767 static int stac92xx_add_input_source(struct sigmatel_spec *spec)
2769 struct snd_kcontrol_new *knew;
2770 struct hda_input_mux *imux = &spec->private_imux;
2772 if (!spec->num_adcs || imux->num_items <= 1)
2773 return 0; /* no need for input source control */
2774 knew = stac_control_new(spec, &stac_input_src_temp,
2775 stac_input_src_temp.name);
2778 knew->count = spec->num_adcs;
2782 /* check whether the line-input can be used as line-out */
2783 static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2785 struct sigmatel_spec *spec = codec->spec;
2786 struct auto_pin_cfg *cfg = &spec->autocfg;
2788 unsigned int pincap;
2790 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2792 nid = cfg->input_pins[AUTO_PIN_LINE];
2793 pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
2794 if (pincap & AC_PINCAP_OUT)
2799 /* check whether the mic-input can be used as line-out */
2800 static hda_nid_t check_mic_out_switch(struct hda_codec *codec)
2802 struct sigmatel_spec *spec = codec->spec;
2803 struct auto_pin_cfg *cfg = &spec->autocfg;
2804 unsigned int def_conf, pincap;
2805 unsigned int mic_pin;
2807 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2809 mic_pin = AUTO_PIN_MIC;
2811 hda_nid_t nid = cfg->input_pins[mic_pin];
2812 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2813 /* some laptops have an internal analog microphone
2814 * which can't be used as a output */
2815 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2816 pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
2817 if (pincap & AC_PINCAP_OUT)
2820 if (mic_pin == AUTO_PIN_MIC)
2821 mic_pin = AUTO_PIN_FRONT_MIC;
2828 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2832 for (i = 0; i < spec->multiout.num_dacs; i++) {
2833 if (spec->multiout.dac_nids[i] == nid)
2840 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2843 if (is_in_dac_nids(spec, nid))
2845 for (i = 0; i < spec->autocfg.hp_outs; i++)
2846 if (spec->hp_dacs[i] == nid)
2848 for (i = 0; i < spec->autocfg.speaker_outs; i++)
2849 if (spec->speaker_dacs[i] == nid)
2854 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2856 struct sigmatel_spec *spec = codec->spec;
2858 hda_nid_t conn[HDA_MAX_CONNECTIONS];
2859 unsigned int wcaps, wtype;
2861 conn_len = snd_hda_get_connections(codec, nid, conn,
2862 HDA_MAX_CONNECTIONS);
2863 for (j = 0; j < conn_len; j++) {
2864 wcaps = snd_hda_param_read(codec, conn[j],
2865 AC_PAR_AUDIO_WIDGET_CAP);
2866 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2867 /* we check only analog outputs */
2868 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2870 /* if this route has a free DAC, assign it */
2871 if (!check_all_dac_nids(spec, conn[j])) {
2873 /* select this DAC in the pin's input mux */
2874 snd_hda_codec_write_cache(codec, nid, 0,
2875 AC_VERB_SET_CONNECT_SEL, j);
2883 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2884 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2887 * Fill in the dac_nids table from the parsed pin configuration
2888 * This function only works when every pin in line_out_pins[]
2889 * contains atleast one DAC in its connection list. Some 92xx
2890 * codecs are not connected directly to a DAC, such as the 9200
2891 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2893 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2895 struct sigmatel_spec *spec = codec->spec;
2896 struct auto_pin_cfg *cfg = &spec->autocfg;
2900 for (i = 0; i < cfg->line_outs; i++) {
2901 nid = cfg->line_out_pins[i];
2902 dac = get_unassigned_dac(codec, nid);
2904 if (spec->multiout.num_dacs > 0) {
2905 /* we have already working output pins,
2906 * so let's drop the broken ones again
2908 cfg->line_outs = spec->multiout.num_dacs;
2911 /* error out, no available DAC found */
2913 "%s: No available DAC for pin 0x%x\n",
2917 add_spec_dacs(spec, dac);
2920 /* add line-in as output */
2921 nid = check_line_out_switch(codec);
2923 dac = get_unassigned_dac(codec, nid);
2925 snd_printdd("STAC: Add line-in 0x%x as output %d\n",
2926 nid, cfg->line_outs);
2927 cfg->line_out_pins[cfg->line_outs] = nid;
2929 spec->line_switch = nid;
2930 add_spec_dacs(spec, dac);
2933 /* add mic as output */
2934 nid = check_mic_out_switch(codec);
2936 dac = get_unassigned_dac(codec, nid);
2938 snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
2939 nid, cfg->line_outs);
2940 cfg->line_out_pins[cfg->line_outs] = nid;
2942 spec->mic_switch = nid;
2943 add_spec_dacs(spec, dac);
2947 for (i = 0; i < cfg->hp_outs; i++) {
2948 nid = cfg->hp_pins[i];
2949 dac = get_unassigned_dac(codec, nid);
2951 if (!spec->multiout.hp_nid)
2952 spec->multiout.hp_nid = dac;
2954 add_spec_extra_dacs(spec, dac);
2956 spec->hp_dacs[i] = dac;
2959 for (i = 0; i < cfg->speaker_outs; i++) {
2960 nid = cfg->speaker_pins[i];
2961 dac = get_unassigned_dac(codec, nid);
2963 add_spec_extra_dacs(spec, dac);
2964 spec->speaker_dacs[i] = dac;
2967 snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2968 spec->multiout.num_dacs,
2969 spec->multiout.dac_nids[0],
2970 spec->multiout.dac_nids[1],
2971 spec->multiout.dac_nids[2],
2972 spec->multiout.dac_nids[3],
2973 spec->multiout.dac_nids[4]);
2978 /* create volume control/switch for the given prefx type */
2979 static int create_controls(struct hda_codec *codec, const char *pfx,
2980 hda_nid_t nid, int chs)
2982 struct sigmatel_spec *spec = codec->spec;
2986 if (!spec->check_volume_offset) {
2987 unsigned int caps, step, nums, db_scale;
2988 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
2989 step = (caps & AC_AMPCAP_STEP_SIZE) >>
2990 AC_AMPCAP_STEP_SIZE_SHIFT;
2991 step = (step + 1) * 25; /* in .01dB unit */
2992 nums = (caps & AC_AMPCAP_NUM_STEPS) >>
2993 AC_AMPCAP_NUM_STEPS_SHIFT;
2994 db_scale = nums * step;
2995 /* if dB scale is over -64dB, and finer enough,
2996 * let's reduce it to half
2998 if (db_scale > 6400 && nums >= 0x1f)
2999 spec->volume_offset = nums / 2;
3000 spec->check_volume_offset = 1;
3003 sprintf(name, "%s Playback Volume", pfx);
3004 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
3005 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3006 spec->volume_offset));
3009 sprintf(name, "%s Playback Switch", pfx);
3010 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
3011 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3017 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3019 if (spec->multiout.num_dacs > 4) {
3020 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3023 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
3024 spec->multiout.num_dacs++;
3029 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3032 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3033 if (!spec->multiout.extra_out_nid[i]) {
3034 spec->multiout.extra_out_nid[i] = nid;
3038 printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3042 static int is_unique_dac(struct sigmatel_spec *spec, hda_nid_t nid)
3046 if (spec->autocfg.line_outs != 1)
3048 if (spec->multiout.hp_nid == nid)
3050 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++)
3051 if (spec->multiout.extra_out_nid[i] == nid)
3056 /* add playback controls from the parsed DAC table */
3057 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3058 const struct auto_pin_cfg *cfg)
3060 struct sigmatel_spec *spec = codec->spec;
3061 static const char *chname[4] = {
3062 "Front", "Surround", NULL /*CLFE*/, "Side"
3066 unsigned int wid_caps;
3068 for (i = 0; i < cfg->line_outs && spec->multiout.dac_nids[i]; i++) {
3069 nid = spec->multiout.dac_nids[i];
3072 err = create_controls(codec, "Center", nid, 1);
3075 err = create_controls(codec, "LFE", nid, 2);
3079 wid_caps = get_wcaps(codec, nid);
3081 if (wid_caps & AC_WCAP_LR_SWAP) {
3082 err = stac92xx_add_control(spec,
3083 STAC_CTL_WIDGET_CLFE_SWITCH,
3084 "Swap Center/LFE Playback Switch", nid);
3091 const char *name = chname[i];
3092 /* if it's a single DAC, assign a better name */
3093 if (!i && is_unique_dac(spec, nid)) {
3094 switch (cfg->line_out_type) {
3095 case AUTO_PIN_HP_OUT:
3098 case AUTO_PIN_SPEAKER_OUT:
3103 err = create_controls(codec, name, nid, 3);
3109 if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3110 err = stac92xx_add_control(spec,
3111 STAC_CTL_WIDGET_HP_SWITCH,
3112 "Headphone as Line Out Switch",
3113 cfg->hp_pins[cfg->hp_outs - 1]);
3118 if (spec->line_switch) {
3119 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
3120 "Line In as Output Switch",
3121 spec->line_switch << 8);
3126 if (spec->mic_switch) {
3127 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
3128 "Mic as Output Switch",
3129 (spec->mic_switch << 8) | 1);
3137 /* add playback controls for Speaker and HP outputs */
3138 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3139 struct auto_pin_cfg *cfg)
3141 struct sigmatel_spec *spec = codec->spec;
3146 for (i = 0; i < cfg->hp_outs; i++) {
3147 static const char *pfxs[] = {
3148 "Headphone", "Headphone2", "Headphone3",
3150 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
3151 if (wid_caps & AC_WCAP_UNSOL_CAP)
3152 spec->hp_detect = 1;
3153 if (nums >= ARRAY_SIZE(pfxs))
3155 nid = spec->hp_dacs[i];
3158 err = create_controls(codec, pfxs[nums++], nid, 3);
3163 for (i = 0; i < cfg->speaker_outs; i++) {
3164 static const char *pfxs[] = {
3165 "Speaker", "External Speaker", "Speaker2",
3167 if (nums >= ARRAY_SIZE(pfxs))
3169 nid = spec->speaker_dacs[i];
3172 err = create_controls(codec, pfxs[nums++], nid, 3);
3179 /* labels for mono mux outputs */
3180 static const char *stac92xx_mono_labels[4] = {
3181 "DAC0", "DAC1", "Mixer", "DAC2"
3184 /* create mono mux for mono out on capable codecs */
3185 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3187 struct sigmatel_spec *spec = codec->spec;
3188 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3190 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3192 num_cons = snd_hda_get_connections(codec,
3195 HDA_MAX_NUM_INPUTS);
3196 if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3199 for (i = 0; i < num_cons; i++) {
3200 mono_mux->items[mono_mux->num_items].label =
3201 stac92xx_mono_labels[i];
3202 mono_mux->items[mono_mux->num_items].index = i;
3203 mono_mux->num_items++;
3206 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3207 "Mono Mux", spec->mono_nid);
3210 /* labels for amp mux outputs */
3211 static const char *stac92xx_amp_labels[3] = {
3212 "Front Microphone", "Microphone", "Line In",
3215 /* create amp out controls mux on capable codecs */
3216 static int stac92xx_auto_create_amp_output_ctls(struct hda_codec *codec)
3218 struct sigmatel_spec *spec = codec->spec;
3219 struct hda_input_mux *amp_mux = &spec->private_amp_mux;
3222 for (i = 0; i < spec->num_amps; i++) {
3223 amp_mux->items[amp_mux->num_items].label =
3224 stac92xx_amp_labels[i];
3225 amp_mux->items[amp_mux->num_items].index = i;
3226 amp_mux->num_items++;
3229 if (spec->num_amps > 1) {
3230 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_MUX,
3231 "Amp Selector Capture Switch", 0);
3235 return stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_VOL,
3236 "Amp Capture Volume",
3237 HDA_COMPOSE_AMP_VAL(spec->amp_nids[0], 3, 0, HDA_INPUT));
3241 /* create PC beep volume controls */
3242 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3245 struct sigmatel_spec *spec = codec->spec;
3246 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3249 /* check for mute support for the the amp */
3250 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3251 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3252 "PC Beep Playback Switch",
3253 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3258 /* check to see if there is volume support for the amp */
3259 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3260 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3261 "PC Beep Playback Volume",
3262 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3269 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3270 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3272 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3273 struct snd_ctl_elem_value *ucontrol)
3275 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3276 ucontrol->value.integer.value[0] = codec->beep->enabled;
3280 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3281 struct snd_ctl_elem_value *ucontrol)
3283 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3284 int enabled = !!ucontrol->value.integer.value[0];
3285 if (codec->beep->enabled != enabled) {
3286 codec->beep->enabled = enabled;
3292 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3293 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3294 .info = stac92xx_dig_beep_switch_info,
3295 .get = stac92xx_dig_beep_switch_get,
3296 .put = stac92xx_dig_beep_switch_put,
3299 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3301 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3302 0, "PC Beep Playback Switch", 0);
3306 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3308 struct sigmatel_spec *spec = codec->spec;
3309 int wcaps, nid, i, err = 0;
3311 for (i = 0; i < spec->num_muxes; i++) {
3312 nid = spec->mux_nids[i];
3313 wcaps = get_wcaps(codec, nid);
3315 if (wcaps & AC_WCAP_OUT_AMP) {
3316 err = stac92xx_add_control_idx(spec,
3317 STAC_CTL_WIDGET_VOL, i, "Mux Capture Volume",
3318 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3326 static const char *stac92xx_spdif_labels[3] = {
3327 "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3330 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3332 struct sigmatel_spec *spec = codec->spec;
3333 struct hda_input_mux *spdif_mux = &spec->private_smux;
3334 const char **labels = spec->spdif_labels;
3336 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3338 num_cons = snd_hda_get_connections(codec,
3341 HDA_MAX_NUM_INPUTS);
3346 labels = stac92xx_spdif_labels;
3348 for (i = 0; i < num_cons; i++) {
3349 spdif_mux->items[spdif_mux->num_items].label = labels[i];
3350 spdif_mux->items[spdif_mux->num_items].index = i;
3351 spdif_mux->num_items++;
3357 /* labels for dmic mux inputs */
3358 static const char *stac92xx_dmic_labels[5] = {
3359 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3360 "Digital Mic 3", "Digital Mic 4"
3363 /* create playback/capture controls for input pins on dmic capable codecs */
3364 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3365 const struct auto_pin_cfg *cfg)
3367 struct sigmatel_spec *spec = codec->spec;
3368 struct hda_input_mux *dimux = &spec->private_dimux;
3369 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3373 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
3374 dimux->items[dimux->num_items].index = 0;
3377 for (i = 0; i < spec->num_dmics; i++) {
3382 unsigned int def_conf;
3384 def_conf = snd_hda_codec_get_pincfg(codec, spec->dmic_nids[i]);
3385 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3388 nid = spec->dmic_nids[i];
3389 num_cons = snd_hda_get_connections(codec,
3392 HDA_MAX_NUM_INPUTS);
3393 for (j = 0; j < num_cons; j++)
3394 if (con_lst[j] == nid) {
3400 wcaps = get_wcaps(codec, nid) &
3401 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3404 sprintf(name, "%s Capture Volume",
3405 stac92xx_dmic_labels[dimux->num_items]);
3407 err = stac92xx_add_control(spec,
3408 STAC_CTL_WIDGET_VOL,
3410 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3411 (wcaps & AC_WCAP_OUT_AMP) ?
3412 HDA_OUTPUT : HDA_INPUT));
3417 dimux->items[dimux->num_items].label =
3418 stac92xx_dmic_labels[dimux->num_items];
3419 dimux->items[dimux->num_items].index = index;
3426 /* create playback/capture controls for input pins */
3427 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3429 struct sigmatel_spec *spec = codec->spec;
3430 struct hda_input_mux *imux = &spec->private_imux;
3431 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3434 for (i = 0; i < AUTO_PIN_LAST; i++) {
3437 if (!cfg->input_pins[i])
3440 for (j = 0; j < spec->num_muxes; j++) {
3442 num_cons = snd_hda_get_connections(codec,
3445 HDA_MAX_NUM_INPUTS);
3446 for (k = 0; k < num_cons; k++)
3447 if (con_lst[k] == cfg->input_pins[i]) {
3454 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3455 imux->items[imux->num_items].index = index;
3459 if (imux->num_items) {
3461 * Set the current input for the muxes.
3462 * The STAC9221 has two input muxes with identical source
3463 * NID lists. Hopefully this won't get confused.
3465 for (i = 0; i < spec->num_muxes; i++) {
3466 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3467 AC_VERB_SET_CONNECT_SEL,
3468 imux->items[0].index);
3475 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3477 struct sigmatel_spec *spec = codec->spec;
3480 for (i = 0; i < spec->autocfg.line_outs; i++) {
3481 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3482 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3486 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3488 struct sigmatel_spec *spec = codec->spec;
3491 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3493 pin = spec->autocfg.hp_pins[i];
3494 if (pin) /* connect to front */
3495 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3497 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3499 pin = spec->autocfg.speaker_pins[i];
3500 if (pin) /* connect to front */
3501 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3505 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3507 struct sigmatel_spec *spec = codec->spec;
3510 if ((err = snd_hda_parse_pin_def_config(codec,
3512 spec->dmic_nids)) < 0)
3514 if (! spec->autocfg.line_outs)
3515 return 0; /* can't find valid pin config */
3517 /* If we have no real line-out pin and multiple hp-outs, HPs should
3518 * be set up as multi-channel outputs.
3520 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
3521 spec->autocfg.hp_outs > 1) {
3522 /* Copy hp_outs to line_outs, backup line_outs in
3523 * speaker_outs so that the following routines can handle
3524 * HP pins as primary outputs.
3526 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3527 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3528 sizeof(spec->autocfg.line_out_pins));
3529 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3530 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3531 sizeof(spec->autocfg.hp_pins));
3532 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3533 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3534 spec->autocfg.hp_outs = 0;
3536 if (spec->autocfg.mono_out_pin) {
3537 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3538 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3539 u32 caps = query_amp_caps(codec,
3540 spec->autocfg.mono_out_pin, dir);
3541 hda_nid_t conn_list[1];
3543 /* get the mixer node and then the mono mux if it exists */
3544 if (snd_hda_get_connections(codec,
3545 spec->autocfg.mono_out_pin, conn_list, 1) &&
3546 snd_hda_get_connections(codec, conn_list[0],
3549 int wcaps = get_wcaps(codec, conn_list[0]);
3550 int wid_type = (wcaps & AC_WCAP_TYPE)
3551 >> AC_WCAP_TYPE_SHIFT;
3552 /* LR swap check, some stac925x have a mux that
3553 * changes the DACs output path instead of the
3556 if (wid_type == AC_WID_AUD_SEL &&
3557 !(wcaps & AC_WCAP_LR_SWAP))
3558 spec->mono_nid = conn_list[0];
3561 hda_nid_t nid = spec->autocfg.mono_out_pin;
3563 /* most mono outs have a least a mute/unmute switch */
3564 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3565 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3566 "Mono Playback Switch",
3567 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3570 /* check for volume support for the amp */
3571 if ((caps & AC_AMPCAP_NUM_STEPS)
3572 >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3573 err = stac92xx_add_control(spec,
3574 STAC_CTL_WIDGET_VOL,
3575 "Mono Playback Volume",
3576 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3582 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3586 if (!spec->multiout.num_dacs) {
3587 err = stac92xx_auto_fill_dac_nids(codec);
3590 err = stac92xx_auto_create_multi_out_ctls(codec,
3596 /* setup analog beep controls */
3597 if (spec->anabeep_nid > 0) {
3598 err = stac92xx_auto_create_beep_ctls(codec,
3604 /* setup digital beep controls and input device */
3605 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3606 if (spec->digbeep_nid > 0) {
3607 hda_nid_t nid = spec->digbeep_nid;
3610 err = stac92xx_auto_create_beep_ctls(codec, nid);
3613 err = snd_hda_attach_beep_device(codec, nid);
3616 /* if no beep switch is available, make its own one */
3617 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3619 !((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT)) {
3620 err = stac92xx_beep_switch_ctl(codec);
3627 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3632 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3637 if (spec->mono_nid > 0) {
3638 err = stac92xx_auto_create_mono_output_ctls(codec);
3642 if (spec->num_amps > 0) {
3643 err = stac92xx_auto_create_amp_output_ctls(codec);
3647 if (spec->num_dmics > 0 && !spec->dinput_mux)
3648 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3649 &spec->autocfg)) < 0)
3651 if (spec->num_muxes > 0) {
3652 err = stac92xx_auto_create_mux_input_ctls(codec);
3656 if (spec->num_smuxes > 0) {
3657 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3662 err = stac92xx_add_input_source(spec);
3666 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3667 if (spec->multiout.max_channels > 2)
3668 spec->surr_switch = 1;
3670 if (spec->autocfg.dig_outs)
3671 spec->multiout.dig_out_nid = dig_out;
3672 if (dig_in && spec->autocfg.dig_in_pin)
3673 spec->dig_in_nid = dig_in;
3675 if (spec->kctls.list)
3676 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3678 spec->input_mux = &spec->private_imux;
3679 if (!spec->dinput_mux)
3680 spec->dinput_mux = &spec->private_dimux;
3681 spec->sinput_mux = &spec->private_smux;
3682 spec->mono_mux = &spec->private_mono_mux;
3683 spec->amp_mux = &spec->private_amp_mux;
3687 /* add playback controls for HP output */
3688 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3689 struct auto_pin_cfg *cfg)
3691 struct sigmatel_spec *spec = codec->spec;
3692 hda_nid_t pin = cfg->hp_pins[0];
3693 unsigned int wid_caps;
3698 wid_caps = get_wcaps(codec, pin);
3699 if (wid_caps & AC_WCAP_UNSOL_CAP)
3700 spec->hp_detect = 1;
3705 /* add playback controls for LFE output */
3706 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3707 struct auto_pin_cfg *cfg)
3709 struct sigmatel_spec *spec = codec->spec;
3711 hda_nid_t lfe_pin = 0x0;
3715 * search speaker outs and line outs for a mono speaker pin
3716 * with an amp. If one is found, add LFE controls
3719 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3720 hda_nid_t pin = spec->autocfg.speaker_pins[i];
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, must be lfe */
3728 /* if speaker_outs is 0, then speakers may be in line_outs */
3729 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3730 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3731 hda_nid_t pin = spec->autocfg.line_out_pins[i];
3732 unsigned int defcfg;
3733 defcfg = snd_hda_codec_get_pincfg(codec, pin);
3734 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3735 unsigned int wcaps = get_wcaps(codec, pin);
3736 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3737 if (wcaps == AC_WCAP_OUT_AMP)
3738 /* found a mono speaker with an amp,
3746 err = create_controls(codec, "LFE", lfe_pin, 1);
3754 static int stac9200_parse_auto_config(struct hda_codec *codec)
3756 struct sigmatel_spec *spec = codec->spec;
3759 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3762 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3765 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
3768 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
3771 if (spec->num_muxes > 0) {
3772 err = stac92xx_auto_create_mux_input_ctls(codec);
3777 err = stac92xx_add_input_source(spec);
3781 if (spec->autocfg.dig_outs)
3782 spec->multiout.dig_out_nid = 0x05;
3783 if (spec->autocfg.dig_in_pin)
3784 spec->dig_in_nid = 0x04;
3786 if (spec->kctls.list)
3787 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3789 spec->input_mux = &spec->private_imux;
3790 spec->dinput_mux = &spec->private_dimux;
3796 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
3797 * funky external mute control using GPIO pins.
3800 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
3801 unsigned int dir_mask, unsigned int data)
3803 unsigned int gpiostate, gpiomask, gpiodir;
3805 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
3806 AC_VERB_GET_GPIO_DATA, 0);
3807 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
3809 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
3810 AC_VERB_GET_GPIO_MASK, 0);
3813 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
3814 AC_VERB_GET_GPIO_DIRECTION, 0);
3815 gpiodir |= dir_mask;
3817 /* Configure GPIOx as CMOS */
3818 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
3820 snd_hda_codec_write(codec, codec->afg, 0,
3821 AC_VERB_SET_GPIO_MASK, gpiomask);
3822 snd_hda_codec_read(codec, codec->afg, 0,
3823 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
3827 snd_hda_codec_read(codec, codec->afg, 0,
3828 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
3831 static int stac92xx_add_jack(struct hda_codec *codec,
3832 hda_nid_t nid, int type)
3834 #ifdef CONFIG_SND_JACK
3835 struct sigmatel_spec *spec = codec->spec;
3836 struct sigmatel_jack *jack;
3837 int def_conf = snd_hda_codec_get_pincfg(codec, nid);
3838 int connectivity = get_defcfg_connect(def_conf);
3841 if (connectivity && connectivity != AC_JACK_PORT_FIXED)
3844 snd_array_init(&spec->jacks, sizeof(*jack), 32);
3845 jack = snd_array_new(&spec->jacks);
3851 sprintf(name, "%s at %s %s Jack",
3852 snd_hda_get_jack_type(def_conf),
3853 snd_hda_get_jack_connectivity(def_conf),
3854 snd_hda_get_jack_location(def_conf));
3856 return snd_jack_new(codec->bus->card, name, type, &jack->jack);
3862 static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
3863 unsigned char type, int data)
3865 struct sigmatel_event *event;
3867 snd_array_init(&spec->events, sizeof(*event), 32);
3868 event = snd_array_new(&spec->events);
3873 event->tag = spec->events.used;
3879 static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
3880 hda_nid_t nid, unsigned char type)
3882 struct sigmatel_spec *spec = codec->spec;
3883 struct sigmatel_event *event = spec->events.list;
3886 for (i = 0; i < spec->events.used; i++, event++) {
3887 if (event->nid == nid && event->type == type)
3893 static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
3896 struct sigmatel_spec *spec = codec->spec;
3897 struct sigmatel_event *event = spec->events.list;
3900 for (i = 0; i < spec->events.used; i++, event++) {
3901 if (event->tag == tag)
3907 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
3910 struct sigmatel_event *event;
3913 if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
3915 event = stac_get_event(codec, nid, type);
3919 tag = stac_add_event(codec->spec, nid, type, 0);
3922 snd_hda_codec_write_cache(codec, nid, 0,
3923 AC_VERB_SET_UNSOLICITED_ENABLE,
3927 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
3930 for (i = 0; i < cfg->hp_outs; i++)
3931 if (cfg->hp_pins[i] == nid)
3932 return 1; /* nid is a HP-Out */
3934 return 0; /* nid is not a HP-Out */
3937 static void stac92xx_power_down(struct hda_codec *codec)
3939 struct sigmatel_spec *spec = codec->spec;
3941 /* power down inactive DACs */
3943 for (dac = spec->dac_list; *dac; dac++)
3944 if (!check_all_dac_nids(spec, *dac))
3945 snd_hda_codec_write(codec, *dac, 0,
3946 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3949 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
3952 static int stac92xx_init(struct hda_codec *codec)
3954 struct sigmatel_spec *spec = codec->spec;
3955 struct auto_pin_cfg *cfg = &spec->autocfg;
3959 snd_hda_sequence_write(codec, spec->init);
3961 /* power down adcs initially */
3962 if (spec->powerdown_adcs)
3963 for (i = 0; i < spec->num_adcs; i++)
3964 snd_hda_codec_write(codec,
3965 spec->adc_nids[i], 0,
3966 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3969 gpio = spec->gpio_data;
3970 /* turn on EAPD statically when spec->eapd_switch isn't set.
3971 * otherwise, unsol event will turn it on/off dynamically
3973 if (!spec->eapd_switch)
3974 gpio |= spec->eapd_mask;
3975 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
3978 if (spec->hp_detect) {
3979 /* Enable unsolicited responses on the HP widget */
3980 for (i = 0; i < cfg->hp_outs; i++) {
3981 hda_nid_t nid = cfg->hp_pins[i];
3982 enable_pin_detect(codec, nid, STAC_HP_EVENT);
3984 /* force to enable the first line-out; the others are set up
3987 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
3989 /* fake event to set up pins */
3990 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
3993 stac92xx_auto_init_multi_out(codec);
3994 stac92xx_auto_init_hp_out(codec);
3995 for (i = 0; i < cfg->hp_outs; i++)
3996 stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
3998 for (i = 0; i < AUTO_PIN_LAST; i++) {
3999 hda_nid_t nid = cfg->input_pins[i];
4001 unsigned int pinctl, conf;
4002 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
4003 /* for mic pins, force to initialize */
4004 pinctl = stac92xx_get_vref(codec, nid);
4005 pinctl |= AC_PINCTL_IN_EN;
4006 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4008 pinctl = snd_hda_codec_read(codec, nid, 0,
4009 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4010 /* if PINCTL already set then skip */
4011 if (!(pinctl & AC_PINCTL_IN_EN)) {
4012 pinctl |= AC_PINCTL_IN_EN;
4013 stac92xx_auto_set_pinctl(codec, nid,
4017 conf = snd_hda_codec_get_pincfg(codec, nid);
4018 if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
4019 enable_pin_detect(codec, nid,
4021 stac_issue_unsol_event(codec, nid,
4026 for (i = 0; i < spec->num_dmics; i++)
4027 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4029 if (cfg->dig_out_pins[0])
4030 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0],
4032 if (cfg->dig_in_pin)
4033 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4035 for (i = 0; i < spec->num_pwrs; i++) {
4036 hda_nid_t nid = spec->pwr_nids[i];
4037 int pinctl, def_conf;
4039 /* power on when no jack detection is available */
4040 if (!spec->hp_detect) {
4041 stac_toggle_power_map(codec, nid, 1);
4045 if (is_nid_hp_pin(cfg, nid))
4046 continue; /* already has an unsol event */
4048 pinctl = snd_hda_codec_read(codec, nid, 0,
4049 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4050 /* outputs are only ports capable of power management
4051 * any attempts on powering down a input port cause the
4052 * referenced VREF to act quirky.
4054 if (pinctl & AC_PINCTL_IN_EN) {
4055 stac_toggle_power_map(codec, nid, 1);
4058 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4059 def_conf = get_defcfg_connect(def_conf);
4060 /* skip any ports that don't have jacks since presence
4061 * detection is useless */
4062 if (def_conf != AC_JACK_PORT_COMPLEX) {
4063 if (def_conf != AC_JACK_PORT_NONE)
4064 stac_toggle_power_map(codec, nid, 1);
4067 if (!stac_get_event(codec, nid, STAC_INSERT_EVENT)) {
4068 enable_pin_detect(codec, nid, STAC_PWR_EVENT);
4069 stac_issue_unsol_event(codec, nid, STAC_PWR_EVENT);
4073 stac92xx_power_down(codec);
4077 static void stac92xx_free_jacks(struct hda_codec *codec)
4079 #ifdef CONFIG_SND_JACK
4080 /* free jack instances manually when clearing/reconfiguring */
4081 struct sigmatel_spec *spec = codec->spec;
4082 if (!codec->bus->shutdown && spec->jacks.list) {
4083 struct sigmatel_jack *jacks = spec->jacks.list;
4085 for (i = 0; i < spec->jacks.used; i++)
4086 snd_device_free(codec->bus->card, &jacks[i].jack);
4088 snd_array_free(&spec->jacks);
4092 static void stac92xx_free_kctls(struct hda_codec *codec)
4094 struct sigmatel_spec *spec = codec->spec;
4096 if (spec->kctls.list) {
4097 struct snd_kcontrol_new *kctl = spec->kctls.list;
4099 for (i = 0; i < spec->kctls.used; i++)
4100 kfree(kctl[i].name);
4102 snd_array_free(&spec->kctls);
4105 static void stac92xx_free(struct hda_codec *codec)
4107 struct sigmatel_spec *spec = codec->spec;
4112 stac92xx_free_jacks(codec);
4113 snd_array_free(&spec->events);
4116 snd_hda_detach_beep_device(codec);
4119 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4122 unsigned int old_ctl, pin_ctl;
4124 pin_ctl = snd_hda_codec_read(codec, nid,
4125 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4127 if (pin_ctl & AC_PINCTL_IN_EN) {
4129 * we need to check the current set-up direction of
4130 * shared input pins since they can be switched via
4131 * "xxx as Output" mixer switch
4133 struct sigmatel_spec *spec = codec->spec;
4134 if (nid == spec->line_switch || nid == spec->mic_switch)
4139 /* if setting pin direction bits, clear the current
4140 direction bits first */
4141 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4142 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4145 if (old_ctl != pin_ctl)
4146 snd_hda_codec_write_cache(codec, nid, 0,
4147 AC_VERB_SET_PIN_WIDGET_CONTROL,
4151 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4154 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4155 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4157 snd_hda_codec_write_cache(codec, nid, 0,
4158 AC_VERB_SET_PIN_WIDGET_CONTROL,
4162 static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4166 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
4172 /* return non-zero if the hp-pin of the given array index isn't
4173 * a jack-detection target
4175 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4177 struct auto_pin_cfg *cfg = &spec->autocfg;
4179 /* ignore sensing of shared line and mic jacks */
4180 if (cfg->hp_pins[i] == spec->line_switch)
4182 if (cfg->hp_pins[i] == spec->mic_switch)
4184 /* ignore if the pin is set as line-out */
4185 if (cfg->hp_pins[i] == spec->hp_switch)
4190 static void stac92xx_hp_detect(struct hda_codec *codec)
4192 struct sigmatel_spec *spec = codec->spec;
4193 struct auto_pin_cfg *cfg = &spec->autocfg;
4197 if (spec->gpio_mute)
4198 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4199 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4201 for (i = 0; i < cfg->hp_outs; i++) {
4204 if (no_hp_sensing(spec, i))
4206 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4208 unsigned int pinctl;
4209 pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4210 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4211 if (pinctl & AC_PINCTL_IN_EN)
4212 presence = 0; /* mic- or line-input */
4217 /* disable lineouts */
4218 if (spec->hp_switch)
4219 stac92xx_reset_pinctl(codec, spec->hp_switch,
4221 for (i = 0; i < cfg->line_outs; i++)
4222 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4224 for (i = 0; i < cfg->speaker_outs; i++)
4225 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4227 if (spec->eapd_mask && spec->eapd_switch)
4228 stac_gpio_set(codec, spec->gpio_mask,
4229 spec->gpio_dir, spec->gpio_data &
4232 /* enable lineouts */
4233 if (spec->hp_switch)
4234 stac92xx_set_pinctl(codec, spec->hp_switch,
4236 for (i = 0; i < cfg->line_outs; i++)
4237 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4239 for (i = 0; i < cfg->speaker_outs; i++)
4240 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4242 if (spec->eapd_mask && spec->eapd_switch)
4243 stac_gpio_set(codec, spec->gpio_mask,
4244 spec->gpio_dir, spec->gpio_data |
4247 /* toggle hp outs */
4248 for (i = 0; i < cfg->hp_outs; i++) {
4249 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4250 if (no_hp_sensing(spec, i))
4253 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4255 /* Resetting the pinctl like below may lead to (a sort of) regressions
4256 * on some devices since they use the HP pin actually for line/speaker
4257 * outs although the default pin config shows a different pin (that is
4258 * wrong and useless).
4260 * So, it's basically a problem of default pin configs, likely a BIOS issue.
4261 * But, disabling the code below just works around it, and I'm too tired of
4262 * bug reports with such devices...
4265 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4270 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4273 struct sigmatel_spec *spec = codec->spec;
4274 unsigned int idx, val;
4276 for (idx = 0; idx < spec->num_pwrs; idx++) {
4277 if (spec->pwr_nids[idx] == nid)
4280 if (idx >= spec->num_pwrs)
4283 /* several codecs have two power down bits */
4284 if (spec->pwr_mapping)
4285 idx = spec->pwr_mapping[idx];
4289 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
4295 /* power down unused output ports */
4296 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4299 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4301 stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4304 static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
4306 struct sigmatel_spec *spec = codec->spec;
4307 struct sigmatel_jack *jacks = spec->jacks.list;
4311 for (i = 0; i < spec->jacks.used; i++) {
4312 if (jacks->nid == nid) {
4313 unsigned int pin_ctl =
4314 snd_hda_codec_read(codec, nid,
4315 0, AC_VERB_GET_PIN_WIDGET_CONTROL,
4317 int type = jacks->type;
4318 if (type == (SND_JACK_LINEOUT
4319 | SND_JACK_HEADPHONE))
4320 type = (pin_ctl & AC_PINCTL_HP_EN)
4321 ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
4322 snd_jack_report(jacks->jack,
4323 get_pin_presence(codec, nid)
4331 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
4334 struct sigmatel_event *event = stac_get_event(codec, nid, type);
4337 codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
4340 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4342 struct sigmatel_spec *spec = codec->spec;
4343 struct sigmatel_event *event;
4346 tag = (res >> 26) & 0x7f;
4347 event = stac_get_event_from_tag(codec, tag);
4351 switch (event->type) {
4353 stac92xx_hp_detect(codec);
4355 case STAC_INSERT_EVENT:
4356 case STAC_PWR_EVENT:
4357 if (spec->num_pwrs > 0)
4358 stac92xx_pin_sense(codec, event->nid);
4359 stac92xx_report_jack(codec, event->nid);
4361 case STAC_VREF_EVENT:
4362 data = snd_hda_codec_read(codec, codec->afg, 0,
4363 AC_VERB_GET_GPIO_DATA, 0);
4364 /* toggle VREF state based on GPIOx status */
4365 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4366 !!(data & (1 << event->data)));
4371 #ifdef CONFIG_PROC_FS
4372 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4373 struct hda_codec *codec, hda_nid_t nid)
4375 if (nid == codec->afg)
4376 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4377 snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
4380 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4381 struct hda_codec *codec,
4384 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4385 snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
4388 /* stac92hd71bxx, stac92hd73xx */
4389 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4390 struct hda_codec *codec, hda_nid_t nid)
4392 stac92hd_proc_hook(buffer, codec, nid);
4393 if (nid == codec->afg)
4394 analog_loop_proc_hook(buffer, codec, 0xfa0);
4397 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4398 struct hda_codec *codec, hda_nid_t nid)
4400 if (nid == codec->afg)
4401 analog_loop_proc_hook(buffer, codec, 0xfe0);
4404 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4405 struct hda_codec *codec, hda_nid_t nid)
4407 if (nid == codec->afg)
4408 analog_loop_proc_hook(buffer, codec, 0xfeb);
4411 #define stac92hd_proc_hook NULL
4412 #define stac92hd7x_proc_hook NULL
4413 #define stac9205_proc_hook NULL
4414 #define stac927x_proc_hook NULL
4417 #ifdef SND_HDA_NEEDS_RESUME
4418 static int stac92xx_resume(struct hda_codec *codec)
4420 struct sigmatel_spec *spec = codec->spec;
4422 stac92xx_init(codec);
4423 snd_hda_codec_resume_amp(codec);
4424 snd_hda_codec_resume_cache(codec);
4425 /* fake event to set up pins again to override cached values */
4426 if (spec->hp_detect)
4427 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
4432 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
4434 struct sigmatel_spec *spec = codec->spec;
4435 if (spec->eapd_mask)
4436 stac_gpio_set(codec, spec->gpio_mask,
4437 spec->gpio_dir, spec->gpio_data &
4443 static struct hda_codec_ops stac92xx_patch_ops = {
4444 .build_controls = stac92xx_build_controls,
4445 .build_pcms = stac92xx_build_pcms,
4446 .init = stac92xx_init,
4447 .free = stac92xx_free,
4448 .unsol_event = stac92xx_unsol_event,
4449 #ifdef SND_HDA_NEEDS_RESUME
4450 .suspend = stac92xx_suspend,
4451 .resume = stac92xx_resume,
4455 static int patch_stac9200(struct hda_codec *codec)
4457 struct sigmatel_spec *spec;
4460 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4465 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
4466 spec->pin_nids = stac9200_pin_nids;
4467 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
4470 if (spec->board_config < 0)
4471 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
4473 stac92xx_set_config_regs(codec,
4474 stac9200_brd_tbl[spec->board_config]);
4476 spec->multiout.max_channels = 2;
4477 spec->multiout.num_dacs = 1;
4478 spec->multiout.dac_nids = stac9200_dac_nids;
4479 spec->adc_nids = stac9200_adc_nids;
4480 spec->mux_nids = stac9200_mux_nids;
4481 spec->num_muxes = 1;
4482 spec->num_dmics = 0;
4486 if (spec->board_config == STAC_9200_M4 ||
4487 spec->board_config == STAC_9200_M4_2 ||
4488 spec->board_config == STAC_9200_OQO)
4489 spec->init = stac9200_eapd_init;
4491 spec->init = stac9200_core_init;
4492 spec->mixer = stac9200_mixer;
4494 if (spec->board_config == STAC_9200_PANASONIC) {
4495 spec->gpio_mask = spec->gpio_dir = 0x09;
4496 spec->gpio_data = 0x00;
4499 err = stac9200_parse_auto_config(codec);
4501 stac92xx_free(codec);
4505 /* CF-74 has no headphone detection, and the driver should *NOT*
4506 * do detection and HP/speaker toggle because the hardware does it.
4508 if (spec->board_config == STAC_9200_PANASONIC)
4509 spec->hp_detect = 0;
4511 codec->patch_ops = stac92xx_patch_ops;
4516 static int patch_stac925x(struct hda_codec *codec)
4518 struct sigmatel_spec *spec;
4521 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4526 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
4527 spec->pin_nids = stac925x_pin_nids;
4529 /* Check first for codec ID */
4530 spec->board_config = snd_hda_check_board_codec_sid_config(codec,
4533 stac925x_codec_id_cfg_tbl);
4535 /* Now checks for PCI ID, if codec ID is not found */
4536 if (spec->board_config < 0)
4537 spec->board_config = snd_hda_check_board_config(codec,
4542 if (spec->board_config < 0)
4543 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
4544 "using BIOS defaults\n");
4546 stac92xx_set_config_regs(codec,
4547 stac925x_brd_tbl[spec->board_config]);
4549 spec->multiout.max_channels = 2;
4550 spec->multiout.num_dacs = 1;
4551 spec->multiout.dac_nids = stac925x_dac_nids;
4552 spec->adc_nids = stac925x_adc_nids;
4553 spec->mux_nids = stac925x_mux_nids;
4554 spec->num_muxes = 1;
4557 switch (codec->vendor_id) {
4558 case 0x83847632: /* STAC9202 */
4559 case 0x83847633: /* STAC9202D */
4560 case 0x83847636: /* STAC9251 */
4561 case 0x83847637: /* STAC9251D */
4562 spec->num_dmics = STAC925X_NUM_DMICS;
4563 spec->dmic_nids = stac925x_dmic_nids;
4564 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
4565 spec->dmux_nids = stac925x_dmux_nids;
4568 spec->num_dmics = 0;
4572 spec->init = stac925x_core_init;
4573 spec->mixer = stac925x_mixer;
4575 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
4577 if (spec->board_config < 0) {
4578 printk(KERN_WARNING "hda_codec: No auto-config is "
4579 "available, default to model=ref\n");
4580 spec->board_config = STAC_925x_REF;
4586 stac92xx_free(codec);
4590 codec->patch_ops = stac92xx_patch_ops;
4595 static struct hda_input_mux stac92hd73xx_dmux = {
4598 { "Analog Inputs", 0x0b },
4599 { "Digital Mic 1", 0x09 },
4600 { "Digital Mic 2", 0x0a },
4605 static int patch_stac92hd73xx(struct hda_codec *codec)
4607 struct sigmatel_spec *spec;
4608 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
4612 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4617 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
4618 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
4619 spec->pin_nids = stac92hd73xx_pin_nids;
4620 spec->board_config = snd_hda_check_board_config(codec,
4621 STAC_92HD73XX_MODELS,
4622 stac92hd73xx_models,
4623 stac92hd73xx_cfg_tbl);
4625 if (spec->board_config < 0)
4626 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4627 " STAC92HD73XX, using BIOS defaults\n");
4629 stac92xx_set_config_regs(codec,
4630 stac92hd73xx_brd_tbl[spec->board_config]);
4632 num_dacs = snd_hda_get_connections(codec, 0x0a,
4633 conn, STAC92HD73_DAC_COUNT + 2) - 1;
4635 if (num_dacs < 3 || num_dacs > 5) {
4636 printk(KERN_WARNING "hda_codec: Could not determine "
4637 "number of channels defaulting to DAC count\n");
4638 num_dacs = STAC92HD73_DAC_COUNT;
4641 case 0x3: /* 6 Channel */
4642 spec->mixer = stac92hd73xx_6ch_mixer;
4643 spec->init = stac92hd73xx_6ch_core_init;
4644 spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
4646 case 0x4: /* 8 Channel */
4647 spec->mixer = stac92hd73xx_8ch_mixer;
4648 spec->init = stac92hd73xx_8ch_core_init;
4649 spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
4651 case 0x5: /* 10 Channel */
4652 spec->mixer = stac92hd73xx_10ch_mixer;
4653 spec->init = stac92hd73xx_10ch_core_init;
4654 spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
4657 spec->multiout.dac_nids = spec->dac_nids;
4659 spec->aloopback_mask = 0x01;
4660 spec->aloopback_shift = 8;
4662 spec->digbeep_nid = 0x1c;
4663 spec->mux_nids = stac92hd73xx_mux_nids;
4664 spec->adc_nids = stac92hd73xx_adc_nids;
4665 spec->dmic_nids = stac92hd73xx_dmic_nids;
4666 spec->dmux_nids = stac92hd73xx_dmux_nids;
4667 spec->smux_nids = stac92hd73xx_smux_nids;
4668 spec->amp_nids = stac92hd73xx_amp_nids;
4669 spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
4671 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
4672 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
4673 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
4674 memcpy(&spec->private_dimux, &stac92hd73xx_dmux,
4675 sizeof(stac92hd73xx_dmux));
4677 switch (spec->board_config) {
4679 spec->init = dell_eq_core_init;
4681 case STAC_DELL_M6_AMIC:
4682 case STAC_DELL_M6_DMIC:
4683 case STAC_DELL_M6_BOTH:
4684 spec->num_smuxes = 0;
4685 spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
4686 spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
4687 spec->eapd_switch = 0;
4690 if (spec->board_config != STAC_DELL_EQ)
4691 spec->init = dell_m6_core_init;
4692 switch (spec->board_config) {
4693 case STAC_DELL_M6_AMIC: /* Analog Mics */
4694 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
4695 spec->num_dmics = 0;
4696 spec->private_dimux.num_items = 1;
4698 case STAC_DELL_M6_DMIC: /* Digital Mics */
4699 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
4700 spec->num_dmics = 1;
4701 spec->private_dimux.num_items = 2;
4703 case STAC_DELL_M6_BOTH: /* Both */
4704 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
4705 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
4706 spec->num_dmics = 1;
4707 spec->private_dimux.num_items = 2;
4712 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
4713 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
4714 spec->eapd_switch = 1;
4716 if (spec->board_config > STAC_92HD73XX_REF) {
4717 /* GPIO0 High = Enable EAPD */
4718 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4719 spec->gpio_data = 0x01;
4721 spec->dinput_mux = &spec->private_dimux;
4723 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
4724 spec->pwr_nids = stac92hd73xx_pwr_nids;
4726 err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
4729 if (spec->board_config < 0) {
4730 printk(KERN_WARNING "hda_codec: No auto-config is "
4731 "available, default to model=ref\n");
4732 spec->board_config = STAC_92HD73XX_REF;
4739 stac92xx_free(codec);
4743 if (spec->board_config == STAC_92HD73XX_NO_JD)
4744 spec->hp_detect = 0;
4746 codec->patch_ops = stac92xx_patch_ops;
4748 codec->proc_widget_hook = stac92hd7x_proc_hook;
4753 static struct hda_input_mux stac92hd83xxx_dmux = {
4756 { "Analog Inputs", 0x03 },
4757 { "Digital Mic 1", 0x04 },
4758 { "Digital Mic 2", 0x05 },
4762 static int patch_stac92hd83xxx(struct hda_codec *codec)
4764 struct sigmatel_spec *spec;
4765 hda_nid_t conn[STAC92HD83_DAC_COUNT + 1];
4770 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4775 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
4776 spec->mono_nid = 0x19;
4777 spec->digbeep_nid = 0x21;
4778 spec->dmic_nids = stac92hd83xxx_dmic_nids;
4779 spec->dmux_nids = stac92hd83xxx_dmux_nids;
4780 spec->adc_nids = stac92hd83xxx_adc_nids;
4781 spec->pwr_nids = stac92hd83xxx_pwr_nids;
4782 spec->amp_nids = stac92hd83xxx_amp_nids;
4783 spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
4784 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
4785 spec->multiout.dac_nids = spec->dac_nids;
4787 spec->init = stac92hd83xxx_core_init;
4788 spec->mixer = stac92hd83xxx_mixer;
4789 spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
4790 spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
4791 spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
4792 spec->num_amps = ARRAY_SIZE(stac92hd83xxx_amp_nids);
4793 spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
4794 spec->dinput_mux = &stac92hd83xxx_dmux;
4795 spec->pin_nids = stac92hd83xxx_pin_nids;
4796 spec->board_config = snd_hda_check_board_config(codec,
4797 STAC_92HD83XXX_MODELS,
4798 stac92hd83xxx_models,
4799 stac92hd83xxx_cfg_tbl);
4801 if (spec->board_config < 0)
4802 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4803 " STAC92HD83XXX, using BIOS defaults\n");
4805 stac92xx_set_config_regs(codec,
4806 stac92hd83xxx_brd_tbl[spec->board_config]);
4808 switch (codec->vendor_id) {
4811 if (spec->board_config == STAC_92HD83XXX_PWR_REF)
4817 err = stac92xx_parse_auto_config(codec, 0x1d, 0);
4819 if (spec->board_config < 0) {
4820 printk(KERN_WARNING "hda_codec: No auto-config is "
4821 "available, default to model=ref\n");
4822 spec->board_config = STAC_92HD83XXX_REF;
4829 stac92xx_free(codec);
4833 switch (spec->board_config) {
4842 num_dacs = snd_hda_get_connections(codec, nid,
4843 conn, STAC92HD83_DAC_COUNT + 1) - 1;
4845 /* set port X to select the last DAC
4847 snd_hda_codec_write_cache(codec, nid, 0,
4848 AC_VERB_SET_CONNECT_SEL, num_dacs);
4850 codec->patch_ops = stac92xx_patch_ops;
4852 codec->proc_widget_hook = stac92hd_proc_hook;
4857 static struct hda_input_mux stac92hd71bxx_dmux_nomixer = {
4860 { "Analog Inputs", 0x00 },
4861 { "Digital Mic 1", 0x02 },
4862 { "Digital Mic 2", 0x03 },
4866 static struct hda_input_mux stac92hd71bxx_dmux_amixer = {
4869 { "Analog Inputs", 0x00 },
4871 { "Digital Mic 1", 0x02 },
4872 { "Digital Mic 2", 0x03 },
4876 /* get the pin connection (fixed, none, etc) */
4877 static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
4879 struct sigmatel_spec *spec = codec->spec;
4882 cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]);
4883 return get_defcfg_connect(cfg);
4886 static int stac92hd71bxx_connected_ports(struct hda_codec *codec,
4887 hda_nid_t *nids, int num_nids)
4889 struct sigmatel_spec *spec = codec->spec;
4891 unsigned int def_conf;
4893 for (num = 0; num < num_nids; num++) {
4894 for (idx = 0; idx < spec->num_pins; idx++)
4895 if (spec->pin_nids[idx] == nids[num])
4897 if (idx >= spec->num_pins)
4899 def_conf = stac_get_defcfg_connect(codec, idx);
4900 if (def_conf == AC_JACK_PORT_NONE)
4906 static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
4909 struct sigmatel_spec *spec = codec->spec;
4912 for (idx = 0; idx < spec->num_pins; idx++)
4913 if (spec->pin_nids[idx] == dig0pin)
4915 if ((idx + 2) >= spec->num_pins)
4919 if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE)
4922 /* dig0pin + dig2pin case */
4923 if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE)
4925 if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE)
4931 static int patch_stac92hd71bxx(struct hda_codec *codec)
4933 struct sigmatel_spec *spec;
4934 struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
4936 unsigned int ndmic_nids = 0;
4938 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4943 codec->patch_ops = stac92xx_patch_ops;
4944 spec->num_pins = STAC92HD71BXX_NUM_PINS;
4945 switch (codec->vendor_id) {
4948 spec->pin_nids = stac92hd71bxx_pin_nids_4port;
4952 /* On 92HD75Bx 0x27 isn't a pin nid */
4956 spec->pin_nids = stac92hd71bxx_pin_nids_6port;
4958 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
4959 spec->board_config = snd_hda_check_board_config(codec,
4960 STAC_92HD71BXX_MODELS,
4961 stac92hd71bxx_models,
4962 stac92hd71bxx_cfg_tbl);
4964 if (spec->board_config < 0)
4965 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4966 " STAC92HD71BXX, using BIOS defaults\n");
4968 stac92xx_set_config_regs(codec,
4969 stac92hd71bxx_brd_tbl[spec->board_config]);
4971 if (spec->board_config > STAC_92HD71BXX_REF) {
4973 spec->gpio_mask = 0x01;
4974 spec->gpio_dir = 0x01;
4975 spec->gpio_data = 0x01;
4978 spec->dmic_nids = stac92hd71bxx_dmic_nids;
4979 spec->dmux_nids = stac92hd71bxx_dmux_nids;
4981 switch (codec->vendor_id) {
4982 case 0x111d76b6: /* 4 Port without Analog Mixer */
4986 case 0x111d76b4: /* 6 Port without Analog Mixer */
4988 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_nomixer,
4989 sizeof(stac92hd71bxx_dmux_nomixer));
4990 spec->mixer = stac92hd71bxx_mixer;
4991 spec->init = stac92hd71bxx_core_init;
4992 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4993 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
4994 stac92hd71bxx_dmic_nids,
4995 STAC92HD71BXX_NUM_DMICS);
4996 if (spec->num_dmics) {
4997 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
4998 spec->dinput_mux = &spec->private_dimux;
4999 ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1;
5002 case 0x111d7608: /* 5 Port with Analog Mixer */
5003 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_amixer,
5004 sizeof(stac92hd71bxx_dmux_amixer));
5005 spec->private_dimux.num_items--;
5006 switch (spec->board_config) {
5008 /* Enable VREF power saving on GPIO1 detect */
5009 err = stac_add_event(spec, codec->afg,
5010 STAC_VREF_EVENT, 0x02);
5013 snd_hda_codec_write_cache(codec, codec->afg, 0,
5014 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
5015 snd_hda_codec_write_cache(codec, codec->afg, 0,
5016 AC_VERB_SET_UNSOLICITED_ENABLE,
5018 spec->gpio_mask |= 0x02;
5021 if ((codec->revision_id & 0xf) == 0 ||
5022 (codec->revision_id & 0xf) == 1)
5023 spec->stream_delay = 40; /* 40 milliseconds */
5025 /* no output amps */
5027 spec->mixer = stac92hd71bxx_analog_mixer;
5028 spec->dinput_mux = &spec->private_dimux;
5031 spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
5033 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
5034 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
5035 stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS - 1] = 0;
5036 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5037 stac92hd71bxx_dmic_nids,
5038 STAC92HD71BXX_NUM_DMICS - 1);
5039 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5040 ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 2;
5042 case 0x111d7603: /* 6 Port with Analog Mixer */
5043 if ((codec->revision_id & 0xf) == 1)
5044 spec->stream_delay = 40; /* 40 milliseconds */
5046 /* no output amps */
5050 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_amixer,
5051 sizeof(stac92hd71bxx_dmux_amixer));
5052 spec->dinput_mux = &spec->private_dimux;
5053 spec->mixer = stac92hd71bxx_analog_mixer;
5054 spec->init = stac92hd71bxx_analog_core_init;
5055 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5056 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5057 stac92hd71bxx_dmic_nids,
5058 STAC92HD71BXX_NUM_DMICS);
5059 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5060 ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1;
5063 if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
5064 snd_hda_sequence_write_cache(codec, unmute_init);
5066 spec->aloopback_ctl = stac92hd71bxx_loopback;
5067 spec->aloopback_mask = 0x50;
5068 spec->aloopback_shift = 0;
5070 spec->powerdown_adcs = 1;
5071 spec->digbeep_nid = 0x26;
5072 spec->mux_nids = stac92hd71bxx_mux_nids;
5073 spec->adc_nids = stac92hd71bxx_adc_nids;
5074 spec->smux_nids = stac92hd71bxx_smux_nids;
5075 spec->pwr_nids = stac92hd71bxx_pwr_nids;
5077 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
5078 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
5079 spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
5081 switch (spec->board_config) {
5083 /* enable internal microphone */
5084 snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
5085 stac92xx_auto_set_pinctl(codec, 0x0e,
5086 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
5088 case STAC_DELL_M4_2:
5089 spec->num_dmics = 0;
5090 spec->num_smuxes = 0;
5091 spec->num_dmuxes = 0;
5093 case STAC_DELL_M4_1:
5094 case STAC_DELL_M4_3:
5095 spec->num_dmics = 1;
5096 spec->num_smuxes = 0;
5097 spec->num_dmuxes = 1;
5100 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
5101 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
5105 spec->multiout.dac_nids = spec->dac_nids;
5106 if (spec->dinput_mux)
5107 spec->private_dimux.num_items += spec->num_dmics - ndmic_nids;
5109 err = stac92xx_parse_auto_config(codec, 0x21, 0);
5111 if (spec->board_config < 0) {
5112 printk(KERN_WARNING "hda_codec: No auto-config is "
5113 "available, default to model=ref\n");
5114 spec->board_config = STAC_92HD71BXX_REF;
5121 stac92xx_free(codec);
5125 codec->proc_widget_hook = stac92hd7x_proc_hook;
5130 static int patch_stac922x(struct hda_codec *codec)
5132 struct sigmatel_spec *spec;
5135 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5140 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
5141 spec->pin_nids = stac922x_pin_nids;
5142 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
5145 if (spec->board_config == STAC_INTEL_MAC_AUTO) {
5146 spec->gpio_mask = spec->gpio_dir = 0x03;
5147 spec->gpio_data = 0x03;
5148 /* Intel Macs have all same PCI SSID, so we need to check
5149 * codec SSID to distinguish the exact models
5151 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
5152 switch (codec->subsystem_id) {
5155 spec->board_config = STAC_INTEL_MAC_V1;
5159 spec->board_config = STAC_INTEL_MAC_V2;
5167 spec->board_config = STAC_INTEL_MAC_V3;
5171 spec->board_config = STAC_INTEL_MAC_V4;
5175 spec->board_config = STAC_INTEL_MAC_V5;
5178 spec->board_config = STAC_INTEL_MAC_V3;
5184 if (spec->board_config < 0)
5185 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
5186 "using BIOS defaults\n");
5188 stac92xx_set_config_regs(codec,
5189 stac922x_brd_tbl[spec->board_config]);
5191 spec->adc_nids = stac922x_adc_nids;
5192 spec->mux_nids = stac922x_mux_nids;
5193 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
5194 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
5195 spec->num_dmics = 0;
5198 spec->init = stac922x_core_init;
5199 spec->mixer = stac922x_mixer;
5201 spec->multiout.dac_nids = spec->dac_nids;
5203 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
5205 if (spec->board_config < 0) {
5206 printk(KERN_WARNING "hda_codec: No auto-config is "
5207 "available, default to model=ref\n");
5208 spec->board_config = STAC_D945_REF;
5214 stac92xx_free(codec);
5218 codec->patch_ops = stac92xx_patch_ops;
5220 /* Fix Mux capture level; max to 2 */
5221 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
5222 (0 << AC_AMPCAP_OFFSET_SHIFT) |
5223 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5224 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5225 (0 << AC_AMPCAP_MUTE_SHIFT));
5230 static int patch_stac927x(struct hda_codec *codec)
5232 struct sigmatel_spec *spec;
5235 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5240 codec->slave_dig_outs = stac927x_slave_dig_outs;
5241 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
5242 spec->pin_nids = stac927x_pin_nids;
5243 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
5247 if (spec->board_config < 0)
5248 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
5249 "STAC927x, using BIOS defaults\n");
5251 stac92xx_set_config_regs(codec,
5252 stac927x_brd_tbl[spec->board_config]);
5254 spec->digbeep_nid = 0x23;
5255 spec->adc_nids = stac927x_adc_nids;
5256 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
5257 spec->mux_nids = stac927x_mux_nids;
5258 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
5259 spec->smux_nids = stac927x_smux_nids;
5260 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
5261 spec->spdif_labels = stac927x_spdif_labels;
5262 spec->dac_list = stac927x_dac_nids;
5263 spec->multiout.dac_nids = spec->dac_nids;
5265 switch (spec->board_config) {
5268 /* GPIO0 High = Enable EAPD */
5269 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01;
5270 spec->gpio_data = 0x01;
5271 spec->num_dmics = 0;
5273 spec->init = d965_core_init;
5274 spec->mixer = stac927x_mixer;
5276 case STAC_DELL_BIOS:
5277 switch (codec->subsystem_id) {
5280 /* correct the device field to SPDIF out */
5281 snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
5284 /* configure the analog microphone on some laptops */
5285 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
5286 /* correct the front output jack as a hp out */
5287 snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f);
5288 /* correct the front input jack as a mic */
5289 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
5292 /* GPIO2 High = Enable EAPD */
5293 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
5294 spec->gpio_data = 0x04;
5295 spec->dmic_nids = stac927x_dmic_nids;
5296 spec->num_dmics = STAC927X_NUM_DMICS;
5298 spec->init = d965_core_init;
5299 spec->mixer = stac927x_mixer;
5300 spec->dmux_nids = stac927x_dmux_nids;
5301 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
5304 if (spec->board_config > STAC_D965_REF) {
5305 /* GPIO0 High = Enable EAPD */
5306 spec->eapd_mask = spec->gpio_mask = 0x01;
5307 spec->gpio_dir = spec->gpio_data = 0x01;
5309 spec->num_dmics = 0;
5311 spec->init = stac927x_core_init;
5312 spec->mixer = stac927x_mixer;
5316 spec->aloopback_ctl = stac927x_loopback;
5317 spec->aloopback_mask = 0x40;
5318 spec->aloopback_shift = 0;
5319 spec->eapd_switch = 1;
5321 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
5323 if (spec->board_config < 0) {
5324 printk(KERN_WARNING "hda_codec: No auto-config is "
5325 "available, default to model=ref\n");
5326 spec->board_config = STAC_D965_REF;
5332 stac92xx_free(codec);
5336 codec->patch_ops = stac92xx_patch_ops;
5338 codec->proc_widget_hook = stac927x_proc_hook;
5342 * The STAC927x seem to require fairly long delays for certain
5343 * command sequences. With too short delays (even if the answer
5344 * is set to RIRB properly), it results in the silence output
5345 * on some hardwares like Dell.
5347 * The below flag enables the longer delay (see get_response
5350 codec->bus->needs_damn_long_delay = 1;
5352 /* no jack detecion for ref-no-jd model */
5353 if (spec->board_config == STAC_D965_REF_NO_JD)
5354 spec->hp_detect = 0;
5359 static int patch_stac9205(struct hda_codec *codec)
5361 struct sigmatel_spec *spec;
5364 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5369 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
5370 spec->pin_nids = stac9205_pin_nids;
5371 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
5375 if (spec->board_config < 0)
5376 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
5378 stac92xx_set_config_regs(codec,
5379 stac9205_brd_tbl[spec->board_config]);
5381 spec->digbeep_nid = 0x23;
5382 spec->adc_nids = stac9205_adc_nids;
5383 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
5384 spec->mux_nids = stac9205_mux_nids;
5385 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
5386 spec->smux_nids = stac9205_smux_nids;
5387 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
5388 spec->dmic_nids = stac9205_dmic_nids;
5389 spec->num_dmics = STAC9205_NUM_DMICS;
5390 spec->dmux_nids = stac9205_dmux_nids;
5391 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
5394 spec->init = stac9205_core_init;
5395 spec->mixer = stac9205_mixer;
5396 spec->aloopback_ctl = stac9205_loopback;
5398 spec->aloopback_mask = 0x40;
5399 spec->aloopback_shift = 0;
5400 /* Turn on/off EAPD per HP plugging */
5401 if (spec->board_config != STAC_9205_EAPD)
5402 spec->eapd_switch = 1;
5403 spec->multiout.dac_nids = spec->dac_nids;
5405 switch (spec->board_config){
5406 case STAC_9205_DELL_M43:
5407 /* Enable SPDIF in/out */
5408 snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030);
5409 snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030);
5411 /* Enable unsol response for GPIO4/Dock HP connection */
5412 err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
5415 snd_hda_codec_write_cache(codec, codec->afg, 0,
5416 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
5417 snd_hda_codec_write_cache(codec, codec->afg, 0,
5418 AC_VERB_SET_UNSOLICITED_ENABLE,
5421 spec->gpio_dir = 0x0b;
5422 spec->eapd_mask = 0x01;
5423 spec->gpio_mask = 0x1b;
5424 spec->gpio_mute = 0x10;
5425 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
5428 spec->gpio_data = 0x01;
5431 /* SPDIF-In enabled */
5434 /* GPIO0 High = EAPD */
5435 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5436 spec->gpio_data = 0x01;
5440 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
5442 if (spec->board_config < 0) {
5443 printk(KERN_WARNING "hda_codec: No auto-config is "
5444 "available, default to model=ref\n");
5445 spec->board_config = STAC_9205_REF;
5451 stac92xx_free(codec);
5455 codec->patch_ops = stac92xx_patch_ops;
5457 codec->proc_widget_hook = stac9205_proc_hook;
5466 static struct hda_verb stac9872_core_init[] = {
5467 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5468 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5472 static struct snd_kcontrol_new stac9872_mixer[] = {
5473 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5474 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5478 static hda_nid_t stac9872_pin_nids[] = {
5479 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
5483 static hda_nid_t stac9872_adc_nids[] = {
5487 static hda_nid_t stac9872_mux_nids[] = {
5491 static int patch_stac9872(struct hda_codec *codec)
5493 struct sigmatel_spec *spec;
5496 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5501 #if 0 /* no model right now */
5502 spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
5507 spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
5508 spec->pin_nids = stac9872_pin_nids;
5509 spec->multiout.dac_nids = spec->dac_nids;
5510 spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
5511 spec->adc_nids = stac9872_adc_nids;
5512 spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
5513 spec->mux_nids = stac9872_mux_nids;
5514 spec->mixer = stac9872_mixer;
5515 spec->init = stac9872_core_init;
5517 err = stac92xx_parse_auto_config(codec, 0x10, 0x12);
5519 stac92xx_free(codec);
5522 spec->input_mux = &spec->private_imux;
5523 codec->patch_ops = stac92xx_patch_ops;
5531 static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
5532 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
5533 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
5534 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
5535 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
5536 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
5537 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
5538 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
5539 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
5540 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
5541 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
5542 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
5543 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
5544 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
5545 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
5546 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
5547 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
5548 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
5549 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
5550 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
5551 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
5552 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
5553 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
5554 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
5555 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
5556 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
5557 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
5558 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
5559 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
5560 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
5561 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
5562 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
5563 /* The following does not take into account .id=0x83847661 when subsys =
5564 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
5565 * currently not fully supported.
5567 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
5568 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
5569 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
5570 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
5571 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
5572 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
5573 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
5574 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
5575 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
5576 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
5577 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
5578 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
5579 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
5580 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
5581 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
5582 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
5583 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
5584 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
5585 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5586 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5587 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5588 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5589 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5590 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5591 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5592 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5596 MODULE_ALIAS("snd-hda-codec-id:8384*");
5597 MODULE_ALIAS("snd-hda-codec-id:111d*");
5599 MODULE_LICENSE("GPL");
5600 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
5602 static struct hda_codec_preset_list sigmatel_list = {
5603 .preset = snd_hda_preset_sigmatel,
5604 .owner = THIS_MODULE,
5607 static int __init patch_sigmatel_init(void)
5609 return snd_hda_add_codec_preset(&sigmatel_list);
5612 static void __exit patch_sigmatel_exit(void)
5614 snd_hda_delete_codec_preset(&sigmatel_list);
5617 module_init(patch_sigmatel_init)
5618 module_exit(patch_sigmatel_exit)