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"
36 #include "hda_patch.h"
39 #define STAC_INSERT_EVENT 0x10
40 #define STAC_PWR_EVENT 0x20
41 #define STAC_HP_EVENT 0x30
42 #define STAC_VREF_EVENT 0x40
107 STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
108 * is given, one of the above models will be
109 * chosen according to the subsystem id. */
110 /* for backward compatibility */
134 struct sigmatel_event {
139 struct sigmatel_jack {
142 struct snd_jack *jack;
145 struct sigmatel_spec {
146 struct snd_kcontrol_new *mixers[4];
147 unsigned int num_mixers;
150 unsigned int surr_switch: 1;
151 unsigned int line_switch: 1;
152 unsigned int mic_switch: 1;
153 unsigned int alt_switch: 1;
154 unsigned int hp_detect: 1;
155 unsigned int spdif_mute: 1;
158 unsigned int eapd_mask;
159 unsigned int gpio_mask;
160 unsigned int gpio_dir;
161 unsigned int gpio_data;
162 unsigned int gpio_mute;
165 unsigned int stream_delay;
167 /* analog loopback */
168 unsigned char aloopback_mask;
169 unsigned char aloopback_shift;
171 /* power management */
172 unsigned int num_pwrs;
173 unsigned int *pwr_mapping;
178 struct snd_array jacks;
181 struct snd_array events;
184 struct hda_input_mux *mono_mux;
185 struct hda_input_mux *amp_mux;
186 unsigned int cur_mmux;
187 struct hda_multi_out multiout;
188 hda_nid_t dac_nids[5];
192 unsigned int num_adcs;
194 unsigned int num_muxes;
195 hda_nid_t *dmic_nids;
196 unsigned int num_dmics;
197 hda_nid_t *dmux_nids;
198 unsigned int num_dmuxes;
199 hda_nid_t *smux_nids;
200 unsigned int num_smuxes;
201 const char **spdif_labels;
203 hda_nid_t dig_in_nid;
205 hda_nid_t anabeep_nid;
206 hda_nid_t digbeep_nid;
210 unsigned int num_pins;
211 unsigned int *pin_configs;
212 unsigned int *bios_pin_configs;
214 /* codec specific stuff */
215 struct hda_verb *init;
216 struct snd_kcontrol_new *mixer;
219 struct hda_input_mux *dinput_mux;
220 unsigned int cur_dmux[2];
221 struct hda_input_mux *input_mux;
222 unsigned int cur_mux[3];
223 struct hda_input_mux *sinput_mux;
224 unsigned int cur_smux[2];
225 unsigned int cur_amux;
227 unsigned int num_amps;
228 unsigned int powerdown_adcs;
231 unsigned int io_switch[2];
232 unsigned int clfe_swap;
233 unsigned int hp_switch; /* NID of HP as line-out */
234 unsigned int aloopback;
236 struct hda_pcm pcm_rec[2]; /* PCM information */
238 /* dynamic controls and input_mux */
239 struct auto_pin_cfg autocfg;
240 struct snd_array kctls;
241 struct hda_input_mux private_dimux;
242 struct hda_input_mux private_imux;
243 struct hda_input_mux private_smux;
244 struct hda_input_mux private_amp_mux;
245 struct hda_input_mux private_mono_mux;
248 static hda_nid_t stac9200_adc_nids[1] = {
252 static hda_nid_t stac9200_mux_nids[1] = {
256 static hda_nid_t stac9200_dac_nids[1] = {
260 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
261 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
265 static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
269 static hda_nid_t stac92hd73xx_adc_nids[2] = {
273 #define DELL_M6_AMP 2
274 static hda_nid_t stac92hd73xx_amp_nids[3] = {
278 #define STAC92HD73XX_NUM_DMICS 2
279 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
283 #define STAC92HD73_DAC_COUNT 5
284 static hda_nid_t stac92hd73xx_dac_nids[STAC92HD73_DAC_COUNT] = {
285 0x15, 0x16, 0x17, 0x18, 0x19,
288 static hda_nid_t stac92hd73xx_mux_nids[4] = {
289 0x28, 0x29, 0x2a, 0x2b,
292 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
296 static hda_nid_t stac92hd73xx_smux_nids[2] = {
300 #define STAC92HD83XXX_NUM_DMICS 2
301 static hda_nid_t stac92hd83xxx_dmic_nids[STAC92HD83XXX_NUM_DMICS + 1] = {
305 #define STAC92HD81_DAC_COUNT 2
306 #define STAC92HD83_DAC_COUNT 3
307 static hda_nid_t stac92hd83xxx_dac_nids[STAC92HD73_DAC_COUNT] = {
311 static hda_nid_t stac92hd83xxx_dmux_nids[2] = {
315 static hda_nid_t stac92hd83xxx_adc_nids[2] = {
319 static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
323 static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
327 static unsigned int stac92hd83xxx_pwr_mapping[4] = {
328 0x03, 0x0c, 0x10, 0x40,
331 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
335 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
339 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
343 static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
347 static hda_nid_t stac92hd71bxx_smux_nids[2] = {
351 static hda_nid_t stac92hd71bxx_dac_nids[1] = {
355 #define STAC92HD71BXX_NUM_DMICS 2
356 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
360 static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
364 static hda_nid_t stac925x_adc_nids[1] = {
368 static hda_nid_t stac925x_mux_nids[1] = {
372 static hda_nid_t stac925x_dac_nids[1] = {
376 #define STAC925X_NUM_DMICS 1
377 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
381 static hda_nid_t stac925x_dmux_nids[1] = {
385 static hda_nid_t stac922x_adc_nids[2] = {
389 static hda_nid_t stac922x_mux_nids[2] = {
393 static hda_nid_t stac927x_adc_nids[3] = {
397 static hda_nid_t stac927x_mux_nids[3] = {
401 static hda_nid_t stac927x_smux_nids[1] = {
405 static hda_nid_t stac927x_dac_nids[6] = {
406 0x02, 0x03, 0x04, 0x05, 0x06, 0
409 static hda_nid_t stac927x_dmux_nids[1] = {
413 #define STAC927X_NUM_DMICS 2
414 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
418 static const char *stac927x_spdif_labels[5] = {
419 "Digital Playback", "ADAT", "Analog Mux 1",
420 "Analog Mux 2", "Analog Mux 3"
423 static hda_nid_t stac9205_adc_nids[2] = {
427 static hda_nid_t stac9205_mux_nids[2] = {
431 static hda_nid_t stac9205_dmux_nids[1] = {
435 static hda_nid_t stac9205_smux_nids[1] = {
439 #define STAC9205_NUM_DMICS 2
440 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
444 static hda_nid_t stac9200_pin_nids[8] = {
445 0x08, 0x09, 0x0d, 0x0e,
446 0x0f, 0x10, 0x11, 0x12,
449 static hda_nid_t stac925x_pin_nids[8] = {
450 0x07, 0x08, 0x0a, 0x0b,
451 0x0c, 0x0d, 0x10, 0x11,
454 static hda_nid_t stac922x_pin_nids[10] = {
455 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
456 0x0f, 0x10, 0x11, 0x15, 0x1b,
459 static hda_nid_t stac92hd73xx_pin_nids[13] = {
460 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
461 0x0f, 0x10, 0x11, 0x12, 0x13,
465 static hda_nid_t stac92hd83xxx_pin_nids[14] = {
466 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
467 0x0f, 0x10, 0x11, 0x12, 0x13,
468 0x1d, 0x1e, 0x1f, 0x20
470 static hda_nid_t stac92hd71bxx_pin_nids[11] = {
471 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
472 0x0f, 0x14, 0x18, 0x19, 0x1e,
476 static hda_nid_t stac927x_pin_nids[14] = {
477 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
478 0x0f, 0x10, 0x11, 0x12, 0x13,
479 0x14, 0x21, 0x22, 0x23,
482 static hda_nid_t stac9205_pin_nids[12] = {
483 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
484 0x0f, 0x14, 0x16, 0x17, 0x18,
488 #define stac92xx_amp_volume_info snd_hda_mixer_amp_volume_info
490 static int stac92xx_amp_volume_get(struct snd_kcontrol *kcontrol,
491 struct snd_ctl_elem_value *ucontrol)
493 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
494 struct sigmatel_spec *spec = codec->spec;
495 hda_nid_t nid = spec->amp_nids[spec->cur_amux];
497 kcontrol->private_value ^= get_amp_nid(kcontrol);
498 kcontrol->private_value |= nid;
500 return snd_hda_mixer_amp_volume_get(kcontrol, ucontrol);
503 static int stac92xx_amp_volume_put(struct snd_kcontrol *kcontrol,
504 struct snd_ctl_elem_value *ucontrol)
506 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
507 struct sigmatel_spec *spec = codec->spec;
508 hda_nid_t nid = spec->amp_nids[spec->cur_amux];
510 kcontrol->private_value ^= get_amp_nid(kcontrol);
511 kcontrol->private_value |= nid;
513 return snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
516 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
517 struct snd_ctl_elem_info *uinfo)
519 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
520 struct sigmatel_spec *spec = codec->spec;
521 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
524 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
525 struct snd_ctl_elem_value *ucontrol)
527 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
528 struct sigmatel_spec *spec = codec->spec;
529 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
531 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
535 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
536 struct snd_ctl_elem_value *ucontrol)
538 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
539 struct sigmatel_spec *spec = codec->spec;
540 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
542 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
543 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
546 static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
547 struct snd_ctl_elem_info *uinfo)
549 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
550 struct sigmatel_spec *spec = codec->spec;
551 return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
554 static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
555 struct snd_ctl_elem_value *ucontrol)
557 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
558 struct sigmatel_spec *spec = codec->spec;
559 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
561 ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
565 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
566 struct snd_ctl_elem_value *ucontrol)
568 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
569 struct sigmatel_spec *spec = codec->spec;
570 struct hda_input_mux *smux = &spec->private_smux;
571 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
575 err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
576 spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
580 if (spec->spdif_mute) {
582 nid = spec->multiout.dig_out_nid;
584 nid = codec->slave_dig_outs[smux_idx - 1];
585 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
588 val = AMP_OUT_UNMUTE;
589 /* un/mute SPDIF out */
590 snd_hda_codec_write_cache(codec, nid, 0,
591 AC_VERB_SET_AMP_GAIN_MUTE, val);
596 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
598 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
599 struct sigmatel_spec *spec = codec->spec;
600 return snd_hda_input_mux_info(spec->input_mux, uinfo);
603 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
605 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
606 struct sigmatel_spec *spec = codec->spec;
607 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
609 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
613 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
615 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
616 struct sigmatel_spec *spec = codec->spec;
617 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
619 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
620 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
623 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
624 struct snd_ctl_elem_info *uinfo)
626 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
627 struct sigmatel_spec *spec = codec->spec;
628 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
631 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
632 struct snd_ctl_elem_value *ucontrol)
634 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
635 struct sigmatel_spec *spec = codec->spec;
637 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
641 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
642 struct snd_ctl_elem_value *ucontrol)
644 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
645 struct sigmatel_spec *spec = codec->spec;
647 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
648 spec->mono_nid, &spec->cur_mmux);
651 static int stac92xx_amp_mux_enum_info(struct snd_kcontrol *kcontrol,
652 struct snd_ctl_elem_info *uinfo)
654 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
655 struct sigmatel_spec *spec = codec->spec;
656 return snd_hda_input_mux_info(spec->amp_mux, uinfo);
659 static int stac92xx_amp_mux_enum_get(struct snd_kcontrol *kcontrol,
660 struct snd_ctl_elem_value *ucontrol)
662 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
663 struct sigmatel_spec *spec = codec->spec;
665 ucontrol->value.enumerated.item[0] = spec->cur_amux;
669 static int stac92xx_amp_mux_enum_put(struct snd_kcontrol *kcontrol,
670 struct snd_ctl_elem_value *ucontrol)
672 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
673 struct sigmatel_spec *spec = codec->spec;
674 struct snd_kcontrol *ctl =
675 snd_hda_find_mixer_ctl(codec, "Amp Capture Volume");
679 snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE |
680 SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
682 return snd_hda_input_mux_put(codec, spec->amp_mux, ucontrol,
686 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
688 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
689 struct snd_ctl_elem_value *ucontrol)
691 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
692 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
693 struct sigmatel_spec *spec = codec->spec;
695 ucontrol->value.integer.value[0] = !!(spec->aloopback &
696 (spec->aloopback_mask << idx));
700 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
701 struct snd_ctl_elem_value *ucontrol)
703 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
704 struct sigmatel_spec *spec = codec->spec;
705 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
706 unsigned int dac_mode;
707 unsigned int val, idx_val;
709 idx_val = spec->aloopback_mask << idx;
710 if (ucontrol->value.integer.value[0])
711 val = spec->aloopback | idx_val;
713 val = spec->aloopback & ~idx_val;
714 if (spec->aloopback == val)
717 spec->aloopback = val;
719 /* Only return the bits defined by the shift value of the
720 * first two bytes of the mask
722 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
723 kcontrol->private_value & 0xFFFF, 0x0);
724 dac_mode >>= spec->aloopback_shift;
726 if (spec->aloopback & idx_val) {
727 snd_hda_power_up(codec);
730 snd_hda_power_down(codec);
731 dac_mode &= ~idx_val;
734 snd_hda_codec_write_cache(codec, codec->afg, 0,
735 kcontrol->private_value >> 16, dac_mode);
740 static struct hda_verb stac9200_core_init[] = {
741 /* set dac0mux for dac converter */
742 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
746 static struct hda_verb stac9200_eapd_init[] = {
747 /* set dac0mux for dac converter */
748 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
749 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
753 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
754 /* set master volume and direct control */
755 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
756 /* setup audio connections */
757 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
758 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
759 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
760 /* setup adcs to point to mixer */
761 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
762 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
763 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
764 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
765 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
766 /* setup import muxs */
767 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
768 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
769 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
770 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
774 static struct hda_verb dell_eq_core_init[] = {
775 /* set master volume to max value without distortion
776 * and direct control */
777 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
778 /* setup audio connections */
779 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
780 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x02},
781 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x01},
782 /* setup adcs to point to mixer */
783 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
784 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
785 /* setup import muxs */
786 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
787 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
788 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
789 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
793 static struct hda_verb dell_m6_core_init[] = {
794 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
795 /* setup audio connections */
796 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
797 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
798 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x02},
799 /* setup adcs to point to mixer */
800 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
801 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
802 /* setup import muxs */
803 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
804 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
805 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
806 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
810 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
811 /* set master volume and direct control */
812 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
813 /* setup audio connections */
814 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
815 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
816 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
817 /* connect hp ports to dac3 */
818 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x03},
819 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x03},
820 /* setup adcs to point to mixer */
821 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
822 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
823 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
824 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
825 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
826 /* setup import muxs */
827 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
828 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
829 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
830 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
834 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
835 /* set master volume and direct control */
836 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
837 /* setup audio connections */
838 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
839 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01 },
840 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02 },
841 /* dac3 is connected to import3 mux */
842 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
843 /* connect hp ports to dac4 */
844 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x04},
845 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x04},
846 /* setup adcs to point to mixer */
847 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
848 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
849 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
850 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
851 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
852 /* setup import muxs */
853 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
854 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
855 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
856 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
860 static struct hda_verb stac92hd83xxx_core_init[] = {
861 /* start of config #1 */
862 { 0xe, AC_VERB_SET_CONNECT_SEL, 0x3},
864 /* start of config #2 */
865 { 0xa, AC_VERB_SET_CONNECT_SEL, 0x0},
866 { 0xb, AC_VERB_SET_CONNECT_SEL, 0x0},
867 { 0xd, AC_VERB_SET_CONNECT_SEL, 0x1},
869 /* power state controls amps */
870 { 0x01, AC_VERB_SET_EAPD, 1 << 2},
873 static struct hda_verb stac92hd71bxx_core_init[] = {
874 /* set master volume and direct control */
875 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
876 /* connect headphone jack to dac1 */
877 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
878 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
879 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
880 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
881 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
884 #define HD_DISABLE_PORTF 2
885 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
886 /* start of config #1 */
888 /* connect port 0f to audio mixer */
889 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
890 /* unmute right and left channels for node 0x0f */
891 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
892 /* start of config #2 */
894 /* set master volume and direct control */
895 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
896 /* connect headphone jack to dac1 */
897 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
898 /* unmute right and left channels for nodes 0x0a, 0xd */
899 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
900 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
904 static struct hda_verb stac925x_core_init[] = {
905 /* set dac0mux for dac converter */
906 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
910 static struct hda_verb stac922x_core_init[] = {
911 /* set master volume and direct control */
912 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
916 static struct hda_verb d965_core_init[] = {
917 /* set master volume and direct control */
918 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
919 /* unmute node 0x1b */
920 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
921 /* select node 0x03 as DAC */
922 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
926 static struct hda_verb stac927x_core_init[] = {
927 /* set master volume and direct control */
928 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
929 /* enable analog pc beep path */
930 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
934 static struct hda_verb stac9205_core_init[] = {
935 /* set master volume and direct control */
936 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
937 /* enable analog pc beep path */
938 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
942 #define STAC_MONO_MUX \
944 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
945 .name = "Mono Mux", \
947 .info = stac92xx_mono_mux_enum_info, \
948 .get = stac92xx_mono_mux_enum_get, \
949 .put = stac92xx_mono_mux_enum_put, \
952 #define STAC_AMP_MUX \
954 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
955 .name = "Amp Selector Capture Switch", \
957 .info = stac92xx_amp_mux_enum_info, \
958 .get = stac92xx_amp_mux_enum_get, \
959 .put = stac92xx_amp_mux_enum_put, \
962 #define STAC_AMP_VOL(xname, nid, chs, idx, dir) \
964 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
967 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
968 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
969 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
970 .info = stac92xx_amp_volume_info, \
971 .get = stac92xx_amp_volume_get, \
972 .put = stac92xx_amp_volume_put, \
973 .tlv = { .c = snd_hda_mixer_amp_tlv }, \
974 .private_value = HDA_COMPOSE_AMP_VAL(nid, chs, idx, dir) \
977 #define STAC_INPUT_SOURCE(cnt) \
979 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
980 .name = "Input Source", \
982 .info = stac92xx_mux_enum_info, \
983 .get = stac92xx_mux_enum_get, \
984 .put = stac92xx_mux_enum_put, \
987 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
989 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
990 .name = "Analog Loopback", \
992 .info = stac92xx_aloopback_info, \
993 .get = stac92xx_aloopback_get, \
994 .put = stac92xx_aloopback_put, \
995 .private_value = verb_read | (verb_write << 16), \
998 static struct snd_kcontrol_new stac9200_mixer[] = {
999 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
1000 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
1001 STAC_INPUT_SOURCE(1),
1002 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
1003 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
1007 #define DELL_M6_MIXER 6
1008 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
1009 /* start of config #1 */
1010 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1011 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1013 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1014 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1016 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1017 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1019 /* start of config #2 */
1020 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1021 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1023 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1024 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1026 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
1028 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1029 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1031 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1032 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1037 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
1038 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1040 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1041 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1043 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1044 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1046 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1047 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1049 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1050 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1052 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1053 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1055 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1056 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1058 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1059 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1063 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
1064 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1066 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1067 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1069 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1070 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1072 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1073 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1075 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1076 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1078 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1079 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1081 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1082 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1084 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1085 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1090 static struct snd_kcontrol_new stac92hd83xxx_mixer[] = {
1091 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_OUTPUT),
1092 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_OUTPUT),
1094 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_OUTPUT),
1095 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_OUTPUT),
1097 HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x1b, 0, HDA_INPUT),
1098 HDA_CODEC_MUTE("DAC0 Capture Switch", 0x1b, 0, HDA_INPUT),
1100 HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x1b, 0x1, HDA_INPUT),
1101 HDA_CODEC_MUTE("DAC1 Capture Switch", 0x1b, 0x1, HDA_INPUT),
1103 HDA_CODEC_VOLUME("Front Mic Capture Volume", 0x1b, 0x2, HDA_INPUT),
1104 HDA_CODEC_MUTE("Front Mic Capture Switch", 0x1b, 0x2, HDA_INPUT),
1106 HDA_CODEC_VOLUME("Line In Capture Volume", 0x1b, 0x3, HDA_INPUT),
1107 HDA_CODEC_MUTE("Line In Capture Switch", 0x1b, 0x3, HDA_INPUT),
1110 HDA_CODEC_VOLUME("Mic Capture Volume", 0x1b, 0x4, HDA_INPUT),
1111 HDA_CODEC_MUTE("Mic Capture Switch", 0x1b 0x4, HDA_INPUT),
1116 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
1117 STAC_INPUT_SOURCE(2),
1118 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
1120 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1121 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1123 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1124 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1125 /* analog pc-beep replaced with digital beep support */
1127 HDA_CODEC_VOLUME("PC Beep Volume", 0x17, 0x2, HDA_INPUT),
1128 HDA_CODEC_MUTE("PC Beep Switch", 0x17, 0x2, HDA_INPUT),
1131 HDA_CODEC_MUTE("Import0 Mux Capture Switch", 0x17, 0x0, HDA_INPUT),
1132 HDA_CODEC_VOLUME("Import0 Mux Capture Volume", 0x17, 0x0, HDA_INPUT),
1134 HDA_CODEC_MUTE("Import1 Mux Capture Switch", 0x17, 0x1, HDA_INPUT),
1135 HDA_CODEC_VOLUME("Import1 Mux Capture Volume", 0x17, 0x1, HDA_INPUT),
1137 HDA_CODEC_MUTE("DAC0 Capture Switch", 0x17, 0x3, HDA_INPUT),
1138 HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x17, 0x3, HDA_INPUT),
1140 HDA_CODEC_MUTE("DAC1 Capture Switch", 0x17, 0x4, HDA_INPUT),
1141 HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x17, 0x4, HDA_INPUT),
1145 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
1146 STAC_INPUT_SOURCE(2),
1147 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
1149 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1150 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1152 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1153 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1157 static struct snd_kcontrol_new stac925x_mixer[] = {
1158 STAC_INPUT_SOURCE(1),
1159 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
1160 HDA_CODEC_MUTE("Capture Switch", 0x14, 0, HDA_OUTPUT),
1164 static struct snd_kcontrol_new stac9205_mixer[] = {
1165 STAC_INPUT_SOURCE(2),
1166 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1168 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
1169 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
1171 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
1172 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
1176 /* This needs to be generated dynamically based on sequence */
1177 static struct snd_kcontrol_new stac922x_mixer[] = {
1178 STAC_INPUT_SOURCE(2),
1179 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
1180 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
1182 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
1183 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
1188 static struct snd_kcontrol_new stac927x_mixer[] = {
1189 STAC_INPUT_SOURCE(3),
1190 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1192 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
1193 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
1195 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
1196 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
1198 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
1199 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
1203 static struct snd_kcontrol_new stac_dmux_mixer = {
1204 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1205 .name = "Digital Input Source",
1206 /* count set later */
1207 .info = stac92xx_dmux_enum_info,
1208 .get = stac92xx_dmux_enum_get,
1209 .put = stac92xx_dmux_enum_put,
1212 static struct snd_kcontrol_new stac_smux_mixer = {
1213 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1214 .name = "IEC958 Playback Source",
1215 /* count set later */
1216 .info = stac92xx_smux_enum_info,
1217 .get = stac92xx_smux_enum_get,
1218 .put = stac92xx_smux_enum_put,
1221 static const char *slave_vols[] = {
1222 "Front Playback Volume",
1223 "Surround Playback Volume",
1224 "Center Playback Volume",
1225 "LFE Playback Volume",
1226 "Side Playback Volume",
1227 "Headphone Playback Volume",
1228 "Headphone Playback Volume",
1229 "Speaker Playback Volume",
1230 "External Speaker Playback Volume",
1231 "Speaker2 Playback Volume",
1235 static const char *slave_sws[] = {
1236 "Front Playback Switch",
1237 "Surround Playback Switch",
1238 "Center Playback Switch",
1239 "LFE Playback Switch",
1240 "Side Playback Switch",
1241 "Headphone Playback Switch",
1242 "Headphone Playback Switch",
1243 "Speaker Playback Switch",
1244 "External Speaker Playback Switch",
1245 "Speaker2 Playback Switch",
1246 "IEC958 Playback Switch",
1250 static void stac92xx_free_kctls(struct hda_codec *codec);
1252 static int stac92xx_build_controls(struct hda_codec *codec)
1254 struct sigmatel_spec *spec = codec->spec;
1258 err = snd_hda_add_new_ctls(codec, spec->mixer);
1262 for (i = 0; i < spec->num_mixers; i++) {
1263 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1267 if (spec->num_dmuxes > 0) {
1268 stac_dmux_mixer.count = spec->num_dmuxes;
1269 err = snd_hda_ctl_add(codec,
1270 snd_ctl_new1(&stac_dmux_mixer, codec));
1274 if (spec->num_smuxes > 0) {
1275 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1276 struct hda_input_mux *smux = &spec->private_smux;
1277 /* check for mute support on SPDIF out */
1278 if (wcaps & AC_WCAP_OUT_AMP) {
1279 smux->items[smux->num_items].label = "Off";
1280 smux->items[smux->num_items].index = 0;
1282 spec->spdif_mute = 1;
1284 stac_smux_mixer.count = spec->num_smuxes;
1285 err = snd_ctl_add(codec->bus->card,
1286 snd_ctl_new1(&stac_smux_mixer, codec));
1291 if (spec->multiout.dig_out_nid) {
1292 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1295 err = snd_hda_create_spdif_share_sw(codec,
1299 spec->multiout.share_spdif = 1;
1301 if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1302 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1307 /* if we have no master control, let's create it */
1308 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1309 unsigned int vmaster_tlv[4];
1310 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1311 HDA_OUTPUT, vmaster_tlv);
1312 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1313 vmaster_tlv, slave_vols);
1317 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1318 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1324 stac92xx_free_kctls(codec); /* no longer needed */
1328 static unsigned int ref9200_pin_configs[8] = {
1329 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1330 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1334 STAC 9200 pin configs for
1339 static unsigned int dell9200_d21_pin_configs[8] = {
1340 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
1341 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1345 STAC 9200 pin configs for
1349 static unsigned int dell9200_d22_pin_configs[8] = {
1350 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1351 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1355 STAC 9200 pin configs for
1356 102801C4 (Dell Dimension E310)
1363 static unsigned int dell9200_d23_pin_configs[8] = {
1364 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1365 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
1370 STAC 9200-32 pin configs for
1371 102801B5 (Dell Inspiron 630m)
1372 102801D8 (Dell Inspiron 640m)
1374 static unsigned int dell9200_m21_pin_configs[8] = {
1375 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1376 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1380 STAC 9200-32 pin configs for
1381 102801C2 (Dell Latitude D620)
1383 102801CC (Dell Latitude D820)
1387 static unsigned int dell9200_m22_pin_configs[8] = {
1388 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1389 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1393 STAC 9200-32 pin configs for
1394 102801CE (Dell XPS M1710)
1395 102801CF (Dell Precision M90)
1397 static unsigned int dell9200_m23_pin_configs[8] = {
1398 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1399 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1403 STAC 9200-32 pin configs for
1406 102801CB (Dell Latitude 120L)
1409 static unsigned int dell9200_m24_pin_configs[8] = {
1410 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1411 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1415 STAC 9200-32 pin configs for
1416 102801BD (Dell Inspiron E1505n)
1420 static unsigned int dell9200_m25_pin_configs[8] = {
1421 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1422 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1426 STAC 9200-32 pin configs for
1427 102801F5 (Dell Inspiron 1501)
1430 static unsigned int dell9200_m26_pin_configs[8] = {
1431 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1432 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1437 102801CD (Dell Inspiron E1705/9400)
1439 static unsigned int dell9200_m27_pin_configs[8] = {
1440 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1441 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1444 static unsigned int oqo9200_pin_configs[8] = {
1445 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1446 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1450 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1451 [STAC_REF] = ref9200_pin_configs,
1452 [STAC_9200_OQO] = oqo9200_pin_configs,
1453 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1454 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1455 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1456 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1457 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1458 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1459 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1460 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1461 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1462 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1463 [STAC_9200_PANASONIC] = ref9200_pin_configs,
1466 static const char *stac9200_models[STAC_9200_MODELS] = {
1468 [STAC_9200_OQO] = "oqo",
1469 [STAC_9200_DELL_D21] = "dell-d21",
1470 [STAC_9200_DELL_D22] = "dell-d22",
1471 [STAC_9200_DELL_D23] = "dell-d23",
1472 [STAC_9200_DELL_M21] = "dell-m21",
1473 [STAC_9200_DELL_M22] = "dell-m22",
1474 [STAC_9200_DELL_M23] = "dell-m23",
1475 [STAC_9200_DELL_M24] = "dell-m24",
1476 [STAC_9200_DELL_M25] = "dell-m25",
1477 [STAC_9200_DELL_M26] = "dell-m26",
1478 [STAC_9200_DELL_M27] = "dell-m27",
1479 [STAC_9200_GATEWAY] = "gateway",
1480 [STAC_9200_PANASONIC] = "panasonic",
1483 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1484 /* SigmaTel reference board */
1485 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1486 "DFI LanParty", STAC_REF),
1487 /* Dell laptops have BIOS problem */
1488 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1489 "unknown Dell", STAC_9200_DELL_D21),
1490 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1491 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1492 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1493 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1494 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1495 "unknown Dell", STAC_9200_DELL_D22),
1496 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1497 "unknown Dell", STAC_9200_DELL_D22),
1498 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1499 "Dell Latitude D620", STAC_9200_DELL_M22),
1500 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1501 "unknown Dell", STAC_9200_DELL_D23),
1502 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1503 "unknown Dell", STAC_9200_DELL_D23),
1504 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1505 "unknown Dell", STAC_9200_DELL_M22),
1506 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1507 "unknown Dell", STAC_9200_DELL_M24),
1508 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1509 "unknown Dell", STAC_9200_DELL_M24),
1510 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1511 "Dell Latitude 120L", STAC_9200_DELL_M24),
1512 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1513 "Dell Latitude D820", STAC_9200_DELL_M22),
1514 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1515 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1516 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1517 "Dell XPS M1710", STAC_9200_DELL_M23),
1518 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1519 "Dell Precision M90", STAC_9200_DELL_M23),
1520 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1521 "unknown Dell", STAC_9200_DELL_M22),
1522 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1523 "unknown Dell", STAC_9200_DELL_M22),
1524 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1525 "unknown Dell", STAC_9200_DELL_M22),
1526 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1527 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1528 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1529 "unknown Dell", STAC_9200_DELL_D23),
1530 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1531 "unknown Dell", STAC_9200_DELL_D23),
1532 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1533 "unknown Dell", STAC_9200_DELL_D21),
1534 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1535 "unknown Dell", STAC_9200_DELL_D23),
1536 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1537 "unknown Dell", STAC_9200_DELL_D21),
1538 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1539 "unknown Dell", STAC_9200_DELL_M25),
1540 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1541 "unknown Dell", STAC_9200_DELL_M25),
1542 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1543 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1544 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1545 "unknown Dell", STAC_9200_DELL_M26),
1547 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1548 /* Gateway machines needs EAPD to be set on resume */
1549 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
1550 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
1552 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
1555 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1559 static unsigned int ref925x_pin_configs[8] = {
1560 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1561 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1564 static unsigned int stac925x_MA6_pin_configs[8] = {
1565 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1566 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
1569 static unsigned int stac925x_PA6_pin_configs[8] = {
1570 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1571 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
1574 static unsigned int stac925xM2_2_pin_configs[8] = {
1575 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
1576 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
1579 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1580 [STAC_REF] = ref925x_pin_configs,
1581 [STAC_M2_2] = stac925xM2_2_pin_configs,
1582 [STAC_MA6] = stac925x_MA6_pin_configs,
1583 [STAC_PA6] = stac925x_PA6_pin_configs,
1586 static const char *stac925x_models[STAC_925x_MODELS] = {
1588 [STAC_M2_2] = "m2-2",
1593 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1594 /* SigmaTel reference board */
1595 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1596 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1597 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
1598 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
1599 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
1600 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
1601 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
1605 static unsigned int ref92hd73xx_pin_configs[13] = {
1606 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1607 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1608 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1612 static unsigned int dell_m6_pin_configs[13] = {
1613 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1614 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1615 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1619 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1620 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1621 [STAC_DELL_M6] = dell_m6_pin_configs,
1622 [STAC_DELL_EQ] = dell_m6_pin_configs,
1625 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1626 [STAC_92HD73XX_REF] = "ref",
1627 [STAC_DELL_M6] = "dell-m6",
1628 [STAC_DELL_EQ] = "dell-eq",
1631 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1632 /* SigmaTel reference board */
1633 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1634 "DFI LanParty", STAC_92HD73XX_REF),
1635 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1636 "unknown Dell", STAC_DELL_M6),
1637 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1638 "unknown Dell", STAC_DELL_M6),
1639 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1640 "unknown Dell", STAC_DELL_M6),
1641 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1642 "unknown Dell", STAC_DELL_M6),
1643 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1644 "unknown Dell", STAC_DELL_M6),
1645 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1646 "unknown Dell", STAC_DELL_M6),
1647 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1648 "unknown Dell", STAC_DELL_M6),
1652 static unsigned int ref92hd83xxx_pin_configs[14] = {
1653 0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1654 0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1655 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x40f000f0,
1656 0x01451160, 0x98560170,
1659 static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1660 [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1663 static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1664 [STAC_92HD83XXX_REF] = "ref",
1667 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1668 /* SigmaTel reference board */
1669 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1670 "DFI LanParty", STAC_92HD71BXX_REF),
1673 static unsigned int ref92hd71bxx_pin_configs[11] = {
1674 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1675 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1676 0x90a000f0, 0x01452050, 0x01452050,
1679 static unsigned int dell_m4_1_pin_configs[11] = {
1680 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1681 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1682 0x40f000f0, 0x4f0000f0, 0x4f0000f0,
1685 static unsigned int dell_m4_2_pin_configs[11] = {
1686 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1687 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1688 0x40f000f0, 0x044413b0, 0x044413b0,
1691 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1692 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1693 [STAC_DELL_M4_1] = dell_m4_1_pin_configs,
1694 [STAC_DELL_M4_2] = dell_m4_2_pin_configs,
1695 [STAC_HP_M4] = NULL,
1698 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1699 [STAC_92HD71BXX_REF] = "ref",
1700 [STAC_DELL_M4_1] = "dell-m4-1",
1701 [STAC_DELL_M4_2] = "dell-m4-2",
1702 [STAC_HP_M4] = "hp-m4",
1705 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1706 /* SigmaTel reference board */
1707 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1708 "DFI LanParty", STAC_92HD71BXX_REF),
1709 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1710 "unknown HP", STAC_HP_M4),
1711 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1712 "unknown Dell", STAC_DELL_M4_1),
1713 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1714 "unknown Dell", STAC_DELL_M4_1),
1715 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1716 "unknown Dell", STAC_DELL_M4_1),
1717 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1718 "unknown Dell", STAC_DELL_M4_1),
1719 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1720 "unknown Dell", STAC_DELL_M4_1),
1721 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1722 "unknown Dell", STAC_DELL_M4_1),
1723 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1724 "unknown Dell", STAC_DELL_M4_1),
1725 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1726 "unknown Dell", STAC_DELL_M4_2),
1727 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1728 "unknown Dell", STAC_DELL_M4_2),
1729 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1730 "unknown Dell", STAC_DELL_M4_2),
1731 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1732 "unknown Dell", STAC_DELL_M4_2),
1736 static unsigned int ref922x_pin_configs[10] = {
1737 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1738 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1739 0x40000100, 0x40000100,
1743 STAC 922X pin configs for
1750 static unsigned int dell_922x_d81_pin_configs[10] = {
1751 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1752 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1753 0x01813122, 0x400001f2,
1757 STAC 922X pin configs for
1761 static unsigned int dell_922x_d82_pin_configs[10] = {
1762 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1763 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1764 0x01813122, 0x400001f1,
1768 STAC 922X pin configs for
1771 static unsigned int dell_922x_m81_pin_configs[10] = {
1772 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1773 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1774 0x40C003f1, 0x405003f0,
1778 STAC 9221 A1 pin configs for
1779 102801D7 (Dell XPS M1210)
1781 static unsigned int dell_922x_m82_pin_configs[10] = {
1782 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1783 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1784 0x508003f3, 0x405003f4,
1787 static unsigned int d945gtp3_pin_configs[10] = {
1788 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1789 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1790 0x02a19120, 0x40000100,
1793 static unsigned int d945gtp5_pin_configs[10] = {
1794 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1795 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1796 0x02a19320, 0x40000100,
1799 static unsigned int intel_mac_v1_pin_configs[10] = {
1800 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1801 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1802 0x400000fc, 0x400000fb,
1805 static unsigned int intel_mac_v2_pin_configs[10] = {
1806 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1807 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1808 0x400000fc, 0x400000fb,
1811 static unsigned int intel_mac_v3_pin_configs[10] = {
1812 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1813 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1814 0x400000fc, 0x400000fb,
1817 static unsigned int intel_mac_v4_pin_configs[10] = {
1818 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1819 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1820 0x400000fc, 0x400000fb,
1823 static unsigned int intel_mac_v5_pin_configs[10] = {
1824 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1825 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1826 0x400000fc, 0x400000fb,
1829 static unsigned int ecs202_pin_configs[10] = {
1830 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1831 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1832 0x9037012e, 0x40e000f2,
1835 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1836 [STAC_D945_REF] = ref922x_pin_configs,
1837 [STAC_D945GTP3] = d945gtp3_pin_configs,
1838 [STAC_D945GTP5] = d945gtp5_pin_configs,
1839 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1840 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1841 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1842 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1843 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1844 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1845 /* for backward compatibility */
1846 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1847 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1848 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1849 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1850 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1851 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1852 [STAC_ECS_202] = ecs202_pin_configs,
1853 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1854 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1855 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1856 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1859 static const char *stac922x_models[STAC_922X_MODELS] = {
1860 [STAC_D945_REF] = "ref",
1861 [STAC_D945GTP5] = "5stack",
1862 [STAC_D945GTP3] = "3stack",
1863 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1864 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1865 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1866 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1867 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1868 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1869 /* for backward compatibility */
1870 [STAC_MACMINI] = "macmini",
1871 [STAC_MACBOOK] = "macbook",
1872 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1873 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1874 [STAC_IMAC_INTEL] = "imac-intel",
1875 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1876 [STAC_ECS_202] = "ecs202",
1877 [STAC_922X_DELL_D81] = "dell-d81",
1878 [STAC_922X_DELL_D82] = "dell-d82",
1879 [STAC_922X_DELL_M81] = "dell-m81",
1880 [STAC_922X_DELL_M82] = "dell-m82",
1883 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1884 /* SigmaTel reference board */
1885 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1886 "DFI LanParty", STAC_D945_REF),
1887 /* Intel 945G based systems */
1888 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1889 "Intel D945G", STAC_D945GTP3),
1890 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1891 "Intel D945G", STAC_D945GTP3),
1892 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1893 "Intel D945G", STAC_D945GTP3),
1894 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1895 "Intel D945G", STAC_D945GTP3),
1896 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1897 "Intel D945G", STAC_D945GTP3),
1898 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1899 "Intel D945G", STAC_D945GTP3),
1900 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1901 "Intel D945G", STAC_D945GTP3),
1902 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1903 "Intel D945G", STAC_D945GTP3),
1904 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1905 "Intel D945G", STAC_D945GTP3),
1906 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1907 "Intel D945G", STAC_D945GTP3),
1908 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1909 "Intel D945G", STAC_D945GTP3),
1910 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1911 "Intel D945G", STAC_D945GTP3),
1912 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1913 "Intel D945G", STAC_D945GTP3),
1914 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1915 "Intel D945G", STAC_D945GTP3),
1916 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1917 "Intel D945G", STAC_D945GTP3),
1918 /* Intel D945G 5-stack systems */
1919 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1920 "Intel D945G", STAC_D945GTP5),
1921 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1922 "Intel D945G", STAC_D945GTP5),
1923 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1924 "Intel D945G", STAC_D945GTP5),
1925 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1926 "Intel D945G", STAC_D945GTP5),
1927 /* Intel 945P based systems */
1928 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1929 "Intel D945P", STAC_D945GTP3),
1930 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1931 "Intel D945P", STAC_D945GTP3),
1932 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1933 "Intel D945P", STAC_D945GTP3),
1934 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1935 "Intel D945P", STAC_D945GTP3),
1936 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1937 "Intel D945P", STAC_D945GTP3),
1938 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1939 "Intel D945P", STAC_D945GTP5),
1941 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
1942 SND_PCI_QUIRK(0x8384, 0x7680,
1943 "Mac", STAC_INTEL_MAC_AUTO),
1945 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1946 "unknown Dell", STAC_922X_DELL_D81),
1947 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1948 "unknown Dell", STAC_922X_DELL_D81),
1949 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1950 "unknown Dell", STAC_922X_DELL_D81),
1951 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1952 "unknown Dell", STAC_922X_DELL_D82),
1953 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1954 "unknown Dell", STAC_922X_DELL_M81),
1955 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1956 "unknown Dell", STAC_922X_DELL_D82),
1957 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1958 "unknown Dell", STAC_922X_DELL_D81),
1959 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1960 "unknown Dell", STAC_922X_DELL_D81),
1961 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1962 "Dell XPS M1210", STAC_922X_DELL_M82),
1963 /* ECS/PC Chips boards */
1964 SND_PCI_QUIRK(0x1019, 0x2144,
1965 "ECS/PC chips", STAC_ECS_202),
1966 SND_PCI_QUIRK(0x1019, 0x2608,
1967 "ECS/PC chips", STAC_ECS_202),
1968 SND_PCI_QUIRK(0x1019, 0x2633,
1969 "ECS/PC chips P17G/1333", STAC_ECS_202),
1970 SND_PCI_QUIRK(0x1019, 0x2811,
1971 "ECS/PC chips", STAC_ECS_202),
1972 SND_PCI_QUIRK(0x1019, 0x2812,
1973 "ECS/PC chips", STAC_ECS_202),
1974 SND_PCI_QUIRK(0x1019, 0x2813,
1975 "ECS/PC chips", STAC_ECS_202),
1976 SND_PCI_QUIRK(0x1019, 0x2814,
1977 "ECS/PC chips", STAC_ECS_202),
1978 SND_PCI_QUIRK(0x1019, 0x2815,
1979 "ECS/PC chips", STAC_ECS_202),
1980 SND_PCI_QUIRK(0x1019, 0x2816,
1981 "ECS/PC chips", STAC_ECS_202),
1982 SND_PCI_QUIRK(0x1019, 0x2817,
1983 "ECS/PC chips", STAC_ECS_202),
1984 SND_PCI_QUIRK(0x1019, 0x2818,
1985 "ECS/PC chips", STAC_ECS_202),
1986 SND_PCI_QUIRK(0x1019, 0x2819,
1987 "ECS/PC chips", STAC_ECS_202),
1988 SND_PCI_QUIRK(0x1019, 0x2820,
1989 "ECS/PC chips", STAC_ECS_202),
1993 static unsigned int ref927x_pin_configs[14] = {
1994 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1995 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1996 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1997 0x01c42190, 0x40000100,
2000 static unsigned int d965_3st_pin_configs[14] = {
2001 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2002 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2003 0x40000100, 0x40000100, 0x40000100, 0x40000100,
2004 0x40000100, 0x40000100
2007 static unsigned int d965_5st_pin_configs[14] = {
2008 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2009 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2010 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2011 0x40000100, 0x40000100
2014 static unsigned int dell_3st_pin_configs[14] = {
2015 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2016 0x01111212, 0x01116211, 0x01813050, 0x01112214,
2017 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2018 0x40c003fc, 0x40000100
2021 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2022 [STAC_D965_REF] = ref927x_pin_configs,
2023 [STAC_D965_3ST] = d965_3st_pin_configs,
2024 [STAC_D965_5ST] = d965_5st_pin_configs,
2025 [STAC_DELL_3ST] = dell_3st_pin_configs,
2026 [STAC_DELL_BIOS] = NULL,
2029 static const char *stac927x_models[STAC_927X_MODELS] = {
2030 [STAC_D965_REF] = "ref",
2031 [STAC_D965_3ST] = "3stack",
2032 [STAC_D965_5ST] = "5stack",
2033 [STAC_DELL_3ST] = "dell-3stack",
2034 [STAC_DELL_BIOS] = "dell-bios",
2037 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2038 /* SigmaTel reference board */
2039 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2040 "DFI LanParty", STAC_D965_REF),
2041 /* Intel 946 based systems */
2042 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2043 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2044 /* 965 based 3 stack systems */
2045 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
2046 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
2047 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
2048 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
2049 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
2050 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
2051 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
2052 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
2053 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
2054 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
2055 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
2056 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
2057 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
2058 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
2059 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
2060 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
2061 /* Dell 3 stack systems */
2062 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
2063 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2064 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
2065 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
2066 /* Dell 3 stack systems with verb table in BIOS */
2067 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2068 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
2069 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
2070 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_3ST),
2071 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
2072 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
2073 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
2074 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2075 /* 965 based 5 stack systems */
2076 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
2077 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
2078 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
2079 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
2080 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
2081 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
2082 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
2083 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
2084 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
2088 static unsigned int ref9205_pin_configs[12] = {
2089 0x40000100, 0x40000100, 0x01016011, 0x01014010,
2090 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2091 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2095 STAC 9205 pin configs for
2102 10280228 (Dell Vostro 1500)
2104 static unsigned int dell_9205_m42_pin_configs[12] = {
2105 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2106 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2107 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2111 STAC 9205 pin configs for
2115 102801FF (Dell Precision M4300)
2120 static unsigned int dell_9205_m43_pin_configs[12] = {
2121 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2122 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2123 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2126 static unsigned int dell_9205_m44_pin_configs[12] = {
2127 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2128 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2129 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2132 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2133 [STAC_9205_REF] = ref9205_pin_configs,
2134 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2135 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2136 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2139 static const char *stac9205_models[STAC_9205_MODELS] = {
2140 [STAC_9205_REF] = "ref",
2141 [STAC_9205_DELL_M42] = "dell-m42",
2142 [STAC_9205_DELL_M43] = "dell-m43",
2143 [STAC_9205_DELL_M44] = "dell-m44",
2146 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
2147 /* SigmaTel reference board */
2148 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2149 "DFI LanParty", STAC_9205_REF),
2150 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2151 "unknown Dell", STAC_9205_DELL_M42),
2152 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2153 "unknown Dell", STAC_9205_DELL_M42),
2154 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2155 "Dell Precision", STAC_9205_DELL_M43),
2156 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2157 "Dell Precision", STAC_9205_DELL_M43),
2158 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2159 "Dell Precision", STAC_9205_DELL_M43),
2160 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2161 "unknown Dell", STAC_9205_DELL_M42),
2162 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2163 "unknown Dell", STAC_9205_DELL_M42),
2164 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2165 "Dell Precision", STAC_9205_DELL_M43),
2166 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2167 "Dell Precision M4300", STAC_9205_DELL_M43),
2168 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2169 "unknown Dell", STAC_9205_DELL_M42),
2170 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2171 "Dell Precision", STAC_9205_DELL_M43),
2172 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2173 "Dell Precision", STAC_9205_DELL_M43),
2174 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2175 "Dell Precision", STAC_9205_DELL_M43),
2176 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2177 "Dell Inspiron", STAC_9205_DELL_M44),
2178 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2179 "Dell Vostro 1500", STAC_9205_DELL_M42),
2183 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
2186 struct sigmatel_spec *spec = codec->spec;
2188 if (! spec->bios_pin_configs) {
2189 spec->bios_pin_configs = kcalloc(spec->num_pins,
2190 sizeof(*spec->bios_pin_configs), GFP_KERNEL);
2191 if (! spec->bios_pin_configs)
2195 for (i = 0; i < spec->num_pins; i++) {
2196 hda_nid_t nid = spec->pin_nids[i];
2197 unsigned int pin_cfg;
2199 pin_cfg = snd_hda_codec_read(codec, nid, 0,
2200 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
2201 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
2203 spec->bios_pin_configs[i] = pin_cfg;
2209 static void stac92xx_set_config_reg(struct hda_codec *codec,
2210 hda_nid_t pin_nid, unsigned int pin_config)
2213 snd_hda_codec_write(codec, pin_nid, 0,
2214 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
2215 pin_config & 0x000000ff);
2216 snd_hda_codec_write(codec, pin_nid, 0,
2217 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
2218 (pin_config & 0x0000ff00) >> 8);
2219 snd_hda_codec_write(codec, pin_nid, 0,
2220 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
2221 (pin_config & 0x00ff0000) >> 16);
2222 snd_hda_codec_write(codec, pin_nid, 0,
2223 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
2225 i = snd_hda_codec_read(codec, pin_nid, 0,
2226 AC_VERB_GET_CONFIG_DEFAULT,
2228 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
2232 static void stac92xx_set_config_regs(struct hda_codec *codec)
2235 struct sigmatel_spec *spec = codec->spec;
2237 if (!spec->pin_configs)
2240 for (i = 0; i < spec->num_pins; i++)
2241 stac92xx_set_config_reg(codec, spec->pin_nids[i],
2242 spec->pin_configs[i]);
2246 * Analog playback callbacks
2248 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2249 struct hda_codec *codec,
2250 struct snd_pcm_substream *substream)
2252 struct sigmatel_spec *spec = codec->spec;
2253 if (spec->stream_delay)
2254 msleep(spec->stream_delay);
2255 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2259 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2260 struct hda_codec *codec,
2261 unsigned int stream_tag,
2262 unsigned int format,
2263 struct snd_pcm_substream *substream)
2265 struct sigmatel_spec *spec = codec->spec;
2266 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2269 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2270 struct hda_codec *codec,
2271 struct snd_pcm_substream *substream)
2273 struct sigmatel_spec *spec = codec->spec;
2274 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2278 * Digital playback callbacks
2280 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2281 struct hda_codec *codec,
2282 struct snd_pcm_substream *substream)
2284 struct sigmatel_spec *spec = codec->spec;
2285 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2288 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2289 struct hda_codec *codec,
2290 struct snd_pcm_substream *substream)
2292 struct sigmatel_spec *spec = codec->spec;
2293 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2296 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2297 struct hda_codec *codec,
2298 unsigned int stream_tag,
2299 unsigned int format,
2300 struct snd_pcm_substream *substream)
2302 struct sigmatel_spec *spec = codec->spec;
2303 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2304 stream_tag, format, substream);
2309 * Analog capture callbacks
2311 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2312 struct hda_codec *codec,
2313 unsigned int stream_tag,
2314 unsigned int format,
2315 struct snd_pcm_substream *substream)
2317 struct sigmatel_spec *spec = codec->spec;
2318 hda_nid_t nid = spec->adc_nids[substream->number];
2320 if (spec->powerdown_adcs) {
2322 snd_hda_codec_write_cache(codec, nid, 0,
2323 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2325 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2329 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2330 struct hda_codec *codec,
2331 struct snd_pcm_substream *substream)
2333 struct sigmatel_spec *spec = codec->spec;
2334 hda_nid_t nid = spec->adc_nids[substream->number];
2336 snd_hda_codec_cleanup_stream(codec, nid);
2337 if (spec->powerdown_adcs)
2338 snd_hda_codec_write_cache(codec, nid, 0,
2339 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2343 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2347 /* NID is set in stac92xx_build_pcms */
2349 .open = stac92xx_dig_playback_pcm_open,
2350 .close = stac92xx_dig_playback_pcm_close,
2351 .prepare = stac92xx_dig_playback_pcm_prepare
2355 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2359 /* NID is set in stac92xx_build_pcms */
2362 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2366 .nid = 0x02, /* NID to query formats and rates */
2368 .open = stac92xx_playback_pcm_open,
2369 .prepare = stac92xx_playback_pcm_prepare,
2370 .cleanup = stac92xx_playback_pcm_cleanup
2374 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2378 .nid = 0x06, /* NID to query formats and rates */
2380 .open = stac92xx_playback_pcm_open,
2381 .prepare = stac92xx_playback_pcm_prepare,
2382 .cleanup = stac92xx_playback_pcm_cleanup
2386 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2389 /* NID + .substreams is set in stac92xx_build_pcms */
2391 .prepare = stac92xx_capture_pcm_prepare,
2392 .cleanup = stac92xx_capture_pcm_cleanup
2396 static int stac92xx_build_pcms(struct hda_codec *codec)
2398 struct sigmatel_spec *spec = codec->spec;
2399 struct hda_pcm *info = spec->pcm_rec;
2401 codec->num_pcms = 1;
2402 codec->pcm_info = info;
2404 info->name = "STAC92xx Analog";
2405 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2406 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2407 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2408 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2410 if (spec->alt_switch) {
2413 info->name = "STAC92xx Analog Alt";
2414 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2417 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2420 info->name = "STAC92xx Digital";
2421 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2422 if (spec->multiout.dig_out_nid) {
2423 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2424 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2426 if (spec->dig_in_nid) {
2427 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2428 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2435 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
2437 unsigned int pincap = snd_hda_param_read(codec, nid,
2439 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2440 if (pincap & AC_PINCAP_VREF_100)
2441 return AC_PINCTL_VREF_100;
2442 if (pincap & AC_PINCAP_VREF_80)
2443 return AC_PINCTL_VREF_80;
2444 if (pincap & AC_PINCAP_VREF_50)
2445 return AC_PINCTL_VREF_50;
2446 if (pincap & AC_PINCAP_VREF_GRD)
2447 return AC_PINCTL_VREF_GRD;
2451 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2454 snd_hda_codec_write_cache(codec, nid, 0,
2455 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2458 #define stac92xx_hp_switch_info snd_ctl_boolean_mono_info
2460 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2461 struct snd_ctl_elem_value *ucontrol)
2463 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2464 struct sigmatel_spec *spec = codec->spec;
2466 ucontrol->value.integer.value[0] = !!spec->hp_switch;
2470 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2471 struct snd_ctl_elem_value *ucontrol)
2473 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2474 struct sigmatel_spec *spec = codec->spec;
2475 int nid = kcontrol->private_value;
2477 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2479 /* check to be sure that the ports are upto date with
2482 codec->patch_ops.unsol_event(codec, (STAC_HP_EVENT | nid) << 26);
2487 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
2489 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2491 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2492 struct sigmatel_spec *spec = codec->spec;
2493 int io_idx = kcontrol-> private_value & 0xff;
2495 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
2499 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2501 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2502 struct sigmatel_spec *spec = codec->spec;
2503 hda_nid_t nid = kcontrol->private_value >> 8;
2504 int io_idx = kcontrol-> private_value & 0xff;
2505 unsigned short val = !!ucontrol->value.integer.value[0];
2507 spec->io_switch[io_idx] = val;
2510 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2512 unsigned int pinctl = AC_PINCTL_IN_EN;
2513 if (io_idx) /* set VREF for mic */
2514 pinctl |= stac92xx_get_vref(codec, nid);
2515 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2518 /* check the auto-mute again: we need to mute/unmute the speaker
2519 * appropriately according to the pin direction
2521 if (spec->hp_detect)
2522 codec->patch_ops.unsol_event(codec,
2523 (STAC_HP_EVENT | nid) << 26);
2528 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2530 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2531 struct snd_ctl_elem_value *ucontrol)
2533 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2534 struct sigmatel_spec *spec = codec->spec;
2536 ucontrol->value.integer.value[0] = spec->clfe_swap;
2540 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2541 struct snd_ctl_elem_value *ucontrol)
2543 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2544 struct sigmatel_spec *spec = codec->spec;
2545 hda_nid_t nid = kcontrol->private_value & 0xff;
2546 unsigned int val = !!ucontrol->value.integer.value[0];
2548 if (spec->clfe_swap == val)
2551 spec->clfe_swap = val;
2553 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2554 spec->clfe_swap ? 0x4 : 0x0);
2559 #define STAC_CODEC_HP_SWITCH(xname) \
2560 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2563 .info = stac92xx_hp_switch_info, \
2564 .get = stac92xx_hp_switch_get, \
2565 .put = stac92xx_hp_switch_put, \
2568 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2569 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2572 .info = stac92xx_io_switch_info, \
2573 .get = stac92xx_io_switch_get, \
2574 .put = stac92xx_io_switch_put, \
2575 .private_value = xpval, \
2578 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2579 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2582 .info = stac92xx_clfe_switch_info, \
2583 .get = stac92xx_clfe_switch_get, \
2584 .put = stac92xx_clfe_switch_put, \
2585 .private_value = xpval, \
2589 STAC_CTL_WIDGET_VOL,
2590 STAC_CTL_WIDGET_MUTE,
2591 STAC_CTL_WIDGET_MONO_MUX,
2592 STAC_CTL_WIDGET_AMP_MUX,
2593 STAC_CTL_WIDGET_AMP_VOL,
2594 STAC_CTL_WIDGET_HP_SWITCH,
2595 STAC_CTL_WIDGET_IO_SWITCH,
2596 STAC_CTL_WIDGET_CLFE_SWITCH
2599 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2600 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2601 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2604 STAC_AMP_VOL(NULL, 0, 0, 0, 0),
2605 STAC_CODEC_HP_SWITCH(NULL),
2606 STAC_CODEC_IO_SWITCH(NULL, 0),
2607 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2610 /* add dynamic controls */
2611 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2612 struct snd_kcontrol_new *ktemp,
2613 int idx, const char *name,
2616 struct snd_kcontrol_new *knew;
2618 snd_array_init(&spec->kctls, sizeof(*knew), 32);
2619 knew = snd_array_new(&spec->kctls);
2624 knew->name = kstrdup(name, GFP_KERNEL);
2627 knew->private_value = val;
2631 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2632 int type, int idx, const char *name,
2635 return stac92xx_add_control_temp(spec,
2636 &stac92xx_control_templates[type],
2641 /* add dynamic controls */
2642 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2643 const char *name, unsigned long val)
2645 return stac92xx_add_control_idx(spec, type, 0, name, val);
2648 /* flag inputs as additional dynamic lineouts */
2649 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
2651 struct sigmatel_spec *spec = codec->spec;
2652 unsigned int wcaps, wtype;
2653 int i, num_dacs = 0;
2655 /* use the wcaps cache to count all DACs available for line-outs */
2656 for (i = 0; i < codec->num_nodes; i++) {
2657 wcaps = codec->wcaps[i];
2658 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2660 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
2664 snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
2666 switch (cfg->line_outs) {
2668 /* add line-in as side */
2669 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
2670 cfg->line_out_pins[cfg->line_outs] =
2671 cfg->input_pins[AUTO_PIN_LINE];
2672 spec->line_switch = 1;
2677 /* add line-in as clfe and mic as side */
2678 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
2679 cfg->line_out_pins[cfg->line_outs] =
2680 cfg->input_pins[AUTO_PIN_LINE];
2681 spec->line_switch = 1;
2684 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
2685 cfg->line_out_pins[cfg->line_outs] =
2686 cfg->input_pins[AUTO_PIN_MIC];
2687 spec->mic_switch = 1;
2692 /* add line-in as surr and mic as clfe */
2693 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
2694 cfg->line_out_pins[cfg->line_outs] =
2695 cfg->input_pins[AUTO_PIN_LINE];
2696 spec->line_switch = 1;
2699 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
2700 cfg->line_out_pins[cfg->line_outs] =
2701 cfg->input_pins[AUTO_PIN_MIC];
2702 spec->mic_switch = 1;
2712 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2716 for (i = 0; i < spec->multiout.num_dacs; i++) {
2717 if (spec->multiout.dac_nids[i] == nid)
2725 * Fill in the dac_nids table from the parsed pin configuration
2726 * This function only works when every pin in line_out_pins[]
2727 * contains atleast one DAC in its connection list. Some 92xx
2728 * codecs are not connected directly to a DAC, such as the 9200
2729 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2731 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
2732 struct auto_pin_cfg *cfg)
2734 struct sigmatel_spec *spec = codec->spec;
2735 int i, j, conn_len = 0;
2736 hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
2737 unsigned int wcaps, wtype;
2739 for (i = 0; i < cfg->line_outs; i++) {
2740 nid = cfg->line_out_pins[i];
2741 conn_len = snd_hda_get_connections(codec, nid, conn,
2742 HDA_MAX_CONNECTIONS);
2743 for (j = 0; j < conn_len; j++) {
2744 wcaps = snd_hda_param_read(codec, conn[j],
2745 AC_PAR_AUDIO_WIDGET_CAP);
2746 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2747 if (wtype != AC_WID_AUD_OUT ||
2748 (wcaps & AC_WCAP_DIGITAL))
2750 /* conn[j] is a DAC routed to this line-out */
2751 if (!is_in_dac_nids(spec, conn[j]))
2755 if (j == conn_len) {
2756 if (spec->multiout.num_dacs > 0) {
2757 /* we have already working output pins,
2758 * so let's drop the broken ones again
2760 cfg->line_outs = spec->multiout.num_dacs;
2763 /* error out, no available DAC found */
2765 "%s: No available DAC for pin 0x%x\n",
2770 spec->multiout.dac_nids[i] = conn[j];
2771 spec->multiout.num_dacs++;
2773 /* select this DAC in the pin's input mux */
2774 snd_hda_codec_write_cache(codec, nid, 0,
2775 AC_VERB_SET_CONNECT_SEL, j);
2780 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2781 spec->multiout.num_dacs,
2782 spec->multiout.dac_nids[0],
2783 spec->multiout.dac_nids[1],
2784 spec->multiout.dac_nids[2],
2785 spec->multiout.dac_nids[3],
2786 spec->multiout.dac_nids[4]);
2790 /* create volume control/switch for the given prefx type */
2791 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
2796 sprintf(name, "%s Playback Volume", pfx);
2797 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
2798 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2801 sprintf(name, "%s Playback Switch", pfx);
2802 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
2803 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2809 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
2811 if (!spec->multiout.hp_nid)
2812 spec->multiout.hp_nid = nid;
2813 else if (spec->multiout.num_dacs > 4) {
2814 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
2817 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
2818 spec->multiout.num_dacs++;
2823 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2825 if (is_in_dac_nids(spec, nid))
2827 if (spec->multiout.hp_nid == nid)
2832 /* add playback controls from the parsed DAC table */
2833 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
2834 const struct auto_pin_cfg *cfg)
2836 static const char *chname[4] = {
2837 "Front", "Surround", NULL /*CLFE*/, "Side"
2842 struct sigmatel_spec *spec = codec->spec;
2843 unsigned int wid_caps, pincap;
2846 for (i = 0; i < cfg->line_outs && i < spec->multiout.num_dacs; i++) {
2847 if (!spec->multiout.dac_nids[i])
2850 nid = spec->multiout.dac_nids[i];
2854 err = create_controls(spec, "Center", nid, 1);
2857 err = create_controls(spec, "LFE", nid, 2);
2861 wid_caps = get_wcaps(codec, nid);
2863 if (wid_caps & AC_WCAP_LR_SWAP) {
2864 err = stac92xx_add_control(spec,
2865 STAC_CTL_WIDGET_CLFE_SWITCH,
2866 "Swap Center/LFE Playback Switch", nid);
2873 err = create_controls(spec, chname[i], nid, 3);
2879 if ((spec->multiout.num_dacs - cfg->line_outs) > 0 &&
2880 cfg->hp_outs && !spec->multiout.hp_nid)
2881 spec->multiout.hp_nid = nid;
2883 if (cfg->hp_outs > 1) {
2884 err = stac92xx_add_control(spec,
2885 STAC_CTL_WIDGET_HP_SWITCH,
2886 "Headphone as Line Out Switch",
2887 cfg->hp_pins[cfg->hp_outs - 1]);
2892 if (spec->line_switch) {
2893 nid = cfg->input_pins[AUTO_PIN_LINE];
2894 pincap = snd_hda_param_read(codec, nid,
2896 if (pincap & AC_PINCAP_OUT) {
2897 err = stac92xx_add_control(spec,
2898 STAC_CTL_WIDGET_IO_SWITCH,
2899 "Line In as Output Switch", nid << 8);
2905 if (spec->mic_switch) {
2906 unsigned int def_conf;
2907 unsigned int mic_pin = AUTO_PIN_MIC;
2909 nid = cfg->input_pins[mic_pin];
2910 def_conf = snd_hda_codec_read(codec, nid, 0,
2911 AC_VERB_GET_CONFIG_DEFAULT, 0);
2912 /* some laptops have an internal analog microphone
2913 * which can't be used as a output */
2914 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2915 pincap = snd_hda_param_read(codec, nid,
2917 if (pincap & AC_PINCAP_OUT) {
2918 err = stac92xx_add_control(spec,
2919 STAC_CTL_WIDGET_IO_SWITCH,
2920 "Mic as Output Switch", (nid << 8) | 1);
2921 nid = snd_hda_codec_read(codec, nid, 0,
2922 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2923 if (!check_in_dac_nids(spec, nid))
2924 add_spec_dacs(spec, nid);
2928 } else if (mic_pin == AUTO_PIN_MIC) {
2929 mic_pin = AUTO_PIN_FRONT_MIC;
2937 /* add playback controls for Speaker and HP outputs */
2938 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
2939 struct auto_pin_cfg *cfg)
2941 struct sigmatel_spec *spec = codec->spec;
2943 int i, old_num_dacs, err;
2945 old_num_dacs = spec->multiout.num_dacs;
2946 for (i = 0; i < cfg->hp_outs; i++) {
2947 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
2948 if (wid_caps & AC_WCAP_UNSOL_CAP)
2949 spec->hp_detect = 1;
2950 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
2951 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2952 if (check_in_dac_nids(spec, nid))
2956 add_spec_dacs(spec, nid);
2958 for (i = 0; i < cfg->speaker_outs; i++) {
2959 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
2960 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2961 if (check_in_dac_nids(spec, nid))
2965 add_spec_dacs(spec, nid);
2967 for (i = 0; i < cfg->line_outs; i++) {
2968 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
2969 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2970 if (check_in_dac_nids(spec, nid))
2974 add_spec_dacs(spec, nid);
2976 for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
2977 static const char *pfxs[] = {
2978 "Speaker", "External Speaker", "Speaker2",
2980 err = create_controls(spec, pfxs[i - old_num_dacs],
2981 spec->multiout.dac_nids[i], 3);
2985 if (spec->multiout.hp_nid) {
2986 err = create_controls(spec, "Headphone",
2987 spec->multiout.hp_nid, 3);
2995 /* labels for mono mux outputs */
2996 static const char *stac92xx_mono_labels[4] = {
2997 "DAC0", "DAC1", "Mixer", "DAC2"
3000 /* create mono mux for mono out on capable codecs */
3001 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3003 struct sigmatel_spec *spec = codec->spec;
3004 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3006 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3008 num_cons = snd_hda_get_connections(codec,
3011 HDA_MAX_NUM_INPUTS);
3012 if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3015 for (i = 0; i < num_cons; i++) {
3016 mono_mux->items[mono_mux->num_items].label =
3017 stac92xx_mono_labels[i];
3018 mono_mux->items[mono_mux->num_items].index = i;
3019 mono_mux->num_items++;
3022 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3023 "Mono Mux", spec->mono_nid);
3026 /* labels for amp mux outputs */
3027 static const char *stac92xx_amp_labels[3] = {
3028 "Front Microphone", "Microphone", "Line In",
3031 /* create amp out controls mux on capable codecs */
3032 static int stac92xx_auto_create_amp_output_ctls(struct hda_codec *codec)
3034 struct sigmatel_spec *spec = codec->spec;
3035 struct hda_input_mux *amp_mux = &spec->private_amp_mux;
3038 for (i = 0; i < spec->num_amps; i++) {
3039 amp_mux->items[amp_mux->num_items].label =
3040 stac92xx_amp_labels[i];
3041 amp_mux->items[amp_mux->num_items].index = i;
3042 amp_mux->num_items++;
3045 if (spec->num_amps > 1) {
3046 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_MUX,
3047 "Amp Selector Capture Switch", 0);
3051 return stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_VOL,
3052 "Amp Capture Volume",
3053 HDA_COMPOSE_AMP_VAL(spec->amp_nids[0], 3, 0, HDA_INPUT));
3057 /* create PC beep volume controls */
3058 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3061 struct sigmatel_spec *spec = codec->spec;
3062 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3065 /* check for mute support for the the amp */
3066 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3067 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3068 "PC Beep Playback Switch",
3069 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3074 /* check to see if there is volume support for the amp */
3075 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3076 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3077 "PC Beep Playback Volume",
3078 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3085 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3086 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3088 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3089 struct snd_ctl_elem_value *ucontrol)
3091 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3092 ucontrol->value.integer.value[0] = codec->beep->enabled;
3096 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3097 struct snd_ctl_elem_value *ucontrol)
3099 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3100 int enabled = !!ucontrol->value.integer.value[0];
3101 if (codec->beep->enabled != enabled) {
3102 codec->beep->enabled = enabled;
3108 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3109 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3110 .info = stac92xx_dig_beep_switch_info,
3111 .get = stac92xx_dig_beep_switch_get,
3112 .put = stac92xx_dig_beep_switch_put,
3115 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3117 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3118 0, "PC Beep Playback Switch", 0);
3122 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3124 struct sigmatel_spec *spec = codec->spec;
3125 int wcaps, nid, i, err = 0;
3127 for (i = 0; i < spec->num_muxes; i++) {
3128 nid = spec->mux_nids[i];
3129 wcaps = get_wcaps(codec, nid);
3131 if (wcaps & AC_WCAP_OUT_AMP) {
3132 err = stac92xx_add_control_idx(spec,
3133 STAC_CTL_WIDGET_VOL, i, "Mux Capture Volume",
3134 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3142 static const char *stac92xx_spdif_labels[3] = {
3143 "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3146 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3148 struct sigmatel_spec *spec = codec->spec;
3149 struct hda_input_mux *spdif_mux = &spec->private_smux;
3150 const char **labels = spec->spdif_labels;
3152 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3154 num_cons = snd_hda_get_connections(codec,
3157 HDA_MAX_NUM_INPUTS);
3162 labels = stac92xx_spdif_labels;
3164 for (i = 0; i < num_cons; i++) {
3165 spdif_mux->items[spdif_mux->num_items].label = labels[i];
3166 spdif_mux->items[spdif_mux->num_items].index = i;
3167 spdif_mux->num_items++;
3173 /* labels for dmic mux inputs */
3174 static const char *stac92xx_dmic_labels[5] = {
3175 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3176 "Digital Mic 3", "Digital Mic 4"
3179 /* create playback/capture controls for input pins on dmic capable codecs */
3180 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3181 const struct auto_pin_cfg *cfg)
3183 struct sigmatel_spec *spec = codec->spec;
3184 struct hda_input_mux *dimux = &spec->private_dimux;
3185 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3189 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
3190 dimux->items[dimux->num_items].index = 0;
3193 for (i = 0; i < spec->num_dmics; i++) {
3198 unsigned int def_conf;
3200 def_conf = snd_hda_codec_read(codec,
3203 AC_VERB_GET_CONFIG_DEFAULT,
3205 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3208 nid = spec->dmic_nids[i];
3209 num_cons = snd_hda_get_connections(codec,
3212 HDA_MAX_NUM_INPUTS);
3213 for (j = 0; j < num_cons; j++)
3214 if (con_lst[j] == nid) {
3220 wcaps = get_wcaps(codec, nid) &
3221 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3224 sprintf(name, "%s Capture Volume",
3225 stac92xx_dmic_labels[dimux->num_items]);
3227 err = stac92xx_add_control(spec,
3228 STAC_CTL_WIDGET_VOL,
3230 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3231 (wcaps & AC_WCAP_OUT_AMP) ?
3232 HDA_OUTPUT : HDA_INPUT));
3237 dimux->items[dimux->num_items].label =
3238 stac92xx_dmic_labels[dimux->num_items];
3239 dimux->items[dimux->num_items].index = index;
3246 /* create playback/capture controls for input pins */
3247 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3249 struct sigmatel_spec *spec = codec->spec;
3250 struct hda_input_mux *imux = &spec->private_imux;
3251 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3254 for (i = 0; i < AUTO_PIN_LAST; i++) {
3257 if (!cfg->input_pins[i])
3260 for (j = 0; j < spec->num_muxes; j++) {
3262 num_cons = snd_hda_get_connections(codec,
3265 HDA_MAX_NUM_INPUTS);
3266 for (k = 0; k < num_cons; k++)
3267 if (con_lst[k] == cfg->input_pins[i]) {
3274 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3275 imux->items[imux->num_items].index = index;
3279 if (imux->num_items) {
3281 * Set the current input for the muxes.
3282 * The STAC9221 has two input muxes with identical source
3283 * NID lists. Hopefully this won't get confused.
3285 for (i = 0; i < spec->num_muxes; i++) {
3286 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3287 AC_VERB_SET_CONNECT_SEL,
3288 imux->items[0].index);
3295 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3297 struct sigmatel_spec *spec = codec->spec;
3300 for (i = 0; i < spec->autocfg.line_outs; i++) {
3301 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3302 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3306 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3308 struct sigmatel_spec *spec = codec->spec;
3311 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3313 pin = spec->autocfg.hp_pins[i];
3314 if (pin) /* connect to front */
3315 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3317 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3319 pin = spec->autocfg.speaker_pins[i];
3320 if (pin) /* connect to front */
3321 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3325 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3327 struct sigmatel_spec *spec = codec->spec;
3329 int hp_speaker_swap = 0;
3331 if ((err = snd_hda_parse_pin_def_config(codec,
3333 spec->dmic_nids)) < 0)
3335 if (! spec->autocfg.line_outs)
3336 return 0; /* can't find valid pin config */
3338 /* If we have no real line-out pin and multiple hp-outs, HPs should
3339 * be set up as multi-channel outputs.
3341 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
3342 spec->autocfg.hp_outs > 1) {
3343 /* Copy hp_outs to line_outs, backup line_outs in
3344 * speaker_outs so that the following routines can handle
3345 * HP pins as primary outputs.
3347 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3348 sizeof(spec->autocfg.line_out_pins));
3349 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3350 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3351 sizeof(spec->autocfg.hp_pins));
3352 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3353 hp_speaker_swap = 1;
3355 if (spec->autocfg.mono_out_pin) {
3356 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3357 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3358 u32 caps = query_amp_caps(codec,
3359 spec->autocfg.mono_out_pin, dir);
3360 hda_nid_t conn_list[1];
3362 /* get the mixer node and then the mono mux if it exists */
3363 if (snd_hda_get_connections(codec,
3364 spec->autocfg.mono_out_pin, conn_list, 1) &&
3365 snd_hda_get_connections(codec, conn_list[0],
3368 int wcaps = get_wcaps(codec, conn_list[0]);
3369 int wid_type = (wcaps & AC_WCAP_TYPE)
3370 >> AC_WCAP_TYPE_SHIFT;
3371 /* LR swap check, some stac925x have a mux that
3372 * changes the DACs output path instead of the
3375 if (wid_type == AC_WID_AUD_SEL &&
3376 !(wcaps & AC_WCAP_LR_SWAP))
3377 spec->mono_nid = conn_list[0];
3380 hda_nid_t nid = spec->autocfg.mono_out_pin;
3382 /* most mono outs have a least a mute/unmute switch */
3383 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3384 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3385 "Mono Playback Switch",
3386 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3389 /* check for volume support for the amp */
3390 if ((caps & AC_AMPCAP_NUM_STEPS)
3391 >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3392 err = stac92xx_add_control(spec,
3393 STAC_CTL_WIDGET_VOL,
3394 "Mono Playback Volume",
3395 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3401 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3405 if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
3407 if (spec->multiout.num_dacs == 0)
3408 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
3411 err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
3416 /* setup analog beep controls */
3417 if (spec->anabeep_nid > 0) {
3418 err = stac92xx_auto_create_beep_ctls(codec,
3424 /* setup digital beep controls and input device */
3425 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3426 if (spec->digbeep_nid > 0) {
3427 hda_nid_t nid = spec->digbeep_nid;
3430 err = stac92xx_auto_create_beep_ctls(codec, nid);
3433 err = snd_hda_attach_beep_device(codec, nid);
3436 /* if no beep switch is available, make its own one */
3437 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3439 !((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT)) {
3440 err = stac92xx_beep_switch_ctl(codec);
3447 if (hp_speaker_swap == 1) {
3448 /* Restore the hp_outs and line_outs */
3449 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3450 sizeof(spec->autocfg.line_out_pins));
3451 spec->autocfg.hp_outs = spec->autocfg.line_outs;
3452 memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins,
3453 sizeof(spec->autocfg.speaker_pins));
3454 spec->autocfg.line_outs = spec->autocfg.speaker_outs;
3455 memset(spec->autocfg.speaker_pins, 0,
3456 sizeof(spec->autocfg.speaker_pins));
3457 spec->autocfg.speaker_outs = 0;
3460 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3465 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3470 if (spec->mono_nid > 0) {
3471 err = stac92xx_auto_create_mono_output_ctls(codec);
3475 if (spec->num_amps > 0) {
3476 err = stac92xx_auto_create_amp_output_ctls(codec);
3480 if (spec->num_dmics > 0 && !spec->dinput_mux)
3481 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3482 &spec->autocfg)) < 0)
3484 if (spec->num_muxes > 0) {
3485 err = stac92xx_auto_create_mux_input_ctls(codec);
3489 if (spec->num_smuxes > 0) {
3490 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3495 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3496 if (spec->multiout.max_channels > 2)
3497 spec->surr_switch = 1;
3499 if (spec->autocfg.dig_out_pin)
3500 spec->multiout.dig_out_nid = dig_out;
3501 if (dig_in && spec->autocfg.dig_in_pin)
3502 spec->dig_in_nid = dig_in;
3504 if (spec->kctls.list)
3505 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3507 spec->input_mux = &spec->private_imux;
3508 spec->dinput_mux = &spec->private_dimux;
3509 spec->sinput_mux = &spec->private_smux;
3510 spec->mono_mux = &spec->private_mono_mux;
3511 spec->amp_mux = &spec->private_amp_mux;
3515 /* add playback controls for HP output */
3516 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3517 struct auto_pin_cfg *cfg)
3519 struct sigmatel_spec *spec = codec->spec;
3520 hda_nid_t pin = cfg->hp_pins[0];
3521 unsigned int wid_caps;
3526 wid_caps = get_wcaps(codec, pin);
3527 if (wid_caps & AC_WCAP_UNSOL_CAP)
3528 spec->hp_detect = 1;
3533 /* add playback controls for LFE output */
3534 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3535 struct auto_pin_cfg *cfg)
3537 struct sigmatel_spec *spec = codec->spec;
3539 hda_nid_t lfe_pin = 0x0;
3543 * search speaker outs and line outs for a mono speaker pin
3544 * with an amp. If one is found, add LFE controls
3547 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3548 hda_nid_t pin = spec->autocfg.speaker_pins[i];
3549 unsigned int wcaps = get_wcaps(codec, pin);
3550 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3551 if (wcaps == AC_WCAP_OUT_AMP)
3552 /* found a mono speaker with an amp, must be lfe */
3556 /* if speaker_outs is 0, then speakers may be in line_outs */
3557 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3558 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3559 hda_nid_t pin = spec->autocfg.line_out_pins[i];
3560 unsigned int defcfg;
3561 defcfg = snd_hda_codec_read(codec, pin, 0,
3562 AC_VERB_GET_CONFIG_DEFAULT,
3564 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3565 unsigned int wcaps = get_wcaps(codec, pin);
3566 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3567 if (wcaps == AC_WCAP_OUT_AMP)
3568 /* found a mono speaker with an amp,
3576 err = create_controls(spec, "LFE", lfe_pin, 1);
3584 static int stac9200_parse_auto_config(struct hda_codec *codec)
3586 struct sigmatel_spec *spec = codec->spec;
3589 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3592 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3595 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
3598 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
3601 if (spec->num_muxes > 0) {
3602 err = stac92xx_auto_create_mux_input_ctls(codec);
3607 if (spec->autocfg.dig_out_pin)
3608 spec->multiout.dig_out_nid = 0x05;
3609 if (spec->autocfg.dig_in_pin)
3610 spec->dig_in_nid = 0x04;
3612 if (spec->kctls.list)
3613 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3615 spec->input_mux = &spec->private_imux;
3616 spec->dinput_mux = &spec->private_dimux;
3622 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
3623 * funky external mute control using GPIO pins.
3626 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
3627 unsigned int dir_mask, unsigned int data)
3629 unsigned int gpiostate, gpiomask, gpiodir;
3631 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
3632 AC_VERB_GET_GPIO_DATA, 0);
3633 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
3635 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
3636 AC_VERB_GET_GPIO_MASK, 0);
3639 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
3640 AC_VERB_GET_GPIO_DIRECTION, 0);
3641 gpiodir |= dir_mask;
3643 /* Configure GPIOx as CMOS */
3644 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
3646 snd_hda_codec_write(codec, codec->afg, 0,
3647 AC_VERB_SET_GPIO_MASK, gpiomask);
3648 snd_hda_codec_read(codec, codec->afg, 0,
3649 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
3653 snd_hda_codec_read(codec, codec->afg, 0,
3654 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
3657 static int stac92xx_add_jack(struct hda_codec *codec,
3658 hda_nid_t nid, int type)
3660 struct sigmatel_spec *spec = codec->spec;
3661 struct sigmatel_jack *jack;
3662 int def_conf = snd_hda_codec_read(codec, nid,
3663 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
3664 int connectivity = get_defcfg_connect(def_conf);
3667 if (connectivity && connectivity != AC_JACK_PORT_FIXED)
3670 snd_array_init(&spec->jacks, sizeof(*jack), 32);
3671 jack = snd_array_new(&spec->jacks);
3677 sprintf(name, "%s at %s %s Jack",
3678 snd_hda_get_jack_type(def_conf),
3679 snd_hda_get_jack_connectivity(def_conf),
3680 snd_hda_get_jack_location(def_conf));
3682 return snd_jack_new(codec->bus->card, name, type, &jack->jack);
3685 static int stac92xx_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
3688 struct sigmatel_event *event;
3690 snd_array_init(&spec->events, sizeof(*event), 32);
3691 event = snd_array_new(&spec->events);
3700 static int stac92xx_event_data(struct hda_codec *codec, hda_nid_t nid)
3702 struct sigmatel_spec *spec = codec->spec;
3703 struct sigmatel_event *events = spec->events.list;
3706 for (i = 0; i < spec->events.used; i++)
3707 if (events[i].nid == nid)
3708 return events[i].data;
3713 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
3716 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
3717 snd_hda_codec_write_cache(codec, nid, 0,
3718 AC_VERB_SET_UNSOLICITED_ENABLE,
3719 (AC_USRSP_EN | event | nid));
3723 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
3726 for (i = 0; i < cfg->hp_outs; i++)
3727 if (cfg->hp_pins[i] == nid)
3728 return 1; /* nid is a HP-Out */
3730 return 0; /* nid is not a HP-Out */
3733 static void stac92xx_power_down(struct hda_codec *codec)
3735 struct sigmatel_spec *spec = codec->spec;
3737 /* power down inactive DACs */
3739 for (dac = spec->dac_list; *dac; dac++)
3740 if (!is_in_dac_nids(spec, *dac) &&
3741 spec->multiout.hp_nid != *dac)
3742 snd_hda_codec_write_cache(codec, *dac, 0,
3743 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3746 static int stac92xx_init(struct hda_codec *codec)
3748 struct sigmatel_spec *spec = codec->spec;
3749 struct auto_pin_cfg *cfg = &spec->autocfg;
3752 snd_hda_sequence_write(codec, spec->init);
3754 /* power down adcs initially */
3755 if (spec->powerdown_adcs)
3756 for (i = 0; i < spec->num_adcs; i++)
3757 snd_hda_codec_write_cache(codec,
3758 spec->adc_nids[i], 0,
3759 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3761 if (spec->hp_detect) {
3762 /* Enable unsolicited responses on the HP widget */
3763 for (i = 0; i < cfg->hp_outs; i++) {
3764 int type = SND_JACK_HEADPHONE;
3765 hda_nid_t nid = cfg->hp_pins[i];
3766 enable_pin_detect(codec, nid, STAC_HP_EVENT | nid);
3767 /* jack detection */
3768 if (cfg->hp_outs == i)
3769 type |= SND_JACK_LINEOUT;
3770 err = stac92xx_add_jack(codec, nid, type);
3775 /* force to enable the first line-out; the others are set up
3778 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
3780 /* fake event to set up pins */
3781 codec->patch_ops.unsol_event(codec,
3782 (STAC_HP_EVENT | spec->autocfg.hp_pins[0]) << 26);
3784 stac92xx_auto_init_multi_out(codec);
3785 stac92xx_auto_init_hp_out(codec);
3787 for (i = 0; i < cfg->line_outs; i++) {
3788 err = stac92xx_add_jack(codec,
3789 cfg->line_out_pins[i], SND_JACK_LINEOUT);
3793 for (i = 0; i < AUTO_PIN_LAST; i++) {
3794 hda_nid_t nid = cfg->input_pins[i];
3796 unsigned int pinctl;
3797 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
3798 /* for mic pins, force to initialize */
3799 pinctl = stac92xx_get_vref(codec, nid);
3801 pinctl = snd_hda_codec_read(codec, nid, 0,
3802 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3803 /* if PINCTL already set then skip */
3804 if (pinctl & AC_PINCTL_IN_EN)
3807 pinctl |= AC_PINCTL_IN_EN;
3808 stac92xx_auto_set_pinctl(codec, nid, pinctl);
3809 err = stac92xx_add_jack(codec, nid,
3810 SND_JACK_MICROPHONE);
3813 enable_pin_detect(codec, nid, STAC_INSERT_EVENT | nid);
3816 for (i = 0; i < spec->num_dmics; i++)
3817 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
3819 for (i = 0; i < spec->num_pwrs; i++) {
3820 int event = is_nid_hp_pin(cfg, spec->pwr_nids[i])
3821 ? STAC_HP_EVENT : STAC_PWR_EVENT;
3822 int pinctl = snd_hda_codec_read(codec, spec->pwr_nids[i],
3823 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3824 int def_conf = snd_hda_codec_read(codec, spec->pwr_nids[i],
3825 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
3826 def_conf = get_defcfg_connect(def_conf);
3827 /* outputs are only ports capable of power management
3828 * any attempts on powering down a input port cause the
3829 * referenced VREF to act quirky.
3831 if (pinctl & AC_PINCTL_IN_EN)
3833 /* skip any ports that don't have jacks since presence
3834 * detection is useless */
3835 if (def_conf && def_conf != AC_JACK_PORT_FIXED)
3837 enable_pin_detect(codec, spec->pwr_nids[i], event | i);
3838 codec->patch_ops.unsol_event(codec, (event | i) << 26);
3841 stac92xx_power_down(codec);
3842 if (cfg->dig_out_pin)
3843 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
3845 if (cfg->dig_in_pin)
3846 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
3849 stac_gpio_set(codec, spec->gpio_mask,
3850 spec->gpio_dir, spec->gpio_data);
3855 static void stac92xx_free_jacks(struct hda_codec *codec)
3857 struct sigmatel_spec *spec = codec->spec;
3858 if (spec->jacks.list) {
3859 struct sigmatel_jack *jacks = spec->jacks.list;
3861 for (i = 0; i < spec->jacks.used; i++)
3862 snd_device_free(codec->bus->card, &jacks[i].jack);
3864 snd_array_free(&spec->jacks);
3867 static void stac92xx_free_kctls(struct hda_codec *codec)
3869 struct sigmatel_spec *spec = codec->spec;
3871 if (spec->kctls.list) {
3872 struct snd_kcontrol_new *kctl = spec->kctls.list;
3874 for (i = 0; i < spec->kctls.used; i++)
3875 kfree(kctl[i].name);
3877 snd_array_free(&spec->kctls);
3880 static void stac92xx_free(struct hda_codec *codec)
3882 struct sigmatel_spec *spec = codec->spec;
3887 if (spec->bios_pin_configs)
3888 kfree(spec->bios_pin_configs);
3889 stac92xx_free_jacks(codec);
3890 snd_array_free(&spec->events);
3893 snd_hda_detach_beep_device(codec);
3896 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
3899 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
3900 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
3902 if (pin_ctl & AC_PINCTL_IN_EN) {
3904 * we need to check the current set-up direction of
3905 * shared input pins since they can be switched via
3906 * "xxx as Output" mixer switch
3908 struct sigmatel_spec *spec = codec->spec;
3909 struct auto_pin_cfg *cfg = &spec->autocfg;
3910 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
3911 spec->line_switch) ||
3912 (nid == cfg->input_pins[AUTO_PIN_MIC] &&
3917 /* if setting pin direction bits, clear the current
3918 direction bits first */
3919 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
3920 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
3922 snd_hda_codec_write_cache(codec, nid, 0,
3923 AC_VERB_SET_PIN_WIDGET_CONTROL,
3927 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
3930 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
3931 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
3932 snd_hda_codec_write_cache(codec, nid, 0,
3933 AC_VERB_SET_PIN_WIDGET_CONTROL,
3937 static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid)
3941 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
3943 unsigned int pinctl;
3944 pinctl = snd_hda_codec_read(codec, nid, 0,
3945 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3946 if (pinctl & AC_PINCTL_IN_EN)
3947 return 0; /* mic- or line-input */
3949 return 1; /* HP-output */
3954 /* return non-zero if the hp-pin of the given array index isn't
3955 * a jack-detection target
3957 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
3959 struct auto_pin_cfg *cfg = &spec->autocfg;
3961 /* ignore sensing of shared line and mic jacks */
3962 if (spec->line_switch &&
3963 cfg->hp_pins[i] == cfg->input_pins[AUTO_PIN_LINE])
3965 if (spec->mic_switch &&
3966 cfg->hp_pins[i] == cfg->input_pins[AUTO_PIN_MIC])
3968 /* ignore if the pin is set as line-out */
3969 if (cfg->hp_pins[i] == spec->hp_switch)
3974 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
3976 struct sigmatel_spec *spec = codec->spec;
3977 struct auto_pin_cfg *cfg = &spec->autocfg;
3981 if (spec->gpio_mute)
3982 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
3983 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
3985 for (i = 0; i < cfg->hp_outs; i++) {
3988 if (no_hp_sensing(spec, i))
3990 presence = get_hp_pin_presence(codec, cfg->hp_pins[i]);
3994 /* disable lineouts */
3995 if (spec->hp_switch)
3996 stac92xx_reset_pinctl(codec, spec->hp_switch,
3998 for (i = 0; i < cfg->line_outs; i++)
3999 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4001 for (i = 0; i < cfg->speaker_outs; i++)
4002 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4004 if (spec->eapd_mask)
4005 stac_gpio_set(codec, spec->gpio_mask,
4006 spec->gpio_dir, spec->gpio_data &
4009 /* enable lineouts */
4010 if (spec->hp_switch)
4011 stac92xx_set_pinctl(codec, spec->hp_switch,
4013 for (i = 0; i < cfg->line_outs; i++)
4014 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4016 for (i = 0; i < cfg->speaker_outs; i++)
4017 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4019 if (spec->eapd_mask)
4020 stac_gpio_set(codec, spec->gpio_mask,
4021 spec->gpio_dir, spec->gpio_data |
4024 /* toggle hp outs */
4025 for (i = 0; i < cfg->hp_outs; i++) {
4026 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4027 if (no_hp_sensing(spec, i))
4030 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4032 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4036 static void stac92xx_pin_sense(struct hda_codec *codec, int idx)
4038 struct sigmatel_spec *spec = codec->spec;
4039 hda_nid_t nid = spec->pwr_nids[idx];
4041 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0)
4043 presence = get_hp_pin_presence(codec, nid);
4045 /* several codecs have two power down bits */
4046 if (spec->pwr_mapping)
4047 idx = spec->pwr_mapping[idx];
4056 /* power down unused output ports */
4057 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4060 static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
4062 struct sigmatel_spec *spec = codec->spec;
4063 struct sigmatel_jack *jacks = spec->jacks.list;
4067 for (i = 0; i < spec->jacks.used; i++) {
4068 if (jacks->nid == nid) {
4069 unsigned int pin_ctl =
4070 snd_hda_codec_read(codec, nid,
4071 0, AC_VERB_GET_PIN_WIDGET_CONTROL,
4073 int type = jacks->type;
4074 if (type == (SND_JACK_LINEOUT
4075 | SND_JACK_HEADPHONE))
4076 type = (pin_ctl & AC_PINCTL_HP_EN)
4077 ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
4078 snd_jack_report(jacks->jack,
4079 get_hp_pin_presence(codec, nid)
4087 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4089 struct sigmatel_spec *spec = codec->spec;
4090 int event = (res >> 26) & 0x70;
4091 int nid = res >> 26 & 0x0f;
4095 stac92xx_hp_detect(codec, res);
4097 case STAC_INSERT_EVENT:
4098 case STAC_PWR_EVENT:
4100 if (spec->num_pwrs > 0)
4101 stac92xx_pin_sense(codec, nid);
4102 stac92xx_report_jack(codec, nid);
4105 case STAC_VREF_EVENT: {
4106 int data = snd_hda_codec_read(codec, codec->afg, 0,
4107 AC_VERB_GET_GPIO_DATA, 0);
4108 int idx = stac92xx_event_data(codec, nid);
4109 /* toggle VREF state based on GPIOx status */
4110 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4111 !!(data & (1 << idx)));
4117 #ifdef SND_HDA_NEEDS_RESUME
4118 static int stac92xx_resume(struct hda_codec *codec)
4120 struct sigmatel_spec *spec = codec->spec;
4122 stac92xx_set_config_regs(codec);
4123 snd_hda_sequence_write(codec, spec->init);
4124 stac_gpio_set(codec, spec->gpio_mask,
4125 spec->gpio_dir, spec->gpio_data);
4126 snd_hda_codec_resume_amp(codec);
4127 snd_hda_codec_resume_cache(codec);
4128 /* power down inactive DACs */
4130 stac92xx_power_down(codec);
4131 /* invoke unsolicited event to reset the HP state */
4132 if (spec->hp_detect)
4133 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
4138 static struct hda_codec_ops stac92xx_patch_ops = {
4139 .build_controls = stac92xx_build_controls,
4140 .build_pcms = stac92xx_build_pcms,
4141 .init = stac92xx_init,
4142 .free = stac92xx_free,
4143 .unsol_event = stac92xx_unsol_event,
4144 #ifdef SND_HDA_NEEDS_RESUME
4145 .resume = stac92xx_resume,
4149 static int patch_stac9200(struct hda_codec *codec)
4151 struct sigmatel_spec *spec;
4154 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4159 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
4160 spec->pin_nids = stac9200_pin_nids;
4161 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
4164 if (spec->board_config < 0) {
4165 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
4166 err = stac92xx_save_bios_config_regs(codec);
4168 stac92xx_free(codec);
4171 spec->pin_configs = spec->bios_pin_configs;
4173 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
4174 stac92xx_set_config_regs(codec);
4177 spec->multiout.max_channels = 2;
4178 spec->multiout.num_dacs = 1;
4179 spec->multiout.dac_nids = stac9200_dac_nids;
4180 spec->adc_nids = stac9200_adc_nids;
4181 spec->mux_nids = stac9200_mux_nids;
4182 spec->num_muxes = 1;
4183 spec->num_dmics = 0;
4187 if (spec->board_config == STAC_9200_GATEWAY ||
4188 spec->board_config == STAC_9200_OQO)
4189 spec->init = stac9200_eapd_init;
4191 spec->init = stac9200_core_init;
4192 spec->mixer = stac9200_mixer;
4194 if (spec->board_config == STAC_9200_PANASONIC) {
4195 spec->gpio_mask = spec->gpio_dir = 0x09;
4196 spec->gpio_data = 0x00;
4199 err = stac9200_parse_auto_config(codec);
4201 stac92xx_free(codec);
4205 codec->patch_ops = stac92xx_patch_ops;
4210 static int patch_stac925x(struct hda_codec *codec)
4212 struct sigmatel_spec *spec;
4215 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4220 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
4221 spec->pin_nids = stac925x_pin_nids;
4222 spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
4226 if (spec->board_config < 0) {
4227 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
4228 "using BIOS defaults\n");
4229 err = stac92xx_save_bios_config_regs(codec);
4231 stac92xx_free(codec);
4234 spec->pin_configs = spec->bios_pin_configs;
4235 } else if (stac925x_brd_tbl[spec->board_config] != NULL){
4236 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
4237 stac92xx_set_config_regs(codec);
4240 spec->multiout.max_channels = 2;
4241 spec->multiout.num_dacs = 1;
4242 spec->multiout.dac_nids = stac925x_dac_nids;
4243 spec->adc_nids = stac925x_adc_nids;
4244 spec->mux_nids = stac925x_mux_nids;
4245 spec->num_muxes = 1;
4248 switch (codec->vendor_id) {
4249 case 0x83847632: /* STAC9202 */
4250 case 0x83847633: /* STAC9202D */
4251 case 0x83847636: /* STAC9251 */
4252 case 0x83847637: /* STAC9251D */
4253 spec->num_dmics = STAC925X_NUM_DMICS;
4254 spec->dmic_nids = stac925x_dmic_nids;
4255 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
4256 spec->dmux_nids = stac925x_dmux_nids;
4259 spec->num_dmics = 0;
4263 spec->init = stac925x_core_init;
4264 spec->mixer = stac925x_mixer;
4266 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
4268 if (spec->board_config < 0) {
4269 printk(KERN_WARNING "hda_codec: No auto-config is "
4270 "available, default to model=ref\n");
4271 spec->board_config = STAC_925x_REF;
4277 stac92xx_free(codec);
4281 codec->patch_ops = stac92xx_patch_ops;
4286 static struct hda_input_mux stac92hd73xx_dmux = {
4289 { "Analog Inputs", 0x0b },
4290 { "Digital Mic 1", 0x09 },
4291 { "Digital Mic 2", 0x0a },
4296 static int patch_stac92hd73xx(struct hda_codec *codec)
4298 struct sigmatel_spec *spec;
4299 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
4302 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4307 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
4308 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
4309 spec->pin_nids = stac92hd73xx_pin_nids;
4310 spec->board_config = snd_hda_check_board_config(codec,
4311 STAC_92HD73XX_MODELS,
4312 stac92hd73xx_models,
4313 stac92hd73xx_cfg_tbl);
4315 if (spec->board_config < 0) {
4316 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4317 " STAC92HD73XX, using BIOS defaults\n");
4318 err = stac92xx_save_bios_config_regs(codec);
4320 stac92xx_free(codec);
4323 spec->pin_configs = spec->bios_pin_configs;
4325 spec->pin_configs = stac92hd73xx_brd_tbl[spec->board_config];
4326 stac92xx_set_config_regs(codec);
4329 spec->multiout.num_dacs = snd_hda_get_connections(codec, 0x0a,
4330 conn, STAC92HD73_DAC_COUNT + 2) - 1;
4332 if (spec->multiout.num_dacs < 0) {
4333 printk(KERN_WARNING "hda_codec: Could not determine "
4334 "number of channels defaulting to DAC count\n");
4335 spec->multiout.num_dacs = STAC92HD73_DAC_COUNT;
4338 switch (spec->multiout.num_dacs) {
4339 case 0x3: /* 6 Channel */
4340 spec->mixer = stac92hd73xx_6ch_mixer;
4341 spec->init = stac92hd73xx_6ch_core_init;
4343 case 0x4: /* 8 Channel */
4344 spec->mixer = stac92hd73xx_8ch_mixer;
4345 spec->init = stac92hd73xx_8ch_core_init;
4347 case 0x5: /* 10 Channel */
4348 spec->mixer = stac92hd73xx_10ch_mixer;
4349 spec->init = stac92hd73xx_10ch_core_init;
4352 spec->multiout.dac_nids = stac92hd73xx_dac_nids;
4353 spec->aloopback_mask = 0x01;
4354 spec->aloopback_shift = 8;
4356 spec->digbeep_nid = 0x1c;
4357 spec->mux_nids = stac92hd73xx_mux_nids;
4358 spec->adc_nids = stac92hd73xx_adc_nids;
4359 spec->dmic_nids = stac92hd73xx_dmic_nids;
4360 spec->dmux_nids = stac92hd73xx_dmux_nids;
4361 spec->smux_nids = stac92hd73xx_smux_nids;
4362 spec->amp_nids = stac92hd73xx_amp_nids;
4363 spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
4365 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
4366 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
4367 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
4368 memcpy(&spec->private_dimux, &stac92hd73xx_dmux,
4369 sizeof(stac92hd73xx_dmux));
4371 switch (spec->board_config) {
4373 spec->init = dell_eq_core_init;
4376 spec->num_smuxes = 0;
4377 spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
4378 spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
4382 spec->init = dell_m6_core_init;
4383 switch (codec->subsystem_id) {
4384 case 0x1028025e: /* Analog Mics */
4386 stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
4387 spec->num_dmics = 0;
4388 spec->private_dimux.num_items = 1;
4390 case 0x10280271: /* Digital Mics */
4394 stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
4395 spec->num_dmics = 1;
4396 spec->private_dimux.num_items = 2;
4398 case 0x10280256: /* Both */
4400 stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
4401 stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
4402 spec->num_dmics = 1;
4403 spec->private_dimux.num_items = 2;
4408 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
4409 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
4411 if (spec->board_config > STAC_92HD73XX_REF) {
4412 /* GPIO0 High = Enable EAPD */
4413 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4414 spec->gpio_data = 0x01;
4416 spec->dinput_mux = &spec->private_dimux;
4418 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
4419 spec->pwr_nids = stac92hd73xx_pwr_nids;
4421 err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
4424 if (spec->board_config < 0) {
4425 printk(KERN_WARNING "hda_codec: No auto-config is "
4426 "available, default to model=ref\n");
4427 spec->board_config = STAC_92HD73XX_REF;
4434 stac92xx_free(codec);
4438 codec->patch_ops = stac92xx_patch_ops;
4443 static struct hda_input_mux stac92hd83xxx_dmux = {
4446 { "Analog Inputs", 0x03 },
4447 { "Digital Mic 1", 0x04 },
4448 { "Digital Mic 2", 0x05 },
4452 static int patch_stac92hd83xxx(struct hda_codec *codec)
4454 struct sigmatel_spec *spec;
4457 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4462 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
4463 spec->mono_nid = 0x19;
4464 spec->digbeep_nid = 0x21;
4465 spec->dmic_nids = stac92hd83xxx_dmic_nids;
4466 spec->dmux_nids = stac92hd83xxx_dmux_nids;
4467 spec->adc_nids = stac92hd83xxx_adc_nids;
4468 spec->pwr_nids = stac92hd83xxx_pwr_nids;
4469 spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
4470 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
4471 spec->multiout.dac_nids = stac92hd83xxx_dac_nids;
4473 spec->init = stac92hd83xxx_core_init;
4474 switch (codec->vendor_id) {
4476 spec->multiout.num_dacs = STAC92HD81_DAC_COUNT;
4480 spec->init++; /* switch to config #2 */
4481 spec->multiout.num_dacs = STAC92HD83_DAC_COUNT;
4484 spec->mixer = stac92hd83xxx_mixer;
4485 spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
4486 spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
4487 spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
4488 spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
4489 spec->dinput_mux = &stac92hd83xxx_dmux;
4490 spec->pin_nids = stac92hd83xxx_pin_nids;
4491 spec->board_config = snd_hda_check_board_config(codec,
4492 STAC_92HD83XXX_MODELS,
4493 stac92hd83xxx_models,
4494 stac92hd83xxx_cfg_tbl);
4496 if (spec->board_config < 0) {
4497 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4498 " STAC92HD83XXX, using BIOS defaults\n");
4499 err = stac92xx_save_bios_config_regs(codec);
4501 stac92xx_free(codec);
4504 spec->pin_configs = spec->bios_pin_configs;
4506 spec->pin_configs = stac92hd83xxx_brd_tbl[spec->board_config];
4507 stac92xx_set_config_regs(codec);
4510 err = stac92xx_parse_auto_config(codec, 0x1d, 0);
4512 if (spec->board_config < 0) {
4513 printk(KERN_WARNING "hda_codec: No auto-config is "
4514 "available, default to model=ref\n");
4515 spec->board_config = STAC_92HD83XXX_REF;
4522 stac92xx_free(codec);
4526 codec->patch_ops = stac92xx_patch_ops;
4531 #ifdef SND_HDA_NEEDS_RESUME
4532 static void stac92hd71xx_set_power_state(struct hda_codec *codec, int pwr)
4534 struct sigmatel_spec *spec = codec->spec;
4536 snd_hda_codec_write_cache(codec, codec->afg, 0,
4537 AC_VERB_SET_POWER_STATE, pwr);
4540 for (i = 0; i < spec->num_adcs; i++) {
4541 snd_hda_codec_write_cache(codec,
4542 spec->adc_nids[i], 0,
4543 AC_VERB_SET_POWER_STATE, pwr);
4547 static int stac92hd71xx_resume(struct hda_codec *codec)
4549 stac92hd71xx_set_power_state(codec, AC_PWRST_D0);
4550 return stac92xx_resume(codec);
4553 static int stac92hd71xx_suspend(struct hda_codec *codec, pm_message_t state)
4555 stac92hd71xx_set_power_state(codec, AC_PWRST_D3);
4561 static struct hda_codec_ops stac92hd71bxx_patch_ops = {
4562 .build_controls = stac92xx_build_controls,
4563 .build_pcms = stac92xx_build_pcms,
4564 .init = stac92xx_init,
4565 .free = stac92xx_free,
4566 .unsol_event = stac92xx_unsol_event,
4567 #ifdef SND_HDA_NEEDS_RESUME
4568 .resume = stac92hd71xx_resume,
4569 .suspend = stac92hd71xx_suspend,
4573 static struct hda_input_mux stac92hd71bxx_dmux = {
4576 { "Analog Inputs", 0x00 },
4578 { "Digital Mic 1", 0x02 },
4579 { "Digital Mic 2", 0x03 },
4583 static int patch_stac92hd71bxx(struct hda_codec *codec)
4585 struct sigmatel_spec *spec;
4588 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4593 codec->patch_ops = stac92xx_patch_ops;
4594 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
4595 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
4596 spec->pin_nids = stac92hd71bxx_pin_nids;
4597 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux,
4598 sizeof(stac92hd71bxx_dmux));
4599 spec->board_config = snd_hda_check_board_config(codec,
4600 STAC_92HD71BXX_MODELS,
4601 stac92hd71bxx_models,
4602 stac92hd71bxx_cfg_tbl);
4604 if (spec->board_config < 0) {
4605 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4606 " STAC92HD71BXX, using BIOS defaults\n");
4607 err = stac92xx_save_bios_config_regs(codec);
4609 stac92xx_free(codec);
4612 spec->pin_configs = spec->bios_pin_configs;
4614 spec->pin_configs = stac92hd71bxx_brd_tbl[spec->board_config];
4615 stac92xx_set_config_regs(codec);
4618 switch (codec->vendor_id) {
4619 case 0x111d76b6: /* 4 Port without Analog Mixer */
4621 case 0x111d76b4: /* 6 Port without Analog Mixer */
4623 spec->mixer = stac92hd71bxx_mixer;
4624 spec->init = stac92hd71bxx_core_init;
4625 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4627 case 0x111d7608: /* 5 Port with Analog Mixer */
4628 switch (codec->subsystem_id) {
4630 /* Enable VREF power saving on GPIO1 detect */
4631 snd_hda_codec_write(codec, codec->afg, 0,
4632 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
4633 snd_hda_codec_write_cache(codec, codec->afg, 0,
4634 AC_VERB_SET_UNSOLICITED_ENABLE,
4635 (AC_USRSP_EN | STAC_VREF_EVENT | codec->afg));
4636 err = stac92xx_add_event(spec, codec->afg, 0x02);
4639 spec->gpio_mask |= 0x02;
4642 if ((codec->revision_id & 0xf) == 0 ||
4643 (codec->revision_id & 0xf) == 1) {
4644 #ifdef SND_HDA_NEEDS_RESUME
4645 codec->patch_ops = stac92hd71bxx_patch_ops;
4647 spec->stream_delay = 40; /* 40 milliseconds */
4650 /* no output amps */
4652 spec->mixer = stac92hd71bxx_analog_mixer;
4653 spec->dinput_mux = &spec->private_dimux;
4656 spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
4657 stac92xx_set_config_reg(codec, 0xf, 0x40f000f0);
4659 case 0x111d7603: /* 6 Port with Analog Mixer */
4660 if ((codec->revision_id & 0xf) == 1) {
4661 #ifdef SND_HDA_NEEDS_RESUME
4662 codec->patch_ops = stac92hd71bxx_patch_ops;
4664 spec->stream_delay = 40; /* 40 milliseconds */
4667 /* no output amps */
4671 spec->dinput_mux = &spec->private_dimux;
4672 spec->mixer = stac92hd71bxx_analog_mixer;
4673 spec->init = stac92hd71bxx_analog_core_init;
4674 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4677 spec->aloopback_mask = 0x50;
4678 spec->aloopback_shift = 0;
4680 if (spec->board_config > STAC_92HD71BXX_REF) {
4682 spec->gpio_mask = 0x01;
4683 spec->gpio_dir = 0x01;
4684 spec->gpio_data = 0x01;
4687 spec->powerdown_adcs = 1;
4688 spec->digbeep_nid = 0x26;
4689 spec->mux_nids = stac92hd71bxx_mux_nids;
4690 spec->adc_nids = stac92hd71bxx_adc_nids;
4691 spec->dmic_nids = stac92hd71bxx_dmic_nids;
4692 spec->dmux_nids = stac92hd71bxx_dmux_nids;
4693 spec->smux_nids = stac92hd71bxx_smux_nids;
4694 spec->pwr_nids = stac92hd71bxx_pwr_nids;
4696 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
4697 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
4699 switch (spec->board_config) {
4701 spec->num_dmics = 0;
4702 spec->num_smuxes = 0;
4703 spec->num_dmuxes = 0;
4705 /* enable internal microphone */
4706 stac92xx_set_config_reg(codec, 0x0e, 0x01813040);
4707 stac92xx_auto_set_pinctl(codec, 0x0e,
4708 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
4711 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
4712 spec->num_smuxes = ARRAY_SIZE(stac92hd71bxx_smux_nids);
4713 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
4716 spec->multiout.num_dacs = 1;
4717 spec->multiout.hp_nid = 0x11;
4718 spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
4719 if (spec->dinput_mux)
4720 spec->private_dimux.num_items +=
4722 (ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1);
4724 err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
4726 if (spec->board_config < 0) {
4727 printk(KERN_WARNING "hda_codec: No auto-config is "
4728 "available, default to model=ref\n");
4729 spec->board_config = STAC_92HD71BXX_REF;
4736 stac92xx_free(codec);
4743 static int patch_stac922x(struct hda_codec *codec)
4745 struct sigmatel_spec *spec;
4748 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4753 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
4754 spec->pin_nids = stac922x_pin_nids;
4755 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
4758 if (spec->board_config == STAC_INTEL_MAC_AUTO) {
4759 spec->gpio_mask = spec->gpio_dir = 0x03;
4760 spec->gpio_data = 0x03;
4761 /* Intel Macs have all same PCI SSID, so we need to check
4762 * codec SSID to distinguish the exact models
4764 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
4765 switch (codec->subsystem_id) {
4768 spec->board_config = STAC_INTEL_MAC_V1;
4772 spec->board_config = STAC_INTEL_MAC_V2;
4780 spec->board_config = STAC_INTEL_MAC_V3;
4784 spec->board_config = STAC_INTEL_MAC_V4;
4788 spec->board_config = STAC_INTEL_MAC_V5;
4791 spec->board_config = STAC_INTEL_MAC_V3;
4797 if (spec->board_config < 0) {
4798 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
4799 "using BIOS defaults\n");
4800 err = stac92xx_save_bios_config_regs(codec);
4802 stac92xx_free(codec);
4805 spec->pin_configs = spec->bios_pin_configs;
4806 } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
4807 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
4808 stac92xx_set_config_regs(codec);
4811 spec->adc_nids = stac922x_adc_nids;
4812 spec->mux_nids = stac922x_mux_nids;
4813 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
4814 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
4815 spec->num_dmics = 0;
4818 spec->init = stac922x_core_init;
4819 spec->mixer = stac922x_mixer;
4821 spec->multiout.dac_nids = spec->dac_nids;
4823 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
4825 if (spec->board_config < 0) {
4826 printk(KERN_WARNING "hda_codec: No auto-config is "
4827 "available, default to model=ref\n");
4828 spec->board_config = STAC_D945_REF;
4834 stac92xx_free(codec);
4838 codec->patch_ops = stac92xx_patch_ops;
4840 /* Fix Mux capture level; max to 2 */
4841 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
4842 (0 << AC_AMPCAP_OFFSET_SHIFT) |
4843 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4844 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4845 (0 << AC_AMPCAP_MUTE_SHIFT));
4850 static int patch_stac927x(struct hda_codec *codec)
4852 struct sigmatel_spec *spec;
4855 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4860 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
4861 spec->pin_nids = stac927x_pin_nids;
4862 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
4866 if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
4867 if (spec->board_config < 0)
4868 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4869 "STAC927x, using BIOS defaults\n");
4870 err = stac92xx_save_bios_config_regs(codec);
4872 stac92xx_free(codec);
4875 spec->pin_configs = spec->bios_pin_configs;
4877 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
4878 stac92xx_set_config_regs(codec);
4881 spec->digbeep_nid = 0x23;
4882 spec->adc_nids = stac927x_adc_nids;
4883 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
4884 spec->mux_nids = stac927x_mux_nids;
4885 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
4886 spec->smux_nids = stac927x_smux_nids;
4887 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
4888 spec->spdif_labels = stac927x_spdif_labels;
4889 spec->dac_list = stac927x_dac_nids;
4890 spec->multiout.dac_nids = spec->dac_nids;
4892 switch (spec->board_config) {
4895 /* GPIO0 High = Enable EAPD */
4896 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01;
4897 spec->gpio_data = 0x01;
4898 spec->num_dmics = 0;
4900 spec->init = d965_core_init;
4901 spec->mixer = stac927x_mixer;
4903 case STAC_DELL_BIOS:
4904 switch (codec->subsystem_id) {
4907 /* correct the device field to SPDIF out */
4908 stac92xx_set_config_reg(codec, 0x21, 0x01442070);
4911 /* configure the analog microphone on some laptops */
4912 stac92xx_set_config_reg(codec, 0x0c, 0x90a79130);
4913 /* correct the front output jack as a hp out */
4914 stac92xx_set_config_reg(codec, 0x0f, 0x0227011f);
4915 /* correct the front input jack as a mic */
4916 stac92xx_set_config_reg(codec, 0x0e, 0x02a79130);
4919 /* GPIO2 High = Enable EAPD */
4920 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
4921 spec->gpio_data = 0x04;
4922 spec->dmic_nids = stac927x_dmic_nids;
4923 spec->num_dmics = STAC927X_NUM_DMICS;
4925 spec->init = d965_core_init;
4926 spec->mixer = stac927x_mixer;
4927 spec->dmux_nids = stac927x_dmux_nids;
4928 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
4931 if (spec->board_config > STAC_D965_REF) {
4932 /* GPIO0 High = Enable EAPD */
4933 spec->eapd_mask = spec->gpio_mask = 0x01;
4934 spec->gpio_dir = spec->gpio_data = 0x01;
4936 spec->num_dmics = 0;
4938 spec->init = stac927x_core_init;
4939 spec->mixer = stac927x_mixer;
4943 spec->aloopback_mask = 0x40;
4944 spec->aloopback_shift = 0;
4946 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
4948 if (spec->board_config < 0) {
4949 printk(KERN_WARNING "hda_codec: No auto-config is "
4950 "available, default to model=ref\n");
4951 spec->board_config = STAC_D965_REF;
4957 stac92xx_free(codec);
4961 codec->patch_ops = stac92xx_patch_ops;
4965 * The STAC927x seem to require fairly long delays for certain
4966 * command sequences. With too short delays (even if the answer
4967 * is set to RIRB properly), it results in the silence output
4968 * on some hardwares like Dell.
4970 * The below flag enables the longer delay (see get_response
4973 codec->bus->needs_damn_long_delay = 1;
4978 static int patch_stac9205(struct hda_codec *codec)
4980 struct sigmatel_spec *spec;
4983 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4988 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
4989 spec->pin_nids = stac9205_pin_nids;
4990 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
4994 if (spec->board_config < 0) {
4995 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
4996 err = stac92xx_save_bios_config_regs(codec);
4998 stac92xx_free(codec);
5001 spec->pin_configs = spec->bios_pin_configs;
5003 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
5004 stac92xx_set_config_regs(codec);
5007 spec->digbeep_nid = 0x23;
5008 spec->adc_nids = stac9205_adc_nids;
5009 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
5010 spec->mux_nids = stac9205_mux_nids;
5011 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
5012 spec->smux_nids = stac9205_smux_nids;
5013 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
5014 spec->dmic_nids = stac9205_dmic_nids;
5015 spec->num_dmics = STAC9205_NUM_DMICS;
5016 spec->dmux_nids = stac9205_dmux_nids;
5017 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
5020 spec->init = stac9205_core_init;
5021 spec->mixer = stac9205_mixer;
5023 spec->aloopback_mask = 0x40;
5024 spec->aloopback_shift = 0;
5025 spec->multiout.dac_nids = spec->dac_nids;
5027 switch (spec->board_config){
5028 case STAC_9205_DELL_M43:
5029 /* Enable SPDIF in/out */
5030 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
5031 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
5033 /* Enable unsol response for GPIO4/Dock HP connection */
5034 snd_hda_codec_write(codec, codec->afg, 0,
5035 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
5036 snd_hda_codec_write_cache(codec, codec->afg, 0,
5037 AC_VERB_SET_UNSOLICITED_ENABLE,
5038 (AC_USRSP_EN | STAC_VREF_EVENT | codec->afg));
5039 err = stac92xx_add_event(spec, codec->afg, 0x01);
5043 spec->gpio_dir = 0x0b;
5044 spec->eapd_mask = 0x01;
5045 spec->gpio_mask = 0x1b;
5046 spec->gpio_mute = 0x10;
5047 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
5050 spec->gpio_data = 0x01;
5053 /* SPDIF-In enabled */
5056 /* GPIO0 High = EAPD */
5057 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5058 spec->gpio_data = 0x01;
5062 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
5064 if (spec->board_config < 0) {
5065 printk(KERN_WARNING "hda_codec: No auto-config is "
5066 "available, default to model=ref\n");
5067 spec->board_config = STAC_9205_REF;
5073 stac92xx_free(codec);
5077 codec->patch_ops = stac92xx_patch_ops;
5086 /* static config for Sony VAIO FE550G and Sony VAIO AR */
5087 static hda_nid_t vaio_dacs[] = { 0x2 };
5088 #define VAIO_HP_DAC 0x5
5089 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
5090 static hda_nid_t vaio_mux_nids[] = { 0x15 };
5092 static struct hda_input_mux vaio_mux = {
5095 /* { "HP", 0x0 }, */
5096 { "Mic Jack", 0x1 },
5097 { "Internal Mic", 0x2 },
5102 static struct hda_verb vaio_init[] = {
5103 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
5104 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
5105 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
5106 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
5107 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
5108 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
5109 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5110 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
5111 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
5112 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
5113 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
5114 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5118 static struct hda_verb vaio_ar_init[] = {
5119 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
5120 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
5121 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
5122 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
5123 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
5124 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
5125 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5126 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
5127 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
5128 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
5129 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
5130 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
5131 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5135 /* bind volumes of both NID 0x02 and 0x05 */
5136 static struct hda_bind_ctls vaio_bind_master_vol = {
5137 .ops = &snd_hda_bind_vol,
5139 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
5140 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
5145 /* bind volumes of both NID 0x02 and 0x05 */
5146 static struct hda_bind_ctls vaio_bind_master_sw = {
5147 .ops = &snd_hda_bind_sw,
5149 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
5150 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
5155 static struct snd_kcontrol_new vaio_mixer[] = {
5156 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
5157 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
5158 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
5159 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5160 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5162 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5163 .name = "Capture Source",
5165 .info = stac92xx_mux_enum_info,
5166 .get = stac92xx_mux_enum_get,
5167 .put = stac92xx_mux_enum_put,
5172 static struct snd_kcontrol_new vaio_ar_mixer[] = {
5173 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
5174 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
5175 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
5176 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5177 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5178 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
5179 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
5181 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5182 .name = "Capture Source",
5184 .info = stac92xx_mux_enum_info,
5185 .get = stac92xx_mux_enum_get,
5186 .put = stac92xx_mux_enum_put,
5191 static struct hda_codec_ops stac9872_patch_ops = {
5192 .build_controls = stac92xx_build_controls,
5193 .build_pcms = stac92xx_build_pcms,
5194 .init = stac92xx_init,
5195 .free = stac92xx_free,
5196 #ifdef SND_HDA_NEEDS_RESUME
5197 .resume = stac92xx_resume,
5201 static int stac9872_vaio_init(struct hda_codec *codec)
5205 err = stac92xx_init(codec);
5208 if (codec->patch_ops.unsol_event)
5209 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
5213 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
5215 if (get_hp_pin_presence(codec, 0x0a)) {
5216 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
5217 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
5219 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
5220 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
5224 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
5226 switch (res >> 26) {
5228 stac9872_vaio_hp_detect(codec, res);
5233 static struct hda_codec_ops stac9872_vaio_patch_ops = {
5234 .build_controls = stac92xx_build_controls,
5235 .build_pcms = stac92xx_build_pcms,
5236 .init = stac9872_vaio_init,
5237 .free = stac92xx_free,
5238 .unsol_event = stac9872_vaio_unsol_event,
5240 .resume = stac92xx_resume,
5244 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
5246 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
5248 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
5250 /* AR Series. id=0x83847664 and subsys=104D1300 */
5255 static const char *stac9872_models[STAC_9872_MODELS] = {
5256 [CXD9872RD_VAIO] = "vaio",
5257 [CXD9872AKD_VAIO] = "vaio-ar",
5260 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
5261 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
5262 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
5263 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
5264 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
5268 static int patch_stac9872(struct hda_codec *codec)
5270 struct sigmatel_spec *spec;
5273 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
5276 if (board_config < 0)
5277 /* unknown config, let generic-parser do its job... */
5278 return snd_hda_parse_generic_codec(codec);
5280 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5285 switch (board_config) {
5286 case CXD9872RD_VAIO:
5287 case STAC9872AK_VAIO:
5288 case STAC9872K_VAIO:
5289 spec->mixer = vaio_mixer;
5290 spec->init = vaio_init;
5291 spec->multiout.max_channels = 2;
5292 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
5293 spec->multiout.dac_nids = vaio_dacs;
5294 spec->multiout.hp_nid = VAIO_HP_DAC;
5295 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
5296 spec->adc_nids = vaio_adcs;
5298 spec->input_mux = &vaio_mux;
5299 spec->mux_nids = vaio_mux_nids;
5300 codec->patch_ops = stac9872_vaio_patch_ops;
5303 case CXD9872AKD_VAIO:
5304 spec->mixer = vaio_ar_mixer;
5305 spec->init = vaio_ar_init;
5306 spec->multiout.max_channels = 2;
5307 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
5308 spec->multiout.dac_nids = vaio_dacs;
5309 spec->multiout.hp_nid = VAIO_HP_DAC;
5310 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
5312 spec->adc_nids = vaio_adcs;
5313 spec->input_mux = &vaio_mux;
5314 spec->mux_nids = vaio_mux_nids;
5315 codec->patch_ops = stac9872_patch_ops;
5326 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
5327 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
5328 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
5329 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
5330 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
5331 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
5332 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
5333 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
5334 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
5335 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
5336 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
5337 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
5338 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
5339 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
5340 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
5341 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
5342 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
5343 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
5344 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
5345 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
5346 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
5347 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
5348 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
5349 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
5350 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
5351 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
5352 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
5353 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
5354 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
5355 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
5356 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
5357 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
5358 /* The following does not take into account .id=0x83847661 when subsys =
5359 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
5360 * currently not fully supported.
5362 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
5363 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
5364 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
5365 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
5366 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
5367 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
5368 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
5369 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
5370 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
5371 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
5372 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
5373 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
5374 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
5375 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
5376 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
5377 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
5378 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
5379 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
5380 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5381 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5382 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5383 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5384 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5385 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5386 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5387 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },