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"
74 STAC_92HD73XX_NO_JD, /* no jack-detection */
85 STAC_92HD83XXX_PWR_REF,
120 STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
121 * is given, one of the above models will be
122 * chosen according to the subsystem id. */
123 /* for backward compatibility */
139 STAC_D965_REF_NO_JD, /* no jack-detection */
148 struct sigmatel_event {
155 struct sigmatel_jack {
158 struct snd_jack *jack;
161 struct sigmatel_spec {
162 struct snd_kcontrol_new *mixers[4];
163 unsigned int num_mixers;
166 unsigned int eapd_switch: 1;
167 unsigned int surr_switch: 1;
168 unsigned int alt_switch: 1;
169 unsigned int hp_detect: 1;
170 unsigned int spdif_mute: 1;
171 unsigned int check_volume_offset:1;
174 unsigned int eapd_mask;
175 unsigned int gpio_mask;
176 unsigned int gpio_dir;
177 unsigned int gpio_data;
178 unsigned int gpio_mute;
181 unsigned int stream_delay;
183 /* analog loopback */
184 unsigned char aloopback_mask;
185 unsigned char aloopback_shift;
187 /* power management */
188 unsigned int num_pwrs;
189 unsigned int *pwr_mapping;
194 struct snd_array jacks;
197 struct snd_array events;
200 struct hda_input_mux *mono_mux;
201 struct hda_input_mux *amp_mux;
202 unsigned int cur_mmux;
203 struct hda_multi_out multiout;
204 hda_nid_t dac_nids[5];
205 hda_nid_t hp_dacs[5];
206 hda_nid_t speaker_dacs[5];
212 unsigned int num_adcs;
214 unsigned int num_muxes;
215 hda_nid_t *dmic_nids;
216 unsigned int num_dmics;
217 hda_nid_t *dmux_nids;
218 unsigned int num_dmuxes;
219 hda_nid_t *smux_nids;
220 unsigned int num_smuxes;
221 const char **spdif_labels;
223 hda_nid_t dig_in_nid;
225 hda_nid_t anabeep_nid;
226 hda_nid_t digbeep_nid;
230 unsigned int num_pins;
231 unsigned int *pin_configs;
233 /* codec specific stuff */
234 struct hda_verb *init;
235 struct snd_kcontrol_new *mixer;
238 struct hda_input_mux *dinput_mux;
239 unsigned int cur_dmux[2];
240 struct hda_input_mux *input_mux;
241 unsigned int cur_mux[3];
242 struct hda_input_mux *sinput_mux;
243 unsigned int cur_smux[2];
244 unsigned int cur_amux;
246 unsigned int num_amps;
247 unsigned int powerdown_adcs;
250 unsigned int io_switch[2];
251 unsigned int clfe_swap;
252 hda_nid_t line_switch; /* shared line-in for input and output */
253 hda_nid_t mic_switch; /* shared mic-in for input and output */
254 hda_nid_t hp_switch; /* NID of HP as line-out */
255 unsigned int aloopback;
257 struct hda_pcm pcm_rec[2]; /* PCM information */
259 /* dynamic controls and input_mux */
260 struct auto_pin_cfg autocfg;
261 struct snd_array kctls;
262 struct hda_input_mux private_dimux;
263 struct hda_input_mux private_imux;
264 struct hda_input_mux private_smux;
265 struct hda_input_mux private_amp_mux;
266 struct hda_input_mux private_mono_mux;
269 static hda_nid_t stac9200_adc_nids[1] = {
273 static hda_nid_t stac9200_mux_nids[1] = {
277 static hda_nid_t stac9200_dac_nids[1] = {
281 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
282 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
286 static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
290 static hda_nid_t stac92hd73xx_adc_nids[2] = {
294 #define DELL_M6_AMP 2
295 static hda_nid_t stac92hd73xx_amp_nids[3] = {
299 #define STAC92HD73XX_NUM_DMICS 2
300 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
304 #define STAC92HD73_DAC_COUNT 5
306 static hda_nid_t stac92hd73xx_mux_nids[4] = {
307 0x28, 0x29, 0x2a, 0x2b,
310 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
314 static hda_nid_t stac92hd73xx_smux_nids[2] = {
318 #define STAC92HD83XXX_NUM_DMICS 2
319 static hda_nid_t stac92hd83xxx_dmic_nids[STAC92HD83XXX_NUM_DMICS + 1] = {
323 #define STAC92HD83_DAC_COUNT 3
325 static hda_nid_t stac92hd83xxx_dmux_nids[2] = {
329 static hda_nid_t stac92hd83xxx_adc_nids[2] = {
333 static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
337 static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
341 static unsigned int stac92hd83xxx_pwr_mapping[4] = {
342 0x03, 0x0c, 0x20, 0x40,
345 static hda_nid_t stac92hd83xxx_amp_nids[1] = {
349 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
353 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
357 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
361 static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
365 static hda_nid_t stac92hd71bxx_smux_nids[2] = {
369 #define STAC92HD71BXX_NUM_DMICS 2
370 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
374 static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
378 static hda_nid_t stac925x_adc_nids[1] = {
382 static hda_nid_t stac925x_mux_nids[1] = {
386 static hda_nid_t stac925x_dac_nids[1] = {
390 #define STAC925X_NUM_DMICS 1
391 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
395 static hda_nid_t stac925x_dmux_nids[1] = {
399 static hda_nid_t stac922x_adc_nids[2] = {
403 static hda_nid_t stac922x_mux_nids[2] = {
407 static hda_nid_t stac927x_adc_nids[3] = {
411 static hda_nid_t stac927x_mux_nids[3] = {
415 static hda_nid_t stac927x_smux_nids[1] = {
419 static hda_nid_t stac927x_dac_nids[6] = {
420 0x02, 0x03, 0x04, 0x05, 0x06, 0
423 static hda_nid_t stac927x_dmux_nids[1] = {
427 #define STAC927X_NUM_DMICS 2
428 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
432 static const char *stac927x_spdif_labels[5] = {
433 "Digital Playback", "ADAT", "Analog Mux 1",
434 "Analog Mux 2", "Analog Mux 3"
437 static hda_nid_t stac9205_adc_nids[2] = {
441 static hda_nid_t stac9205_mux_nids[2] = {
445 static hda_nid_t stac9205_dmux_nids[1] = {
449 static hda_nid_t stac9205_smux_nids[1] = {
453 #define STAC9205_NUM_DMICS 2
454 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
458 static hda_nid_t stac9200_pin_nids[8] = {
459 0x08, 0x09, 0x0d, 0x0e,
460 0x0f, 0x10, 0x11, 0x12,
463 static hda_nid_t stac925x_pin_nids[8] = {
464 0x07, 0x08, 0x0a, 0x0b,
465 0x0c, 0x0d, 0x10, 0x11,
468 static hda_nid_t stac922x_pin_nids[10] = {
469 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
470 0x0f, 0x10, 0x11, 0x15, 0x1b,
473 static hda_nid_t stac92hd73xx_pin_nids[13] = {
474 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
475 0x0f, 0x10, 0x11, 0x12, 0x13,
479 static hda_nid_t stac92hd83xxx_pin_nids[14] = {
480 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
481 0x0f, 0x10, 0x11, 0x12, 0x13,
482 0x1d, 0x1e, 0x1f, 0x20
484 static hda_nid_t stac92hd71bxx_pin_nids[11] = {
485 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
486 0x0f, 0x14, 0x18, 0x19, 0x1e,
490 static hda_nid_t stac927x_pin_nids[14] = {
491 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
492 0x0f, 0x10, 0x11, 0x12, 0x13,
493 0x14, 0x21, 0x22, 0x23,
496 static hda_nid_t stac9205_pin_nids[12] = {
497 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
498 0x0f, 0x14, 0x16, 0x17, 0x18,
502 #define stac92xx_amp_volume_info snd_hda_mixer_amp_volume_info
504 static int stac92xx_amp_volume_get(struct snd_kcontrol *kcontrol,
505 struct snd_ctl_elem_value *ucontrol)
507 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
508 struct sigmatel_spec *spec = codec->spec;
509 hda_nid_t nid = spec->amp_nids[spec->cur_amux];
511 kcontrol->private_value ^= get_amp_nid(kcontrol);
512 kcontrol->private_value |= nid;
514 return snd_hda_mixer_amp_volume_get(kcontrol, ucontrol);
517 static int stac92xx_amp_volume_put(struct snd_kcontrol *kcontrol,
518 struct snd_ctl_elem_value *ucontrol)
520 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
521 struct sigmatel_spec *spec = codec->spec;
522 hda_nid_t nid = spec->amp_nids[spec->cur_amux];
524 kcontrol->private_value ^= get_amp_nid(kcontrol);
525 kcontrol->private_value |= nid;
527 return snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
530 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
531 struct snd_ctl_elem_info *uinfo)
533 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
534 struct sigmatel_spec *spec = codec->spec;
535 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
538 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
539 struct snd_ctl_elem_value *ucontrol)
541 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
542 struct sigmatel_spec *spec = codec->spec;
543 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
545 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
549 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
550 struct snd_ctl_elem_value *ucontrol)
552 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
553 struct sigmatel_spec *spec = codec->spec;
554 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
556 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
557 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
560 static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
561 struct snd_ctl_elem_info *uinfo)
563 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
564 struct sigmatel_spec *spec = codec->spec;
565 return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
568 static int stac92xx_smux_enum_get(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 smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
575 ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
579 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
580 struct snd_ctl_elem_value *ucontrol)
582 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
583 struct sigmatel_spec *spec = codec->spec;
584 struct hda_input_mux *smux = &spec->private_smux;
585 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
589 err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
590 spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
594 if (spec->spdif_mute) {
596 nid = spec->multiout.dig_out_nid;
598 nid = codec->slave_dig_outs[smux_idx - 1];
599 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
603 /* un/mute SPDIF out */
604 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
610 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
612 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
613 struct sigmatel_spec *spec = codec->spec;
614 return snd_hda_input_mux_info(spec->input_mux, uinfo);
617 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
619 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
620 struct sigmatel_spec *spec = codec->spec;
621 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
623 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
627 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
629 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
630 struct sigmatel_spec *spec = codec->spec;
631 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
633 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
634 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
637 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
638 struct snd_ctl_elem_info *uinfo)
640 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
641 struct sigmatel_spec *spec = codec->spec;
642 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
645 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
646 struct snd_ctl_elem_value *ucontrol)
648 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
649 struct sigmatel_spec *spec = codec->spec;
651 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
655 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
656 struct snd_ctl_elem_value *ucontrol)
658 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
659 struct sigmatel_spec *spec = codec->spec;
661 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
662 spec->mono_nid, &spec->cur_mmux);
665 static int stac92xx_amp_mux_enum_info(struct snd_kcontrol *kcontrol,
666 struct snd_ctl_elem_info *uinfo)
668 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
669 struct sigmatel_spec *spec = codec->spec;
670 return snd_hda_input_mux_info(spec->amp_mux, uinfo);
673 static int stac92xx_amp_mux_enum_get(struct snd_kcontrol *kcontrol,
674 struct snd_ctl_elem_value *ucontrol)
676 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
677 struct sigmatel_spec *spec = codec->spec;
679 ucontrol->value.enumerated.item[0] = spec->cur_amux;
683 static int stac92xx_amp_mux_enum_put(struct snd_kcontrol *kcontrol,
684 struct snd_ctl_elem_value *ucontrol)
686 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
687 struct sigmatel_spec *spec = codec->spec;
688 struct snd_kcontrol *ctl =
689 snd_hda_find_mixer_ctl(codec, "Amp Capture Volume");
693 snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE |
694 SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
696 return snd_hda_input_mux_put(codec, spec->amp_mux, ucontrol,
700 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
702 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
703 struct snd_ctl_elem_value *ucontrol)
705 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
706 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
707 struct sigmatel_spec *spec = codec->spec;
709 ucontrol->value.integer.value[0] = !!(spec->aloopback &
710 (spec->aloopback_mask << idx));
714 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
715 struct snd_ctl_elem_value *ucontrol)
717 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
718 struct sigmatel_spec *spec = codec->spec;
719 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
720 unsigned int dac_mode;
721 unsigned int val, idx_val;
723 idx_val = spec->aloopback_mask << idx;
724 if (ucontrol->value.integer.value[0])
725 val = spec->aloopback | idx_val;
727 val = spec->aloopback & ~idx_val;
728 if (spec->aloopback == val)
731 spec->aloopback = val;
733 /* Only return the bits defined by the shift value of the
734 * first two bytes of the mask
736 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
737 kcontrol->private_value & 0xFFFF, 0x0);
738 dac_mode >>= spec->aloopback_shift;
740 if (spec->aloopback & idx_val) {
741 snd_hda_power_up(codec);
744 snd_hda_power_down(codec);
745 dac_mode &= ~idx_val;
748 snd_hda_codec_write_cache(codec, codec->afg, 0,
749 kcontrol->private_value >> 16, dac_mode);
754 static struct hda_verb stac9200_core_init[] = {
755 /* set dac0mux for dac converter */
756 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
760 static struct hda_verb stac9200_eapd_init[] = {
761 /* set dac0mux for dac converter */
762 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
763 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
767 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
768 /* set master volume and direct control */
769 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
770 /* setup adcs to point to mixer */
771 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
772 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
773 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
774 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
775 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
776 /* setup import muxs */
777 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
778 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
779 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
780 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
784 static struct hda_verb dell_eq_core_init[] = {
785 /* set master volume to max value without distortion
786 * and direct control */
787 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
788 /* setup adcs to point to mixer */
789 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
790 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
791 /* setup import muxs */
792 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
793 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
794 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
795 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
799 static struct hda_verb dell_m6_core_init[] = {
800 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
801 /* setup adcs to point to mixer */
802 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
803 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
804 /* setup import muxs */
805 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
806 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
807 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
808 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
812 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
813 /* set master volume and direct control */
814 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
815 /* setup adcs to point to mixer */
816 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
817 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
818 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
819 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
820 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
821 /* setup import muxs */
822 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
823 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
824 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
825 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
829 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
830 /* set master volume and direct control */
831 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
832 /* dac3 is connected to import3 mux */
833 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
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 stac92hd83xxx_core_init[] = {
849 { 0xa, AC_VERB_SET_CONNECT_SEL, 0x0},
850 { 0xb, AC_VERB_SET_CONNECT_SEL, 0x0},
851 { 0xd, AC_VERB_SET_CONNECT_SEL, 0x1},
853 /* power state controls amps */
854 { 0x01, AC_VERB_SET_EAPD, 1 << 2},
858 static struct hda_verb stac92hd71bxx_core_init[] = {
859 /* set master volume and direct control */
860 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
861 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
862 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
863 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
864 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
868 #define HD_DISABLE_PORTF 2
869 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
870 /* start of config #1 */
872 /* connect port 0f to audio mixer */
873 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
874 /* unmute right and left channels for node 0x0f */
875 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
876 /* start of config #2 */
878 /* set master volume and direct control */
879 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
880 /* unmute right and left channels for nodes 0x0a, 0xd */
881 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
882 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
886 static struct hda_verb stac925x_core_init[] = {
887 /* set dac0mux for dac converter */
888 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
889 /* mute the master volume */
890 { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
894 static struct hda_verb stac922x_core_init[] = {
895 /* set master volume and direct control */
896 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
900 static struct hda_verb d965_core_init[] = {
901 /* set master volume and direct control */
902 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
903 /* unmute node 0x1b */
904 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
905 /* select node 0x03 as DAC */
906 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
910 static struct hda_verb stac927x_core_init[] = {
911 /* set master volume and direct control */
912 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
913 /* enable analog pc beep path */
914 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
918 static struct hda_verb stac9205_core_init[] = {
919 /* set master volume and direct control */
920 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
921 /* enable analog pc beep path */
922 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
926 #define STAC_MONO_MUX \
928 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
929 .name = "Mono Mux", \
931 .info = stac92xx_mono_mux_enum_info, \
932 .get = stac92xx_mono_mux_enum_get, \
933 .put = stac92xx_mono_mux_enum_put, \
936 #define STAC_AMP_MUX \
938 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
939 .name = "Amp Selector Capture Switch", \
941 .info = stac92xx_amp_mux_enum_info, \
942 .get = stac92xx_amp_mux_enum_get, \
943 .put = stac92xx_amp_mux_enum_put, \
946 #define STAC_AMP_VOL(xname, nid, chs, idx, dir) \
948 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
951 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
952 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
953 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
954 .info = stac92xx_amp_volume_info, \
955 .get = stac92xx_amp_volume_get, \
956 .put = stac92xx_amp_volume_put, \
957 .tlv = { .c = snd_hda_mixer_amp_tlv }, \
958 .private_value = HDA_COMPOSE_AMP_VAL(nid, chs, idx, dir) \
961 #define STAC_INPUT_SOURCE(cnt) \
963 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
964 .name = "Input Source", \
966 .info = stac92xx_mux_enum_info, \
967 .get = stac92xx_mux_enum_get, \
968 .put = stac92xx_mux_enum_put, \
971 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
973 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
974 .name = "Analog Loopback", \
976 .info = stac92xx_aloopback_info, \
977 .get = stac92xx_aloopback_get, \
978 .put = stac92xx_aloopback_put, \
979 .private_value = verb_read | (verb_write << 16), \
982 static struct snd_kcontrol_new stac9200_mixer[] = {
983 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
984 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
985 STAC_INPUT_SOURCE(1),
986 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
987 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
991 #define DELL_M6_MIXER 6
992 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
993 /* start of config #1 */
994 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
995 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
997 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
998 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1000 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1001 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1003 /* start of config #2 */
1004 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1005 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1007 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1008 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1010 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
1012 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1013 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1015 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1016 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1021 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
1022 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1024 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1025 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1027 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1028 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1030 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1031 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1033 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1034 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1036 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1037 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1039 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1040 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1042 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1043 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1047 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
1048 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1050 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1051 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1053 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1054 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1056 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1057 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1059 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1060 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1062 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1063 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1065 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1066 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1068 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1069 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1074 static struct snd_kcontrol_new stac92hd83xxx_mixer[] = {
1075 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_OUTPUT),
1076 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_OUTPUT),
1078 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_OUTPUT),
1079 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_OUTPUT),
1081 HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x1b, 0x3, HDA_INPUT),
1082 HDA_CODEC_MUTE("DAC0 Capture Switch", 0x1b, 0x3, HDA_INPUT),
1084 HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x1b, 0x4, HDA_INPUT),
1085 HDA_CODEC_MUTE("DAC1 Capture Switch", 0x1b, 0x4, HDA_INPUT),
1087 HDA_CODEC_VOLUME("Front Mic Capture Volume", 0x1b, 0x0, HDA_INPUT),
1088 HDA_CODEC_MUTE("Front Mic Capture Switch", 0x1b, 0x0, HDA_INPUT),
1090 HDA_CODEC_VOLUME("Line In Capture Volume", 0x1b, 0x2, HDA_INPUT),
1091 HDA_CODEC_MUTE("Line In Capture Switch", 0x1b, 0x2, HDA_INPUT),
1094 HDA_CODEC_VOLUME("Mic Capture Volume", 0x1b, 0x1, HDA_INPUT),
1095 HDA_CODEC_MUTE("Mic Capture Switch", 0x1b 0x1, HDA_INPUT),
1100 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
1101 STAC_INPUT_SOURCE(2),
1102 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
1104 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1105 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1107 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1108 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1109 /* analog pc-beep replaced with digital beep support */
1111 HDA_CODEC_VOLUME("PC Beep Volume", 0x17, 0x2, HDA_INPUT),
1112 HDA_CODEC_MUTE("PC Beep Switch", 0x17, 0x2, HDA_INPUT),
1115 HDA_CODEC_MUTE("Import0 Mux Capture Switch", 0x17, 0x0, HDA_INPUT),
1116 HDA_CODEC_VOLUME("Import0 Mux Capture Volume", 0x17, 0x0, HDA_INPUT),
1118 HDA_CODEC_MUTE("Import1 Mux Capture Switch", 0x17, 0x1, HDA_INPUT),
1119 HDA_CODEC_VOLUME("Import1 Mux Capture Volume", 0x17, 0x1, HDA_INPUT),
1121 HDA_CODEC_MUTE("DAC0 Capture Switch", 0x17, 0x3, HDA_INPUT),
1122 HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x17, 0x3, HDA_INPUT),
1124 HDA_CODEC_MUTE("DAC1 Capture Switch", 0x17, 0x4, HDA_INPUT),
1125 HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x17, 0x4, HDA_INPUT),
1129 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
1130 STAC_INPUT_SOURCE(2),
1131 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
1133 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1134 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1136 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1137 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1141 static struct snd_kcontrol_new stac925x_mixer[] = {
1142 HDA_CODEC_VOLUME("Master Playback Volume", 0x0e, 0, HDA_OUTPUT),
1143 HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
1144 STAC_INPUT_SOURCE(1),
1145 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
1146 HDA_CODEC_MUTE("Capture Switch", 0x14, 0, HDA_OUTPUT),
1150 static struct snd_kcontrol_new stac9205_mixer[] = {
1151 STAC_INPUT_SOURCE(2),
1152 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1154 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
1155 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
1157 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
1158 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
1162 /* This needs to be generated dynamically based on sequence */
1163 static struct snd_kcontrol_new stac922x_mixer[] = {
1164 STAC_INPUT_SOURCE(2),
1165 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
1166 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
1168 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
1169 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
1174 static struct snd_kcontrol_new stac927x_mixer[] = {
1175 STAC_INPUT_SOURCE(3),
1176 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1178 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
1179 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
1181 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
1182 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
1184 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
1185 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
1189 static struct snd_kcontrol_new stac_dmux_mixer = {
1190 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1191 .name = "Digital Input Source",
1192 /* count set later */
1193 .info = stac92xx_dmux_enum_info,
1194 .get = stac92xx_dmux_enum_get,
1195 .put = stac92xx_dmux_enum_put,
1198 static struct snd_kcontrol_new stac_smux_mixer = {
1199 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1200 .name = "IEC958 Playback Source",
1201 /* count set later */
1202 .info = stac92xx_smux_enum_info,
1203 .get = stac92xx_smux_enum_get,
1204 .put = stac92xx_smux_enum_put,
1207 static const char *slave_vols[] = {
1208 "Front Playback Volume",
1209 "Surround Playback Volume",
1210 "Center Playback Volume",
1211 "LFE Playback Volume",
1212 "Side Playback Volume",
1213 "Headphone Playback Volume",
1214 "Headphone Playback Volume",
1215 "Speaker Playback Volume",
1216 "External Speaker Playback Volume",
1217 "Speaker2 Playback Volume",
1221 static const char *slave_sws[] = {
1222 "Front Playback Switch",
1223 "Surround Playback Switch",
1224 "Center Playback Switch",
1225 "LFE Playback Switch",
1226 "Side Playback Switch",
1227 "Headphone Playback Switch",
1228 "Headphone Playback Switch",
1229 "Speaker Playback Switch",
1230 "External Speaker Playback Switch",
1231 "Speaker2 Playback Switch",
1232 "IEC958 Playback Switch",
1236 static void stac92xx_free_kctls(struct hda_codec *codec);
1237 static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
1239 static int stac92xx_build_controls(struct hda_codec *codec)
1241 struct sigmatel_spec *spec = codec->spec;
1242 struct auto_pin_cfg *cfg = &spec->autocfg;
1247 err = snd_hda_add_new_ctls(codec, spec->mixer);
1251 for (i = 0; i < spec->num_mixers; i++) {
1252 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1256 if (spec->num_dmuxes > 0) {
1257 stac_dmux_mixer.count = spec->num_dmuxes;
1258 err = snd_hda_ctl_add(codec,
1259 snd_ctl_new1(&stac_dmux_mixer, codec));
1263 if (spec->num_smuxes > 0) {
1264 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1265 struct hda_input_mux *smux = &spec->private_smux;
1266 /* check for mute support on SPDIF out */
1267 if (wcaps & AC_WCAP_OUT_AMP) {
1268 smux->items[smux->num_items].label = "Off";
1269 smux->items[smux->num_items].index = 0;
1271 spec->spdif_mute = 1;
1273 stac_smux_mixer.count = spec->num_smuxes;
1274 err = snd_hda_ctl_add(codec,
1275 snd_ctl_new1(&stac_smux_mixer, codec));
1280 if (spec->multiout.dig_out_nid) {
1281 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1284 err = snd_hda_create_spdif_share_sw(codec,
1288 spec->multiout.share_spdif = 1;
1290 if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1291 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1296 /* if we have no master control, let's create it */
1297 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1298 unsigned int vmaster_tlv[4];
1299 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1300 HDA_OUTPUT, vmaster_tlv);
1301 /* correct volume offset */
1302 vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
1303 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1304 vmaster_tlv, slave_vols);
1308 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1309 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1315 stac92xx_free_kctls(codec); /* no longer needed */
1317 /* create jack input elements */
1318 if (spec->hp_detect) {
1319 for (i = 0; i < cfg->hp_outs; i++) {
1320 int type = SND_JACK_HEADPHONE;
1321 nid = cfg->hp_pins[i];
1322 /* jack detection */
1323 if (cfg->hp_outs == i)
1324 type |= SND_JACK_LINEOUT;
1325 err = stac92xx_add_jack(codec, nid, type);
1330 for (i = 0; i < cfg->line_outs; i++) {
1331 err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
1336 for (i = 0; i < AUTO_PIN_LAST; i++) {
1337 nid = cfg->input_pins[i];
1339 err = stac92xx_add_jack(codec, nid,
1340 SND_JACK_MICROPHONE);
1349 static unsigned int ref9200_pin_configs[8] = {
1350 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1351 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1354 static unsigned int gateway9200_m4_pin_configs[8] = {
1355 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1356 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1358 static unsigned int gateway9200_m4_2_pin_configs[8] = {
1359 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1360 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1364 STAC 9200 pin configs for
1369 static unsigned int dell9200_d21_pin_configs[8] = {
1370 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
1371 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1375 STAC 9200 pin configs for
1379 static unsigned int dell9200_d22_pin_configs[8] = {
1380 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1381 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1385 STAC 9200 pin configs for
1386 102801C4 (Dell Dimension E310)
1393 static unsigned int dell9200_d23_pin_configs[8] = {
1394 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1395 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
1400 STAC 9200-32 pin configs for
1401 102801B5 (Dell Inspiron 630m)
1402 102801D8 (Dell Inspiron 640m)
1404 static unsigned int dell9200_m21_pin_configs[8] = {
1405 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1406 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1410 STAC 9200-32 pin configs for
1411 102801C2 (Dell Latitude D620)
1413 102801CC (Dell Latitude D820)
1417 static unsigned int dell9200_m22_pin_configs[8] = {
1418 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1419 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1423 STAC 9200-32 pin configs for
1424 102801CE (Dell XPS M1710)
1425 102801CF (Dell Precision M90)
1427 static unsigned int dell9200_m23_pin_configs[8] = {
1428 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1429 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1433 STAC 9200-32 pin configs for
1436 102801CB (Dell Latitude 120L)
1439 static unsigned int dell9200_m24_pin_configs[8] = {
1440 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1441 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1445 STAC 9200-32 pin configs for
1446 102801BD (Dell Inspiron E1505n)
1450 static unsigned int dell9200_m25_pin_configs[8] = {
1451 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1452 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1456 STAC 9200-32 pin configs for
1457 102801F5 (Dell Inspiron 1501)
1460 static unsigned int dell9200_m26_pin_configs[8] = {
1461 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1462 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1467 102801CD (Dell Inspiron E1705/9400)
1469 static unsigned int dell9200_m27_pin_configs[8] = {
1470 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1471 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1474 static unsigned int oqo9200_pin_configs[8] = {
1475 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1476 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1480 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1481 [STAC_REF] = ref9200_pin_configs,
1482 [STAC_9200_OQO] = oqo9200_pin_configs,
1483 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1484 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1485 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1486 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1487 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1488 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1489 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1490 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1491 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1492 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1493 [STAC_9200_M4] = gateway9200_m4_pin_configs,
1494 [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1495 [STAC_9200_PANASONIC] = ref9200_pin_configs,
1498 static const char *stac9200_models[STAC_9200_MODELS] = {
1500 [STAC_9200_OQO] = "oqo",
1501 [STAC_9200_DELL_D21] = "dell-d21",
1502 [STAC_9200_DELL_D22] = "dell-d22",
1503 [STAC_9200_DELL_D23] = "dell-d23",
1504 [STAC_9200_DELL_M21] = "dell-m21",
1505 [STAC_9200_DELL_M22] = "dell-m22",
1506 [STAC_9200_DELL_M23] = "dell-m23",
1507 [STAC_9200_DELL_M24] = "dell-m24",
1508 [STAC_9200_DELL_M25] = "dell-m25",
1509 [STAC_9200_DELL_M26] = "dell-m26",
1510 [STAC_9200_DELL_M27] = "dell-m27",
1511 [STAC_9200_M4] = "gateway-m4",
1512 [STAC_9200_M4_2] = "gateway-m4-2",
1513 [STAC_9200_PANASONIC] = "panasonic",
1516 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1517 /* SigmaTel reference board */
1518 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1519 "DFI LanParty", STAC_REF),
1520 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1521 "DFI LanParty", STAC_REF),
1522 /* Dell laptops have BIOS problem */
1523 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1524 "unknown Dell", STAC_9200_DELL_D21),
1525 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1526 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1527 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1528 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1529 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1530 "unknown Dell", STAC_9200_DELL_D22),
1531 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1532 "unknown Dell", STAC_9200_DELL_D22),
1533 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1534 "Dell Latitude D620", STAC_9200_DELL_M22),
1535 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1536 "unknown Dell", STAC_9200_DELL_D23),
1537 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1538 "unknown Dell", STAC_9200_DELL_D23),
1539 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1540 "unknown Dell", STAC_9200_DELL_M22),
1541 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1542 "unknown Dell", STAC_9200_DELL_M24),
1543 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1544 "unknown Dell", STAC_9200_DELL_M24),
1545 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1546 "Dell Latitude 120L", STAC_9200_DELL_M24),
1547 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1548 "Dell Latitude D820", STAC_9200_DELL_M22),
1549 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1550 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1551 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1552 "Dell XPS M1710", STAC_9200_DELL_M23),
1553 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1554 "Dell Precision M90", STAC_9200_DELL_M23),
1555 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1556 "unknown Dell", STAC_9200_DELL_M22),
1557 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1558 "unknown Dell", STAC_9200_DELL_M22),
1559 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1560 "unknown Dell", STAC_9200_DELL_M22),
1561 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1562 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1563 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1564 "unknown Dell", STAC_9200_DELL_D23),
1565 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1566 "unknown Dell", STAC_9200_DELL_D23),
1567 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1568 "unknown Dell", STAC_9200_DELL_D21),
1569 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1570 "unknown Dell", STAC_9200_DELL_D23),
1571 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1572 "unknown Dell", STAC_9200_DELL_D21),
1573 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1574 "unknown Dell", STAC_9200_DELL_M25),
1575 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1576 "unknown Dell", STAC_9200_DELL_M25),
1577 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1578 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1579 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1580 "unknown Dell", STAC_9200_DELL_M26),
1582 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1583 /* Gateway machines needs EAPD to be set on resume */
1584 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1585 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1586 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1588 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1592 static unsigned int ref925x_pin_configs[8] = {
1593 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1594 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1597 static unsigned int stac925xM1_pin_configs[8] = {
1598 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1599 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1602 static unsigned int stac925xM1_2_pin_configs[8] = {
1603 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1604 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1607 static unsigned int stac925xM2_pin_configs[8] = {
1608 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1609 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1612 static unsigned int stac925xM2_2_pin_configs[8] = {
1613 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1614 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1617 static unsigned int stac925xM3_pin_configs[8] = {
1618 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1619 0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1622 static unsigned int stac925xM5_pin_configs[8] = {
1623 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1624 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1627 static unsigned int stac925xM6_pin_configs[8] = {
1628 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1629 0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1632 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1633 [STAC_REF] = ref925x_pin_configs,
1634 [STAC_M1] = stac925xM1_pin_configs,
1635 [STAC_M1_2] = stac925xM1_2_pin_configs,
1636 [STAC_M2] = stac925xM2_pin_configs,
1637 [STAC_M2_2] = stac925xM2_2_pin_configs,
1638 [STAC_M3] = stac925xM3_pin_configs,
1639 [STAC_M5] = stac925xM5_pin_configs,
1640 [STAC_M6] = stac925xM6_pin_configs,
1643 static const char *stac925x_models[STAC_925x_MODELS] = {
1646 [STAC_M1_2] = "m1-2",
1648 [STAC_M2_2] = "m2-2",
1654 static struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1655 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1656 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1657 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1658 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1659 SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1660 /* Not sure about the brand name for those */
1661 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1662 SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1663 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1664 SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1668 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1669 /* SigmaTel reference board */
1670 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1671 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
1672 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1674 /* Default table for unknown ID */
1675 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1680 static unsigned int ref92hd73xx_pin_configs[13] = {
1681 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1682 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1683 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1687 static unsigned int dell_m6_pin_configs[13] = {
1688 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1689 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1690 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1694 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1695 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1696 [STAC_DELL_M6_AMIC] = dell_m6_pin_configs,
1697 [STAC_DELL_M6_DMIC] = dell_m6_pin_configs,
1698 [STAC_DELL_M6_BOTH] = dell_m6_pin_configs,
1699 [STAC_DELL_EQ] = dell_m6_pin_configs,
1702 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1703 [STAC_92HD73XX_NO_JD] = "no-jd",
1704 [STAC_92HD73XX_REF] = "ref",
1705 [STAC_DELL_M6_AMIC] = "dell-m6-amic",
1706 [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1707 [STAC_DELL_M6_BOTH] = "dell-m6",
1708 [STAC_DELL_EQ] = "dell-eq",
1711 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1712 /* SigmaTel reference board */
1713 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1714 "DFI LanParty", STAC_92HD73XX_REF),
1715 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1716 "DFI LanParty", STAC_92HD73XX_REF),
1717 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1718 "Dell Studio 1535", STAC_DELL_M6_DMIC),
1719 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1720 "unknown Dell", STAC_DELL_M6_DMIC),
1721 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1722 "unknown Dell", STAC_DELL_M6_BOTH),
1723 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1724 "unknown Dell", STAC_DELL_M6_BOTH),
1725 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1726 "unknown Dell", STAC_DELL_M6_AMIC),
1727 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1728 "unknown Dell", STAC_DELL_M6_AMIC),
1729 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1730 "unknown Dell", STAC_DELL_M6_DMIC),
1731 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1732 "unknown Dell", STAC_DELL_M6_DMIC),
1733 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1734 "Dell Studio 1537", STAC_DELL_M6_DMIC),
1735 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1736 "Dell Studio 17", STAC_DELL_M6_DMIC),
1740 static unsigned int ref92hd83xxx_pin_configs[14] = {
1741 0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1742 0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1743 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x40f000f0,
1744 0x01451160, 0x98560170,
1747 static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1748 [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1749 [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
1752 static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1753 [STAC_92HD83XXX_REF] = "ref",
1754 [STAC_92HD83XXX_PWR_REF] = "mic-ref",
1757 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1758 /* SigmaTel reference board */
1759 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1760 "DFI LanParty", STAC_92HD83XXX_REF),
1761 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1762 "DFI LanParty", STAC_92HD83XXX_REF),
1766 static unsigned int ref92hd71bxx_pin_configs[11] = {
1767 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1768 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1769 0x90a000f0, 0x01452050, 0x01452050,
1772 static unsigned int dell_m4_1_pin_configs[11] = {
1773 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1774 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1775 0x40f000f0, 0x4f0000f0, 0x4f0000f0,
1778 static unsigned int dell_m4_2_pin_configs[11] = {
1779 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1780 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1781 0x40f000f0, 0x044413b0, 0x044413b0,
1784 static unsigned int dell_m4_3_pin_configs[11] = {
1785 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1786 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1787 0x40f000f0, 0x044413b0, 0x044413b0,
1790 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1791 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1792 [STAC_DELL_M4_1] = dell_m4_1_pin_configs,
1793 [STAC_DELL_M4_2] = dell_m4_2_pin_configs,
1794 [STAC_DELL_M4_3] = dell_m4_3_pin_configs,
1795 [STAC_HP_M4] = NULL,
1796 [STAC_HP_DV5] = NULL,
1799 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1800 [STAC_92HD71BXX_REF] = "ref",
1801 [STAC_DELL_M4_1] = "dell-m4-1",
1802 [STAC_DELL_M4_2] = "dell-m4-2",
1803 [STAC_DELL_M4_3] = "dell-m4-3",
1804 [STAC_HP_M4] = "hp-m4",
1805 [STAC_HP_DV5] = "hp-dv5",
1808 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1809 /* SigmaTel reference board */
1810 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1811 "DFI LanParty", STAC_92HD71BXX_REF),
1812 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1813 "DFI LanParty", STAC_92HD71BXX_REF),
1814 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f2,
1815 "HP dv5", STAC_HP_M4),
1816 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f4,
1817 "HP dv7", STAC_HP_M4),
1818 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f7,
1819 "HP dv4", STAC_HP_DV5),
1820 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fc,
1821 "HP dv7", STAC_HP_M4),
1822 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3603,
1823 "HP dv5", STAC_HP_DV5),
1824 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1825 "unknown HP", STAC_HP_M4),
1826 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1827 "unknown Dell", STAC_DELL_M4_1),
1828 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1829 "unknown Dell", STAC_DELL_M4_1),
1830 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1831 "unknown Dell", STAC_DELL_M4_1),
1832 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1833 "unknown Dell", STAC_DELL_M4_1),
1834 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1835 "unknown Dell", STAC_DELL_M4_1),
1836 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1837 "unknown Dell", STAC_DELL_M4_1),
1838 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1839 "unknown Dell", STAC_DELL_M4_1),
1840 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1841 "unknown Dell", STAC_DELL_M4_2),
1842 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1843 "unknown Dell", STAC_DELL_M4_2),
1844 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1845 "unknown Dell", STAC_DELL_M4_2),
1846 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1847 "unknown Dell", STAC_DELL_M4_2),
1848 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1849 "unknown Dell", STAC_DELL_M4_3),
1853 static unsigned int ref922x_pin_configs[10] = {
1854 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1855 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1856 0x40000100, 0x40000100,
1860 STAC 922X pin configs for
1867 static unsigned int dell_922x_d81_pin_configs[10] = {
1868 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1869 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1870 0x01813122, 0x400001f2,
1874 STAC 922X pin configs for
1878 static unsigned int dell_922x_d82_pin_configs[10] = {
1879 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1880 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1881 0x01813122, 0x400001f1,
1885 STAC 922X pin configs for
1888 static unsigned int dell_922x_m81_pin_configs[10] = {
1889 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1890 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1891 0x40C003f1, 0x405003f0,
1895 STAC 9221 A1 pin configs for
1896 102801D7 (Dell XPS M1210)
1898 static unsigned int dell_922x_m82_pin_configs[10] = {
1899 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1900 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1901 0x508003f3, 0x405003f4,
1904 static unsigned int d945gtp3_pin_configs[10] = {
1905 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1906 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1907 0x02a19120, 0x40000100,
1910 static unsigned int d945gtp5_pin_configs[10] = {
1911 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1912 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1913 0x02a19320, 0x40000100,
1916 static unsigned int intel_mac_v1_pin_configs[10] = {
1917 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1918 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1919 0x400000fc, 0x400000fb,
1922 static unsigned int intel_mac_v2_pin_configs[10] = {
1923 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1924 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1925 0x400000fc, 0x400000fb,
1928 static unsigned int intel_mac_v3_pin_configs[10] = {
1929 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1930 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1931 0x400000fc, 0x400000fb,
1934 static unsigned int intel_mac_v4_pin_configs[10] = {
1935 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1936 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1937 0x400000fc, 0x400000fb,
1940 static unsigned int intel_mac_v5_pin_configs[10] = {
1941 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1942 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1943 0x400000fc, 0x400000fb,
1946 static unsigned int ecs202_pin_configs[10] = {
1947 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1948 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1949 0x9037012e, 0x40e000f2,
1952 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1953 [STAC_D945_REF] = ref922x_pin_configs,
1954 [STAC_D945GTP3] = d945gtp3_pin_configs,
1955 [STAC_D945GTP5] = d945gtp5_pin_configs,
1956 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1957 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1958 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1959 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1960 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1961 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1962 /* for backward compatibility */
1963 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1964 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1965 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1966 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1967 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1968 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1969 [STAC_ECS_202] = ecs202_pin_configs,
1970 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1971 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1972 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1973 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1976 static const char *stac922x_models[STAC_922X_MODELS] = {
1977 [STAC_D945_REF] = "ref",
1978 [STAC_D945GTP5] = "5stack",
1979 [STAC_D945GTP3] = "3stack",
1980 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1981 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1982 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1983 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1984 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1985 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1986 /* for backward compatibility */
1987 [STAC_MACMINI] = "macmini",
1988 [STAC_MACBOOK] = "macbook",
1989 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1990 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1991 [STAC_IMAC_INTEL] = "imac-intel",
1992 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1993 [STAC_ECS_202] = "ecs202",
1994 [STAC_922X_DELL_D81] = "dell-d81",
1995 [STAC_922X_DELL_D82] = "dell-d82",
1996 [STAC_922X_DELL_M81] = "dell-m81",
1997 [STAC_922X_DELL_M82] = "dell-m82",
2000 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
2001 /* SigmaTel reference board */
2002 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2003 "DFI LanParty", STAC_D945_REF),
2004 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2005 "DFI LanParty", STAC_D945_REF),
2006 /* Intel 945G based systems */
2007 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
2008 "Intel D945G", STAC_D945GTP3),
2009 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
2010 "Intel D945G", STAC_D945GTP3),
2011 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
2012 "Intel D945G", STAC_D945GTP3),
2013 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
2014 "Intel D945G", STAC_D945GTP3),
2015 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
2016 "Intel D945G", STAC_D945GTP3),
2017 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
2018 "Intel D945G", STAC_D945GTP3),
2019 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
2020 "Intel D945G", STAC_D945GTP3),
2021 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
2022 "Intel D945G", STAC_D945GTP3),
2023 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
2024 "Intel D945G", STAC_D945GTP3),
2025 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
2026 "Intel D945G", STAC_D945GTP3),
2027 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
2028 "Intel D945G", STAC_D945GTP3),
2029 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
2030 "Intel D945G", STAC_D945GTP3),
2031 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
2032 "Intel D945G", STAC_D945GTP3),
2033 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
2034 "Intel D945G", STAC_D945GTP3),
2035 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
2036 "Intel D945G", STAC_D945GTP3),
2037 /* Intel D945G 5-stack systems */
2038 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
2039 "Intel D945G", STAC_D945GTP5),
2040 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
2041 "Intel D945G", STAC_D945GTP5),
2042 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
2043 "Intel D945G", STAC_D945GTP5),
2044 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
2045 "Intel D945G", STAC_D945GTP5),
2046 /* Intel 945P based systems */
2047 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
2048 "Intel D945P", STAC_D945GTP3),
2049 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
2050 "Intel D945P", STAC_D945GTP3),
2051 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
2052 "Intel D945P", STAC_D945GTP3),
2053 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
2054 "Intel D945P", STAC_D945GTP3),
2055 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
2056 "Intel D945P", STAC_D945GTP3),
2057 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
2058 "Intel D945P", STAC_D945GTP5),
2060 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
2061 SND_PCI_QUIRK(0x8384, 0x7680,
2062 "Mac", STAC_INTEL_MAC_AUTO),
2064 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
2065 "unknown Dell", STAC_922X_DELL_D81),
2066 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
2067 "unknown Dell", STAC_922X_DELL_D81),
2068 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
2069 "unknown Dell", STAC_922X_DELL_D81),
2070 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
2071 "unknown Dell", STAC_922X_DELL_D82),
2072 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
2073 "unknown Dell", STAC_922X_DELL_M81),
2074 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
2075 "unknown Dell", STAC_922X_DELL_D82),
2076 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
2077 "unknown Dell", STAC_922X_DELL_D81),
2078 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
2079 "unknown Dell", STAC_922X_DELL_D81),
2080 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
2081 "Dell XPS M1210", STAC_922X_DELL_M82),
2082 /* ECS/PC Chips boards */
2083 SND_PCI_QUIRK(0x1019, 0x2144,
2084 "ECS/PC chips", STAC_ECS_202),
2085 SND_PCI_QUIRK(0x1019, 0x2608,
2086 "ECS/PC chips", STAC_ECS_202),
2087 SND_PCI_QUIRK(0x1019, 0x2633,
2088 "ECS/PC chips P17G/1333", STAC_ECS_202),
2089 SND_PCI_QUIRK(0x1019, 0x2811,
2090 "ECS/PC chips", STAC_ECS_202),
2091 SND_PCI_QUIRK(0x1019, 0x2812,
2092 "ECS/PC chips", STAC_ECS_202),
2093 SND_PCI_QUIRK(0x1019, 0x2813,
2094 "ECS/PC chips", STAC_ECS_202),
2095 SND_PCI_QUIRK(0x1019, 0x2814,
2096 "ECS/PC chips", STAC_ECS_202),
2097 SND_PCI_QUIRK(0x1019, 0x2815,
2098 "ECS/PC chips", STAC_ECS_202),
2099 SND_PCI_QUIRK(0x1019, 0x2816,
2100 "ECS/PC chips", STAC_ECS_202),
2101 SND_PCI_QUIRK(0x1019, 0x2817,
2102 "ECS/PC chips", STAC_ECS_202),
2103 SND_PCI_QUIRK(0x1019, 0x2818,
2104 "ECS/PC chips", STAC_ECS_202),
2105 SND_PCI_QUIRK(0x1019, 0x2819,
2106 "ECS/PC chips", STAC_ECS_202),
2107 SND_PCI_QUIRK(0x1019, 0x2820,
2108 "ECS/PC chips", STAC_ECS_202),
2112 static unsigned int ref927x_pin_configs[14] = {
2113 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2114 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
2115 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2116 0x01c42190, 0x40000100,
2119 static unsigned int d965_3st_pin_configs[14] = {
2120 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2121 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2122 0x40000100, 0x40000100, 0x40000100, 0x40000100,
2123 0x40000100, 0x40000100
2126 static unsigned int d965_5st_pin_configs[14] = {
2127 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2128 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2129 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2130 0x40000100, 0x40000100
2133 static unsigned int dell_3st_pin_configs[14] = {
2134 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2135 0x01111212, 0x01116211, 0x01813050, 0x01112214,
2136 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2137 0x40c003fc, 0x40000100
2140 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2141 [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2142 [STAC_D965_REF] = ref927x_pin_configs,
2143 [STAC_D965_3ST] = d965_3st_pin_configs,
2144 [STAC_D965_5ST] = d965_5st_pin_configs,
2145 [STAC_DELL_3ST] = dell_3st_pin_configs,
2146 [STAC_DELL_BIOS] = NULL,
2149 static const char *stac927x_models[STAC_927X_MODELS] = {
2150 [STAC_D965_REF_NO_JD] = "ref-no-jd",
2151 [STAC_D965_REF] = "ref",
2152 [STAC_D965_3ST] = "3stack",
2153 [STAC_D965_5ST] = "5stack",
2154 [STAC_DELL_3ST] = "dell-3stack",
2155 [STAC_DELL_BIOS] = "dell-bios",
2158 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2159 /* SigmaTel reference board */
2160 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2161 "DFI LanParty", STAC_D965_REF),
2162 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2163 "DFI LanParty", STAC_D965_REF),
2164 /* Intel 946 based systems */
2165 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2166 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2167 /* 965 based 3 stack systems */
2168 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
2169 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
2170 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
2171 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
2172 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
2173 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
2174 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
2175 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
2176 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
2177 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
2178 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
2179 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
2180 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
2181 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
2182 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
2183 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
2184 /* Dell 3 stack systems */
2185 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
2186 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2187 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
2188 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
2189 /* Dell 3 stack systems with verb table in BIOS */
2190 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2191 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
2192 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
2193 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_3ST),
2194 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
2195 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
2196 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
2197 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2198 /* 965 based 5 stack systems */
2199 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
2200 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
2201 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
2202 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
2203 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
2204 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
2205 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
2206 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
2207 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
2211 static unsigned int ref9205_pin_configs[12] = {
2212 0x40000100, 0x40000100, 0x01016011, 0x01014010,
2213 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2214 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2218 STAC 9205 pin configs for
2225 10280228 (Dell Vostro 1500)
2227 static unsigned int dell_9205_m42_pin_configs[12] = {
2228 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2229 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2230 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2234 STAC 9205 pin configs for
2238 102801FF (Dell Precision M4300)
2243 static unsigned int dell_9205_m43_pin_configs[12] = {
2244 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2245 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2246 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2249 static unsigned int dell_9205_m44_pin_configs[12] = {
2250 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2251 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2252 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2255 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2256 [STAC_9205_REF] = ref9205_pin_configs,
2257 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2258 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2259 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2260 [STAC_9205_EAPD] = NULL,
2263 static const char *stac9205_models[STAC_9205_MODELS] = {
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 int stac92xx_save_bios_config_regs(struct hda_codec *codec)
2316 struct sigmatel_spec *spec = codec->spec;
2318 kfree(spec->pin_configs);
2319 spec->pin_configs = kcalloc(spec->num_pins, sizeof(*spec->pin_configs),
2321 if (!spec->pin_configs)
2324 for (i = 0; i < spec->num_pins; i++) {
2325 hda_nid_t nid = spec->pin_nids[i];
2326 unsigned int pin_cfg;
2328 pin_cfg = snd_hda_codec_read(codec, nid, 0,
2329 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
2330 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
2332 spec->pin_configs[i] = pin_cfg;
2338 static void stac92xx_set_config_reg(struct hda_codec *codec,
2339 hda_nid_t pin_nid, unsigned int pin_config)
2342 snd_hda_codec_write(codec, pin_nid, 0,
2343 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
2344 pin_config & 0x000000ff);
2345 snd_hda_codec_write(codec, pin_nid, 0,
2346 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
2347 (pin_config & 0x0000ff00) >> 8);
2348 snd_hda_codec_write(codec, pin_nid, 0,
2349 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
2350 (pin_config & 0x00ff0000) >> 16);
2351 snd_hda_codec_write(codec, pin_nid, 0,
2352 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
2354 i = snd_hda_codec_read(codec, pin_nid, 0,
2355 AC_VERB_GET_CONFIG_DEFAULT,
2357 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
2361 static void stac92xx_set_config_regs(struct hda_codec *codec)
2364 struct sigmatel_spec *spec = codec->spec;
2366 if (!spec->pin_configs)
2369 for (i = 0; i < spec->num_pins; i++)
2370 stac92xx_set_config_reg(codec, spec->pin_nids[i],
2371 spec->pin_configs[i]);
2374 static int stac_save_pin_cfgs(struct hda_codec *codec, unsigned int *pins)
2376 struct sigmatel_spec *spec = codec->spec;
2379 return stac92xx_save_bios_config_regs(codec);
2381 kfree(spec->pin_configs);
2382 spec->pin_configs = kmemdup(pins,
2383 spec->num_pins * sizeof(*pins),
2385 if (!spec->pin_configs)
2388 stac92xx_set_config_regs(codec);
2392 static void stac_change_pin_config(struct hda_codec *codec, hda_nid_t nid,
2395 struct sigmatel_spec *spec = codec->spec;
2398 for (i = 0; i < spec->num_pins; i++) {
2399 if (spec->pin_nids[i] == nid) {
2400 spec->pin_configs[i] = cfg;
2401 stac92xx_set_config_reg(codec, nid, cfg);
2408 * Analog playback callbacks
2410 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2411 struct hda_codec *codec,
2412 struct snd_pcm_substream *substream)
2414 struct sigmatel_spec *spec = codec->spec;
2415 if (spec->stream_delay)
2416 msleep(spec->stream_delay);
2417 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2421 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2422 struct hda_codec *codec,
2423 unsigned int stream_tag,
2424 unsigned int format,
2425 struct snd_pcm_substream *substream)
2427 struct sigmatel_spec *spec = codec->spec;
2428 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2431 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2432 struct hda_codec *codec,
2433 struct snd_pcm_substream *substream)
2435 struct sigmatel_spec *spec = codec->spec;
2436 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2440 * Digital playback callbacks
2442 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2443 struct hda_codec *codec,
2444 struct snd_pcm_substream *substream)
2446 struct sigmatel_spec *spec = codec->spec;
2447 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2450 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2451 struct hda_codec *codec,
2452 struct snd_pcm_substream *substream)
2454 struct sigmatel_spec *spec = codec->spec;
2455 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2458 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2459 struct hda_codec *codec,
2460 unsigned int stream_tag,
2461 unsigned int format,
2462 struct snd_pcm_substream *substream)
2464 struct sigmatel_spec *spec = codec->spec;
2465 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2466 stream_tag, format, substream);
2471 * Analog capture callbacks
2473 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2474 struct hda_codec *codec,
2475 unsigned int stream_tag,
2476 unsigned int format,
2477 struct snd_pcm_substream *substream)
2479 struct sigmatel_spec *spec = codec->spec;
2480 hda_nid_t nid = spec->adc_nids[substream->number];
2482 if (spec->powerdown_adcs) {
2484 snd_hda_codec_write(codec, nid, 0,
2485 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2487 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2491 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2492 struct hda_codec *codec,
2493 struct snd_pcm_substream *substream)
2495 struct sigmatel_spec *spec = codec->spec;
2496 hda_nid_t nid = spec->adc_nids[substream->number];
2498 snd_hda_codec_cleanup_stream(codec, nid);
2499 if (spec->powerdown_adcs)
2500 snd_hda_codec_write(codec, nid, 0,
2501 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2505 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2509 /* NID is set in stac92xx_build_pcms */
2511 .open = stac92xx_dig_playback_pcm_open,
2512 .close = stac92xx_dig_playback_pcm_close,
2513 .prepare = stac92xx_dig_playback_pcm_prepare
2517 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2521 /* NID is set in stac92xx_build_pcms */
2524 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2528 .nid = 0x02, /* NID to query formats and rates */
2530 .open = stac92xx_playback_pcm_open,
2531 .prepare = stac92xx_playback_pcm_prepare,
2532 .cleanup = stac92xx_playback_pcm_cleanup
2536 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2540 .nid = 0x06, /* NID to query formats and rates */
2542 .open = stac92xx_playback_pcm_open,
2543 .prepare = stac92xx_playback_pcm_prepare,
2544 .cleanup = stac92xx_playback_pcm_cleanup
2548 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2551 /* NID + .substreams is set in stac92xx_build_pcms */
2553 .prepare = stac92xx_capture_pcm_prepare,
2554 .cleanup = stac92xx_capture_pcm_cleanup
2558 static int stac92xx_build_pcms(struct hda_codec *codec)
2560 struct sigmatel_spec *spec = codec->spec;
2561 struct hda_pcm *info = spec->pcm_rec;
2563 codec->num_pcms = 1;
2564 codec->pcm_info = info;
2566 info->name = "STAC92xx Analog";
2567 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2568 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2569 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2570 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2572 if (spec->alt_switch) {
2575 info->name = "STAC92xx Analog Alt";
2576 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2579 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2582 info->name = "STAC92xx Digital";
2583 info->pcm_type = spec->autocfg.dig_out_type;
2584 if (spec->multiout.dig_out_nid) {
2585 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2586 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2588 if (spec->dig_in_nid) {
2589 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2590 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2597 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
2599 unsigned int pincap = snd_hda_param_read(codec, nid,
2601 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2602 if (pincap & AC_PINCAP_VREF_100)
2603 return AC_PINCTL_VREF_100;
2604 if (pincap & AC_PINCAP_VREF_80)
2605 return AC_PINCTL_VREF_80;
2606 if (pincap & AC_PINCAP_VREF_50)
2607 return AC_PINCTL_VREF_50;
2608 if (pincap & AC_PINCAP_VREF_GRD)
2609 return AC_PINCTL_VREF_GRD;
2613 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2616 snd_hda_codec_write_cache(codec, nid, 0,
2617 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2620 #define stac92xx_hp_switch_info snd_ctl_boolean_mono_info
2622 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2623 struct snd_ctl_elem_value *ucontrol)
2625 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2626 struct sigmatel_spec *spec = codec->spec;
2628 ucontrol->value.integer.value[0] = !!spec->hp_switch;
2632 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
2633 unsigned char type);
2635 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2636 struct snd_ctl_elem_value *ucontrol)
2638 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2639 struct sigmatel_spec *spec = codec->spec;
2640 int nid = kcontrol->private_value;
2642 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2644 /* check to be sure that the ports are upto date with
2647 stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
2652 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
2654 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2656 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2657 struct sigmatel_spec *spec = codec->spec;
2658 int io_idx = kcontrol-> private_value & 0xff;
2660 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
2664 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2666 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2667 struct sigmatel_spec *spec = codec->spec;
2668 hda_nid_t nid = kcontrol->private_value >> 8;
2669 int io_idx = kcontrol-> private_value & 0xff;
2670 unsigned short val = !!ucontrol->value.integer.value[0];
2672 spec->io_switch[io_idx] = val;
2675 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2677 unsigned int pinctl = AC_PINCTL_IN_EN;
2678 if (io_idx) /* set VREF for mic */
2679 pinctl |= stac92xx_get_vref(codec, nid);
2680 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2683 /* check the auto-mute again: we need to mute/unmute the speaker
2684 * appropriately according to the pin direction
2686 if (spec->hp_detect)
2687 stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
2692 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2694 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2695 struct snd_ctl_elem_value *ucontrol)
2697 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2698 struct sigmatel_spec *spec = codec->spec;
2700 ucontrol->value.integer.value[0] = spec->clfe_swap;
2704 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2705 struct snd_ctl_elem_value *ucontrol)
2707 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2708 struct sigmatel_spec *spec = codec->spec;
2709 hda_nid_t nid = kcontrol->private_value & 0xff;
2710 unsigned int val = !!ucontrol->value.integer.value[0];
2712 if (spec->clfe_swap == val)
2715 spec->clfe_swap = val;
2717 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2718 spec->clfe_swap ? 0x4 : 0x0);
2723 #define STAC_CODEC_HP_SWITCH(xname) \
2724 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2727 .info = stac92xx_hp_switch_info, \
2728 .get = stac92xx_hp_switch_get, \
2729 .put = stac92xx_hp_switch_put, \
2732 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2733 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2736 .info = stac92xx_io_switch_info, \
2737 .get = stac92xx_io_switch_get, \
2738 .put = stac92xx_io_switch_put, \
2739 .private_value = xpval, \
2742 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2743 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2746 .info = stac92xx_clfe_switch_info, \
2747 .get = stac92xx_clfe_switch_get, \
2748 .put = stac92xx_clfe_switch_put, \
2749 .private_value = xpval, \
2753 STAC_CTL_WIDGET_VOL,
2754 STAC_CTL_WIDGET_MUTE,
2755 STAC_CTL_WIDGET_MONO_MUX,
2756 STAC_CTL_WIDGET_AMP_MUX,
2757 STAC_CTL_WIDGET_AMP_VOL,
2758 STAC_CTL_WIDGET_HP_SWITCH,
2759 STAC_CTL_WIDGET_IO_SWITCH,
2760 STAC_CTL_WIDGET_CLFE_SWITCH
2763 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2764 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2765 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2768 STAC_AMP_VOL(NULL, 0, 0, 0, 0),
2769 STAC_CODEC_HP_SWITCH(NULL),
2770 STAC_CODEC_IO_SWITCH(NULL, 0),
2771 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2774 /* add dynamic controls */
2775 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2776 struct snd_kcontrol_new *ktemp,
2777 int idx, const char *name,
2780 struct snd_kcontrol_new *knew;
2782 snd_array_init(&spec->kctls, sizeof(*knew), 32);
2783 knew = snd_array_new(&spec->kctls);
2788 knew->name = kstrdup(name, GFP_KERNEL);
2791 knew->private_value = val;
2795 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2796 int type, int idx, const char *name,
2799 return stac92xx_add_control_temp(spec,
2800 &stac92xx_control_templates[type],
2805 /* add dynamic controls */
2806 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2807 const char *name, unsigned long val)
2809 return stac92xx_add_control_idx(spec, type, 0, name, val);
2812 /* check whether the line-input can be used as line-out */
2813 static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2815 struct sigmatel_spec *spec = codec->spec;
2816 struct auto_pin_cfg *cfg = &spec->autocfg;
2818 unsigned int pincap;
2820 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2822 nid = cfg->input_pins[AUTO_PIN_LINE];
2823 pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
2824 if (pincap & AC_PINCAP_OUT)
2829 /* check whether the mic-input can be used as line-out */
2830 static hda_nid_t check_mic_out_switch(struct hda_codec *codec)
2832 struct sigmatel_spec *spec = codec->spec;
2833 struct auto_pin_cfg *cfg = &spec->autocfg;
2834 unsigned int def_conf, pincap;
2835 unsigned int mic_pin;
2837 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2839 mic_pin = AUTO_PIN_MIC;
2841 hda_nid_t nid = cfg->input_pins[mic_pin];
2842 def_conf = snd_hda_codec_read(codec, nid, 0,
2843 AC_VERB_GET_CONFIG_DEFAULT, 0);
2844 /* some laptops have an internal analog microphone
2845 * which can't be used as a output */
2846 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2847 pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
2848 if (pincap & AC_PINCAP_OUT)
2851 if (mic_pin == AUTO_PIN_MIC)
2852 mic_pin = AUTO_PIN_FRONT_MIC;
2859 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2863 for (i = 0; i < spec->multiout.num_dacs; i++) {
2864 if (spec->multiout.dac_nids[i] == nid)
2871 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2874 if (is_in_dac_nids(spec, nid))
2876 for (i = 0; i < spec->autocfg.hp_outs; i++)
2877 if (spec->hp_dacs[i] == nid)
2879 for (i = 0; i < spec->autocfg.speaker_outs; i++)
2880 if (spec->speaker_dacs[i] == nid)
2885 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2887 struct sigmatel_spec *spec = codec->spec;
2889 hda_nid_t conn[HDA_MAX_CONNECTIONS];
2890 unsigned int wcaps, wtype;
2892 conn_len = snd_hda_get_connections(codec, nid, conn,
2893 HDA_MAX_CONNECTIONS);
2894 for (j = 0; j < conn_len; j++) {
2895 wcaps = snd_hda_param_read(codec, conn[j],
2896 AC_PAR_AUDIO_WIDGET_CAP);
2897 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2898 /* we check only analog outputs */
2899 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2901 /* if this route has a free DAC, assign it */
2902 if (!check_all_dac_nids(spec, conn[j])) {
2904 /* select this DAC in the pin's input mux */
2905 snd_hda_codec_write_cache(codec, nid, 0,
2906 AC_VERB_SET_CONNECT_SEL, j);
2914 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2915 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2918 * Fill in the dac_nids table from the parsed pin configuration
2919 * This function only works when every pin in line_out_pins[]
2920 * contains atleast one DAC in its connection list. Some 92xx
2921 * codecs are not connected directly to a DAC, such as the 9200
2922 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2924 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2926 struct sigmatel_spec *spec = codec->spec;
2927 struct auto_pin_cfg *cfg = &spec->autocfg;
2931 for (i = 0; i < cfg->line_outs; i++) {
2932 nid = cfg->line_out_pins[i];
2933 dac = get_unassigned_dac(codec, nid);
2935 if (spec->multiout.num_dacs > 0) {
2936 /* we have already working output pins,
2937 * so let's drop the broken ones again
2939 cfg->line_outs = spec->multiout.num_dacs;
2942 /* error out, no available DAC found */
2944 "%s: No available DAC for pin 0x%x\n",
2948 add_spec_dacs(spec, dac);
2951 /* add line-in as output */
2952 nid = check_line_out_switch(codec);
2954 dac = get_unassigned_dac(codec, nid);
2956 snd_printdd("STAC: Add line-in 0x%x as output %d\n",
2957 nid, cfg->line_outs);
2958 cfg->line_out_pins[cfg->line_outs] = nid;
2960 spec->line_switch = nid;
2961 add_spec_dacs(spec, dac);
2964 /* add mic as output */
2965 nid = check_mic_out_switch(codec);
2967 dac = get_unassigned_dac(codec, nid);
2969 snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
2970 nid, cfg->line_outs);
2971 cfg->line_out_pins[cfg->line_outs] = nid;
2973 spec->mic_switch = nid;
2974 add_spec_dacs(spec, dac);
2978 for (i = 0; i < cfg->hp_outs; i++) {
2979 nid = cfg->hp_pins[i];
2980 dac = get_unassigned_dac(codec, nid);
2982 if (!spec->multiout.hp_nid)
2983 spec->multiout.hp_nid = dac;
2985 add_spec_extra_dacs(spec, dac);
2987 spec->hp_dacs[i] = dac;
2990 for (i = 0; i < cfg->speaker_outs; i++) {
2991 nid = cfg->speaker_pins[i];
2992 dac = get_unassigned_dac(codec, nid);
2994 add_spec_extra_dacs(spec, dac);
2995 spec->speaker_dacs[i] = dac;
2998 snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2999 spec->multiout.num_dacs,
3000 spec->multiout.dac_nids[0],
3001 spec->multiout.dac_nids[1],
3002 spec->multiout.dac_nids[2],
3003 spec->multiout.dac_nids[3],
3004 spec->multiout.dac_nids[4]);
3009 /* create volume control/switch for the given prefx type */
3010 static int create_controls(struct hda_codec *codec, const char *pfx,
3011 hda_nid_t nid, int chs)
3013 struct sigmatel_spec *spec = codec->spec;
3017 if (!spec->check_volume_offset) {
3018 unsigned int caps, step, nums, db_scale;
3019 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3020 step = (caps & AC_AMPCAP_STEP_SIZE) >>
3021 AC_AMPCAP_STEP_SIZE_SHIFT;
3022 step = (step + 1) * 25; /* in .01dB unit */
3023 nums = (caps & AC_AMPCAP_NUM_STEPS) >>
3024 AC_AMPCAP_NUM_STEPS_SHIFT;
3025 db_scale = nums * step;
3026 /* if dB scale is over -64dB, and finer enough,
3027 * let's reduce it to half
3029 if (db_scale > 6400 && nums >= 0x1f)
3030 spec->volume_offset = nums / 2;
3031 spec->check_volume_offset = 1;
3034 sprintf(name, "%s Playback Volume", pfx);
3035 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
3036 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3037 spec->volume_offset));
3040 sprintf(name, "%s Playback Switch", pfx);
3041 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
3042 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3048 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3050 if (spec->multiout.num_dacs > 4) {
3051 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3054 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
3055 spec->multiout.num_dacs++;
3060 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3063 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3064 if (!spec->multiout.extra_out_nid[i]) {
3065 spec->multiout.extra_out_nid[i] = nid;
3069 printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3073 static int is_unique_dac(struct sigmatel_spec *spec, hda_nid_t nid)
3077 if (spec->autocfg.line_outs != 1)
3079 if (spec->multiout.hp_nid == nid)
3081 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++)
3082 if (spec->multiout.extra_out_nid[i] == nid)
3087 /* add playback controls from the parsed DAC table */
3088 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3089 const struct auto_pin_cfg *cfg)
3091 struct sigmatel_spec *spec = codec->spec;
3092 static const char *chname[4] = {
3093 "Front", "Surround", NULL /*CLFE*/, "Side"
3097 unsigned int wid_caps;
3099 for (i = 0; i < cfg->line_outs && spec->multiout.dac_nids[i]; i++) {
3100 nid = spec->multiout.dac_nids[i];
3103 err = create_controls(codec, "Center", nid, 1);
3106 err = create_controls(codec, "LFE", nid, 2);
3110 wid_caps = get_wcaps(codec, nid);
3112 if (wid_caps & AC_WCAP_LR_SWAP) {
3113 err = stac92xx_add_control(spec,
3114 STAC_CTL_WIDGET_CLFE_SWITCH,
3115 "Swap Center/LFE Playback Switch", nid);
3122 const char *name = chname[i];
3123 /* if it's a single DAC, assign a better name */
3124 if (!i && is_unique_dac(spec, nid)) {
3125 switch (cfg->line_out_type) {
3126 case AUTO_PIN_HP_OUT:
3129 case AUTO_PIN_SPEAKER_OUT:
3134 err = create_controls(codec, name, nid, 3);
3140 if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3141 err = stac92xx_add_control(spec,
3142 STAC_CTL_WIDGET_HP_SWITCH,
3143 "Headphone as Line Out Switch",
3144 cfg->hp_pins[cfg->hp_outs - 1]);
3149 if (spec->line_switch) {
3150 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
3151 "Line In as Output Switch",
3152 spec->line_switch << 8);
3157 if (spec->mic_switch) {
3158 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
3159 "Mic as Output Switch",
3160 (spec->mic_switch << 8) | 1);
3168 /* add playback controls for Speaker and HP outputs */
3169 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3170 struct auto_pin_cfg *cfg)
3172 struct sigmatel_spec *spec = codec->spec;
3177 for (i = 0; i < cfg->hp_outs; i++) {
3178 static const char *pfxs[] = {
3179 "Headphone", "Headphone2", "Headphone3",
3181 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
3182 if (wid_caps & AC_WCAP_UNSOL_CAP)
3183 spec->hp_detect = 1;
3184 if (nums >= ARRAY_SIZE(pfxs))
3186 nid = spec->hp_dacs[i];
3189 err = create_controls(codec, pfxs[nums++], nid, 3);
3194 for (i = 0; i < cfg->speaker_outs; i++) {
3195 static const char *pfxs[] = {
3196 "Speaker", "External Speaker", "Speaker2",
3198 if (nums >= ARRAY_SIZE(pfxs))
3200 nid = spec->speaker_dacs[i];
3203 err = create_controls(codec, pfxs[nums++], nid, 3);
3210 /* labels for mono mux outputs */
3211 static const char *stac92xx_mono_labels[4] = {
3212 "DAC0", "DAC1", "Mixer", "DAC2"
3215 /* create mono mux for mono out on capable codecs */
3216 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3218 struct sigmatel_spec *spec = codec->spec;
3219 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3221 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3223 num_cons = snd_hda_get_connections(codec,
3226 HDA_MAX_NUM_INPUTS);
3227 if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3230 for (i = 0; i < num_cons; i++) {
3231 mono_mux->items[mono_mux->num_items].label =
3232 stac92xx_mono_labels[i];
3233 mono_mux->items[mono_mux->num_items].index = i;
3234 mono_mux->num_items++;
3237 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3238 "Mono Mux", spec->mono_nid);
3241 /* labels for amp mux outputs */
3242 static const char *stac92xx_amp_labels[3] = {
3243 "Front Microphone", "Microphone", "Line In",
3246 /* create amp out controls mux on capable codecs */
3247 static int stac92xx_auto_create_amp_output_ctls(struct hda_codec *codec)
3249 struct sigmatel_spec *spec = codec->spec;
3250 struct hda_input_mux *amp_mux = &spec->private_amp_mux;
3253 for (i = 0; i < spec->num_amps; i++) {
3254 amp_mux->items[amp_mux->num_items].label =
3255 stac92xx_amp_labels[i];
3256 amp_mux->items[amp_mux->num_items].index = i;
3257 amp_mux->num_items++;
3260 if (spec->num_amps > 1) {
3261 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_MUX,
3262 "Amp Selector Capture Switch", 0);
3266 return stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_VOL,
3267 "Amp Capture Volume",
3268 HDA_COMPOSE_AMP_VAL(spec->amp_nids[0], 3, 0, HDA_INPUT));
3272 /* create PC beep volume controls */
3273 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3276 struct sigmatel_spec *spec = codec->spec;
3277 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3280 /* check for mute support for the the amp */
3281 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3282 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3283 "PC Beep Playback Switch",
3284 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3289 /* check to see if there is volume support for the amp */
3290 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3291 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3292 "PC Beep Playback Volume",
3293 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3300 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3301 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3303 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3304 struct snd_ctl_elem_value *ucontrol)
3306 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3307 ucontrol->value.integer.value[0] = codec->beep->enabled;
3311 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3312 struct snd_ctl_elem_value *ucontrol)
3314 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3315 int enabled = !!ucontrol->value.integer.value[0];
3316 if (codec->beep->enabled != enabled) {
3317 codec->beep->enabled = enabled;
3323 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3324 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3325 .info = stac92xx_dig_beep_switch_info,
3326 .get = stac92xx_dig_beep_switch_get,
3327 .put = stac92xx_dig_beep_switch_put,
3330 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3332 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3333 0, "PC Beep Playback Switch", 0);
3337 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3339 struct sigmatel_spec *spec = codec->spec;
3340 int wcaps, nid, i, err = 0;
3342 for (i = 0; i < spec->num_muxes; i++) {
3343 nid = spec->mux_nids[i];
3344 wcaps = get_wcaps(codec, nid);
3346 if (wcaps & AC_WCAP_OUT_AMP) {
3347 err = stac92xx_add_control_idx(spec,
3348 STAC_CTL_WIDGET_VOL, i, "Mux Capture Volume",
3349 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3357 static const char *stac92xx_spdif_labels[3] = {
3358 "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3361 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3363 struct sigmatel_spec *spec = codec->spec;
3364 struct hda_input_mux *spdif_mux = &spec->private_smux;
3365 const char **labels = spec->spdif_labels;
3367 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3369 num_cons = snd_hda_get_connections(codec,
3372 HDA_MAX_NUM_INPUTS);
3377 labels = stac92xx_spdif_labels;
3379 for (i = 0; i < num_cons; i++) {
3380 spdif_mux->items[spdif_mux->num_items].label = labels[i];
3381 spdif_mux->items[spdif_mux->num_items].index = i;
3382 spdif_mux->num_items++;
3388 /* labels for dmic mux inputs */
3389 static const char *stac92xx_dmic_labels[5] = {
3390 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3391 "Digital Mic 3", "Digital Mic 4"
3394 /* create playback/capture controls for input pins on dmic capable codecs */
3395 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3396 const struct auto_pin_cfg *cfg)
3398 struct sigmatel_spec *spec = codec->spec;
3399 struct hda_input_mux *dimux = &spec->private_dimux;
3400 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3404 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
3405 dimux->items[dimux->num_items].index = 0;
3408 for (i = 0; i < spec->num_dmics; i++) {
3413 unsigned int def_conf;
3415 def_conf = snd_hda_codec_read(codec,
3418 AC_VERB_GET_CONFIG_DEFAULT,
3420 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3423 nid = spec->dmic_nids[i];
3424 num_cons = snd_hda_get_connections(codec,
3427 HDA_MAX_NUM_INPUTS);
3428 for (j = 0; j < num_cons; j++)
3429 if (con_lst[j] == nid) {
3435 wcaps = get_wcaps(codec, nid) &
3436 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3439 sprintf(name, "%s Capture Volume",
3440 stac92xx_dmic_labels[dimux->num_items]);
3442 err = stac92xx_add_control(spec,
3443 STAC_CTL_WIDGET_VOL,
3445 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3446 (wcaps & AC_WCAP_OUT_AMP) ?
3447 HDA_OUTPUT : HDA_INPUT));
3452 dimux->items[dimux->num_items].label =
3453 stac92xx_dmic_labels[dimux->num_items];
3454 dimux->items[dimux->num_items].index = index;
3461 /* create playback/capture controls for input pins */
3462 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3464 struct sigmatel_spec *spec = codec->spec;
3465 struct hda_input_mux *imux = &spec->private_imux;
3466 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3469 for (i = 0; i < AUTO_PIN_LAST; i++) {
3472 if (!cfg->input_pins[i])
3475 for (j = 0; j < spec->num_muxes; j++) {
3477 num_cons = snd_hda_get_connections(codec,
3480 HDA_MAX_NUM_INPUTS);
3481 for (k = 0; k < num_cons; k++)
3482 if (con_lst[k] == cfg->input_pins[i]) {
3489 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3490 imux->items[imux->num_items].index = index;
3494 if (imux->num_items) {
3496 * Set the current input for the muxes.
3497 * The STAC9221 has two input muxes with identical source
3498 * NID lists. Hopefully this won't get confused.
3500 for (i = 0; i < spec->num_muxes; i++) {
3501 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3502 AC_VERB_SET_CONNECT_SEL,
3503 imux->items[0].index);
3510 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3512 struct sigmatel_spec *spec = codec->spec;
3515 for (i = 0; i < spec->autocfg.line_outs; i++) {
3516 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3517 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3521 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3523 struct sigmatel_spec *spec = codec->spec;
3526 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3528 pin = spec->autocfg.hp_pins[i];
3529 if (pin) /* connect to front */
3530 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3532 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3534 pin = spec->autocfg.speaker_pins[i];
3535 if (pin) /* connect to front */
3536 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3540 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3542 struct sigmatel_spec *spec = codec->spec;
3545 if ((err = snd_hda_parse_pin_def_config(codec,
3547 spec->dmic_nids)) < 0)
3549 if (! spec->autocfg.line_outs)
3550 return 0; /* can't find valid pin config */
3552 /* If we have no real line-out pin and multiple hp-outs, HPs should
3553 * be set up as multi-channel outputs.
3555 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
3556 spec->autocfg.hp_outs > 1) {
3557 /* Copy hp_outs to line_outs, backup line_outs in
3558 * speaker_outs so that the following routines can handle
3559 * HP pins as primary outputs.
3561 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3562 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3563 sizeof(spec->autocfg.line_out_pins));
3564 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3565 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3566 sizeof(spec->autocfg.hp_pins));
3567 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3568 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3569 spec->autocfg.hp_outs = 0;
3571 if (spec->autocfg.mono_out_pin) {
3572 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3573 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3574 u32 caps = query_amp_caps(codec,
3575 spec->autocfg.mono_out_pin, dir);
3576 hda_nid_t conn_list[1];
3578 /* get the mixer node and then the mono mux if it exists */
3579 if (snd_hda_get_connections(codec,
3580 spec->autocfg.mono_out_pin, conn_list, 1) &&
3581 snd_hda_get_connections(codec, conn_list[0],
3584 int wcaps = get_wcaps(codec, conn_list[0]);
3585 int wid_type = (wcaps & AC_WCAP_TYPE)
3586 >> AC_WCAP_TYPE_SHIFT;
3587 /* LR swap check, some stac925x have a mux that
3588 * changes the DACs output path instead of the
3591 if (wid_type == AC_WID_AUD_SEL &&
3592 !(wcaps & AC_WCAP_LR_SWAP))
3593 spec->mono_nid = conn_list[0];
3596 hda_nid_t nid = spec->autocfg.mono_out_pin;
3598 /* most mono outs have a least a mute/unmute switch */
3599 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3600 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3601 "Mono Playback Switch",
3602 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3605 /* check for volume support for the amp */
3606 if ((caps & AC_AMPCAP_NUM_STEPS)
3607 >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3608 err = stac92xx_add_control(spec,
3609 STAC_CTL_WIDGET_VOL,
3610 "Mono Playback Volume",
3611 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3617 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3621 if (!spec->multiout.num_dacs) {
3622 err = stac92xx_auto_fill_dac_nids(codec);
3625 err = stac92xx_auto_create_multi_out_ctls(codec,
3631 /* setup analog beep controls */
3632 if (spec->anabeep_nid > 0) {
3633 err = stac92xx_auto_create_beep_ctls(codec,
3639 /* setup digital beep controls and input device */
3640 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3641 if (spec->digbeep_nid > 0) {
3642 hda_nid_t nid = spec->digbeep_nid;
3645 err = stac92xx_auto_create_beep_ctls(codec, nid);
3648 err = snd_hda_attach_beep_device(codec, nid);
3651 /* if no beep switch is available, make its own one */
3652 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3654 !((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT)) {
3655 err = stac92xx_beep_switch_ctl(codec);
3662 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3667 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3672 if (spec->mono_nid > 0) {
3673 err = stac92xx_auto_create_mono_output_ctls(codec);
3677 if (spec->num_amps > 0) {
3678 err = stac92xx_auto_create_amp_output_ctls(codec);
3682 if (spec->num_dmics > 0 && !spec->dinput_mux)
3683 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3684 &spec->autocfg)) < 0)
3686 if (spec->num_muxes > 0) {
3687 err = stac92xx_auto_create_mux_input_ctls(codec);
3691 if (spec->num_smuxes > 0) {
3692 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3697 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3698 if (spec->multiout.max_channels > 2)
3699 spec->surr_switch = 1;
3701 if (spec->autocfg.dig_out_pin)
3702 spec->multiout.dig_out_nid = dig_out;
3703 if (dig_in && spec->autocfg.dig_in_pin)
3704 spec->dig_in_nid = dig_in;
3706 if (spec->kctls.list)
3707 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3709 spec->input_mux = &spec->private_imux;
3710 if (!spec->dinput_mux)
3711 spec->dinput_mux = &spec->private_dimux;
3712 spec->sinput_mux = &spec->private_smux;
3713 spec->mono_mux = &spec->private_mono_mux;
3714 spec->amp_mux = &spec->private_amp_mux;
3718 /* add playback controls for HP output */
3719 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3720 struct auto_pin_cfg *cfg)
3722 struct sigmatel_spec *spec = codec->spec;
3723 hda_nid_t pin = cfg->hp_pins[0];
3724 unsigned int wid_caps;
3729 wid_caps = get_wcaps(codec, pin);
3730 if (wid_caps & AC_WCAP_UNSOL_CAP)
3731 spec->hp_detect = 1;
3736 /* add playback controls for LFE output */
3737 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3738 struct auto_pin_cfg *cfg)
3740 struct sigmatel_spec *spec = codec->spec;
3742 hda_nid_t lfe_pin = 0x0;
3746 * search speaker outs and line outs for a mono speaker pin
3747 * with an amp. If one is found, add LFE controls
3750 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3751 hda_nid_t pin = spec->autocfg.speaker_pins[i];
3752 unsigned int wcaps = get_wcaps(codec, pin);
3753 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3754 if (wcaps == AC_WCAP_OUT_AMP)
3755 /* found a mono speaker with an amp, must be lfe */
3759 /* if speaker_outs is 0, then speakers may be in line_outs */
3760 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3761 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3762 hda_nid_t pin = spec->autocfg.line_out_pins[i];
3763 unsigned int defcfg;
3764 defcfg = snd_hda_codec_read(codec, pin, 0,
3765 AC_VERB_GET_CONFIG_DEFAULT,
3767 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3768 unsigned int wcaps = get_wcaps(codec, pin);
3769 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3770 if (wcaps == AC_WCAP_OUT_AMP)
3771 /* found a mono speaker with an amp,
3779 err = create_controls(codec, "LFE", lfe_pin, 1);
3787 static int stac9200_parse_auto_config(struct hda_codec *codec)
3789 struct sigmatel_spec *spec = codec->spec;
3792 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3795 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3798 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
3801 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
3804 if (spec->num_muxes > 0) {
3805 err = stac92xx_auto_create_mux_input_ctls(codec);
3810 if (spec->autocfg.dig_out_pin)
3811 spec->multiout.dig_out_nid = 0x05;
3812 if (spec->autocfg.dig_in_pin)
3813 spec->dig_in_nid = 0x04;
3815 if (spec->kctls.list)
3816 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3818 spec->input_mux = &spec->private_imux;
3819 spec->dinput_mux = &spec->private_dimux;
3825 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
3826 * funky external mute control using GPIO pins.
3829 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
3830 unsigned int dir_mask, unsigned int data)
3832 unsigned int gpiostate, gpiomask, gpiodir;
3834 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
3835 AC_VERB_GET_GPIO_DATA, 0);
3836 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
3838 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
3839 AC_VERB_GET_GPIO_MASK, 0);
3842 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
3843 AC_VERB_GET_GPIO_DIRECTION, 0);
3844 gpiodir |= dir_mask;
3846 /* Configure GPIOx as CMOS */
3847 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
3849 snd_hda_codec_write(codec, codec->afg, 0,
3850 AC_VERB_SET_GPIO_MASK, gpiomask);
3851 snd_hda_codec_read(codec, codec->afg, 0,
3852 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
3856 snd_hda_codec_read(codec, codec->afg, 0,
3857 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
3860 static int stac92xx_add_jack(struct hda_codec *codec,
3861 hda_nid_t nid, int type)
3863 #ifdef CONFIG_SND_JACK
3864 struct sigmatel_spec *spec = codec->spec;
3865 struct sigmatel_jack *jack;
3866 int def_conf = snd_hda_codec_read(codec, nid,
3867 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
3868 int connectivity = get_defcfg_connect(def_conf);
3871 if (connectivity && connectivity != AC_JACK_PORT_FIXED)
3874 snd_array_init(&spec->jacks, sizeof(*jack), 32);
3875 jack = snd_array_new(&spec->jacks);
3881 sprintf(name, "%s at %s %s Jack",
3882 snd_hda_get_jack_type(def_conf),
3883 snd_hda_get_jack_connectivity(def_conf),
3884 snd_hda_get_jack_location(def_conf));
3886 return snd_jack_new(codec->bus->card, name, type, &jack->jack);
3892 static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
3893 unsigned char type, int data)
3895 struct sigmatel_event *event;
3897 snd_array_init(&spec->events, sizeof(*event), 32);
3898 event = snd_array_new(&spec->events);
3903 event->tag = spec->events.used;
3909 static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
3910 hda_nid_t nid, unsigned char type)
3912 struct sigmatel_spec *spec = codec->spec;
3913 struct sigmatel_event *event = spec->events.list;
3916 for (i = 0; i < spec->events.used; i++, event++) {
3917 if (event->nid == nid && event->type == type)
3923 static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
3926 struct sigmatel_spec *spec = codec->spec;
3927 struct sigmatel_event *event = spec->events.list;
3930 for (i = 0; i < spec->events.used; i++, event++) {
3931 if (event->tag == tag)
3937 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
3940 struct sigmatel_event *event;
3943 if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
3945 event = stac_get_event(codec, nid, type);
3949 tag = stac_add_event(codec->spec, nid, type, 0);
3952 snd_hda_codec_write_cache(codec, nid, 0,
3953 AC_VERB_SET_UNSOLICITED_ENABLE,
3957 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
3960 for (i = 0; i < cfg->hp_outs; i++)
3961 if (cfg->hp_pins[i] == nid)
3962 return 1; /* nid is a HP-Out */
3964 return 0; /* nid is not a HP-Out */
3967 static void stac92xx_power_down(struct hda_codec *codec)
3969 struct sigmatel_spec *spec = codec->spec;
3971 /* power down inactive DACs */
3973 for (dac = spec->dac_list; *dac; dac++)
3974 if (!check_all_dac_nids(spec, *dac))
3975 snd_hda_codec_write(codec, *dac, 0,
3976 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3979 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
3982 static int stac92xx_init(struct hda_codec *codec)
3984 struct sigmatel_spec *spec = codec->spec;
3985 struct auto_pin_cfg *cfg = &spec->autocfg;
3989 snd_hda_sequence_write(codec, spec->init);
3991 /* power down adcs initially */
3992 if (spec->powerdown_adcs)
3993 for (i = 0; i < spec->num_adcs; i++)
3994 snd_hda_codec_write(codec,
3995 spec->adc_nids[i], 0,
3996 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3999 gpio = spec->gpio_data;
4000 /* turn on EAPD statically when spec->eapd_switch isn't set.
4001 * otherwise, unsol event will turn it on/off dynamically
4003 if (!spec->eapd_switch)
4004 gpio |= spec->eapd_mask;
4005 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
4008 if (spec->hp_detect) {
4009 /* Enable unsolicited responses on the HP widget */
4010 for (i = 0; i < cfg->hp_outs; i++) {
4011 hda_nid_t nid = cfg->hp_pins[i];
4012 enable_pin_detect(codec, nid, STAC_HP_EVENT);
4014 /* force to enable the first line-out; the others are set up
4017 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
4019 /* fake event to set up pins */
4020 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
4023 stac92xx_auto_init_multi_out(codec);
4024 stac92xx_auto_init_hp_out(codec);
4025 for (i = 0; i < cfg->hp_outs; i++)
4026 stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
4028 for (i = 0; i < AUTO_PIN_LAST; i++) {
4029 hda_nid_t nid = cfg->input_pins[i];
4031 unsigned int pinctl, conf;
4032 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
4033 /* for mic pins, force to initialize */
4034 pinctl = stac92xx_get_vref(codec, nid);
4035 pinctl |= AC_PINCTL_IN_EN;
4036 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4038 pinctl = snd_hda_codec_read(codec, nid, 0,
4039 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4040 /* if PINCTL already set then skip */
4041 if (!(pinctl & AC_PINCTL_IN_EN)) {
4042 pinctl |= AC_PINCTL_IN_EN;
4043 stac92xx_auto_set_pinctl(codec, nid,
4047 conf = snd_hda_codec_read(codec, nid, 0,
4048 AC_VERB_GET_CONFIG_DEFAULT, 0);
4049 if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
4050 enable_pin_detect(codec, nid,
4052 stac_issue_unsol_event(codec, nid,
4057 for (i = 0; i < spec->num_dmics; i++)
4058 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4060 if (cfg->dig_out_pin)
4061 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
4063 if (cfg->dig_in_pin)
4064 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4066 for (i = 0; i < spec->num_pwrs; i++) {
4067 hda_nid_t nid = spec->pwr_nids[i];
4068 int pinctl, def_conf;
4070 /* power on when no jack detection is available */
4071 if (!spec->hp_detect) {
4072 stac_toggle_power_map(codec, nid, 1);
4076 if (is_nid_hp_pin(cfg, nid))
4077 continue; /* already has an unsol event */
4079 pinctl = snd_hda_codec_read(codec, nid, 0,
4080 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4081 /* outputs are only ports capable of power management
4082 * any attempts on powering down a input port cause the
4083 * referenced VREF to act quirky.
4085 if (pinctl & AC_PINCTL_IN_EN) {
4086 stac_toggle_power_map(codec, nid, 1);
4089 def_conf = snd_hda_codec_read(codec, nid, 0,
4090 AC_VERB_GET_CONFIG_DEFAULT, 0);
4091 def_conf = get_defcfg_connect(def_conf);
4092 /* skip any ports that don't have jacks since presence
4093 * detection is useless */
4094 if (def_conf != AC_JACK_PORT_COMPLEX) {
4095 if (def_conf != AC_JACK_PORT_NONE)
4096 stac_toggle_power_map(codec, nid, 1);
4099 if (!stac_get_event(codec, nid, STAC_INSERT_EVENT)) {
4100 enable_pin_detect(codec, nid, STAC_PWR_EVENT);
4101 stac_issue_unsol_event(codec, nid, STAC_PWR_EVENT);
4105 stac92xx_power_down(codec);
4109 static void stac92xx_free_jacks(struct hda_codec *codec)
4111 #ifdef CONFIG_SND_JACK
4112 /* free jack instances manually when clearing/reconfiguring */
4113 struct sigmatel_spec *spec = codec->spec;
4114 if (!codec->bus->shutdown && spec->jacks.list) {
4115 struct sigmatel_jack *jacks = spec->jacks.list;
4117 for (i = 0; i < spec->jacks.used; i++)
4118 snd_device_free(codec->bus->card, &jacks[i].jack);
4120 snd_array_free(&spec->jacks);
4124 static void stac92xx_free_kctls(struct hda_codec *codec)
4126 struct sigmatel_spec *spec = codec->spec;
4128 if (spec->kctls.list) {
4129 struct snd_kcontrol_new *kctl = spec->kctls.list;
4131 for (i = 0; i < spec->kctls.used; i++)
4132 kfree(kctl[i].name);
4134 snd_array_free(&spec->kctls);
4137 static void stac92xx_free(struct hda_codec *codec)
4139 struct sigmatel_spec *spec = codec->spec;
4144 kfree(spec->pin_configs);
4145 stac92xx_free_jacks(codec);
4146 snd_array_free(&spec->events);
4149 snd_hda_detach_beep_device(codec);
4152 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4155 unsigned int old_ctl, pin_ctl;
4157 pin_ctl = snd_hda_codec_read(codec, nid,
4158 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4160 if (pin_ctl & AC_PINCTL_IN_EN) {
4162 * we need to check the current set-up direction of
4163 * shared input pins since they can be switched via
4164 * "xxx as Output" mixer switch
4166 struct sigmatel_spec *spec = codec->spec;
4167 if (nid == spec->line_switch || nid == spec->mic_switch)
4172 /* if setting pin direction bits, clear the current
4173 direction bits first */
4174 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4175 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4178 if (old_ctl != pin_ctl)
4179 snd_hda_codec_write_cache(codec, nid, 0,
4180 AC_VERB_SET_PIN_WIDGET_CONTROL,
4184 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4187 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4188 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4190 snd_hda_codec_write_cache(codec, nid, 0,
4191 AC_VERB_SET_PIN_WIDGET_CONTROL,
4195 static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4199 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
4205 /* return non-zero if the hp-pin of the given array index isn't
4206 * a jack-detection target
4208 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4210 struct auto_pin_cfg *cfg = &spec->autocfg;
4212 /* ignore sensing of shared line and mic jacks */
4213 if (cfg->hp_pins[i] == spec->line_switch)
4215 if (cfg->hp_pins[i] == spec->mic_switch)
4217 /* ignore if the pin is set as line-out */
4218 if (cfg->hp_pins[i] == spec->hp_switch)
4223 static void stac92xx_hp_detect(struct hda_codec *codec)
4225 struct sigmatel_spec *spec = codec->spec;
4226 struct auto_pin_cfg *cfg = &spec->autocfg;
4230 if (spec->gpio_mute)
4231 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4232 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4234 for (i = 0; i < cfg->hp_outs; i++) {
4237 if (no_hp_sensing(spec, i))
4239 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4241 unsigned int pinctl;
4242 pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4243 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4244 if (pinctl & AC_PINCTL_IN_EN)
4245 presence = 0; /* mic- or line-input */
4250 /* disable lineouts */
4251 if (spec->hp_switch)
4252 stac92xx_reset_pinctl(codec, spec->hp_switch,
4254 for (i = 0; i < cfg->line_outs; i++)
4255 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4257 for (i = 0; i < cfg->speaker_outs; i++)
4258 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4260 if (spec->eapd_mask && spec->eapd_switch)
4261 stac_gpio_set(codec, spec->gpio_mask,
4262 spec->gpio_dir, spec->gpio_data &
4265 /* enable lineouts */
4266 if (spec->hp_switch)
4267 stac92xx_set_pinctl(codec, spec->hp_switch,
4269 for (i = 0; i < cfg->line_outs; i++)
4270 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4272 for (i = 0; i < cfg->speaker_outs; i++)
4273 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4275 if (spec->eapd_mask && spec->eapd_switch)
4276 stac_gpio_set(codec, spec->gpio_mask,
4277 spec->gpio_dir, spec->gpio_data |
4280 /* toggle hp outs */
4281 for (i = 0; i < cfg->hp_outs; i++) {
4282 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4283 if (no_hp_sensing(spec, i))
4286 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4288 /* Resetting the pinctl like below may lead to (a sort of) regressions
4289 * on some devices since they use the HP pin actually for line/speaker
4290 * outs although the default pin config shows a different pin (that is
4291 * wrong and useless).
4293 * So, it's basically a problem of default pin configs, likely a BIOS issue.
4294 * But, disabling the code below just works around it, and I'm too tired of
4295 * bug reports with such devices...
4298 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4303 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4306 struct sigmatel_spec *spec = codec->spec;
4307 unsigned int idx, val;
4309 for (idx = 0; idx < spec->num_pwrs; idx++) {
4310 if (spec->pwr_nids[idx] == nid)
4313 if (idx >= spec->num_pwrs)
4316 /* several codecs have two power down bits */
4317 if (spec->pwr_mapping)
4318 idx = spec->pwr_mapping[idx];
4322 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
4328 /* power down unused output ports */
4329 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4332 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4334 stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4337 static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
4339 struct sigmatel_spec *spec = codec->spec;
4340 struct sigmatel_jack *jacks = spec->jacks.list;
4344 for (i = 0; i < spec->jacks.used; i++) {
4345 if (jacks->nid == nid) {
4346 unsigned int pin_ctl =
4347 snd_hda_codec_read(codec, nid,
4348 0, AC_VERB_GET_PIN_WIDGET_CONTROL,
4350 int type = jacks->type;
4351 if (type == (SND_JACK_LINEOUT
4352 | SND_JACK_HEADPHONE))
4353 type = (pin_ctl & AC_PINCTL_HP_EN)
4354 ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
4355 snd_jack_report(jacks->jack,
4356 get_pin_presence(codec, nid)
4364 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
4367 struct sigmatel_event *event = stac_get_event(codec, nid, type);
4370 codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
4373 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4375 struct sigmatel_spec *spec = codec->spec;
4376 struct sigmatel_event *event;
4379 tag = (res >> 26) & 0x7f;
4380 event = stac_get_event_from_tag(codec, tag);
4384 switch (event->type) {
4386 stac92xx_hp_detect(codec);
4388 case STAC_INSERT_EVENT:
4389 case STAC_PWR_EVENT:
4390 if (spec->num_pwrs > 0)
4391 stac92xx_pin_sense(codec, event->nid);
4392 stac92xx_report_jack(codec, event->nid);
4394 case STAC_VREF_EVENT:
4395 data = snd_hda_codec_read(codec, codec->afg, 0,
4396 AC_VERB_GET_GPIO_DATA, 0);
4397 /* toggle VREF state based on GPIOx status */
4398 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4399 !!(data & (1 << event->data)));
4404 #ifdef CONFIG_PROC_FS
4405 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4406 struct hda_codec *codec, hda_nid_t nid)
4408 if (nid == codec->afg)
4409 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4410 snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
4413 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4414 struct hda_codec *codec,
4417 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4418 snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
4421 /* stac92hd71bxx, stac92hd73xx */
4422 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4423 struct hda_codec *codec, hda_nid_t nid)
4425 stac92hd_proc_hook(buffer, codec, nid);
4426 if (nid == codec->afg)
4427 analog_loop_proc_hook(buffer, codec, 0xfa0);
4430 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4431 struct hda_codec *codec, hda_nid_t nid)
4433 if (nid == codec->afg)
4434 analog_loop_proc_hook(buffer, codec, 0xfe0);
4437 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4438 struct hda_codec *codec, hda_nid_t nid)
4440 if (nid == codec->afg)
4441 analog_loop_proc_hook(buffer, codec, 0xfeb);
4444 #define stac92hd_proc_hook NULL
4445 #define stac92hd7x_proc_hook NULL
4446 #define stac9205_proc_hook NULL
4447 #define stac927x_proc_hook NULL
4450 #ifdef SND_HDA_NEEDS_RESUME
4451 static int stac92xx_resume(struct hda_codec *codec)
4453 struct sigmatel_spec *spec = codec->spec;
4455 stac92xx_set_config_regs(codec);
4456 stac92xx_init(codec);
4457 snd_hda_codec_resume_amp(codec);
4458 snd_hda_codec_resume_cache(codec);
4459 /* fake event to set up pins again to override cached values */
4460 if (spec->hp_detect)
4461 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
4466 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
4468 struct sigmatel_spec *spec = codec->spec;
4469 if (spec->eapd_mask)
4470 stac_gpio_set(codec, spec->gpio_mask,
4471 spec->gpio_dir, spec->gpio_data &
4477 static struct hda_codec_ops stac92xx_patch_ops = {
4478 .build_controls = stac92xx_build_controls,
4479 .build_pcms = stac92xx_build_pcms,
4480 .init = stac92xx_init,
4481 .free = stac92xx_free,
4482 .unsol_event = stac92xx_unsol_event,
4483 #ifdef SND_HDA_NEEDS_RESUME
4484 .suspend = stac92xx_suspend,
4485 .resume = stac92xx_resume,
4489 static int patch_stac9200(struct hda_codec *codec)
4491 struct sigmatel_spec *spec;
4494 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4499 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
4500 spec->pin_nids = stac9200_pin_nids;
4501 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
4504 if (spec->board_config < 0) {
4505 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
4506 err = stac92xx_save_bios_config_regs(codec);
4508 err = stac_save_pin_cfgs(codec,
4509 stac9200_brd_tbl[spec->board_config]);
4511 stac92xx_free(codec);
4515 spec->multiout.max_channels = 2;
4516 spec->multiout.num_dacs = 1;
4517 spec->multiout.dac_nids = stac9200_dac_nids;
4518 spec->adc_nids = stac9200_adc_nids;
4519 spec->mux_nids = stac9200_mux_nids;
4520 spec->num_muxes = 1;
4521 spec->num_dmics = 0;
4525 if (spec->board_config == STAC_9200_M4 ||
4526 spec->board_config == STAC_9200_M4_2 ||
4527 spec->board_config == STAC_9200_OQO)
4528 spec->init = stac9200_eapd_init;
4530 spec->init = stac9200_core_init;
4531 spec->mixer = stac9200_mixer;
4533 if (spec->board_config == STAC_9200_PANASONIC) {
4534 spec->gpio_mask = spec->gpio_dir = 0x09;
4535 spec->gpio_data = 0x00;
4538 err = stac9200_parse_auto_config(codec);
4540 stac92xx_free(codec);
4544 /* CF-74 has no headphone detection, and the driver should *NOT*
4545 * do detection and HP/speaker toggle because the hardware does it.
4547 if (spec->board_config == STAC_9200_PANASONIC)
4548 spec->hp_detect = 0;
4550 codec->patch_ops = stac92xx_patch_ops;
4555 static int patch_stac925x(struct hda_codec *codec)
4557 struct sigmatel_spec *spec;
4560 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4565 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
4566 spec->pin_nids = stac925x_pin_nids;
4568 /* Check first for codec ID */
4569 spec->board_config = snd_hda_check_board_codec_sid_config(codec,
4572 stac925x_codec_id_cfg_tbl);
4574 /* Now checks for PCI ID, if codec ID is not found */
4575 if (spec->board_config < 0)
4576 spec->board_config = snd_hda_check_board_config(codec,
4581 if (spec->board_config < 0) {
4582 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
4583 "using BIOS defaults\n");
4584 err = stac92xx_save_bios_config_regs(codec);
4586 err = stac_save_pin_cfgs(codec,
4587 stac925x_brd_tbl[spec->board_config]);
4589 stac92xx_free(codec);
4593 spec->multiout.max_channels = 2;
4594 spec->multiout.num_dacs = 1;
4595 spec->multiout.dac_nids = stac925x_dac_nids;
4596 spec->adc_nids = stac925x_adc_nids;
4597 spec->mux_nids = stac925x_mux_nids;
4598 spec->num_muxes = 1;
4601 switch (codec->vendor_id) {
4602 case 0x83847632: /* STAC9202 */
4603 case 0x83847633: /* STAC9202D */
4604 case 0x83847636: /* STAC9251 */
4605 case 0x83847637: /* STAC9251D */
4606 spec->num_dmics = STAC925X_NUM_DMICS;
4607 spec->dmic_nids = stac925x_dmic_nids;
4608 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
4609 spec->dmux_nids = stac925x_dmux_nids;
4612 spec->num_dmics = 0;
4616 spec->init = stac925x_core_init;
4617 spec->mixer = stac925x_mixer;
4619 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
4621 if (spec->board_config < 0) {
4622 printk(KERN_WARNING "hda_codec: No auto-config is "
4623 "available, default to model=ref\n");
4624 spec->board_config = STAC_925x_REF;
4630 stac92xx_free(codec);
4634 codec->patch_ops = stac92xx_patch_ops;
4639 static struct hda_input_mux stac92hd73xx_dmux = {
4642 { "Analog Inputs", 0x0b },
4643 { "Digital Mic 1", 0x09 },
4644 { "Digital Mic 2", 0x0a },
4649 static int patch_stac92hd73xx(struct hda_codec *codec)
4651 struct sigmatel_spec *spec;
4652 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
4656 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4661 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
4662 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
4663 spec->pin_nids = stac92hd73xx_pin_nids;
4664 spec->board_config = snd_hda_check_board_config(codec,
4665 STAC_92HD73XX_MODELS,
4666 stac92hd73xx_models,
4667 stac92hd73xx_cfg_tbl);
4669 if (spec->board_config < 0) {
4670 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4671 " STAC92HD73XX, using BIOS defaults\n");
4672 err = stac92xx_save_bios_config_regs(codec);
4674 err = stac_save_pin_cfgs(codec,
4675 stac92hd73xx_brd_tbl[spec->board_config]);
4677 stac92xx_free(codec);
4681 num_dacs = snd_hda_get_connections(codec, 0x0a,
4682 conn, STAC92HD73_DAC_COUNT + 2) - 1;
4684 if (num_dacs < 3 || num_dacs > 5) {
4685 printk(KERN_WARNING "hda_codec: Could not determine "
4686 "number of channels defaulting to DAC count\n");
4687 num_dacs = STAC92HD73_DAC_COUNT;
4690 case 0x3: /* 6 Channel */
4691 spec->mixer = stac92hd73xx_6ch_mixer;
4692 spec->init = stac92hd73xx_6ch_core_init;
4694 case 0x4: /* 8 Channel */
4695 spec->mixer = stac92hd73xx_8ch_mixer;
4696 spec->init = stac92hd73xx_8ch_core_init;
4698 case 0x5: /* 10 Channel */
4699 spec->mixer = stac92hd73xx_10ch_mixer;
4700 spec->init = stac92hd73xx_10ch_core_init;
4702 spec->multiout.dac_nids = spec->dac_nids;
4704 spec->aloopback_mask = 0x01;
4705 spec->aloopback_shift = 8;
4707 spec->digbeep_nid = 0x1c;
4708 spec->mux_nids = stac92hd73xx_mux_nids;
4709 spec->adc_nids = stac92hd73xx_adc_nids;
4710 spec->dmic_nids = stac92hd73xx_dmic_nids;
4711 spec->dmux_nids = stac92hd73xx_dmux_nids;
4712 spec->smux_nids = stac92hd73xx_smux_nids;
4713 spec->amp_nids = stac92hd73xx_amp_nids;
4714 spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
4716 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
4717 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
4718 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
4719 memcpy(&spec->private_dimux, &stac92hd73xx_dmux,
4720 sizeof(stac92hd73xx_dmux));
4722 switch (spec->board_config) {
4724 spec->init = dell_eq_core_init;
4726 case STAC_DELL_M6_AMIC:
4727 case STAC_DELL_M6_DMIC:
4728 case STAC_DELL_M6_BOTH:
4729 spec->num_smuxes = 0;
4730 spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
4731 spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
4732 spec->eapd_switch = 0;
4735 if (spec->board_config != STAC_DELL_EQ)
4736 spec->init = dell_m6_core_init;
4737 switch (spec->board_config) {
4738 case STAC_DELL_M6_AMIC: /* Analog Mics */
4739 stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
4740 spec->num_dmics = 0;
4741 spec->private_dimux.num_items = 1;
4743 case STAC_DELL_M6_DMIC: /* Digital Mics */
4744 stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
4745 spec->num_dmics = 1;
4746 spec->private_dimux.num_items = 2;
4748 case STAC_DELL_M6_BOTH: /* Both */
4749 stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
4750 stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
4751 spec->num_dmics = 1;
4752 spec->private_dimux.num_items = 2;
4757 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
4758 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
4759 spec->eapd_switch = 1;
4761 if (spec->board_config > STAC_92HD73XX_REF) {
4762 /* GPIO0 High = Enable EAPD */
4763 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4764 spec->gpio_data = 0x01;
4766 spec->dinput_mux = &spec->private_dimux;
4768 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
4769 spec->pwr_nids = stac92hd73xx_pwr_nids;
4771 err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
4774 if (spec->board_config < 0) {
4775 printk(KERN_WARNING "hda_codec: No auto-config is "
4776 "available, default to model=ref\n");
4777 spec->board_config = STAC_92HD73XX_REF;
4784 stac92xx_free(codec);
4788 if (spec->board_config == STAC_92HD73XX_NO_JD)
4789 spec->hp_detect = 0;
4791 codec->patch_ops = stac92xx_patch_ops;
4793 codec->proc_widget_hook = stac92hd7x_proc_hook;
4798 static struct hda_input_mux stac92hd83xxx_dmux = {
4801 { "Analog Inputs", 0x03 },
4802 { "Digital Mic 1", 0x04 },
4803 { "Digital Mic 2", 0x05 },
4807 static int patch_stac92hd83xxx(struct hda_codec *codec)
4809 struct sigmatel_spec *spec;
4810 hda_nid_t conn[STAC92HD83_DAC_COUNT + 1];
4814 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4819 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
4820 spec->mono_nid = 0x19;
4821 spec->digbeep_nid = 0x21;
4822 spec->dmic_nids = stac92hd83xxx_dmic_nids;
4823 spec->dmux_nids = stac92hd83xxx_dmux_nids;
4824 spec->adc_nids = stac92hd83xxx_adc_nids;
4825 spec->pwr_nids = stac92hd83xxx_pwr_nids;
4826 spec->amp_nids = stac92hd83xxx_amp_nids;
4827 spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
4828 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
4829 spec->multiout.dac_nids = spec->dac_nids;
4832 /* set port 0xe to select the last DAC
4834 num_dacs = snd_hda_get_connections(codec, 0x0e,
4835 conn, STAC92HD83_DAC_COUNT + 1) - 1;
4837 snd_hda_codec_write_cache(codec, 0xe, 0,
4838 AC_VERB_SET_CONNECT_SEL, num_dacs);
4840 spec->init = stac92hd83xxx_core_init;
4841 spec->mixer = stac92hd83xxx_mixer;
4842 spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
4843 spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
4844 spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
4845 spec->num_amps = ARRAY_SIZE(stac92hd83xxx_amp_nids);
4846 spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
4847 spec->dinput_mux = &stac92hd83xxx_dmux;
4848 spec->pin_nids = stac92hd83xxx_pin_nids;
4849 spec->board_config = snd_hda_check_board_config(codec,
4850 STAC_92HD83XXX_MODELS,
4851 stac92hd83xxx_models,
4852 stac92hd83xxx_cfg_tbl);
4854 if (spec->board_config < 0) {
4855 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4856 " STAC92HD83XXX, using BIOS defaults\n");
4857 err = stac92xx_save_bios_config_regs(codec);
4859 err = stac_save_pin_cfgs(codec,
4860 stac92hd83xxx_brd_tbl[spec->board_config]);
4862 stac92xx_free(codec);
4866 switch (codec->vendor_id) {
4869 if (spec->board_config == STAC_92HD83XXX_PWR_REF)
4875 err = stac92xx_parse_auto_config(codec, 0x1d, 0);
4877 if (spec->board_config < 0) {
4878 printk(KERN_WARNING "hda_codec: No auto-config is "
4879 "available, default to model=ref\n");
4880 spec->board_config = STAC_92HD83XXX_REF;
4887 stac92xx_free(codec);
4891 codec->patch_ops = stac92xx_patch_ops;
4893 codec->proc_widget_hook = stac92hd_proc_hook;
4898 static struct hda_input_mux stac92hd71bxx_dmux = {
4901 { "Analog Inputs", 0x00 },
4903 { "Digital Mic 1", 0x02 },
4904 { "Digital Mic 2", 0x03 },
4908 static int patch_stac92hd71bxx(struct hda_codec *codec)
4910 struct sigmatel_spec *spec;
4913 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4918 codec->patch_ops = stac92xx_patch_ops;
4919 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
4920 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
4921 spec->pin_nids = stac92hd71bxx_pin_nids;
4922 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux,
4923 sizeof(stac92hd71bxx_dmux));
4924 spec->board_config = snd_hda_check_board_config(codec,
4925 STAC_92HD71BXX_MODELS,
4926 stac92hd71bxx_models,
4927 stac92hd71bxx_cfg_tbl);
4929 if (spec->board_config < 0) {
4930 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4931 " STAC92HD71BXX, using BIOS defaults\n");
4932 err = stac92xx_save_bios_config_regs(codec);
4934 err = stac_save_pin_cfgs(codec,
4935 stac92hd71bxx_brd_tbl[spec->board_config]);
4937 stac92xx_free(codec);
4941 if (spec->board_config > STAC_92HD71BXX_REF) {
4943 spec->gpio_mask = 0x01;
4944 spec->gpio_dir = 0x01;
4945 spec->gpio_data = 0x01;
4948 switch (codec->vendor_id) {
4949 case 0x111d76b6: /* 4 Port without Analog Mixer */
4951 case 0x111d76b4: /* 6 Port without Analog Mixer */
4953 spec->mixer = stac92hd71bxx_mixer;
4954 spec->init = stac92hd71bxx_core_init;
4955 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4957 case 0x111d7608: /* 5 Port with Analog Mixer */
4958 switch (spec->board_config) {
4960 /* Enable VREF power saving on GPIO1 detect */
4961 err = stac_add_event(spec, codec->afg,
4962 STAC_VREF_EVENT, 0x02);
4965 snd_hda_codec_write_cache(codec, codec->afg, 0,
4966 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
4967 snd_hda_codec_write_cache(codec, codec->afg, 0,
4968 AC_VERB_SET_UNSOLICITED_ENABLE,
4970 spec->gpio_mask |= 0x02;
4973 if ((codec->revision_id & 0xf) == 0 ||
4974 (codec->revision_id & 0xf) == 1)
4975 spec->stream_delay = 40; /* 40 milliseconds */
4977 /* no output amps */
4979 spec->mixer = stac92hd71bxx_analog_mixer;
4980 spec->dinput_mux = &spec->private_dimux;
4983 spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
4984 stac_change_pin_config(codec, 0xf, 0x40f000f0);
4986 case 0x111d7603: /* 6 Port with Analog Mixer */
4987 if ((codec->revision_id & 0xf) == 1)
4988 spec->stream_delay = 40; /* 40 milliseconds */
4990 /* no output amps */
4994 spec->dinput_mux = &spec->private_dimux;
4995 spec->mixer = stac92hd71bxx_analog_mixer;
4996 spec->init = stac92hd71bxx_analog_core_init;
4997 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5000 spec->aloopback_mask = 0x50;
5001 spec->aloopback_shift = 0;
5003 spec->powerdown_adcs = 1;
5004 spec->digbeep_nid = 0x26;
5005 spec->mux_nids = stac92hd71bxx_mux_nids;
5006 spec->adc_nids = stac92hd71bxx_adc_nids;
5007 spec->dmic_nids = stac92hd71bxx_dmic_nids;
5008 spec->dmux_nids = stac92hd71bxx_dmux_nids;
5009 spec->smux_nids = stac92hd71bxx_smux_nids;
5010 spec->pwr_nids = stac92hd71bxx_pwr_nids;
5012 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
5013 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
5015 switch (spec->board_config) {
5017 /* enable internal microphone */
5018 stac_change_pin_config(codec, 0x0e, 0x01813040);
5019 stac92xx_auto_set_pinctl(codec, 0x0e,
5020 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
5022 case STAC_DELL_M4_2:
5023 spec->num_dmics = 0;
5024 spec->num_smuxes = 0;
5025 spec->num_dmuxes = 0;
5027 case STAC_DELL_M4_1:
5028 case STAC_DELL_M4_3:
5029 spec->num_dmics = 1;
5030 spec->num_smuxes = 0;
5031 spec->num_dmuxes = 0;
5034 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
5035 spec->num_smuxes = ARRAY_SIZE(stac92hd71bxx_smux_nids);
5036 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5039 spec->multiout.dac_nids = spec->dac_nids;
5040 if (spec->dinput_mux)
5041 spec->private_dimux.num_items +=
5043 (ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1);
5045 err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
5047 if (spec->board_config < 0) {
5048 printk(KERN_WARNING "hda_codec: No auto-config is "
5049 "available, default to model=ref\n");
5050 spec->board_config = STAC_92HD71BXX_REF;
5057 stac92xx_free(codec);
5061 codec->proc_widget_hook = stac92hd7x_proc_hook;
5066 static int patch_stac922x(struct hda_codec *codec)
5068 struct sigmatel_spec *spec;
5071 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5076 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
5077 spec->pin_nids = stac922x_pin_nids;
5078 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
5081 if (spec->board_config == STAC_INTEL_MAC_AUTO) {
5082 spec->gpio_mask = spec->gpio_dir = 0x03;
5083 spec->gpio_data = 0x03;
5084 /* Intel Macs have all same PCI SSID, so we need to check
5085 * codec SSID to distinguish the exact models
5087 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
5088 switch (codec->subsystem_id) {
5091 spec->board_config = STAC_INTEL_MAC_V1;
5095 spec->board_config = STAC_INTEL_MAC_V2;
5103 spec->board_config = STAC_INTEL_MAC_V3;
5107 spec->board_config = STAC_INTEL_MAC_V4;
5111 spec->board_config = STAC_INTEL_MAC_V5;
5114 spec->board_config = STAC_INTEL_MAC_V3;
5120 if (spec->board_config < 0) {
5121 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
5122 "using BIOS defaults\n");
5123 err = stac92xx_save_bios_config_regs(codec);
5125 err = stac_save_pin_cfgs(codec,
5126 stac922x_brd_tbl[spec->board_config]);
5128 stac92xx_free(codec);
5132 spec->adc_nids = stac922x_adc_nids;
5133 spec->mux_nids = stac922x_mux_nids;
5134 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
5135 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
5136 spec->num_dmics = 0;
5139 spec->init = stac922x_core_init;
5140 spec->mixer = stac922x_mixer;
5142 spec->multiout.dac_nids = spec->dac_nids;
5144 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
5146 if (spec->board_config < 0) {
5147 printk(KERN_WARNING "hda_codec: No auto-config is "
5148 "available, default to model=ref\n");
5149 spec->board_config = STAC_D945_REF;
5155 stac92xx_free(codec);
5159 codec->patch_ops = stac92xx_patch_ops;
5161 /* Fix Mux capture level; max to 2 */
5162 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
5163 (0 << AC_AMPCAP_OFFSET_SHIFT) |
5164 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5165 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5166 (0 << AC_AMPCAP_MUTE_SHIFT));
5171 static int patch_stac927x(struct hda_codec *codec)
5173 struct sigmatel_spec *spec;
5176 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5181 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
5182 spec->pin_nids = stac927x_pin_nids;
5183 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
5187 if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
5188 if (spec->board_config < 0)
5189 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
5190 "STAC927x, using BIOS defaults\n");
5191 err = stac92xx_save_bios_config_regs(codec);
5193 err = stac_save_pin_cfgs(codec,
5194 stac927x_brd_tbl[spec->board_config]);
5196 stac92xx_free(codec);
5200 spec->digbeep_nid = 0x23;
5201 spec->adc_nids = stac927x_adc_nids;
5202 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
5203 spec->mux_nids = stac927x_mux_nids;
5204 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
5205 spec->smux_nids = stac927x_smux_nids;
5206 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
5207 spec->spdif_labels = stac927x_spdif_labels;
5208 spec->dac_list = stac927x_dac_nids;
5209 spec->multiout.dac_nids = spec->dac_nids;
5211 switch (spec->board_config) {
5214 /* GPIO0 High = Enable EAPD */
5215 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01;
5216 spec->gpio_data = 0x01;
5217 spec->num_dmics = 0;
5219 spec->init = d965_core_init;
5220 spec->mixer = stac927x_mixer;
5222 case STAC_DELL_BIOS:
5223 switch (codec->subsystem_id) {
5226 /* correct the device field to SPDIF out */
5227 stac_change_pin_config(codec, 0x21, 0x01442070);
5230 /* configure the analog microphone on some laptops */
5231 stac_change_pin_config(codec, 0x0c, 0x90a79130);
5232 /* correct the front output jack as a hp out */
5233 stac_change_pin_config(codec, 0x0f, 0x0227011f);
5234 /* correct the front input jack as a mic */
5235 stac_change_pin_config(codec, 0x0e, 0x02a79130);
5238 /* GPIO2 High = Enable EAPD */
5239 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
5240 spec->gpio_data = 0x04;
5241 spec->dmic_nids = stac927x_dmic_nids;
5242 spec->num_dmics = STAC927X_NUM_DMICS;
5244 spec->init = d965_core_init;
5245 spec->mixer = stac927x_mixer;
5246 spec->dmux_nids = stac927x_dmux_nids;
5247 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
5250 if (spec->board_config > STAC_D965_REF) {
5251 /* GPIO0 High = Enable EAPD */
5252 spec->eapd_mask = spec->gpio_mask = 0x01;
5253 spec->gpio_dir = spec->gpio_data = 0x01;
5255 spec->num_dmics = 0;
5257 spec->init = stac927x_core_init;
5258 spec->mixer = stac927x_mixer;
5262 spec->aloopback_mask = 0x40;
5263 spec->aloopback_shift = 0;
5264 spec->eapd_switch = 1;
5266 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
5268 if (spec->board_config < 0) {
5269 printk(KERN_WARNING "hda_codec: No auto-config is "
5270 "available, default to model=ref\n");
5271 spec->board_config = STAC_D965_REF;
5277 stac92xx_free(codec);
5281 codec->patch_ops = stac92xx_patch_ops;
5283 codec->proc_widget_hook = stac927x_proc_hook;
5287 * The STAC927x seem to require fairly long delays for certain
5288 * command sequences. With too short delays (even if the answer
5289 * is set to RIRB properly), it results in the silence output
5290 * on some hardwares like Dell.
5292 * The below flag enables the longer delay (see get_response
5295 codec->bus->needs_damn_long_delay = 1;
5297 /* no jack detecion for ref-no-jd model */
5298 if (spec->board_config == STAC_D965_REF_NO_JD)
5299 spec->hp_detect = 0;
5304 static int patch_stac9205(struct hda_codec *codec)
5306 struct sigmatel_spec *spec;
5309 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5314 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
5315 spec->pin_nids = stac9205_pin_nids;
5316 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
5320 if (spec->board_config < 0) {
5321 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
5322 err = stac92xx_save_bios_config_regs(codec);
5324 err = stac_save_pin_cfgs(codec,
5325 stac9205_brd_tbl[spec->board_config]);
5327 stac92xx_free(codec);
5331 spec->digbeep_nid = 0x23;
5332 spec->adc_nids = stac9205_adc_nids;
5333 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
5334 spec->mux_nids = stac9205_mux_nids;
5335 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
5336 spec->smux_nids = stac9205_smux_nids;
5337 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
5338 spec->dmic_nids = stac9205_dmic_nids;
5339 spec->num_dmics = STAC9205_NUM_DMICS;
5340 spec->dmux_nids = stac9205_dmux_nids;
5341 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
5344 spec->init = stac9205_core_init;
5345 spec->mixer = stac9205_mixer;
5347 spec->aloopback_mask = 0x40;
5348 spec->aloopback_shift = 0;
5349 /* Turn on/off EAPD per HP plugging */
5350 if (spec->board_config != STAC_9205_EAPD)
5351 spec->eapd_switch = 1;
5352 spec->multiout.dac_nids = spec->dac_nids;
5354 switch (spec->board_config){
5355 case STAC_9205_DELL_M43:
5356 /* Enable SPDIF in/out */
5357 stac_change_pin_config(codec, 0x1f, 0x01441030);
5358 stac_change_pin_config(codec, 0x20, 0x1c410030);
5360 /* Enable unsol response for GPIO4/Dock HP connection */
5361 err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
5364 snd_hda_codec_write_cache(codec, codec->afg, 0,
5365 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
5366 snd_hda_codec_write_cache(codec, codec->afg, 0,
5367 AC_VERB_SET_UNSOLICITED_ENABLE,
5370 spec->gpio_dir = 0x0b;
5371 spec->eapd_mask = 0x01;
5372 spec->gpio_mask = 0x1b;
5373 spec->gpio_mute = 0x10;
5374 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
5377 spec->gpio_data = 0x01;
5380 /* SPDIF-In enabled */
5383 /* GPIO0 High = EAPD */
5384 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5385 spec->gpio_data = 0x01;
5389 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
5391 if (spec->board_config < 0) {
5392 printk(KERN_WARNING "hda_codec: No auto-config is "
5393 "available, default to model=ref\n");
5394 spec->board_config = STAC_9205_REF;
5400 stac92xx_free(codec);
5404 codec->patch_ops = stac92xx_patch_ops;
5406 codec->proc_widget_hook = stac9205_proc_hook;
5415 static struct hda_verb stac9872_core_init[] = {
5416 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5417 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5421 static struct snd_kcontrol_new stac9872_mixer[] = {
5422 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5423 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5424 STAC_INPUT_SOURCE(1),
5428 static hda_nid_t stac9872_pin_nids[] = {
5429 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
5433 static hda_nid_t stac9872_adc_nids[] = {
5437 static hda_nid_t stac9872_mux_nids[] = {
5441 static int patch_stac9872(struct hda_codec *codec)
5443 struct sigmatel_spec *spec;
5446 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5451 #if 0 /* no model right now */
5452 spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
5457 spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
5458 spec->pin_nids = stac9872_pin_nids;
5459 spec->multiout.dac_nids = spec->dac_nids;
5460 spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
5461 spec->adc_nids = stac9872_adc_nids;
5462 spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
5463 spec->mux_nids = stac9872_mux_nids;
5464 spec->mixer = stac9872_mixer;
5465 spec->init = stac9872_core_init;
5467 err = stac92xx_parse_auto_config(codec, 0x10, 0x12);
5469 stac92xx_free(codec);
5472 spec->input_mux = &spec->private_imux;
5473 codec->patch_ops = stac92xx_patch_ops;
5481 static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
5482 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
5483 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
5484 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
5485 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
5486 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
5487 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
5488 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
5489 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
5490 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
5491 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
5492 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
5493 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
5494 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
5495 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
5496 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
5497 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
5498 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
5499 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
5500 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
5501 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
5502 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
5503 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
5504 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
5505 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
5506 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
5507 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
5508 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
5509 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
5510 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
5511 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
5512 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
5513 /* The following does not take into account .id=0x83847661 when subsys =
5514 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
5515 * currently not fully supported.
5517 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
5518 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
5519 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
5520 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
5521 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
5522 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
5523 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
5524 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
5525 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
5526 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
5527 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
5528 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
5529 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
5530 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
5531 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
5532 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
5533 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
5534 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
5535 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5536 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5537 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5538 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5539 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5540 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5541 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5542 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5546 MODULE_ALIAS("snd-hda-codec-id:8384*");
5547 MODULE_ALIAS("snd-hda-codec-id:111d*");
5549 MODULE_LICENSE("GPL");
5550 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
5552 static struct hda_codec_preset_list sigmatel_list = {
5553 .preset = snd_hda_preset_sigmatel,
5554 .owner = THIS_MODULE,
5557 static int __init patch_sigmatel_init(void)
5559 return snd_hda_add_codec_preset(&sigmatel_list);
5562 static void __exit patch_sigmatel_exit(void)
5564 snd_hda_delete_codec_preset(&sigmatel_list);
5567 module_init(patch_sigmatel_init)
5568 module_exit(patch_sigmatel_exit)