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 "Headphone2 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 "Headphone2 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 /* Create output controls
3043 * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
3045 static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
3046 const hda_nid_t *pins,
3047 const hda_nid_t *dac_nids,
3050 struct sigmatel_spec *spec = codec->spec;
3051 static const char *chname[4] = {
3052 "Front", "Surround", NULL /*CLFE*/, "Side"
3054 static const char *hp_pfxs[] = {
3055 "Headphone", "Headphone2", "Headphone3", "Headphone4"
3057 static const char *speaker_pfxs[] = {
3058 "Speaker", "External Speaker", "Speaker2", "Speaker3"
3062 unsigned int wid_caps;
3064 for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
3068 if (type != AUTO_PIN_HP_OUT && i == 2) {
3070 err = create_controls(codec, "Center", nid, 1);
3073 err = create_controls(codec, "LFE", nid, 2);
3077 wid_caps = get_wcaps(codec, nid);
3079 if (wid_caps & AC_WCAP_LR_SWAP) {
3080 err = stac92xx_add_control(spec,
3081 STAC_CTL_WIDGET_CLFE_SWITCH,
3082 "Swap Center/LFE Playback Switch", nid);
3091 case AUTO_PIN_HP_OUT:
3094 case AUTO_PIN_SPEAKER_OUT:
3095 name = speaker_pfxs[i];
3101 err = create_controls(codec, name, nid, 3);
3104 if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3105 wid_caps = get_wcaps(codec, pins[i]);
3106 if (wid_caps & AC_WCAP_UNSOL_CAP)
3107 spec->hp_detect = 1;
3114 /* add playback controls from the parsed DAC table */
3115 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3116 const struct auto_pin_cfg *cfg)
3118 struct sigmatel_spec *spec = codec->spec;
3121 err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
3122 spec->multiout.dac_nids,
3123 cfg->line_out_type);
3127 if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3128 err = stac92xx_add_control(spec,
3129 STAC_CTL_WIDGET_HP_SWITCH,
3130 "Headphone as Line Out Switch",
3131 cfg->hp_pins[cfg->hp_outs - 1]);
3136 if (spec->line_switch) {
3137 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
3138 "Line In as Output Switch",
3139 spec->line_switch << 8);
3144 if (spec->mic_switch) {
3145 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
3146 "Mic as Output Switch",
3147 (spec->mic_switch << 8) | 1);
3155 /* add playback controls for Speaker and HP outputs */
3156 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3157 struct auto_pin_cfg *cfg)
3159 struct sigmatel_spec *spec = codec->spec;
3162 err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
3163 spec->hp_dacs, AUTO_PIN_HP_OUT);
3167 err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
3168 spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
3175 /* labels for mono mux outputs */
3176 static const char *stac92xx_mono_labels[4] = {
3177 "DAC0", "DAC1", "Mixer", "DAC2"
3180 /* create mono mux for mono out on capable codecs */
3181 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3183 struct sigmatel_spec *spec = codec->spec;
3184 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3186 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3188 num_cons = snd_hda_get_connections(codec,
3191 HDA_MAX_NUM_INPUTS);
3192 if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3195 for (i = 0; i < num_cons; i++) {
3196 mono_mux->items[mono_mux->num_items].label =
3197 stac92xx_mono_labels[i];
3198 mono_mux->items[mono_mux->num_items].index = i;
3199 mono_mux->num_items++;
3202 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3203 "Mono Mux", spec->mono_nid);
3206 /* labels for amp mux outputs */
3207 static const char *stac92xx_amp_labels[3] = {
3208 "Front Microphone", "Microphone", "Line In",
3211 /* create amp out controls mux on capable codecs */
3212 static int stac92xx_auto_create_amp_output_ctls(struct hda_codec *codec)
3214 struct sigmatel_spec *spec = codec->spec;
3215 struct hda_input_mux *amp_mux = &spec->private_amp_mux;
3218 for (i = 0; i < spec->num_amps; i++) {
3219 amp_mux->items[amp_mux->num_items].label =
3220 stac92xx_amp_labels[i];
3221 amp_mux->items[amp_mux->num_items].index = i;
3222 amp_mux->num_items++;
3225 if (spec->num_amps > 1) {
3226 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_MUX,
3227 "Amp Selector Capture Switch", 0);
3231 return stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_VOL,
3232 "Amp Capture Volume",
3233 HDA_COMPOSE_AMP_VAL(spec->amp_nids[0], 3, 0, HDA_INPUT));
3237 /* create PC beep volume controls */
3238 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3241 struct sigmatel_spec *spec = codec->spec;
3242 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3245 /* check for mute support for the the amp */
3246 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3247 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3248 "PC Beep Playback Switch",
3249 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3254 /* check to see if there is volume support for the amp */
3255 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3256 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3257 "PC Beep Playback Volume",
3258 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3265 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3266 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3268 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3269 struct snd_ctl_elem_value *ucontrol)
3271 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3272 ucontrol->value.integer.value[0] = codec->beep->enabled;
3276 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3277 struct snd_ctl_elem_value *ucontrol)
3279 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3280 int enabled = !!ucontrol->value.integer.value[0];
3281 if (codec->beep->enabled != enabled) {
3282 codec->beep->enabled = enabled;
3288 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3289 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3290 .info = stac92xx_dig_beep_switch_info,
3291 .get = stac92xx_dig_beep_switch_get,
3292 .put = stac92xx_dig_beep_switch_put,
3295 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3297 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3298 0, "PC Beep Playback Switch", 0);
3302 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3304 struct sigmatel_spec *spec = codec->spec;
3305 int wcaps, nid, i, err = 0;
3307 for (i = 0; i < spec->num_muxes; i++) {
3308 nid = spec->mux_nids[i];
3309 wcaps = get_wcaps(codec, nid);
3311 if (wcaps & AC_WCAP_OUT_AMP) {
3312 err = stac92xx_add_control_idx(spec,
3313 STAC_CTL_WIDGET_VOL, i, "Mux Capture Volume",
3314 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3322 static const char *stac92xx_spdif_labels[3] = {
3323 "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3326 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3328 struct sigmatel_spec *spec = codec->spec;
3329 struct hda_input_mux *spdif_mux = &spec->private_smux;
3330 const char **labels = spec->spdif_labels;
3332 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3334 num_cons = snd_hda_get_connections(codec,
3337 HDA_MAX_NUM_INPUTS);
3342 labels = stac92xx_spdif_labels;
3344 for (i = 0; i < num_cons; i++) {
3345 spdif_mux->items[spdif_mux->num_items].label = labels[i];
3346 spdif_mux->items[spdif_mux->num_items].index = i;
3347 spdif_mux->num_items++;
3353 /* labels for dmic mux inputs */
3354 static const char *stac92xx_dmic_labels[5] = {
3355 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3356 "Digital Mic 3", "Digital Mic 4"
3359 /* create playback/capture controls for input pins on dmic capable codecs */
3360 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3361 const struct auto_pin_cfg *cfg)
3363 struct sigmatel_spec *spec = codec->spec;
3364 struct hda_input_mux *dimux = &spec->private_dimux;
3365 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3369 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
3370 dimux->items[dimux->num_items].index = 0;
3373 for (i = 0; i < spec->num_dmics; i++) {
3378 unsigned int def_conf;
3380 def_conf = snd_hda_codec_get_pincfg(codec, spec->dmic_nids[i]);
3381 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3384 nid = spec->dmic_nids[i];
3385 num_cons = snd_hda_get_connections(codec,
3388 HDA_MAX_NUM_INPUTS);
3389 for (j = 0; j < num_cons; j++)
3390 if (con_lst[j] == nid) {
3396 wcaps = get_wcaps(codec, nid) &
3397 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3400 sprintf(name, "%s Capture Volume",
3401 stac92xx_dmic_labels[dimux->num_items]);
3403 err = stac92xx_add_control(spec,
3404 STAC_CTL_WIDGET_VOL,
3406 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3407 (wcaps & AC_WCAP_OUT_AMP) ?
3408 HDA_OUTPUT : HDA_INPUT));
3413 dimux->items[dimux->num_items].label =
3414 stac92xx_dmic_labels[dimux->num_items];
3415 dimux->items[dimux->num_items].index = index;
3422 /* create playback/capture controls for input pins */
3423 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3425 struct sigmatel_spec *spec = codec->spec;
3426 struct hda_input_mux *imux = &spec->private_imux;
3427 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3430 for (i = 0; i < AUTO_PIN_LAST; i++) {
3433 if (!cfg->input_pins[i])
3436 for (j = 0; j < spec->num_muxes; j++) {
3438 num_cons = snd_hda_get_connections(codec,
3441 HDA_MAX_NUM_INPUTS);
3442 for (k = 0; k < num_cons; k++)
3443 if (con_lst[k] == cfg->input_pins[i]) {
3450 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3451 imux->items[imux->num_items].index = index;
3455 if (imux->num_items) {
3457 * Set the current input for the muxes.
3458 * The STAC9221 has two input muxes with identical source
3459 * NID lists. Hopefully this won't get confused.
3461 for (i = 0; i < spec->num_muxes; i++) {
3462 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3463 AC_VERB_SET_CONNECT_SEL,
3464 imux->items[0].index);
3471 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3473 struct sigmatel_spec *spec = codec->spec;
3476 for (i = 0; i < spec->autocfg.line_outs; i++) {
3477 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3478 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3482 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3484 struct sigmatel_spec *spec = codec->spec;
3487 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3489 pin = spec->autocfg.hp_pins[i];
3490 if (pin) /* connect to front */
3491 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3493 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3495 pin = spec->autocfg.speaker_pins[i];
3496 if (pin) /* connect to front */
3497 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3501 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3503 struct sigmatel_spec *spec = codec->spec;
3507 if ((err = snd_hda_parse_pin_def_config(codec,
3509 spec->dmic_nids)) < 0)
3511 if (! spec->autocfg.line_outs)
3512 return 0; /* can't find valid pin config */
3514 /* If we have no real line-out pin and multiple hp-outs, HPs should
3515 * be set up as multi-channel outputs.
3517 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
3518 spec->autocfg.hp_outs > 1) {
3519 /* Copy hp_outs to line_outs, backup line_outs in
3520 * speaker_outs so that the following routines can handle
3521 * HP pins as primary outputs.
3523 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3524 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3525 sizeof(spec->autocfg.line_out_pins));
3526 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3527 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3528 sizeof(spec->autocfg.hp_pins));
3529 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3530 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3531 spec->autocfg.hp_outs = 0;
3534 if (spec->autocfg.mono_out_pin) {
3535 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3536 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3537 u32 caps = query_amp_caps(codec,
3538 spec->autocfg.mono_out_pin, dir);
3539 hda_nid_t conn_list[1];
3541 /* get the mixer node and then the mono mux if it exists */
3542 if (snd_hda_get_connections(codec,
3543 spec->autocfg.mono_out_pin, conn_list, 1) &&
3544 snd_hda_get_connections(codec, conn_list[0],
3547 int wcaps = get_wcaps(codec, conn_list[0]);
3548 int wid_type = (wcaps & AC_WCAP_TYPE)
3549 >> AC_WCAP_TYPE_SHIFT;
3550 /* LR swap check, some stac925x have a mux that
3551 * changes the DACs output path instead of the
3554 if (wid_type == AC_WID_AUD_SEL &&
3555 !(wcaps & AC_WCAP_LR_SWAP))
3556 spec->mono_nid = conn_list[0];
3559 hda_nid_t nid = spec->autocfg.mono_out_pin;
3561 /* most mono outs have a least a mute/unmute switch */
3562 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3563 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3564 "Mono Playback Switch",
3565 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3568 /* check for volume support for the amp */
3569 if ((caps & AC_AMPCAP_NUM_STEPS)
3570 >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3571 err = stac92xx_add_control(spec,
3572 STAC_CTL_WIDGET_VOL,
3573 "Mono Playback Volume",
3574 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3580 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3584 if (!spec->multiout.num_dacs) {
3585 err = stac92xx_auto_fill_dac_nids(codec);
3588 err = stac92xx_auto_create_multi_out_ctls(codec,
3594 /* setup analog beep controls */
3595 if (spec->anabeep_nid > 0) {
3596 err = stac92xx_auto_create_beep_ctls(codec,
3602 /* setup digital beep controls and input device */
3603 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3604 if (spec->digbeep_nid > 0) {
3605 hda_nid_t nid = spec->digbeep_nid;
3608 err = stac92xx_auto_create_beep_ctls(codec, nid);
3611 err = snd_hda_attach_beep_device(codec, nid);
3614 /* if no beep switch is available, make its own one */
3615 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3617 !((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT)) {
3618 err = stac92xx_beep_switch_ctl(codec);
3625 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3629 /* All output parsing done, now restore the swapped hp pins */
3631 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3632 sizeof(spec->autocfg.hp_pins));
3633 spec->autocfg.hp_outs = spec->autocfg.line_outs;
3634 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3635 spec->autocfg.line_outs = 0;
3638 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3642 if (spec->mono_nid > 0) {
3643 err = stac92xx_auto_create_mono_output_ctls(codec);
3647 if (spec->num_amps > 0) {
3648 err = stac92xx_auto_create_amp_output_ctls(codec);
3652 if (spec->num_dmics > 0 && !spec->dinput_mux)
3653 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3654 &spec->autocfg)) < 0)
3656 if (spec->num_muxes > 0) {
3657 err = stac92xx_auto_create_mux_input_ctls(codec);
3661 if (spec->num_smuxes > 0) {
3662 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3667 err = stac92xx_add_input_source(spec);
3671 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3672 if (spec->multiout.max_channels > 2)
3673 spec->surr_switch = 1;
3675 if (spec->autocfg.dig_outs)
3676 spec->multiout.dig_out_nid = dig_out;
3677 if (dig_in && spec->autocfg.dig_in_pin)
3678 spec->dig_in_nid = dig_in;
3680 if (spec->kctls.list)
3681 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3683 spec->input_mux = &spec->private_imux;
3684 if (!spec->dinput_mux)
3685 spec->dinput_mux = &spec->private_dimux;
3686 spec->sinput_mux = &spec->private_smux;
3687 spec->mono_mux = &spec->private_mono_mux;
3688 spec->amp_mux = &spec->private_amp_mux;
3692 /* add playback controls for HP output */
3693 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3694 struct auto_pin_cfg *cfg)
3696 struct sigmatel_spec *spec = codec->spec;
3697 hda_nid_t pin = cfg->hp_pins[0];
3698 unsigned int wid_caps;
3703 wid_caps = get_wcaps(codec, pin);
3704 if (wid_caps & AC_WCAP_UNSOL_CAP)
3705 spec->hp_detect = 1;
3710 /* add playback controls for LFE output */
3711 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3712 struct auto_pin_cfg *cfg)
3714 struct sigmatel_spec *spec = codec->spec;
3716 hda_nid_t lfe_pin = 0x0;
3720 * search speaker outs and line outs for a mono speaker pin
3721 * with an amp. If one is found, add LFE controls
3724 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3725 hda_nid_t pin = spec->autocfg.speaker_pins[i];
3726 unsigned int wcaps = get_wcaps(codec, pin);
3727 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3728 if (wcaps == AC_WCAP_OUT_AMP)
3729 /* found a mono speaker with an amp, must be lfe */
3733 /* if speaker_outs is 0, then speakers may be in line_outs */
3734 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3735 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3736 hda_nid_t pin = spec->autocfg.line_out_pins[i];
3737 unsigned int defcfg;
3738 defcfg = snd_hda_codec_get_pincfg(codec, pin);
3739 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3740 unsigned int wcaps = get_wcaps(codec, pin);
3741 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3742 if (wcaps == AC_WCAP_OUT_AMP)
3743 /* found a mono speaker with an amp,
3751 err = create_controls(codec, "LFE", lfe_pin, 1);
3759 static int stac9200_parse_auto_config(struct hda_codec *codec)
3761 struct sigmatel_spec *spec = codec->spec;
3764 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3767 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3770 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
3773 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
3776 if (spec->num_muxes > 0) {
3777 err = stac92xx_auto_create_mux_input_ctls(codec);
3782 err = stac92xx_add_input_source(spec);
3786 if (spec->autocfg.dig_outs)
3787 spec->multiout.dig_out_nid = 0x05;
3788 if (spec->autocfg.dig_in_pin)
3789 spec->dig_in_nid = 0x04;
3791 if (spec->kctls.list)
3792 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3794 spec->input_mux = &spec->private_imux;
3795 spec->dinput_mux = &spec->private_dimux;
3801 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
3802 * funky external mute control using GPIO pins.
3805 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
3806 unsigned int dir_mask, unsigned int data)
3808 unsigned int gpiostate, gpiomask, gpiodir;
3810 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
3811 AC_VERB_GET_GPIO_DATA, 0);
3812 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
3814 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
3815 AC_VERB_GET_GPIO_MASK, 0);
3818 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
3819 AC_VERB_GET_GPIO_DIRECTION, 0);
3820 gpiodir |= dir_mask;
3822 /* Configure GPIOx as CMOS */
3823 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
3825 snd_hda_codec_write(codec, codec->afg, 0,
3826 AC_VERB_SET_GPIO_MASK, gpiomask);
3827 snd_hda_codec_read(codec, codec->afg, 0,
3828 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
3832 snd_hda_codec_read(codec, codec->afg, 0,
3833 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
3836 static int stac92xx_add_jack(struct hda_codec *codec,
3837 hda_nid_t nid, int type)
3839 #ifdef CONFIG_SND_JACK
3840 struct sigmatel_spec *spec = codec->spec;
3841 struct sigmatel_jack *jack;
3842 int def_conf = snd_hda_codec_get_pincfg(codec, nid);
3843 int connectivity = get_defcfg_connect(def_conf);
3846 if (connectivity && connectivity != AC_JACK_PORT_FIXED)
3849 snd_array_init(&spec->jacks, sizeof(*jack), 32);
3850 jack = snd_array_new(&spec->jacks);
3856 sprintf(name, "%s at %s %s Jack",
3857 snd_hda_get_jack_type(def_conf),
3858 snd_hda_get_jack_connectivity(def_conf),
3859 snd_hda_get_jack_location(def_conf));
3861 return snd_jack_new(codec->bus->card, name, type, &jack->jack);
3867 static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
3868 unsigned char type, int data)
3870 struct sigmatel_event *event;
3872 snd_array_init(&spec->events, sizeof(*event), 32);
3873 event = snd_array_new(&spec->events);
3878 event->tag = spec->events.used;
3884 static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
3885 hda_nid_t nid, unsigned char type)
3887 struct sigmatel_spec *spec = codec->spec;
3888 struct sigmatel_event *event = spec->events.list;
3891 for (i = 0; i < spec->events.used; i++, event++) {
3892 if (event->nid == nid && event->type == type)
3898 static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
3901 struct sigmatel_spec *spec = codec->spec;
3902 struct sigmatel_event *event = spec->events.list;
3905 for (i = 0; i < spec->events.used; i++, event++) {
3906 if (event->tag == tag)
3912 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
3915 struct sigmatel_event *event;
3918 if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
3920 event = stac_get_event(codec, nid, type);
3924 tag = stac_add_event(codec->spec, nid, type, 0);
3927 snd_hda_codec_write_cache(codec, nid, 0,
3928 AC_VERB_SET_UNSOLICITED_ENABLE,
3932 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
3935 for (i = 0; i < cfg->hp_outs; i++)
3936 if (cfg->hp_pins[i] == nid)
3937 return 1; /* nid is a HP-Out */
3939 return 0; /* nid is not a HP-Out */
3942 static void stac92xx_power_down(struct hda_codec *codec)
3944 struct sigmatel_spec *spec = codec->spec;
3946 /* power down inactive DACs */
3948 for (dac = spec->dac_list; *dac; dac++)
3949 if (!check_all_dac_nids(spec, *dac))
3950 snd_hda_codec_write(codec, *dac, 0,
3951 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3954 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
3957 /* override some hints from the hwdep entry */
3958 static void stac_store_hints(struct hda_codec *codec)
3960 struct sigmatel_spec *spec = codec->spec;
3964 val = snd_hda_get_bool_hint(codec, "hp_detect");
3966 spec->hp_detect = val;
3967 p = snd_hda_get_hint(codec, "gpio_mask");
3969 spec->gpio_mask = simple_strtoul(p, NULL, 0);
3970 spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
3973 p = snd_hda_get_hint(codec, "gpio_dir");
3975 spec->gpio_dir = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
3976 p = snd_hda_get_hint(codec, "gpio_data");
3978 spec->gpio_data = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
3979 p = snd_hda_get_hint(codec, "eapd_mask");
3981 spec->eapd_mask = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
3982 val = snd_hda_get_bool_hint(codec, "eapd_switch");
3984 spec->eapd_switch = val;
3987 static int stac92xx_init(struct hda_codec *codec)
3989 struct sigmatel_spec *spec = codec->spec;
3990 struct auto_pin_cfg *cfg = &spec->autocfg;
3994 snd_hda_sequence_write(codec, spec->init);
3996 /* power down adcs initially */
3997 if (spec->powerdown_adcs)
3998 for (i = 0; i < spec->num_adcs; i++)
3999 snd_hda_codec_write(codec,
4000 spec->adc_nids[i], 0,
4001 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4003 /* override some hints */
4004 stac_store_hints(codec);
4007 gpio = spec->gpio_data;
4008 /* turn on EAPD statically when spec->eapd_switch isn't set.
4009 * otherwise, unsol event will turn it on/off dynamically
4011 if (!spec->eapd_switch)
4012 gpio |= spec->eapd_mask;
4013 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
4016 if (spec->hp_detect) {
4017 /* Enable unsolicited responses on the HP widget */
4018 for (i = 0; i < cfg->hp_outs; i++) {
4019 hda_nid_t nid = cfg->hp_pins[i];
4020 enable_pin_detect(codec, nid, STAC_HP_EVENT);
4022 /* force to enable the first line-out; the others are set up
4025 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
4027 /* fake event to set up pins */
4028 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
4031 stac92xx_auto_init_multi_out(codec);
4032 stac92xx_auto_init_hp_out(codec);
4033 for (i = 0; i < cfg->hp_outs; i++)
4034 stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
4036 for (i = 0; i < AUTO_PIN_LAST; i++) {
4037 hda_nid_t nid = cfg->input_pins[i];
4039 unsigned int pinctl, conf;
4040 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
4041 /* for mic pins, force to initialize */
4042 pinctl = stac92xx_get_vref(codec, nid);
4043 pinctl |= AC_PINCTL_IN_EN;
4044 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4046 pinctl = snd_hda_codec_read(codec, nid, 0,
4047 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4048 /* if PINCTL already set then skip */
4049 if (!(pinctl & AC_PINCTL_IN_EN)) {
4050 pinctl |= AC_PINCTL_IN_EN;
4051 stac92xx_auto_set_pinctl(codec, nid,
4055 conf = snd_hda_codec_get_pincfg(codec, nid);
4056 if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
4057 enable_pin_detect(codec, nid,
4059 stac_issue_unsol_event(codec, nid,
4064 for (i = 0; i < spec->num_dmics; i++)
4065 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4067 if (cfg->dig_out_pins[0])
4068 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0],
4070 if (cfg->dig_in_pin)
4071 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4073 for (i = 0; i < spec->num_pwrs; i++) {
4074 hda_nid_t nid = spec->pwr_nids[i];
4075 int pinctl, def_conf;
4077 /* power on when no jack detection is available */
4078 if (!spec->hp_detect) {
4079 stac_toggle_power_map(codec, nid, 1);
4083 if (is_nid_hp_pin(cfg, nid))
4084 continue; /* already has an unsol event */
4086 pinctl = snd_hda_codec_read(codec, nid, 0,
4087 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4088 /* outputs are only ports capable of power management
4089 * any attempts on powering down a input port cause the
4090 * referenced VREF to act quirky.
4092 if (pinctl & AC_PINCTL_IN_EN) {
4093 stac_toggle_power_map(codec, nid, 1);
4096 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4097 def_conf = get_defcfg_connect(def_conf);
4098 /* skip any ports that don't have jacks since presence
4099 * detection is useless */
4100 if (def_conf != AC_JACK_PORT_COMPLEX) {
4101 if (def_conf != AC_JACK_PORT_NONE)
4102 stac_toggle_power_map(codec, nid, 1);
4105 if (!stac_get_event(codec, nid, STAC_INSERT_EVENT)) {
4106 enable_pin_detect(codec, nid, STAC_PWR_EVENT);
4107 stac_issue_unsol_event(codec, nid, STAC_PWR_EVENT);
4111 stac92xx_power_down(codec);
4115 static void stac92xx_free_jacks(struct hda_codec *codec)
4117 #ifdef CONFIG_SND_JACK
4118 /* free jack instances manually when clearing/reconfiguring */
4119 struct sigmatel_spec *spec = codec->spec;
4120 if (!codec->bus->shutdown && spec->jacks.list) {
4121 struct sigmatel_jack *jacks = spec->jacks.list;
4123 for (i = 0; i < spec->jacks.used; i++)
4124 snd_device_free(codec->bus->card, &jacks[i].jack);
4126 snd_array_free(&spec->jacks);
4130 static void stac92xx_free_kctls(struct hda_codec *codec)
4132 struct sigmatel_spec *spec = codec->spec;
4134 if (spec->kctls.list) {
4135 struct snd_kcontrol_new *kctl = spec->kctls.list;
4137 for (i = 0; i < spec->kctls.used; i++)
4138 kfree(kctl[i].name);
4140 snd_array_free(&spec->kctls);
4143 static void stac92xx_free(struct hda_codec *codec)
4145 struct sigmatel_spec *spec = codec->spec;
4150 stac92xx_free_jacks(codec);
4151 snd_array_free(&spec->events);
4154 snd_hda_detach_beep_device(codec);
4157 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4160 unsigned int old_ctl, pin_ctl;
4162 pin_ctl = snd_hda_codec_read(codec, nid,
4163 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4165 if (pin_ctl & AC_PINCTL_IN_EN) {
4167 * we need to check the current set-up direction of
4168 * shared input pins since they can be switched via
4169 * "xxx as Output" mixer switch
4171 struct sigmatel_spec *spec = codec->spec;
4172 if (nid == spec->line_switch || nid == spec->mic_switch)
4177 /* if setting pin direction bits, clear the current
4178 direction bits first */
4179 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4180 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4183 if (old_ctl != pin_ctl)
4184 snd_hda_codec_write_cache(codec, nid, 0,
4185 AC_VERB_SET_PIN_WIDGET_CONTROL,
4189 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4192 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4193 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4195 snd_hda_codec_write_cache(codec, nid, 0,
4196 AC_VERB_SET_PIN_WIDGET_CONTROL,
4200 static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4204 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
4210 /* return non-zero if the hp-pin of the given array index isn't
4211 * a jack-detection target
4213 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4215 struct auto_pin_cfg *cfg = &spec->autocfg;
4217 /* ignore sensing of shared line and mic jacks */
4218 if (cfg->hp_pins[i] == spec->line_switch)
4220 if (cfg->hp_pins[i] == spec->mic_switch)
4222 /* ignore if the pin is set as line-out */
4223 if (cfg->hp_pins[i] == spec->hp_switch)
4228 static void stac92xx_hp_detect(struct hda_codec *codec)
4230 struct sigmatel_spec *spec = codec->spec;
4231 struct auto_pin_cfg *cfg = &spec->autocfg;
4235 if (spec->gpio_mute)
4236 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4237 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4239 for (i = 0; i < cfg->hp_outs; i++) {
4242 if (no_hp_sensing(spec, i))
4244 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4246 unsigned int pinctl;
4247 pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4248 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4249 if (pinctl & AC_PINCTL_IN_EN)
4250 presence = 0; /* mic- or line-input */
4255 /* disable lineouts */
4256 if (spec->hp_switch)
4257 stac92xx_reset_pinctl(codec, spec->hp_switch,
4259 for (i = 0; i < cfg->line_outs; i++)
4260 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4262 for (i = 0; i < cfg->speaker_outs; i++)
4263 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4265 if (spec->eapd_mask && spec->eapd_switch)
4266 stac_gpio_set(codec, spec->gpio_mask,
4267 spec->gpio_dir, spec->gpio_data &
4270 /* enable lineouts */
4271 if (spec->hp_switch)
4272 stac92xx_set_pinctl(codec, spec->hp_switch,
4274 for (i = 0; i < cfg->line_outs; i++)
4275 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4277 for (i = 0; i < cfg->speaker_outs; i++)
4278 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4280 if (spec->eapd_mask && spec->eapd_switch)
4281 stac_gpio_set(codec, spec->gpio_mask,
4282 spec->gpio_dir, spec->gpio_data |
4285 /* toggle hp outs */
4286 for (i = 0; i < cfg->hp_outs; i++) {
4287 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4288 if (no_hp_sensing(spec, i))
4291 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4293 /* Resetting the pinctl like below may lead to (a sort of) regressions
4294 * on some devices since they use the HP pin actually for line/speaker
4295 * outs although the default pin config shows a different pin (that is
4296 * wrong and useless).
4298 * So, it's basically a problem of default pin configs, likely a BIOS issue.
4299 * But, disabling the code below just works around it, and I'm too tired of
4300 * bug reports with such devices...
4303 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4308 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4311 struct sigmatel_spec *spec = codec->spec;
4312 unsigned int idx, val;
4314 for (idx = 0; idx < spec->num_pwrs; idx++) {
4315 if (spec->pwr_nids[idx] == nid)
4318 if (idx >= spec->num_pwrs)
4321 /* several codecs have two power down bits */
4322 if (spec->pwr_mapping)
4323 idx = spec->pwr_mapping[idx];
4327 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
4333 /* power down unused output ports */
4334 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4337 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4339 stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4342 static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
4344 struct sigmatel_spec *spec = codec->spec;
4345 struct sigmatel_jack *jacks = spec->jacks.list;
4349 for (i = 0; i < spec->jacks.used; i++) {
4350 if (jacks->nid == nid) {
4351 unsigned int pin_ctl =
4352 snd_hda_codec_read(codec, nid,
4353 0, AC_VERB_GET_PIN_WIDGET_CONTROL,
4355 int type = jacks->type;
4356 if (type == (SND_JACK_LINEOUT
4357 | SND_JACK_HEADPHONE))
4358 type = (pin_ctl & AC_PINCTL_HP_EN)
4359 ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
4360 snd_jack_report(jacks->jack,
4361 get_pin_presence(codec, nid)
4369 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
4372 struct sigmatel_event *event = stac_get_event(codec, nid, type);
4375 codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
4378 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4380 struct sigmatel_spec *spec = codec->spec;
4381 struct sigmatel_event *event;
4384 tag = (res >> 26) & 0x7f;
4385 event = stac_get_event_from_tag(codec, tag);
4389 switch (event->type) {
4391 stac92xx_hp_detect(codec);
4393 case STAC_INSERT_EVENT:
4394 case STAC_PWR_EVENT:
4395 if (spec->num_pwrs > 0)
4396 stac92xx_pin_sense(codec, event->nid);
4397 stac92xx_report_jack(codec, event->nid);
4399 case STAC_VREF_EVENT:
4400 data = snd_hda_codec_read(codec, codec->afg, 0,
4401 AC_VERB_GET_GPIO_DATA, 0);
4402 /* toggle VREF state based on GPIOx status */
4403 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4404 !!(data & (1 << event->data)));
4409 #ifdef CONFIG_PROC_FS
4410 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4411 struct hda_codec *codec, hda_nid_t nid)
4413 if (nid == codec->afg)
4414 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4415 snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
4418 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4419 struct hda_codec *codec,
4422 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4423 snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
4426 /* stac92hd71bxx, stac92hd73xx */
4427 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4428 struct hda_codec *codec, hda_nid_t nid)
4430 stac92hd_proc_hook(buffer, codec, nid);
4431 if (nid == codec->afg)
4432 analog_loop_proc_hook(buffer, codec, 0xfa0);
4435 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4436 struct hda_codec *codec, hda_nid_t nid)
4438 if (nid == codec->afg)
4439 analog_loop_proc_hook(buffer, codec, 0xfe0);
4442 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4443 struct hda_codec *codec, hda_nid_t nid)
4445 if (nid == codec->afg)
4446 analog_loop_proc_hook(buffer, codec, 0xfeb);
4449 #define stac92hd_proc_hook NULL
4450 #define stac92hd7x_proc_hook NULL
4451 #define stac9205_proc_hook NULL
4452 #define stac927x_proc_hook NULL
4455 #ifdef SND_HDA_NEEDS_RESUME
4456 static int stac92xx_resume(struct hda_codec *codec)
4458 struct sigmatel_spec *spec = codec->spec;
4460 stac92xx_init(codec);
4461 snd_hda_codec_resume_amp(codec);
4462 snd_hda_codec_resume_cache(codec);
4463 /* fake event to set up pins again to override cached values */
4464 if (spec->hp_detect)
4465 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
4470 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
4472 struct sigmatel_spec *spec = codec->spec;
4473 if (spec->eapd_mask)
4474 stac_gpio_set(codec, spec->gpio_mask,
4475 spec->gpio_dir, spec->gpio_data &
4481 static struct hda_codec_ops stac92xx_patch_ops = {
4482 .build_controls = stac92xx_build_controls,
4483 .build_pcms = stac92xx_build_pcms,
4484 .init = stac92xx_init,
4485 .free = stac92xx_free,
4486 .unsol_event = stac92xx_unsol_event,
4487 #ifdef SND_HDA_NEEDS_RESUME
4488 .suspend = stac92xx_suspend,
4489 .resume = stac92xx_resume,
4493 static int patch_stac9200(struct hda_codec *codec)
4495 struct sigmatel_spec *spec;
4498 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4503 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
4504 spec->pin_nids = stac9200_pin_nids;
4505 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
4508 if (spec->board_config < 0)
4509 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
4511 stac92xx_set_config_regs(codec,
4512 stac9200_brd_tbl[spec->board_config]);
4514 spec->multiout.max_channels = 2;
4515 spec->multiout.num_dacs = 1;
4516 spec->multiout.dac_nids = stac9200_dac_nids;
4517 spec->adc_nids = stac9200_adc_nids;
4518 spec->mux_nids = stac9200_mux_nids;
4519 spec->num_muxes = 1;
4520 spec->num_dmics = 0;
4524 if (spec->board_config == STAC_9200_M4 ||
4525 spec->board_config == STAC_9200_M4_2 ||
4526 spec->board_config == STAC_9200_OQO)
4527 spec->init = stac9200_eapd_init;
4529 spec->init = stac9200_core_init;
4530 spec->mixer = stac9200_mixer;
4532 if (spec->board_config == STAC_9200_PANASONIC) {
4533 spec->gpio_mask = spec->gpio_dir = 0x09;
4534 spec->gpio_data = 0x00;
4537 err = stac9200_parse_auto_config(codec);
4539 stac92xx_free(codec);
4543 /* CF-74 has no headphone detection, and the driver should *NOT*
4544 * do detection and HP/speaker toggle because the hardware does it.
4546 if (spec->board_config == STAC_9200_PANASONIC)
4547 spec->hp_detect = 0;
4549 codec->patch_ops = stac92xx_patch_ops;
4554 static int patch_stac925x(struct hda_codec *codec)
4556 struct sigmatel_spec *spec;
4559 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4564 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
4565 spec->pin_nids = stac925x_pin_nids;
4567 /* Check first for codec ID */
4568 spec->board_config = snd_hda_check_board_codec_sid_config(codec,
4571 stac925x_codec_id_cfg_tbl);
4573 /* Now checks for PCI ID, if codec ID is not found */
4574 if (spec->board_config < 0)
4575 spec->board_config = snd_hda_check_board_config(codec,
4580 if (spec->board_config < 0)
4581 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
4582 "using BIOS defaults\n");
4584 stac92xx_set_config_regs(codec,
4585 stac925x_brd_tbl[spec->board_config]);
4587 spec->multiout.max_channels = 2;
4588 spec->multiout.num_dacs = 1;
4589 spec->multiout.dac_nids = stac925x_dac_nids;
4590 spec->adc_nids = stac925x_adc_nids;
4591 spec->mux_nids = stac925x_mux_nids;
4592 spec->num_muxes = 1;
4595 switch (codec->vendor_id) {
4596 case 0x83847632: /* STAC9202 */
4597 case 0x83847633: /* STAC9202D */
4598 case 0x83847636: /* STAC9251 */
4599 case 0x83847637: /* STAC9251D */
4600 spec->num_dmics = STAC925X_NUM_DMICS;
4601 spec->dmic_nids = stac925x_dmic_nids;
4602 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
4603 spec->dmux_nids = stac925x_dmux_nids;
4606 spec->num_dmics = 0;
4610 spec->init = stac925x_core_init;
4611 spec->mixer = stac925x_mixer;
4613 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
4615 if (spec->board_config < 0) {
4616 printk(KERN_WARNING "hda_codec: No auto-config is "
4617 "available, default to model=ref\n");
4618 spec->board_config = STAC_925x_REF;
4624 stac92xx_free(codec);
4628 codec->patch_ops = stac92xx_patch_ops;
4633 static struct hda_input_mux stac92hd73xx_dmux = {
4636 { "Analog Inputs", 0x0b },
4637 { "Digital Mic 1", 0x09 },
4638 { "Digital Mic 2", 0x0a },
4643 static int patch_stac92hd73xx(struct hda_codec *codec)
4645 struct sigmatel_spec *spec;
4646 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
4650 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4655 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
4656 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
4657 spec->pin_nids = stac92hd73xx_pin_nids;
4658 spec->board_config = snd_hda_check_board_config(codec,
4659 STAC_92HD73XX_MODELS,
4660 stac92hd73xx_models,
4661 stac92hd73xx_cfg_tbl);
4663 if (spec->board_config < 0)
4664 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4665 " STAC92HD73XX, using BIOS defaults\n");
4667 stac92xx_set_config_regs(codec,
4668 stac92hd73xx_brd_tbl[spec->board_config]);
4670 num_dacs = snd_hda_get_connections(codec, 0x0a,
4671 conn, STAC92HD73_DAC_COUNT + 2) - 1;
4673 if (num_dacs < 3 || num_dacs > 5) {
4674 printk(KERN_WARNING "hda_codec: Could not determine "
4675 "number of channels defaulting to DAC count\n");
4676 num_dacs = STAC92HD73_DAC_COUNT;
4679 case 0x3: /* 6 Channel */
4680 spec->mixer = stac92hd73xx_6ch_mixer;
4681 spec->init = stac92hd73xx_6ch_core_init;
4682 spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
4684 case 0x4: /* 8 Channel */
4685 spec->mixer = stac92hd73xx_8ch_mixer;
4686 spec->init = stac92hd73xx_8ch_core_init;
4687 spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
4689 case 0x5: /* 10 Channel */
4690 spec->mixer = stac92hd73xx_10ch_mixer;
4691 spec->init = stac92hd73xx_10ch_core_init;
4692 spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
4695 spec->multiout.dac_nids = spec->dac_nids;
4697 spec->aloopback_mask = 0x01;
4698 spec->aloopback_shift = 8;
4700 spec->digbeep_nid = 0x1c;
4701 spec->mux_nids = stac92hd73xx_mux_nids;
4702 spec->adc_nids = stac92hd73xx_adc_nids;
4703 spec->dmic_nids = stac92hd73xx_dmic_nids;
4704 spec->dmux_nids = stac92hd73xx_dmux_nids;
4705 spec->smux_nids = stac92hd73xx_smux_nids;
4706 spec->amp_nids = stac92hd73xx_amp_nids;
4707 spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
4709 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
4710 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
4711 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
4712 memcpy(&spec->private_dimux, &stac92hd73xx_dmux,
4713 sizeof(stac92hd73xx_dmux));
4715 switch (spec->board_config) {
4717 spec->init = dell_eq_core_init;
4719 case STAC_DELL_M6_AMIC:
4720 case STAC_DELL_M6_DMIC:
4721 case STAC_DELL_M6_BOTH:
4722 spec->num_smuxes = 0;
4723 spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
4724 spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
4725 spec->eapd_switch = 0;
4728 if (spec->board_config != STAC_DELL_EQ)
4729 spec->init = dell_m6_core_init;
4730 switch (spec->board_config) {
4731 case STAC_DELL_M6_AMIC: /* Analog Mics */
4732 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
4733 spec->num_dmics = 0;
4734 spec->private_dimux.num_items = 1;
4736 case STAC_DELL_M6_DMIC: /* Digital Mics */
4737 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
4738 spec->num_dmics = 1;
4739 spec->private_dimux.num_items = 2;
4741 case STAC_DELL_M6_BOTH: /* Both */
4742 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
4743 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
4744 spec->num_dmics = 1;
4745 spec->private_dimux.num_items = 2;
4750 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
4751 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
4752 spec->eapd_switch = 1;
4754 if (spec->board_config > STAC_92HD73XX_REF) {
4755 /* GPIO0 High = Enable EAPD */
4756 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4757 spec->gpio_data = 0x01;
4759 spec->dinput_mux = &spec->private_dimux;
4761 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
4762 spec->pwr_nids = stac92hd73xx_pwr_nids;
4764 err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
4767 if (spec->board_config < 0) {
4768 printk(KERN_WARNING "hda_codec: No auto-config is "
4769 "available, default to model=ref\n");
4770 spec->board_config = STAC_92HD73XX_REF;
4777 stac92xx_free(codec);
4781 if (spec->board_config == STAC_92HD73XX_NO_JD)
4782 spec->hp_detect = 0;
4784 codec->patch_ops = stac92xx_patch_ops;
4786 codec->proc_widget_hook = stac92hd7x_proc_hook;
4791 static struct hda_input_mux stac92hd83xxx_dmux = {
4794 { "Analog Inputs", 0x03 },
4795 { "Digital Mic 1", 0x04 },
4796 { "Digital Mic 2", 0x05 },
4800 static int patch_stac92hd83xxx(struct hda_codec *codec)
4802 struct sigmatel_spec *spec;
4803 hda_nid_t conn[STAC92HD83_DAC_COUNT + 1];
4808 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4813 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
4814 spec->mono_nid = 0x19;
4815 spec->digbeep_nid = 0x21;
4816 spec->dmic_nids = stac92hd83xxx_dmic_nids;
4817 spec->dmux_nids = stac92hd83xxx_dmux_nids;
4818 spec->adc_nids = stac92hd83xxx_adc_nids;
4819 spec->pwr_nids = stac92hd83xxx_pwr_nids;
4820 spec->amp_nids = stac92hd83xxx_amp_nids;
4821 spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
4822 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
4823 spec->multiout.dac_nids = spec->dac_nids;
4825 spec->init = stac92hd83xxx_core_init;
4826 spec->mixer = stac92hd83xxx_mixer;
4827 spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
4828 spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
4829 spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
4830 spec->num_amps = ARRAY_SIZE(stac92hd83xxx_amp_nids);
4831 spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
4832 spec->dinput_mux = &stac92hd83xxx_dmux;
4833 spec->pin_nids = stac92hd83xxx_pin_nids;
4834 spec->board_config = snd_hda_check_board_config(codec,
4835 STAC_92HD83XXX_MODELS,
4836 stac92hd83xxx_models,
4837 stac92hd83xxx_cfg_tbl);
4839 if (spec->board_config < 0)
4840 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4841 " STAC92HD83XXX, using BIOS defaults\n");
4843 stac92xx_set_config_regs(codec,
4844 stac92hd83xxx_brd_tbl[spec->board_config]);
4846 switch (codec->vendor_id) {
4849 if (spec->board_config == STAC_92HD83XXX_PWR_REF)
4855 err = stac92xx_parse_auto_config(codec, 0x1d, 0);
4857 if (spec->board_config < 0) {
4858 printk(KERN_WARNING "hda_codec: No auto-config is "
4859 "available, default to model=ref\n");
4860 spec->board_config = STAC_92HD83XXX_REF;
4867 stac92xx_free(codec);
4871 switch (spec->board_config) {
4880 num_dacs = snd_hda_get_connections(codec, nid,
4881 conn, STAC92HD83_DAC_COUNT + 1) - 1;
4883 /* set port X to select the last DAC
4885 snd_hda_codec_write_cache(codec, nid, 0,
4886 AC_VERB_SET_CONNECT_SEL, num_dacs);
4888 codec->patch_ops = stac92xx_patch_ops;
4890 codec->proc_widget_hook = stac92hd_proc_hook;
4895 static struct hda_input_mux stac92hd71bxx_dmux_nomixer = {
4898 { "Analog Inputs", 0x00 },
4899 { "Digital Mic 1", 0x02 },
4900 { "Digital Mic 2", 0x03 },
4904 static struct hda_input_mux stac92hd71bxx_dmux_amixer = {
4907 { "Analog Inputs", 0x00 },
4909 { "Digital Mic 1", 0x02 },
4910 { "Digital Mic 2", 0x03 },
4914 /* get the pin connection (fixed, none, etc) */
4915 static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
4917 struct sigmatel_spec *spec = codec->spec;
4920 cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]);
4921 return get_defcfg_connect(cfg);
4924 static int stac92hd71bxx_connected_ports(struct hda_codec *codec,
4925 hda_nid_t *nids, int num_nids)
4927 struct sigmatel_spec *spec = codec->spec;
4929 unsigned int def_conf;
4931 for (num = 0; num < num_nids; num++) {
4932 for (idx = 0; idx < spec->num_pins; idx++)
4933 if (spec->pin_nids[idx] == nids[num])
4935 if (idx >= spec->num_pins)
4937 def_conf = stac_get_defcfg_connect(codec, idx);
4938 if (def_conf == AC_JACK_PORT_NONE)
4944 static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
4947 struct sigmatel_spec *spec = codec->spec;
4950 for (idx = 0; idx < spec->num_pins; idx++)
4951 if (spec->pin_nids[idx] == dig0pin)
4953 if ((idx + 2) >= spec->num_pins)
4957 if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE)
4960 /* dig0pin + dig2pin case */
4961 if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE)
4963 if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE)
4969 static int patch_stac92hd71bxx(struct hda_codec *codec)
4971 struct sigmatel_spec *spec;
4972 struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
4974 unsigned int ndmic_nids = 0;
4976 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4981 codec->patch_ops = stac92xx_patch_ops;
4982 spec->num_pins = STAC92HD71BXX_NUM_PINS;
4983 switch (codec->vendor_id) {
4986 spec->pin_nids = stac92hd71bxx_pin_nids_4port;
4990 /* On 92HD75Bx 0x27 isn't a pin nid */
4994 spec->pin_nids = stac92hd71bxx_pin_nids_6port;
4996 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
4997 spec->board_config = snd_hda_check_board_config(codec,
4998 STAC_92HD71BXX_MODELS,
4999 stac92hd71bxx_models,
5000 stac92hd71bxx_cfg_tbl);
5002 if (spec->board_config < 0)
5003 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
5004 " STAC92HD71BXX, using BIOS defaults\n");
5006 stac92xx_set_config_regs(codec,
5007 stac92hd71bxx_brd_tbl[spec->board_config]);
5009 if (spec->board_config > STAC_92HD71BXX_REF) {
5011 spec->gpio_mask = 0x01;
5012 spec->gpio_dir = 0x01;
5013 spec->gpio_data = 0x01;
5016 spec->dmic_nids = stac92hd71bxx_dmic_nids;
5017 spec->dmux_nids = stac92hd71bxx_dmux_nids;
5019 switch (codec->vendor_id) {
5020 case 0x111d76b6: /* 4 Port without Analog Mixer */
5024 case 0x111d76b4: /* 6 Port without Analog Mixer */
5026 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_nomixer,
5027 sizeof(stac92hd71bxx_dmux_nomixer));
5028 spec->mixer = stac92hd71bxx_mixer;
5029 spec->init = stac92hd71bxx_core_init;
5030 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5031 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5032 stac92hd71bxx_dmic_nids,
5033 STAC92HD71BXX_NUM_DMICS);
5034 if (spec->num_dmics) {
5035 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5036 spec->dinput_mux = &spec->private_dimux;
5037 ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1;
5040 case 0x111d7608: /* 5 Port with Analog Mixer */
5041 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_amixer,
5042 sizeof(stac92hd71bxx_dmux_amixer));
5043 spec->private_dimux.num_items--;
5044 switch (spec->board_config) {
5046 /* Enable VREF power saving on GPIO1 detect */
5047 err = stac_add_event(spec, codec->afg,
5048 STAC_VREF_EVENT, 0x02);
5051 snd_hda_codec_write_cache(codec, codec->afg, 0,
5052 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
5053 snd_hda_codec_write_cache(codec, codec->afg, 0,
5054 AC_VERB_SET_UNSOLICITED_ENABLE,
5056 spec->gpio_mask |= 0x02;
5059 if ((codec->revision_id & 0xf) == 0 ||
5060 (codec->revision_id & 0xf) == 1)
5061 spec->stream_delay = 40; /* 40 milliseconds */
5063 /* no output amps */
5065 spec->mixer = stac92hd71bxx_analog_mixer;
5066 spec->dinput_mux = &spec->private_dimux;
5069 spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
5071 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
5072 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
5073 stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS - 1] = 0;
5074 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5075 stac92hd71bxx_dmic_nids,
5076 STAC92HD71BXX_NUM_DMICS - 1);
5077 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5078 ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 2;
5080 case 0x111d7603: /* 6 Port with Analog Mixer */
5081 if ((codec->revision_id & 0xf) == 1)
5082 spec->stream_delay = 40; /* 40 milliseconds */
5084 /* no output amps */
5088 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux_amixer,
5089 sizeof(stac92hd71bxx_dmux_amixer));
5090 spec->dinput_mux = &spec->private_dimux;
5091 spec->mixer = stac92hd71bxx_analog_mixer;
5092 spec->init = stac92hd71bxx_analog_core_init;
5093 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5094 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5095 stac92hd71bxx_dmic_nids,
5096 STAC92HD71BXX_NUM_DMICS);
5097 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5098 ndmic_nids = ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1;
5101 if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
5102 snd_hda_sequence_write_cache(codec, unmute_init);
5104 spec->aloopback_ctl = stac92hd71bxx_loopback;
5105 spec->aloopback_mask = 0x50;
5106 spec->aloopback_shift = 0;
5108 spec->powerdown_adcs = 1;
5109 spec->digbeep_nid = 0x26;
5110 spec->mux_nids = stac92hd71bxx_mux_nids;
5111 spec->adc_nids = stac92hd71bxx_adc_nids;
5112 spec->smux_nids = stac92hd71bxx_smux_nids;
5113 spec->pwr_nids = stac92hd71bxx_pwr_nids;
5115 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
5116 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
5117 spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
5119 switch (spec->board_config) {
5121 /* enable internal microphone */
5122 snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
5123 stac92xx_auto_set_pinctl(codec, 0x0e,
5124 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
5126 case STAC_DELL_M4_2:
5127 spec->num_dmics = 0;
5128 spec->num_smuxes = 0;
5129 spec->num_dmuxes = 0;
5131 case STAC_DELL_M4_1:
5132 case STAC_DELL_M4_3:
5133 spec->num_dmics = 1;
5134 spec->num_smuxes = 0;
5135 spec->num_dmuxes = 1;
5138 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
5139 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
5143 spec->multiout.dac_nids = spec->dac_nids;
5144 if (spec->dinput_mux)
5145 spec->private_dimux.num_items += spec->num_dmics - ndmic_nids;
5147 err = stac92xx_parse_auto_config(codec, 0x21, 0);
5149 if (spec->board_config < 0) {
5150 printk(KERN_WARNING "hda_codec: No auto-config is "
5151 "available, default to model=ref\n");
5152 spec->board_config = STAC_92HD71BXX_REF;
5159 stac92xx_free(codec);
5163 codec->proc_widget_hook = stac92hd7x_proc_hook;
5168 static int patch_stac922x(struct hda_codec *codec)
5170 struct sigmatel_spec *spec;
5173 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5178 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
5179 spec->pin_nids = stac922x_pin_nids;
5180 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
5183 if (spec->board_config == STAC_INTEL_MAC_AUTO) {
5184 spec->gpio_mask = spec->gpio_dir = 0x03;
5185 spec->gpio_data = 0x03;
5186 /* Intel Macs have all same PCI SSID, so we need to check
5187 * codec SSID to distinguish the exact models
5189 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
5190 switch (codec->subsystem_id) {
5193 spec->board_config = STAC_INTEL_MAC_V1;
5197 spec->board_config = STAC_INTEL_MAC_V2;
5205 spec->board_config = STAC_INTEL_MAC_V3;
5209 spec->board_config = STAC_INTEL_MAC_V4;
5213 spec->board_config = STAC_INTEL_MAC_V5;
5216 spec->board_config = STAC_INTEL_MAC_V3;
5222 if (spec->board_config < 0)
5223 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
5224 "using BIOS defaults\n");
5226 stac92xx_set_config_regs(codec,
5227 stac922x_brd_tbl[spec->board_config]);
5229 spec->adc_nids = stac922x_adc_nids;
5230 spec->mux_nids = stac922x_mux_nids;
5231 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
5232 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
5233 spec->num_dmics = 0;
5236 spec->init = stac922x_core_init;
5237 spec->mixer = stac922x_mixer;
5239 spec->multiout.dac_nids = spec->dac_nids;
5241 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
5243 if (spec->board_config < 0) {
5244 printk(KERN_WARNING "hda_codec: No auto-config is "
5245 "available, default to model=ref\n");
5246 spec->board_config = STAC_D945_REF;
5252 stac92xx_free(codec);
5256 codec->patch_ops = stac92xx_patch_ops;
5258 /* Fix Mux capture level; max to 2 */
5259 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
5260 (0 << AC_AMPCAP_OFFSET_SHIFT) |
5261 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5262 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5263 (0 << AC_AMPCAP_MUTE_SHIFT));
5268 static int patch_stac927x(struct hda_codec *codec)
5270 struct sigmatel_spec *spec;
5273 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5278 codec->slave_dig_outs = stac927x_slave_dig_outs;
5279 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
5280 spec->pin_nids = stac927x_pin_nids;
5281 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
5285 if (spec->board_config < 0)
5286 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
5287 "STAC927x, using BIOS defaults\n");
5289 stac92xx_set_config_regs(codec,
5290 stac927x_brd_tbl[spec->board_config]);
5292 spec->digbeep_nid = 0x23;
5293 spec->adc_nids = stac927x_adc_nids;
5294 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
5295 spec->mux_nids = stac927x_mux_nids;
5296 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
5297 spec->smux_nids = stac927x_smux_nids;
5298 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
5299 spec->spdif_labels = stac927x_spdif_labels;
5300 spec->dac_list = stac927x_dac_nids;
5301 spec->multiout.dac_nids = spec->dac_nids;
5303 switch (spec->board_config) {
5306 /* GPIO0 High = Enable EAPD */
5307 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01;
5308 spec->gpio_data = 0x01;
5309 spec->num_dmics = 0;
5311 spec->init = d965_core_init;
5312 spec->mixer = stac927x_mixer;
5314 case STAC_DELL_BIOS:
5315 switch (codec->subsystem_id) {
5318 /* correct the device field to SPDIF out */
5319 snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
5322 /* configure the analog microphone on some laptops */
5323 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
5324 /* correct the front output jack as a hp out */
5325 snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f);
5326 /* correct the front input jack as a mic */
5327 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
5330 /* GPIO2 High = Enable EAPD */
5331 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
5332 spec->gpio_data = 0x04;
5333 spec->dmic_nids = stac927x_dmic_nids;
5334 spec->num_dmics = STAC927X_NUM_DMICS;
5336 spec->init = d965_core_init;
5337 spec->mixer = stac927x_mixer;
5338 spec->dmux_nids = stac927x_dmux_nids;
5339 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
5342 if (spec->board_config > STAC_D965_REF) {
5343 /* GPIO0 High = Enable EAPD */
5344 spec->eapd_mask = spec->gpio_mask = 0x01;
5345 spec->gpio_dir = spec->gpio_data = 0x01;
5347 spec->num_dmics = 0;
5349 spec->init = stac927x_core_init;
5350 spec->mixer = stac927x_mixer;
5354 spec->aloopback_ctl = stac927x_loopback;
5355 spec->aloopback_mask = 0x40;
5356 spec->aloopback_shift = 0;
5357 spec->eapd_switch = 1;
5359 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
5361 if (spec->board_config < 0) {
5362 printk(KERN_WARNING "hda_codec: No auto-config is "
5363 "available, default to model=ref\n");
5364 spec->board_config = STAC_D965_REF;
5370 stac92xx_free(codec);
5374 codec->patch_ops = stac92xx_patch_ops;
5376 codec->proc_widget_hook = stac927x_proc_hook;
5380 * The STAC927x seem to require fairly long delays for certain
5381 * command sequences. With too short delays (even if the answer
5382 * is set to RIRB properly), it results in the silence output
5383 * on some hardwares like Dell.
5385 * The below flag enables the longer delay (see get_response
5388 codec->bus->needs_damn_long_delay = 1;
5390 /* no jack detecion for ref-no-jd model */
5391 if (spec->board_config == STAC_D965_REF_NO_JD)
5392 spec->hp_detect = 0;
5397 static int patch_stac9205(struct hda_codec *codec)
5399 struct sigmatel_spec *spec;
5402 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5407 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
5408 spec->pin_nids = stac9205_pin_nids;
5409 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
5413 if (spec->board_config < 0)
5414 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
5416 stac92xx_set_config_regs(codec,
5417 stac9205_brd_tbl[spec->board_config]);
5419 spec->digbeep_nid = 0x23;
5420 spec->adc_nids = stac9205_adc_nids;
5421 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
5422 spec->mux_nids = stac9205_mux_nids;
5423 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
5424 spec->smux_nids = stac9205_smux_nids;
5425 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
5426 spec->dmic_nids = stac9205_dmic_nids;
5427 spec->num_dmics = STAC9205_NUM_DMICS;
5428 spec->dmux_nids = stac9205_dmux_nids;
5429 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
5432 spec->init = stac9205_core_init;
5433 spec->mixer = stac9205_mixer;
5434 spec->aloopback_ctl = stac9205_loopback;
5436 spec->aloopback_mask = 0x40;
5437 spec->aloopback_shift = 0;
5438 /* Turn on/off EAPD per HP plugging */
5439 if (spec->board_config != STAC_9205_EAPD)
5440 spec->eapd_switch = 1;
5441 spec->multiout.dac_nids = spec->dac_nids;
5443 switch (spec->board_config){
5444 case STAC_9205_DELL_M43:
5445 /* Enable SPDIF in/out */
5446 snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030);
5447 snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030);
5449 /* Enable unsol response for GPIO4/Dock HP connection */
5450 err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
5453 snd_hda_codec_write_cache(codec, codec->afg, 0,
5454 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
5455 snd_hda_codec_write_cache(codec, codec->afg, 0,
5456 AC_VERB_SET_UNSOLICITED_ENABLE,
5459 spec->gpio_dir = 0x0b;
5460 spec->eapd_mask = 0x01;
5461 spec->gpio_mask = 0x1b;
5462 spec->gpio_mute = 0x10;
5463 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
5466 spec->gpio_data = 0x01;
5469 /* SPDIF-In enabled */
5472 /* GPIO0 High = EAPD */
5473 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5474 spec->gpio_data = 0x01;
5478 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
5480 if (spec->board_config < 0) {
5481 printk(KERN_WARNING "hda_codec: No auto-config is "
5482 "available, default to model=ref\n");
5483 spec->board_config = STAC_9205_REF;
5489 stac92xx_free(codec);
5493 codec->patch_ops = stac92xx_patch_ops;
5495 codec->proc_widget_hook = stac9205_proc_hook;
5504 static struct hda_verb stac9872_core_init[] = {
5505 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5506 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5510 static struct snd_kcontrol_new stac9872_mixer[] = {
5511 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5512 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5516 static hda_nid_t stac9872_pin_nids[] = {
5517 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
5521 static hda_nid_t stac9872_adc_nids[] = {
5525 static hda_nid_t stac9872_mux_nids[] = {
5529 static int patch_stac9872(struct hda_codec *codec)
5531 struct sigmatel_spec *spec;
5534 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5539 #if 0 /* no model right now */
5540 spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
5545 spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
5546 spec->pin_nids = stac9872_pin_nids;
5547 spec->multiout.dac_nids = spec->dac_nids;
5548 spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
5549 spec->adc_nids = stac9872_adc_nids;
5550 spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
5551 spec->mux_nids = stac9872_mux_nids;
5552 spec->mixer = stac9872_mixer;
5553 spec->init = stac9872_core_init;
5555 err = stac92xx_parse_auto_config(codec, 0x10, 0x12);
5557 stac92xx_free(codec);
5560 spec->input_mux = &spec->private_imux;
5561 codec->patch_ops = stac92xx_patch_ops;
5569 static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
5570 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
5571 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
5572 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
5573 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
5574 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
5575 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
5576 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
5577 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
5578 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
5579 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
5580 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
5581 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
5582 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
5583 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
5584 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
5585 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
5586 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
5587 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
5588 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
5589 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
5590 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
5591 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
5592 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
5593 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
5594 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
5595 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
5596 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
5597 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
5598 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
5599 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
5600 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
5601 /* The following does not take into account .id=0x83847661 when subsys =
5602 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
5603 * currently not fully supported.
5605 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
5606 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
5607 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
5608 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
5609 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
5610 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
5611 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
5612 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
5613 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
5614 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
5615 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
5616 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
5617 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
5618 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
5619 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
5620 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
5621 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
5622 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
5623 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5624 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5625 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5626 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5627 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5628 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5629 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5630 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5634 MODULE_ALIAS("snd-hda-codec-id:8384*");
5635 MODULE_ALIAS("snd-hda-codec-id:111d*");
5637 MODULE_LICENSE("GPL");
5638 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
5640 static struct hda_codec_preset_list sigmatel_list = {
5641 .preset = snd_hda_preset_sigmatel,
5642 .owner = THIS_MODULE,
5645 static int __init patch_sigmatel_init(void)
5647 return snd_hda_add_codec_preset(&sigmatel_list);
5650 static void __exit patch_sigmatel_exit(void)
5652 snd_hda_delete_codec_preset(&sigmatel_list);
5655 module_init(patch_sigmatel_init)
5656 module_exit(patch_sigmatel_exit)