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 <linux/dmi.h>
32 #include <linux/module.h>
33 #include <sound/core.h>
34 #include <sound/asoundef.h>
35 #include <sound/jack.h>
36 #include <sound/tlv.h>
37 #include "hda_codec.h"
38 #include "hda_local.h"
39 #include "hda_auto_parser.h"
84 STAC_92HD73XX_NO_JD, /* no jack-detection */
98 STAC_92HD83XXX_PWR_REF,
100 STAC_DELL_VOSTRO_3500,
101 STAC_92HD83XXX_HP_cNB11_INTQUAD,
104 STAC_92HD83XXX_MODELS
118 STAC_92HD71BXX_MODELS
144 STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
145 * is given, one of the above models will be
146 * chosen according to the subsystem id. */
147 /* for backward compatibility */
164 STAC_D965_REF_NO_JD, /* no jack-detection */
181 struct sigmatel_mic_route {
184 signed char dmux_idx;
187 #define MAX_PINS_NUM 16
188 #define MAX_ADCS_NUM 4
189 #define MAX_DMICS_NUM 4
191 struct sigmatel_spec {
192 struct snd_kcontrol_new *mixers[4];
193 unsigned int num_mixers;
196 unsigned int eapd_switch: 1;
197 unsigned int surr_switch: 1;
198 unsigned int alt_switch: 1;
199 unsigned int hp_detect: 1;
200 unsigned int spdif_mute: 1;
201 unsigned int check_volume_offset:1;
202 unsigned int auto_mic:1;
203 unsigned int linear_tone_beep:1;
206 unsigned int eapd_mask;
207 unsigned int gpio_mask;
208 unsigned int gpio_dir;
209 unsigned int gpio_data;
210 unsigned int gpio_mute;
211 unsigned int gpio_led;
212 unsigned int gpio_led_polarity;
213 unsigned int vref_mute_led_nid; /* pin NID for mute-LED vref control */
214 unsigned int vref_led;
217 unsigned int stream_delay;
219 /* analog loopback */
220 const struct snd_kcontrol_new *aloopback_ctl;
221 unsigned char aloopback_mask;
222 unsigned char aloopback_shift;
224 /* power management */
225 unsigned int power_map_bits;
226 unsigned int num_pwrs;
227 const hda_nid_t *pwr_nids;
228 const hda_nid_t *dac_list;
231 struct hda_input_mux *mono_mux;
232 unsigned int cur_mmux;
233 struct hda_multi_out multiout;
234 hda_nid_t dac_nids[5];
235 hda_nid_t hp_dacs[5];
236 hda_nid_t speaker_dacs[5];
241 const hda_nid_t *adc_nids;
242 unsigned int num_adcs;
243 const hda_nid_t *mux_nids;
244 unsigned int num_muxes;
245 const hda_nid_t *dmic_nids;
246 unsigned int num_dmics;
247 const hda_nid_t *dmux_nids;
248 unsigned int num_dmuxes;
249 const hda_nid_t *smux_nids;
250 unsigned int num_smuxes;
251 unsigned int num_analog_muxes;
253 const unsigned long *capvols; /* amp-volume attr: HDA_COMPOSE_AMP_VAL() */
254 const unsigned long *capsws; /* amp-mute attr: HDA_COMPOSE_AMP_VAL() */
255 unsigned int num_caps; /* number of capture volume/switch elements */
257 struct sigmatel_mic_route ext_mic;
258 struct sigmatel_mic_route int_mic;
259 struct sigmatel_mic_route dock_mic;
261 const char * const *spdif_labels;
263 hda_nid_t dig_in_nid;
265 hda_nid_t anabeep_nid;
266 hda_nid_t digbeep_nid;
269 const hda_nid_t *pin_nids;
270 unsigned int num_pins;
272 /* codec specific stuff */
273 const struct hda_verb *init;
274 const struct snd_kcontrol_new *mixer;
277 struct hda_input_mux *dinput_mux;
278 unsigned int cur_dmux[2];
279 struct hda_input_mux *input_mux;
280 unsigned int cur_mux[3];
281 struct hda_input_mux *sinput_mux;
282 unsigned int cur_smux[2];
283 unsigned int cur_amux;
285 unsigned int powerdown_adcs;
288 unsigned int io_switch[2];
289 unsigned int clfe_swap;
290 hda_nid_t line_switch; /* shared line-in for input and output */
291 hda_nid_t mic_switch; /* shared mic-in for input and output */
292 hda_nid_t hp_switch; /* NID of HP as line-out */
293 unsigned int aloopback;
295 struct hda_pcm pcm_rec[2]; /* PCM information */
297 /* dynamic controls and input_mux */
298 struct auto_pin_cfg autocfg;
299 struct snd_array kctls;
300 struct hda_input_mux private_dimux;
301 struct hda_input_mux private_imux;
302 struct hda_input_mux private_smux;
303 struct hda_input_mux private_mono_mux;
306 unsigned auto_pin_cnt;
307 hda_nid_t auto_pin_nids[MAX_PINS_NUM];
308 unsigned auto_adc_cnt;
309 hda_nid_t auto_adc_nids[MAX_ADCS_NUM];
310 hda_nid_t auto_mux_nids[MAX_ADCS_NUM];
311 hda_nid_t auto_dmux_nids[MAX_ADCS_NUM];
312 unsigned long auto_capvols[MAX_ADCS_NUM];
313 unsigned auto_dmic_cnt;
314 hda_nid_t auto_dmic_nids[MAX_DMICS_NUM];
316 struct hda_vmaster_mute_hook vmaster_mute;
319 #define AC_VERB_IDT_SET_POWER_MAP 0x7ec
320 #define AC_VERB_IDT_GET_POWER_MAP 0xfec
322 static const hda_nid_t stac9200_adc_nids[1] = {
326 static const hda_nid_t stac9200_mux_nids[1] = {
330 static const hda_nid_t stac9200_dac_nids[1] = {
334 static const hda_nid_t stac92hd73xx_pwr_nids[8] = {
335 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
339 static const hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
343 static const hda_nid_t stac92hd73xx_adc_nids[2] = {
347 #define STAC92HD73XX_NUM_DMICS 2
348 static const hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
352 #define STAC92HD73_DAC_COUNT 5
354 static const hda_nid_t stac92hd73xx_mux_nids[2] = {
358 static const hda_nid_t stac92hd73xx_dmux_nids[2] = {
362 static const hda_nid_t stac92hd73xx_smux_nids[2] = {
366 #define STAC92HD73XX_NUM_CAPS 2
367 static const unsigned long stac92hd73xx_capvols[] = {
368 HDA_COMPOSE_AMP_VAL(0x20, 3, 0, HDA_OUTPUT),
369 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
371 #define stac92hd73xx_capsws stac92hd73xx_capvols
373 #define STAC92HD83_DAC_COUNT 3
375 static const hda_nid_t stac92hd83xxx_pwr_nids[7] = {
376 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
380 static const hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
384 static const hda_nid_t stac92hd83xxx_dmic_nids[] = {
388 static const hda_nid_t stac92hd71bxx_pwr_nids[3] = {
392 static const hda_nid_t stac92hd71bxx_adc_nids[2] = {
396 static const hda_nid_t stac92hd71bxx_mux_nids[2] = {
400 static const hda_nid_t stac92hd71bxx_dmux_nids[2] = {
404 static const hda_nid_t stac92hd71bxx_smux_nids[2] = {
408 #define STAC92HD71BXX_NUM_DMICS 2
409 static const hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
413 static const hda_nid_t stac92hd71bxx_dmic_5port_nids[STAC92HD71BXX_NUM_DMICS] = {
417 static const hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
421 #define STAC92HD71BXX_NUM_CAPS 2
422 static const unsigned long stac92hd71bxx_capvols[] = {
423 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
424 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
426 #define stac92hd71bxx_capsws stac92hd71bxx_capvols
428 static const hda_nid_t stac925x_adc_nids[1] = {
432 static const hda_nid_t stac925x_mux_nids[1] = {
436 static const hda_nid_t stac925x_dac_nids[1] = {
440 #define STAC925X_NUM_DMICS 1
441 static const hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
445 static const hda_nid_t stac925x_dmux_nids[1] = {
449 static const unsigned long stac925x_capvols[] = {
450 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
452 static const unsigned long stac925x_capsws[] = {
453 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
456 static const hda_nid_t stac922x_adc_nids[2] = {
460 static const hda_nid_t stac922x_mux_nids[2] = {
464 #define STAC922X_NUM_CAPS 2
465 static const unsigned long stac922x_capvols[] = {
466 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_INPUT),
467 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
469 #define stac922x_capsws stac922x_capvols
471 static const hda_nid_t stac927x_slave_dig_outs[2] = {
475 static const hda_nid_t stac927x_adc_nids[3] = {
479 static const hda_nid_t stac927x_mux_nids[3] = {
483 static const hda_nid_t stac927x_smux_nids[1] = {
487 static const hda_nid_t stac927x_dac_nids[6] = {
488 0x02, 0x03, 0x04, 0x05, 0x06, 0
491 static const hda_nid_t stac927x_dmux_nids[1] = {
495 #define STAC927X_NUM_DMICS 2
496 static const hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
500 #define STAC927X_NUM_CAPS 3
501 static const unsigned long stac927x_capvols[] = {
502 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
503 HDA_COMPOSE_AMP_VAL(0x19, 3, 0, HDA_INPUT),
504 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_INPUT),
506 static const unsigned long stac927x_capsws[] = {
507 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
508 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
509 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
512 static const char * const stac927x_spdif_labels[5] = {
513 "Digital Playback", "ADAT", "Analog Mux 1",
514 "Analog Mux 2", "Analog Mux 3"
517 static const hda_nid_t stac9205_adc_nids[2] = {
521 static const hda_nid_t stac9205_mux_nids[2] = {
525 static const hda_nid_t stac9205_dmux_nids[1] = {
529 static const hda_nid_t stac9205_smux_nids[1] = {
533 #define STAC9205_NUM_DMICS 2
534 static const hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
538 #define STAC9205_NUM_CAPS 2
539 static const unsigned long stac9205_capvols[] = {
540 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_INPUT),
541 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_INPUT),
543 static const unsigned long stac9205_capsws[] = {
544 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
545 HDA_COMPOSE_AMP_VAL(0x1e, 3, 0, HDA_OUTPUT),
548 static const hda_nid_t stac9200_pin_nids[8] = {
549 0x08, 0x09, 0x0d, 0x0e,
550 0x0f, 0x10, 0x11, 0x12,
553 static const hda_nid_t stac925x_pin_nids[8] = {
554 0x07, 0x08, 0x0a, 0x0b,
555 0x0c, 0x0d, 0x10, 0x11,
558 static const hda_nid_t stac922x_pin_nids[10] = {
559 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
560 0x0f, 0x10, 0x11, 0x15, 0x1b,
563 static const hda_nid_t stac92hd73xx_pin_nids[13] = {
564 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
565 0x0f, 0x10, 0x11, 0x12, 0x13,
569 #define STAC92HD71BXX_NUM_PINS 13
570 static const hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
571 0x0a, 0x0b, 0x0c, 0x0d, 0x00,
572 0x00, 0x14, 0x18, 0x19, 0x1e,
575 static const hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
576 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
577 0x0f, 0x14, 0x18, 0x19, 0x1e,
581 static const hda_nid_t stac927x_pin_nids[14] = {
582 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
583 0x0f, 0x10, 0x11, 0x12, 0x13,
584 0x14, 0x21, 0x22, 0x23,
587 static const hda_nid_t stac9205_pin_nids[12] = {
588 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
589 0x0f, 0x14, 0x16, 0x17, 0x18,
593 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
594 struct snd_ctl_elem_info *uinfo)
596 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
597 struct sigmatel_spec *spec = codec->spec;
598 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
601 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
602 struct snd_ctl_elem_value *ucontrol)
604 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
605 struct sigmatel_spec *spec = codec->spec;
606 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
608 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
612 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
613 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 dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
619 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
620 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
623 static int stac92xx_smux_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->sinput_mux, uinfo);
631 static int stac92xx_smux_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;
636 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
638 ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
642 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
643 struct snd_ctl_elem_value *ucontrol)
645 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
646 struct sigmatel_spec *spec = codec->spec;
647 struct hda_input_mux *smux = &spec->private_smux;
648 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
652 err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
653 spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
657 if (spec->spdif_mute) {
659 nid = spec->multiout.dig_out_nid;
661 nid = codec->slave_dig_outs[smux_idx - 1];
662 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
666 /* un/mute SPDIF out */
667 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
673 static int stac_vrefout_set(struct hda_codec *codec,
674 hda_nid_t nid, unsigned int new_vref)
678 snd_printdd("%s, nid %x ctl %x\n", __func__, nid, new_vref);
679 pinctl = snd_hda_codec_read(codec, nid, 0,
680 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
686 pinctl &= ~AC_PINCTL_VREFEN;
687 pinctl |= (new_vref & AC_PINCTL_VREFEN);
689 error = snd_hda_set_pin_ctl_cache(codec, nid, pinctl);
696 static unsigned int stac92xx_vref_set(struct hda_codec *codec,
697 hda_nid_t nid, unsigned int new_vref)
701 pincfg = snd_hda_codec_read(codec, nid, 0,
702 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
705 pincfg &= ~(AC_PINCTL_VREFEN | AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
708 if (new_vref == AC_PINCTL_VREF_HIZ)
709 pincfg |= AC_PINCTL_OUT_EN;
711 pincfg |= AC_PINCTL_IN_EN;
713 error = snd_hda_set_pin_ctl_cache(codec, nid, pincfg);
720 static unsigned int stac92xx_vref_get(struct hda_codec *codec, hda_nid_t nid)
723 vref = snd_hda_codec_read(codec, nid, 0,
724 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
725 vref &= AC_PINCTL_VREFEN;
729 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
731 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
732 struct sigmatel_spec *spec = codec->spec;
733 return snd_hda_input_mux_info(spec->input_mux, uinfo);
736 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
738 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
739 struct sigmatel_spec *spec = codec->spec;
740 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
742 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
746 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
748 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
749 struct sigmatel_spec *spec = codec->spec;
750 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
751 const struct hda_input_mux *imux = spec->input_mux;
752 unsigned int idx, prev_idx, didx;
754 idx = ucontrol->value.enumerated.item[0];
755 if (idx >= imux->num_items)
756 idx = imux->num_items - 1;
757 prev_idx = spec->cur_mux[adc_idx];
760 if (idx < spec->num_analog_muxes) {
761 snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0,
762 AC_VERB_SET_CONNECT_SEL,
763 imux->items[idx].index);
764 if (prev_idx >= spec->num_analog_muxes &&
765 spec->mux_nids[adc_idx] != spec->dmux_nids[adc_idx]) {
766 imux = spec->dinput_mux;
768 snd_hda_codec_write_cache(codec,
769 spec->dmux_nids[adc_idx], 0,
770 AC_VERB_SET_CONNECT_SEL,
771 imux->items[0].index);
774 imux = spec->dinput_mux;
775 /* first dimux item is hardcoded to select analog imux,
778 didx = idx - spec->num_analog_muxes + 1;
779 snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0,
780 AC_VERB_SET_CONNECT_SEL,
781 imux->items[didx].index);
783 spec->cur_mux[adc_idx] = idx;
787 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
788 struct snd_ctl_elem_info *uinfo)
790 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
791 struct sigmatel_spec *spec = codec->spec;
792 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
795 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
796 struct snd_ctl_elem_value *ucontrol)
798 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
799 struct sigmatel_spec *spec = codec->spec;
801 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
805 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
806 struct snd_ctl_elem_value *ucontrol)
808 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
809 struct sigmatel_spec *spec = codec->spec;
811 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
812 spec->mono_nid, &spec->cur_mmux);
815 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
817 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
818 struct snd_ctl_elem_value *ucontrol)
820 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
821 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
822 struct sigmatel_spec *spec = codec->spec;
824 ucontrol->value.integer.value[0] = !!(spec->aloopback &
825 (spec->aloopback_mask << idx));
829 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
830 struct snd_ctl_elem_value *ucontrol)
832 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
833 struct sigmatel_spec *spec = codec->spec;
834 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
835 unsigned int dac_mode;
836 unsigned int val, idx_val;
838 idx_val = spec->aloopback_mask << idx;
839 if (ucontrol->value.integer.value[0])
840 val = spec->aloopback | idx_val;
842 val = spec->aloopback & ~idx_val;
843 if (spec->aloopback == val)
846 spec->aloopback = val;
848 /* Only return the bits defined by the shift value of the
849 * first two bytes of the mask
851 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
852 kcontrol->private_value & 0xFFFF, 0x0);
853 dac_mode >>= spec->aloopback_shift;
855 if (spec->aloopback & idx_val) {
856 snd_hda_power_up(codec);
859 snd_hda_power_down(codec);
860 dac_mode &= ~idx_val;
863 snd_hda_codec_write_cache(codec, codec->afg, 0,
864 kcontrol->private_value >> 16, dac_mode);
869 static const struct hda_verb stac9200_core_init[] = {
870 /* set dac0mux for dac converter */
871 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
875 static const struct hda_verb stac9200_eapd_init[] = {
876 /* set dac0mux for dac converter */
877 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
878 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
882 static const struct hda_verb dell_eq_core_init[] = {
883 /* set master volume to max value without distortion
884 * and direct control */
885 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
889 static const struct hda_verb stac92hd73xx_core_init[] = {
890 /* set master volume and direct control */
891 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
895 static const struct hda_verb stac92hd83xxx_core_init[] = {
896 /* power state controls amps */
897 { 0x01, AC_VERB_SET_EAPD, 1 << 2},
901 static const struct hda_verb stac92hd83xxx_hp_zephyr_init[] = {
902 { 0x22, 0x785, 0x43 },
903 { 0x22, 0x782, 0xe0 },
904 { 0x22, 0x795, 0x00 },
908 static const struct hda_verb stac92hd71bxx_core_init[] = {
909 /* set master volume and direct control */
910 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
914 static const struct hda_verb stac92hd71bxx_unmute_core_init[] = {
915 /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
916 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
917 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
918 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
922 static const struct hda_verb stac925x_core_init[] = {
923 /* set dac0mux for dac converter */
924 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
925 /* mute the master volume */
926 { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
930 static const struct hda_verb stac922x_core_init[] = {
931 /* set master volume and direct control */
932 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
936 static const struct hda_verb d965_core_init[] = {
937 /* set master volume and direct control */
938 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
939 /* unmute node 0x1b */
940 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
941 /* select node 0x03 as DAC */
942 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
946 static const struct hda_verb dell_3st_core_init[] = {
947 /* don't set delta bit */
948 {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
949 /* unmute node 0x1b */
950 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
951 /* select node 0x03 as DAC */
952 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
956 static const struct hda_verb stac927x_core_init[] = {
957 /* set master volume and direct control */
958 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
959 /* enable analog pc beep path */
960 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
964 static const struct hda_verb stac927x_volknob_core_init[] = {
965 /* don't set delta bit */
966 {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
967 /* enable analog pc beep path */
968 {0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
972 static const struct hda_verb stac9205_core_init[] = {
973 /* set master volume and direct control */
974 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
975 /* enable analog pc beep path */
976 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
980 #define STAC_MONO_MUX \
982 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
983 .name = "Mono Mux", \
985 .info = stac92xx_mono_mux_enum_info, \
986 .get = stac92xx_mono_mux_enum_get, \
987 .put = stac92xx_mono_mux_enum_put, \
990 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
992 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
993 .name = "Analog Loopback", \
995 .info = stac92xx_aloopback_info, \
996 .get = stac92xx_aloopback_get, \
997 .put = stac92xx_aloopback_put, \
998 .private_value = verb_read | (verb_write << 16), \
1001 #define DC_BIAS(xname, idx, nid) \
1003 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1006 .info = stac92xx_dc_bias_info, \
1007 .get = stac92xx_dc_bias_get, \
1008 .put = stac92xx_dc_bias_put, \
1009 .private_value = nid, \
1012 static const struct snd_kcontrol_new stac9200_mixer[] = {
1013 HDA_CODEC_VOLUME_MIN_MUTE("PCM Playback Volume", 0xb, 0, HDA_OUTPUT),
1014 HDA_CODEC_MUTE("PCM Playback Switch", 0xb, 0, HDA_OUTPUT),
1015 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
1016 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
1020 static const struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
1021 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
1025 static const struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = {
1026 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1030 static const struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
1031 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1036 static const struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
1037 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
1040 static const struct snd_kcontrol_new stac925x_mixer[] = {
1041 HDA_CODEC_VOLUME_MIN_MUTE("PCM Playback Volume", 0xe, 0, HDA_OUTPUT),
1042 HDA_CODEC_MUTE("PCM Playback Switch", 0x0e, 0, HDA_OUTPUT),
1046 static const struct snd_kcontrol_new stac9205_loopback[] = {
1047 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1051 static const struct snd_kcontrol_new stac927x_loopback[] = {
1052 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1056 static struct snd_kcontrol_new stac_dmux_mixer = {
1057 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1058 .name = "Digital Input Source",
1059 /* count set later */
1060 .info = stac92xx_dmux_enum_info,
1061 .get = stac92xx_dmux_enum_get,
1062 .put = stac92xx_dmux_enum_put,
1065 static struct snd_kcontrol_new stac_smux_mixer = {
1066 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1067 .name = "IEC958 Playback Source",
1068 /* count set later */
1069 .info = stac92xx_smux_enum_info,
1070 .get = stac92xx_smux_enum_get,
1071 .put = stac92xx_smux_enum_put,
1074 static const char * const slave_pfxs[] = {
1075 "Front", "Surround", "Center", "LFE", "Side",
1076 "Headphone", "Speaker", "IEC958",
1080 static void stac92xx_update_led_status(struct hda_codec *codec, int enabled);
1082 static void stac92xx_vmaster_hook(void *private_data, int val)
1084 stac92xx_update_led_status(private_data, val);
1087 static void stac92xx_free_kctls(struct hda_codec *codec);
1089 static int stac92xx_build_controls(struct hda_codec *codec)
1091 struct sigmatel_spec *spec = codec->spec;
1092 unsigned int vmaster_tlv[4];
1097 err = snd_hda_add_new_ctls(codec, spec->mixer);
1102 for (i = 0; i < spec->num_mixers; i++) {
1103 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1107 if (!spec->auto_mic && spec->num_dmuxes > 0 &&
1108 snd_hda_get_bool_hint(codec, "separate_dmux") == 1) {
1109 stac_dmux_mixer.count = spec->num_dmuxes;
1110 err = snd_hda_ctl_add(codec, 0,
1111 snd_ctl_new1(&stac_dmux_mixer, codec));
1115 if (spec->num_smuxes > 0) {
1116 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1117 struct hda_input_mux *smux = &spec->private_smux;
1118 /* check for mute support on SPDIF out */
1119 if (wcaps & AC_WCAP_OUT_AMP) {
1120 snd_hda_add_imux_item(smux, "Off", 0, NULL);
1121 spec->spdif_mute = 1;
1123 stac_smux_mixer.count = spec->num_smuxes;
1124 err = snd_hda_ctl_add(codec, 0,
1125 snd_ctl_new1(&stac_smux_mixer, codec));
1130 if (spec->multiout.dig_out_nid) {
1131 err = snd_hda_create_spdif_out_ctls(codec,
1132 spec->multiout.dig_out_nid,
1133 spec->multiout.dig_out_nid);
1136 err = snd_hda_create_spdif_share_sw(codec,
1140 spec->multiout.share_spdif = 1;
1142 if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1143 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1148 /* if we have no master control, let's create it */
1149 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1150 HDA_OUTPUT, vmaster_tlv);
1151 /* correct volume offset */
1152 vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
1153 /* minimum value is actually mute */
1154 vmaster_tlv[3] |= TLV_DB_SCALE_MUTE;
1155 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1156 vmaster_tlv, slave_pfxs,
1161 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
1163 "Playback Switch", true,
1164 &spec->vmaster_mute.sw_kctl);
1168 if (spec->gpio_led) {
1169 spec->vmaster_mute.hook = stac92xx_vmaster_hook;
1170 err = snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute, true);
1175 if (spec->aloopback_ctl &&
1176 snd_hda_get_bool_hint(codec, "loopback") == 1) {
1177 err = snd_hda_add_new_ctls(codec, spec->aloopback_ctl);
1182 stac92xx_free_kctls(codec); /* no longer needed */
1184 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
1191 static const unsigned int ref9200_pin_configs[8] = {
1192 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1193 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1196 static const unsigned int gateway9200_m4_pin_configs[8] = {
1197 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1198 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1200 static const unsigned int gateway9200_m4_2_pin_configs[8] = {
1201 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1202 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1206 STAC 9200 pin configs for
1211 static const unsigned int dell9200_d21_pin_configs[8] = {
1212 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
1213 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1217 STAC 9200 pin configs for
1221 static const unsigned int dell9200_d22_pin_configs[8] = {
1222 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1223 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1227 STAC 9200 pin configs for
1228 102801C4 (Dell Dimension E310)
1235 static const unsigned int dell9200_d23_pin_configs[8] = {
1236 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1237 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
1242 STAC 9200-32 pin configs for
1243 102801B5 (Dell Inspiron 630m)
1244 102801D8 (Dell Inspiron 640m)
1246 static const unsigned int dell9200_m21_pin_configs[8] = {
1247 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1248 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1252 STAC 9200-32 pin configs for
1253 102801C2 (Dell Latitude D620)
1255 102801CC (Dell Latitude D820)
1259 static const unsigned int dell9200_m22_pin_configs[8] = {
1260 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1261 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1265 STAC 9200-32 pin configs for
1266 102801CE (Dell XPS M1710)
1267 102801CF (Dell Precision M90)
1269 static const unsigned int dell9200_m23_pin_configs[8] = {
1270 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1271 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1275 STAC 9200-32 pin configs for
1278 102801CB (Dell Latitude 120L)
1281 static const unsigned int dell9200_m24_pin_configs[8] = {
1282 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1283 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1287 STAC 9200-32 pin configs for
1288 102801BD (Dell Inspiron E1505n)
1292 static const unsigned int dell9200_m25_pin_configs[8] = {
1293 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1294 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1298 STAC 9200-32 pin configs for
1299 102801F5 (Dell Inspiron 1501)
1302 static const unsigned int dell9200_m26_pin_configs[8] = {
1303 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1304 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1309 102801CD (Dell Inspiron E1705/9400)
1311 static const unsigned int dell9200_m27_pin_configs[8] = {
1312 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1313 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1316 static const unsigned int oqo9200_pin_configs[8] = {
1317 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1318 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1322 static const unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1323 [STAC_REF] = ref9200_pin_configs,
1324 [STAC_9200_OQO] = oqo9200_pin_configs,
1325 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1326 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1327 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1328 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1329 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1330 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1331 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1332 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1333 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1334 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1335 [STAC_9200_M4] = gateway9200_m4_pin_configs,
1336 [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1337 [STAC_9200_PANASONIC] = ref9200_pin_configs,
1340 static const char * const stac9200_models[STAC_9200_MODELS] = {
1341 [STAC_AUTO] = "auto",
1343 [STAC_9200_OQO] = "oqo",
1344 [STAC_9200_DELL_D21] = "dell-d21",
1345 [STAC_9200_DELL_D22] = "dell-d22",
1346 [STAC_9200_DELL_D23] = "dell-d23",
1347 [STAC_9200_DELL_M21] = "dell-m21",
1348 [STAC_9200_DELL_M22] = "dell-m22",
1349 [STAC_9200_DELL_M23] = "dell-m23",
1350 [STAC_9200_DELL_M24] = "dell-m24",
1351 [STAC_9200_DELL_M25] = "dell-m25",
1352 [STAC_9200_DELL_M26] = "dell-m26",
1353 [STAC_9200_DELL_M27] = "dell-m27",
1354 [STAC_9200_M4] = "gateway-m4",
1355 [STAC_9200_M4_2] = "gateway-m4-2",
1356 [STAC_9200_PANASONIC] = "panasonic",
1359 static const struct snd_pci_quirk stac9200_cfg_tbl[] = {
1360 /* SigmaTel reference board */
1361 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1362 "DFI LanParty", STAC_REF),
1363 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1364 "DFI LanParty", STAC_REF),
1365 /* Dell laptops have BIOS problem */
1366 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1367 "unknown Dell", STAC_9200_DELL_D21),
1368 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1369 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1370 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1371 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1372 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1373 "unknown Dell", STAC_9200_DELL_D22),
1374 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1375 "unknown Dell", STAC_9200_DELL_D22),
1376 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1377 "Dell Latitude D620", STAC_9200_DELL_M22),
1378 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1379 "unknown Dell", STAC_9200_DELL_D23),
1380 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1381 "unknown Dell", STAC_9200_DELL_D23),
1382 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1383 "unknown Dell", STAC_9200_DELL_M22),
1384 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1385 "unknown Dell", STAC_9200_DELL_M24),
1386 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1387 "unknown Dell", STAC_9200_DELL_M24),
1388 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1389 "Dell Latitude 120L", STAC_9200_DELL_M24),
1390 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1391 "Dell Latitude D820", STAC_9200_DELL_M22),
1392 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1393 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1394 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1395 "Dell XPS M1710", STAC_9200_DELL_M23),
1396 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1397 "Dell Precision M90", STAC_9200_DELL_M23),
1398 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1399 "unknown Dell", STAC_9200_DELL_M22),
1400 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1401 "unknown Dell", STAC_9200_DELL_M22),
1402 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1403 "unknown Dell", STAC_9200_DELL_M22),
1404 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1405 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1406 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1407 "unknown Dell", STAC_9200_DELL_D23),
1408 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1409 "unknown Dell", STAC_9200_DELL_D23),
1410 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1411 "unknown Dell", STAC_9200_DELL_D21),
1412 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1413 "unknown Dell", STAC_9200_DELL_D23),
1414 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1415 "unknown Dell", STAC_9200_DELL_D21),
1416 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1417 "unknown Dell", STAC_9200_DELL_M25),
1418 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1419 "unknown Dell", STAC_9200_DELL_M25),
1420 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1421 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1422 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1423 "unknown Dell", STAC_9200_DELL_M26),
1425 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1426 /* Gateway machines needs EAPD to be set on resume */
1427 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1428 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1429 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1431 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1435 static const unsigned int ref925x_pin_configs[8] = {
1436 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1437 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1440 static const unsigned int stac925xM1_pin_configs[8] = {
1441 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1442 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1445 static const unsigned int stac925xM1_2_pin_configs[8] = {
1446 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1447 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1450 static const unsigned int stac925xM2_pin_configs[8] = {
1451 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1452 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1455 static const unsigned int stac925xM2_2_pin_configs[8] = {
1456 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1457 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1460 static const unsigned int stac925xM3_pin_configs[8] = {
1461 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1462 0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1465 static const unsigned int stac925xM5_pin_configs[8] = {
1466 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1467 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1470 static const unsigned int stac925xM6_pin_configs[8] = {
1471 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1472 0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1475 static const unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1476 [STAC_REF] = ref925x_pin_configs,
1477 [STAC_M1] = stac925xM1_pin_configs,
1478 [STAC_M1_2] = stac925xM1_2_pin_configs,
1479 [STAC_M2] = stac925xM2_pin_configs,
1480 [STAC_M2_2] = stac925xM2_2_pin_configs,
1481 [STAC_M3] = stac925xM3_pin_configs,
1482 [STAC_M5] = stac925xM5_pin_configs,
1483 [STAC_M6] = stac925xM6_pin_configs,
1486 static const char * const stac925x_models[STAC_925x_MODELS] = {
1487 [STAC_925x_AUTO] = "auto",
1490 [STAC_M1_2] = "m1-2",
1492 [STAC_M2_2] = "m2-2",
1498 static const struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1499 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1500 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1501 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1502 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1503 SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1504 /* Not sure about the brand name for those */
1505 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1506 SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1507 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1508 SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1512 static const struct snd_pci_quirk stac925x_cfg_tbl[] = {
1513 /* SigmaTel reference board */
1514 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1515 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
1516 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1518 /* Default table for unknown ID */
1519 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1524 static const unsigned int ref92hd73xx_pin_configs[13] = {
1525 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1526 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1527 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1531 static const unsigned int dell_m6_pin_configs[13] = {
1532 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1533 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1534 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1538 static const unsigned int alienware_m17x_pin_configs[13] = {
1539 0x0321101f, 0x0321101f, 0x03a11020, 0x03014020,
1540 0x90170110, 0x4f0000f0, 0x4f0000f0, 0x4f0000f0,
1541 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1545 static const unsigned int intel_dg45id_pin_configs[13] = {
1546 0x02214230, 0x02A19240, 0x01013214, 0x01014210,
1547 0x01A19250, 0x01011212, 0x01016211
1550 static const unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1551 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1552 [STAC_DELL_M6_AMIC] = dell_m6_pin_configs,
1553 [STAC_DELL_M6_DMIC] = dell_m6_pin_configs,
1554 [STAC_DELL_M6_BOTH] = dell_m6_pin_configs,
1555 [STAC_DELL_EQ] = dell_m6_pin_configs,
1556 [STAC_ALIENWARE_M17X] = alienware_m17x_pin_configs,
1557 [STAC_92HD73XX_INTEL] = intel_dg45id_pin_configs,
1560 static const char * const stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1561 [STAC_92HD73XX_AUTO] = "auto",
1562 [STAC_92HD73XX_NO_JD] = "no-jd",
1563 [STAC_92HD73XX_REF] = "ref",
1564 [STAC_92HD73XX_INTEL] = "intel",
1565 [STAC_DELL_M6_AMIC] = "dell-m6-amic",
1566 [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1567 [STAC_DELL_M6_BOTH] = "dell-m6",
1568 [STAC_DELL_EQ] = "dell-eq",
1569 [STAC_ALIENWARE_M17X] = "alienware",
1572 static const struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1573 /* SigmaTel reference board */
1574 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1575 "DFI LanParty", STAC_92HD73XX_REF),
1576 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1577 "DFI LanParty", STAC_92HD73XX_REF),
1578 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
1579 "Intel DG45ID", STAC_92HD73XX_INTEL),
1580 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
1581 "Intel DG45FC", STAC_92HD73XX_INTEL),
1582 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1583 "Dell Studio 1535", STAC_DELL_M6_DMIC),
1584 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1585 "unknown Dell", STAC_DELL_M6_DMIC),
1586 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1587 "unknown Dell", STAC_DELL_M6_BOTH),
1588 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1589 "unknown Dell", STAC_DELL_M6_BOTH),
1590 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1591 "unknown Dell", STAC_DELL_M6_AMIC),
1592 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1593 "unknown Dell", STAC_DELL_M6_AMIC),
1594 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1595 "unknown Dell", STAC_DELL_M6_DMIC),
1596 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1597 "unknown Dell", STAC_DELL_M6_DMIC),
1598 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1599 "Dell Studio 1537", STAC_DELL_M6_DMIC),
1600 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1601 "Dell Studio 17", STAC_DELL_M6_DMIC),
1602 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
1603 "Dell Studio 1555", STAC_DELL_M6_DMIC),
1604 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd,
1605 "Dell Studio 1557", STAC_DELL_M6_DMIC),
1606 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe,
1607 "Dell Studio XPS 1645", STAC_DELL_M6_DMIC),
1608 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413,
1609 "Dell Studio 1558", STAC_DELL_M6_DMIC),
1613 static const struct snd_pci_quirk stac92hd73xx_codec_id_cfg_tbl[] = {
1614 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1,
1615 "Alienware M17x", STAC_ALIENWARE_M17X),
1616 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x043a,
1617 "Alienware M17x", STAC_ALIENWARE_M17X),
1618 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0490,
1619 "Alienware M17x R3", STAC_DELL_EQ),
1623 static const unsigned int ref92hd83xxx_pin_configs[10] = {
1624 0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1625 0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1626 0x01451160, 0x98560170,
1629 static const unsigned int dell_s14_pin_configs[10] = {
1630 0x0221403f, 0x0221101f, 0x02a19020, 0x90170110,
1631 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a60160,
1632 0x40f000f0, 0x40f000f0,
1635 static const unsigned int dell_vostro_3500_pin_configs[10] = {
1636 0x02a11020, 0x0221101f, 0x400000f0, 0x90170110,
1637 0x400000f1, 0x400000f2, 0x400000f3, 0x90a60160,
1638 0x400000f4, 0x400000f5,
1641 static const unsigned int hp_dv7_4000_pin_configs[10] = {
1642 0x03a12050, 0x0321201f, 0x40f000f0, 0x90170110,
1643 0x40f000f0, 0x40f000f0, 0x90170110, 0xd5a30140,
1644 0x40f000f0, 0x40f000f0,
1647 static const unsigned int hp_zephyr_pin_configs[10] = {
1648 0x01813050, 0x0421201f, 0x04a1205e, 0x96130310,
1649 0x96130310, 0x0101401f, 0x1111611f, 0xd5a30130,
1653 static const unsigned int hp_cNB11_intquad_pin_configs[10] = {
1654 0x40f000f0, 0x0221101f, 0x02a11020, 0x92170110,
1655 0x40f000f0, 0x92170110, 0x40f000f0, 0xd5a30130,
1656 0x40f000f0, 0x40f000f0,
1659 static const unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1660 [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1661 [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
1662 [STAC_DELL_S14] = dell_s14_pin_configs,
1663 [STAC_DELL_VOSTRO_3500] = dell_vostro_3500_pin_configs,
1664 [STAC_92HD83XXX_HP_cNB11_INTQUAD] = hp_cNB11_intquad_pin_configs,
1665 [STAC_HP_DV7_4000] = hp_dv7_4000_pin_configs,
1666 [STAC_HP_ZEPHYR] = hp_zephyr_pin_configs,
1669 static const char * const stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1670 [STAC_92HD83XXX_AUTO] = "auto",
1671 [STAC_92HD83XXX_REF] = "ref",
1672 [STAC_92HD83XXX_PWR_REF] = "mic-ref",
1673 [STAC_DELL_S14] = "dell-s14",
1674 [STAC_DELL_VOSTRO_3500] = "dell-vostro-3500",
1675 [STAC_92HD83XXX_HP_cNB11_INTQUAD] = "hp_cNB11_intquad",
1676 [STAC_HP_DV7_4000] = "hp-dv7-4000",
1677 [STAC_HP_ZEPHYR] = "hp-zephyr",
1680 static const struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1681 /* SigmaTel reference board */
1682 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1683 "DFI LanParty", STAC_92HD83XXX_REF),
1684 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1685 "DFI LanParty", STAC_92HD83XXX_REF),
1686 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
1687 "unknown Dell", STAC_DELL_S14),
1688 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x1028,
1689 "Dell Vostro 3500", STAC_DELL_VOSTRO_3500),
1690 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1656,
1691 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1692 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1657,
1693 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1694 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1658,
1695 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1696 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1659,
1697 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1698 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x165A,
1699 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1700 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x165B,
1701 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1702 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3388,
1703 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1704 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3389,
1705 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1706 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355B,
1707 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1708 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355C,
1709 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1710 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355D,
1711 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1712 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355E,
1713 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1714 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355F,
1715 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1716 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3560,
1717 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1718 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358B,
1719 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1720 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358C,
1721 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1722 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358D,
1723 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1724 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3591,
1725 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1726 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3592,
1727 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1728 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3593,
1729 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1730 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3561,
1731 "HP", STAC_HP_ZEPHYR),
1735 static const struct snd_pci_quirk stac92hd83xxx_codec_id_cfg_tbl[] = {
1736 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3561,
1737 "HP", STAC_HP_ZEPHYR),
1741 static const unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1742 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1743 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1744 0x90a000f0, 0x01452050, 0x01452050, 0x00000000,
1748 static const unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1749 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1750 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1751 0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000,
1755 static const unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1756 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1757 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1758 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1762 static const unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1763 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1764 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1765 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1769 static const unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1770 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1771 [STAC_DELL_M4_1] = dell_m4_1_pin_configs,
1772 [STAC_DELL_M4_2] = dell_m4_2_pin_configs,
1773 [STAC_DELL_M4_3] = dell_m4_3_pin_configs,
1774 [STAC_HP_M4] = NULL,
1775 [STAC_HP_DV4] = NULL,
1776 [STAC_HP_DV5] = NULL,
1777 [STAC_HP_HDX] = NULL,
1778 [STAC_HP_DV4_1222NR] = NULL,
1781 static const char * const stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1782 [STAC_92HD71BXX_AUTO] = "auto",
1783 [STAC_92HD71BXX_REF] = "ref",
1784 [STAC_DELL_M4_1] = "dell-m4-1",
1785 [STAC_DELL_M4_2] = "dell-m4-2",
1786 [STAC_DELL_M4_3] = "dell-m4-3",
1787 [STAC_HP_M4] = "hp-m4",
1788 [STAC_HP_DV4] = "hp-dv4",
1789 [STAC_HP_DV5] = "hp-dv5",
1790 [STAC_HP_HDX] = "hp-hdx",
1791 [STAC_HP_DV4_1222NR] = "hp-dv4-1222nr",
1794 static const struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1795 /* SigmaTel reference board */
1796 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1797 "DFI LanParty", STAC_92HD71BXX_REF),
1798 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1799 "DFI LanParty", STAC_92HD71BXX_REF),
1800 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb,
1801 "HP dv4-1222nr", STAC_HP_DV4_1222NR),
1802 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720,
1804 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
1806 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
1807 "HP dv4-7", STAC_HP_DV4),
1808 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
1809 "HP dv4-7", STAC_HP_DV5),
1810 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
1811 "HP HDX", STAC_HP_HDX), /* HDX18 */
1812 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1813 "HP mini 1000", STAC_HP_M4),
1814 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
1815 "HP HDX", STAC_HP_HDX), /* HDX16 */
1816 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
1817 "HP dv6", STAC_HP_DV5),
1818 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061,
1819 "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */
1820 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x363e,
1821 "HP DV6", STAC_HP_DV5),
1822 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
1824 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1825 "unknown Dell", STAC_DELL_M4_1),
1826 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1827 "unknown Dell", STAC_DELL_M4_1),
1828 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1829 "unknown Dell", STAC_DELL_M4_1),
1830 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1831 "unknown Dell", STAC_DELL_M4_1),
1832 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1833 "unknown Dell", STAC_DELL_M4_1),
1834 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1835 "unknown Dell", STAC_DELL_M4_1),
1836 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1837 "unknown Dell", STAC_DELL_M4_1),
1838 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1839 "unknown Dell", STAC_DELL_M4_2),
1840 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1841 "unknown Dell", STAC_DELL_M4_2),
1842 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1843 "unknown Dell", STAC_DELL_M4_2),
1844 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1845 "unknown Dell", STAC_DELL_M4_2),
1846 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1847 "unknown Dell", STAC_DELL_M4_3),
1851 static const unsigned int ref922x_pin_configs[10] = {
1852 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1853 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1854 0x40000100, 0x40000100,
1858 STAC 922X pin configs for
1865 static const unsigned int dell_922x_d81_pin_configs[10] = {
1866 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1867 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1868 0x01813122, 0x400001f2,
1872 STAC 922X pin configs for
1876 static const unsigned int dell_922x_d82_pin_configs[10] = {
1877 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1878 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1879 0x01813122, 0x400001f1,
1883 STAC 922X pin configs for
1886 static const unsigned int dell_922x_m81_pin_configs[10] = {
1887 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1888 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1889 0x40C003f1, 0x405003f0,
1893 STAC 9221 A1 pin configs for
1894 102801D7 (Dell XPS M1210)
1896 static const unsigned int dell_922x_m82_pin_configs[10] = {
1897 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1898 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1899 0x508003f3, 0x405003f4,
1902 static const unsigned int d945gtp3_pin_configs[10] = {
1903 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1904 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1905 0x02a19120, 0x40000100,
1908 static const unsigned int d945gtp5_pin_configs[10] = {
1909 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1910 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1911 0x02a19320, 0x40000100,
1914 static const unsigned int intel_mac_v1_pin_configs[10] = {
1915 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1916 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1917 0x400000fc, 0x400000fb,
1920 static const unsigned int intel_mac_v2_pin_configs[10] = {
1921 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1922 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1923 0x400000fc, 0x400000fb,
1926 static const unsigned int intel_mac_v3_pin_configs[10] = {
1927 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1928 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1929 0x400000fc, 0x400000fb,
1932 static const unsigned int intel_mac_v4_pin_configs[10] = {
1933 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1934 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1935 0x400000fc, 0x400000fb,
1938 static const unsigned int intel_mac_v5_pin_configs[10] = {
1939 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1940 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1941 0x400000fc, 0x400000fb,
1944 static const unsigned int ecs202_pin_configs[10] = {
1945 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1946 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1947 0x9037012e, 0x40e000f2,
1950 static const unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1951 [STAC_D945_REF] = ref922x_pin_configs,
1952 [STAC_D945GTP3] = d945gtp3_pin_configs,
1953 [STAC_D945GTP5] = d945gtp5_pin_configs,
1954 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1955 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1956 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1957 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1958 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1959 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1960 /* for backward compatibility */
1961 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1962 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1963 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1964 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1965 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1966 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1967 [STAC_ECS_202] = ecs202_pin_configs,
1968 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1969 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1970 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1971 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1974 static const char * const stac922x_models[STAC_922X_MODELS] = {
1975 [STAC_922X_AUTO] = "auto",
1976 [STAC_D945_REF] = "ref",
1977 [STAC_D945GTP5] = "5stack",
1978 [STAC_D945GTP3] = "3stack",
1979 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1980 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1981 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1982 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1983 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1984 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1985 /* for backward compatibility */
1986 [STAC_MACMINI] = "macmini",
1987 [STAC_MACBOOK] = "macbook",
1988 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1989 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1990 [STAC_IMAC_INTEL] = "imac-intel",
1991 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1992 [STAC_ECS_202] = "ecs202",
1993 [STAC_922X_DELL_D81] = "dell-d81",
1994 [STAC_922X_DELL_D82] = "dell-d82",
1995 [STAC_922X_DELL_M81] = "dell-m81",
1996 [STAC_922X_DELL_M82] = "dell-m82",
1999 static const struct snd_pci_quirk stac922x_cfg_tbl[] = {
2000 /* SigmaTel reference board */
2001 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2002 "DFI LanParty", STAC_D945_REF),
2003 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2004 "DFI LanParty", STAC_D945_REF),
2005 /* Intel 945G based systems */
2006 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
2007 "Intel D945G", STAC_D945GTP3),
2008 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
2009 "Intel D945G", STAC_D945GTP3),
2010 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
2011 "Intel D945G", STAC_D945GTP3),
2012 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
2013 "Intel D945G", STAC_D945GTP3),
2014 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
2015 "Intel D945G", STAC_D945GTP3),
2016 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
2017 "Intel D945G", STAC_D945GTP3),
2018 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
2019 "Intel D945G", STAC_D945GTP3),
2020 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
2021 "Intel D945G", STAC_D945GTP3),
2022 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
2023 "Intel D945G", STAC_D945GTP3),
2024 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
2025 "Intel D945G", STAC_D945GTP3),
2026 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
2027 "Intel D945G", STAC_D945GTP3),
2028 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
2029 "Intel D945G", STAC_D945GTP3),
2030 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
2031 "Intel D945G", STAC_D945GTP3),
2032 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
2033 "Intel D945G", STAC_D945GTP3),
2034 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
2035 "Intel D945G", STAC_D945GTP3),
2036 /* Intel D945G 5-stack systems */
2037 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
2038 "Intel D945G", STAC_D945GTP5),
2039 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
2040 "Intel D945G", STAC_D945GTP5),
2041 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
2042 "Intel D945G", STAC_D945GTP5),
2043 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
2044 "Intel D945G", STAC_D945GTP5),
2045 /* Intel 945P based systems */
2046 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
2047 "Intel D945P", STAC_D945GTP3),
2048 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
2049 "Intel D945P", STAC_D945GTP3),
2050 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
2051 "Intel D945P", STAC_D945GTP3),
2052 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
2053 "Intel D945P", STAC_D945GTP3),
2054 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
2055 "Intel D945P", STAC_D945GTP3),
2056 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
2057 "Intel D945P", STAC_D945GTP5),
2059 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
2060 "Intel D945", STAC_D945_REF),
2062 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
2063 SND_PCI_QUIRK(0x8384, 0x7680,
2064 "Mac", STAC_INTEL_MAC_AUTO),
2066 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
2067 "unknown Dell", STAC_922X_DELL_D81),
2068 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
2069 "unknown Dell", STAC_922X_DELL_D81),
2070 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
2071 "unknown Dell", STAC_922X_DELL_D81),
2072 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
2073 "unknown Dell", STAC_922X_DELL_D82),
2074 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
2075 "unknown Dell", STAC_922X_DELL_M81),
2076 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
2077 "unknown Dell", STAC_922X_DELL_D82),
2078 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
2079 "unknown Dell", STAC_922X_DELL_D81),
2080 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
2081 "unknown Dell", STAC_922X_DELL_D81),
2082 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
2083 "Dell XPS M1210", STAC_922X_DELL_M82),
2084 /* ECS/PC Chips boards */
2085 SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
2086 "ECS/PC chips", STAC_ECS_202),
2090 static const unsigned int ref927x_pin_configs[14] = {
2091 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2092 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
2093 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2094 0x01c42190, 0x40000100,
2097 static const unsigned int d965_3st_pin_configs[14] = {
2098 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2099 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2100 0x40000100, 0x40000100, 0x40000100, 0x40000100,
2101 0x40000100, 0x40000100
2104 static const unsigned int d965_5st_pin_configs[14] = {
2105 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2106 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2107 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2108 0x40000100, 0x40000100
2111 static const unsigned int d965_5st_no_fp_pin_configs[14] = {
2112 0x40000100, 0x40000100, 0x0181304e, 0x01014010,
2113 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2114 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2115 0x40000100, 0x40000100
2118 static const unsigned int dell_3st_pin_configs[14] = {
2119 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2120 0x01111212, 0x01116211, 0x01813050, 0x01112214,
2121 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2122 0x40c003fc, 0x40000100
2125 static const unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2126 [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2127 [STAC_D965_REF] = ref927x_pin_configs,
2128 [STAC_D965_3ST] = d965_3st_pin_configs,
2129 [STAC_D965_5ST] = d965_5st_pin_configs,
2130 [STAC_D965_5ST_NO_FP] = d965_5st_no_fp_pin_configs,
2131 [STAC_DELL_3ST] = dell_3st_pin_configs,
2132 [STAC_DELL_BIOS] = NULL,
2133 [STAC_927X_VOLKNOB] = NULL,
2136 static const char * const stac927x_models[STAC_927X_MODELS] = {
2137 [STAC_927X_AUTO] = "auto",
2138 [STAC_D965_REF_NO_JD] = "ref-no-jd",
2139 [STAC_D965_REF] = "ref",
2140 [STAC_D965_3ST] = "3stack",
2141 [STAC_D965_5ST] = "5stack",
2142 [STAC_D965_5ST_NO_FP] = "5stack-no-fp",
2143 [STAC_DELL_3ST] = "dell-3stack",
2144 [STAC_DELL_BIOS] = "dell-bios",
2145 [STAC_927X_VOLKNOB] = "volknob",
2148 static const struct snd_pci_quirk stac927x_cfg_tbl[] = {
2149 /* SigmaTel reference board */
2150 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2151 "DFI LanParty", STAC_D965_REF),
2152 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2153 "DFI LanParty", STAC_D965_REF),
2154 /* Intel 946 based systems */
2155 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2156 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2157 /* 965 based 3 stack systems */
2158 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
2159 "Intel D965", STAC_D965_3ST),
2160 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
2161 "Intel D965", STAC_D965_3ST),
2162 /* Dell 3 stack systems */
2163 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2164 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
2165 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
2166 /* Dell 3 stack systems with verb table in BIOS */
2167 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2168 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_BIOS),
2169 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
2170 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
2171 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
2172 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
2173 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
2174 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
2175 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2176 /* 965 based 5 stack systems */
2177 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
2178 "Intel D965", STAC_D965_5ST),
2179 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
2180 "Intel D965", STAC_D965_5ST),
2181 /* volume-knob fixes */
2182 SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB),
2186 static const unsigned int ref9205_pin_configs[12] = {
2187 0x40000100, 0x40000100, 0x01016011, 0x01014010,
2188 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2189 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2193 STAC 9205 pin configs for
2200 10280228 (Dell Vostro 1500)
2201 10280229 (Dell Vostro 1700)
2203 static const unsigned int dell_9205_m42_pin_configs[12] = {
2204 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2205 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2206 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2210 STAC 9205 pin configs for
2214 102801FF (Dell Precision M4300)
2219 static const unsigned int dell_9205_m43_pin_configs[12] = {
2220 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2221 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2222 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2225 static const unsigned int dell_9205_m44_pin_configs[12] = {
2226 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2227 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2228 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2231 static const unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2232 [STAC_9205_REF] = ref9205_pin_configs,
2233 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2234 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2235 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2236 [STAC_9205_EAPD] = NULL,
2239 static const char * const stac9205_models[STAC_9205_MODELS] = {
2240 [STAC_9205_AUTO] = "auto",
2241 [STAC_9205_REF] = "ref",
2242 [STAC_9205_DELL_M42] = "dell-m42",
2243 [STAC_9205_DELL_M43] = "dell-m43",
2244 [STAC_9205_DELL_M44] = "dell-m44",
2245 [STAC_9205_EAPD] = "eapd",
2248 static const struct snd_pci_quirk stac9205_cfg_tbl[] = {
2249 /* SigmaTel reference board */
2250 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2251 "DFI LanParty", STAC_9205_REF),
2252 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
2253 "SigmaTel", STAC_9205_REF),
2254 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2255 "DFI LanParty", STAC_9205_REF),
2257 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2258 "unknown Dell", STAC_9205_DELL_M42),
2259 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2260 "unknown Dell", STAC_9205_DELL_M42),
2261 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2262 "Dell Precision", STAC_9205_DELL_M43),
2263 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2264 "Dell Precision", STAC_9205_DELL_M43),
2265 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2266 "Dell Precision", STAC_9205_DELL_M43),
2267 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2268 "unknown Dell", STAC_9205_DELL_M42),
2269 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2270 "unknown Dell", STAC_9205_DELL_M42),
2271 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2272 "Dell Precision", STAC_9205_DELL_M43),
2273 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2274 "Dell Precision M4300", STAC_9205_DELL_M43),
2275 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2276 "unknown Dell", STAC_9205_DELL_M42),
2277 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2278 "Dell Precision", STAC_9205_DELL_M43),
2279 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2280 "Dell Precision", STAC_9205_DELL_M43),
2281 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2282 "Dell Precision", STAC_9205_DELL_M43),
2283 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2284 "Dell Inspiron", STAC_9205_DELL_M44),
2285 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2286 "Dell Vostro 1500", STAC_9205_DELL_M42),
2287 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229,
2288 "Dell Vostro 1700", STAC_9205_DELL_M42),
2290 SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
2291 SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
2295 static void stac92xx_set_config_regs(struct hda_codec *codec,
2296 const unsigned int *pincfgs)
2299 struct sigmatel_spec *spec = codec->spec;
2304 for (i = 0; i < spec->num_pins; i++)
2305 if (spec->pin_nids[i] && pincfgs[i])
2306 snd_hda_codec_set_pincfg(codec, spec->pin_nids[i],
2311 * Analog playback callbacks
2313 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2314 struct hda_codec *codec,
2315 struct snd_pcm_substream *substream)
2317 struct sigmatel_spec *spec = codec->spec;
2318 if (spec->stream_delay)
2319 msleep(spec->stream_delay);
2320 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2324 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2325 struct hda_codec *codec,
2326 unsigned int stream_tag,
2327 unsigned int format,
2328 struct snd_pcm_substream *substream)
2330 struct sigmatel_spec *spec = codec->spec;
2331 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2334 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2335 struct hda_codec *codec,
2336 struct snd_pcm_substream *substream)
2338 struct sigmatel_spec *spec = codec->spec;
2339 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2343 * Digital playback callbacks
2345 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2346 struct hda_codec *codec,
2347 struct snd_pcm_substream *substream)
2349 struct sigmatel_spec *spec = codec->spec;
2350 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2353 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2354 struct hda_codec *codec,
2355 struct snd_pcm_substream *substream)
2357 struct sigmatel_spec *spec = codec->spec;
2358 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2361 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2362 struct hda_codec *codec,
2363 unsigned int stream_tag,
2364 unsigned int format,
2365 struct snd_pcm_substream *substream)
2367 struct sigmatel_spec *spec = codec->spec;
2368 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2369 stream_tag, format, substream);
2372 static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2373 struct hda_codec *codec,
2374 struct snd_pcm_substream *substream)
2376 struct sigmatel_spec *spec = codec->spec;
2377 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2382 * Analog capture callbacks
2384 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2385 struct hda_codec *codec,
2386 unsigned int stream_tag,
2387 unsigned int format,
2388 struct snd_pcm_substream *substream)
2390 struct sigmatel_spec *spec = codec->spec;
2391 hda_nid_t nid = spec->adc_nids[substream->number];
2393 if (spec->powerdown_adcs) {
2395 snd_hda_codec_write(codec, nid, 0,
2396 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2398 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2402 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2403 struct hda_codec *codec,
2404 struct snd_pcm_substream *substream)
2406 struct sigmatel_spec *spec = codec->spec;
2407 hda_nid_t nid = spec->adc_nids[substream->number];
2409 snd_hda_codec_cleanup_stream(codec, nid);
2410 if (spec->powerdown_adcs)
2411 snd_hda_codec_write(codec, nid, 0,
2412 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2416 static const struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2420 /* NID is set in stac92xx_build_pcms */
2422 .open = stac92xx_dig_playback_pcm_open,
2423 .close = stac92xx_dig_playback_pcm_close,
2424 .prepare = stac92xx_dig_playback_pcm_prepare,
2425 .cleanup = stac92xx_dig_playback_pcm_cleanup
2429 static const struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2433 /* NID is set in stac92xx_build_pcms */
2436 static const struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2440 .nid = 0x02, /* NID to query formats and rates */
2442 .open = stac92xx_playback_pcm_open,
2443 .prepare = stac92xx_playback_pcm_prepare,
2444 .cleanup = stac92xx_playback_pcm_cleanup
2448 static const struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2452 .nid = 0x06, /* NID to query formats and rates */
2454 .open = stac92xx_playback_pcm_open,
2455 .prepare = stac92xx_playback_pcm_prepare,
2456 .cleanup = stac92xx_playback_pcm_cleanup
2460 static const struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2463 /* NID + .substreams is set in stac92xx_build_pcms */
2465 .prepare = stac92xx_capture_pcm_prepare,
2466 .cleanup = stac92xx_capture_pcm_cleanup
2470 static int stac92xx_build_pcms(struct hda_codec *codec)
2472 struct sigmatel_spec *spec = codec->spec;
2473 struct hda_pcm *info = spec->pcm_rec;
2475 codec->num_pcms = 1;
2476 codec->pcm_info = info;
2478 info->name = "STAC92xx Analog";
2479 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2480 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2481 spec->multiout.dac_nids[0];
2482 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2483 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2484 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2486 if (spec->alt_switch) {
2489 info->name = "STAC92xx Analog Alt";
2490 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2493 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2496 info->name = "STAC92xx Digital";
2497 info->pcm_type = spec->autocfg.dig_out_type[0];
2498 if (spec->multiout.dig_out_nid) {
2499 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2500 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2502 if (spec->dig_in_nid) {
2503 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2504 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2511 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2514 snd_hda_set_pin_ctl_cache(codec, nid, pin_type);
2517 #define stac92xx_hp_switch_info snd_ctl_boolean_mono_info
2519 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2520 struct snd_ctl_elem_value *ucontrol)
2522 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2523 struct sigmatel_spec *spec = codec->spec;
2525 ucontrol->value.integer.value[0] = !!spec->hp_switch;
2529 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid);
2531 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2532 struct snd_ctl_elem_value *ucontrol)
2534 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2535 struct sigmatel_spec *spec = codec->spec;
2536 int nid = kcontrol->private_value;
2538 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2540 /* check to be sure that the ports are up to date with
2543 stac_issue_unsol_event(codec, nid);
2548 static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol,
2549 struct snd_ctl_elem_info *uinfo)
2552 static const char * const texts[] = {
2553 "Mic In", "Line In", "Line Out"
2556 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2557 struct sigmatel_spec *spec = codec->spec;
2558 hda_nid_t nid = kcontrol->private_value;
2560 if (nid == spec->mic_switch || nid == spec->line_switch)
2565 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2566 uinfo->value.enumerated.items = i;
2568 if (uinfo->value.enumerated.item >= i)
2569 uinfo->value.enumerated.item = i-1;
2570 strcpy(uinfo->value.enumerated.name,
2571 texts[uinfo->value.enumerated.item]);
2576 static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol,
2577 struct snd_ctl_elem_value *ucontrol)
2579 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2580 hda_nid_t nid = kcontrol->private_value;
2581 unsigned int vref = stac92xx_vref_get(codec, nid);
2583 if (vref == snd_hda_get_default_vref(codec, nid))
2584 ucontrol->value.enumerated.item[0] = 0;
2585 else if (vref == AC_PINCTL_VREF_GRD)
2586 ucontrol->value.enumerated.item[0] = 1;
2587 else if (vref == AC_PINCTL_VREF_HIZ)
2588 ucontrol->value.enumerated.item[0] = 2;
2593 static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol,
2594 struct snd_ctl_elem_value *ucontrol)
2596 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2597 unsigned int new_vref = 0;
2599 hda_nid_t nid = kcontrol->private_value;
2601 if (ucontrol->value.enumerated.item[0] == 0)
2602 new_vref = snd_hda_get_default_vref(codec, nid);
2603 else if (ucontrol->value.enumerated.item[0] == 1)
2604 new_vref = AC_PINCTL_VREF_GRD;
2605 else if (ucontrol->value.enumerated.item[0] == 2)
2606 new_vref = AC_PINCTL_VREF_HIZ;
2610 if (new_vref != stac92xx_vref_get(codec, nid)) {
2611 error = stac92xx_vref_set(codec, nid, new_vref);
2618 static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol,
2619 struct snd_ctl_elem_info *uinfo)
2622 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2623 struct sigmatel_spec *spec = codec->spec;
2625 if (kcontrol->private_value == spec->line_switch)
2626 texts[0] = "Line In";
2628 texts[0] = "Mic In";
2629 texts[1] = "Line Out";
2630 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2631 uinfo->value.enumerated.items = 2;
2634 if (uinfo->value.enumerated.item >= 2)
2635 uinfo->value.enumerated.item = 1;
2636 strcpy(uinfo->value.enumerated.name,
2637 texts[uinfo->value.enumerated.item]);
2642 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2644 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2645 struct sigmatel_spec *spec = codec->spec;
2646 hda_nid_t nid = kcontrol->private_value;
2647 int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2649 ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx];
2653 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2655 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2656 struct sigmatel_spec *spec = codec->spec;
2657 hda_nid_t nid = kcontrol->private_value;
2658 int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2659 unsigned short val = !!ucontrol->value.enumerated.item[0];
2661 spec->io_switch[io_idx] = val;
2664 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2666 unsigned int pinctl = AC_PINCTL_IN_EN;
2667 if (io_idx) /* set VREF for mic */
2668 pinctl |= snd_hda_get_default_vref(codec, nid);
2669 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2672 /* check the auto-mute again: we need to mute/unmute the speaker
2673 * appropriately according to the pin direction
2675 if (spec->hp_detect)
2676 stac_issue_unsol_event(codec, nid);
2681 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2683 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2684 struct snd_ctl_elem_value *ucontrol)
2686 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2687 struct sigmatel_spec *spec = codec->spec;
2689 ucontrol->value.integer.value[0] = spec->clfe_swap;
2693 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2694 struct snd_ctl_elem_value *ucontrol)
2696 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2697 struct sigmatel_spec *spec = codec->spec;
2698 hda_nid_t nid = kcontrol->private_value & 0xff;
2699 unsigned int val = !!ucontrol->value.integer.value[0];
2701 if (spec->clfe_swap == val)
2704 spec->clfe_swap = val;
2706 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2707 spec->clfe_swap ? 0x4 : 0x0);
2712 #define STAC_CODEC_HP_SWITCH(xname) \
2713 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2716 .info = stac92xx_hp_switch_info, \
2717 .get = stac92xx_hp_switch_get, \
2718 .put = stac92xx_hp_switch_put, \
2721 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2722 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2725 .info = stac92xx_io_switch_info, \
2726 .get = stac92xx_io_switch_get, \
2727 .put = stac92xx_io_switch_put, \
2728 .private_value = xpval, \
2731 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2732 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2735 .info = stac92xx_clfe_switch_info, \
2736 .get = stac92xx_clfe_switch_get, \
2737 .put = stac92xx_clfe_switch_put, \
2738 .private_value = xpval, \
2742 STAC_CTL_WIDGET_VOL,
2743 STAC_CTL_WIDGET_MUTE,
2744 STAC_CTL_WIDGET_MUTE_BEEP,
2745 STAC_CTL_WIDGET_MONO_MUX,
2746 STAC_CTL_WIDGET_HP_SWITCH,
2747 STAC_CTL_WIDGET_IO_SWITCH,
2748 STAC_CTL_WIDGET_CLFE_SWITCH,
2749 STAC_CTL_WIDGET_DC_BIAS
2752 static const struct snd_kcontrol_new stac92xx_control_templates[] = {
2753 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2754 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2755 HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0),
2757 STAC_CODEC_HP_SWITCH(NULL),
2758 STAC_CODEC_IO_SWITCH(NULL, 0),
2759 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2760 DC_BIAS(NULL, 0, 0),
2763 /* add dynamic controls */
2764 static struct snd_kcontrol_new *
2765 stac_control_new(struct sigmatel_spec *spec,
2766 const struct snd_kcontrol_new *ktemp,
2768 unsigned int subdev)
2770 struct snd_kcontrol_new *knew;
2772 snd_array_init(&spec->kctls, sizeof(*knew), 32);
2773 knew = snd_array_new(&spec->kctls);
2777 knew->name = kstrdup(name, GFP_KERNEL);
2780 memset(knew, 0, sizeof(*knew));
2781 spec->kctls.alloced--;
2784 knew->subdevice = subdev;
2788 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2789 const struct snd_kcontrol_new *ktemp,
2790 int idx, const char *name,
2793 struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name,
2794 HDA_SUBDEV_AMP_FLAG);
2798 knew->private_value = val;
2802 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2803 int type, int idx, const char *name,
2806 return stac92xx_add_control_temp(spec,
2807 &stac92xx_control_templates[type],
2812 /* add dynamic controls */
2813 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2814 const char *name, unsigned long val)
2816 return stac92xx_add_control_idx(spec, type, 0, name, val);
2819 static const struct snd_kcontrol_new stac_input_src_temp = {
2820 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2821 .name = "Input Source",
2822 .info = stac92xx_mux_enum_info,
2823 .get = stac92xx_mux_enum_get,
2824 .put = stac92xx_mux_enum_put,
2827 static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
2828 hda_nid_t nid, int idx)
2830 int def_conf = snd_hda_codec_get_pincfg(codec, nid);
2832 struct sigmatel_spec *spec = codec->spec;
2835 if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
2836 if (snd_hda_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
2837 && nid == spec->line_switch)
2838 control = STAC_CTL_WIDGET_IO_SWITCH;
2839 else if (snd_hda_query_pin_caps(codec, nid)
2840 & (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT))
2841 control = STAC_CTL_WIDGET_DC_BIAS;
2842 else if (nid == spec->mic_switch)
2843 control = STAC_CTL_WIDGET_IO_SWITCH;
2847 snd_hda_get_pin_label(codec, nid, &spec->autocfg,
2848 name, sizeof(name), NULL);
2849 return stac92xx_add_control(codec->spec, control,
2850 strcat(name, " Jack Mode"), nid);
2856 static int stac92xx_add_input_source(struct sigmatel_spec *spec)
2858 struct snd_kcontrol_new *knew;
2859 struct hda_input_mux *imux = &spec->private_imux;
2862 return 0; /* no need for input source */
2863 if (!spec->num_adcs || imux->num_items <= 1)
2864 return 0; /* no need for input source control */
2865 knew = stac_control_new(spec, &stac_input_src_temp,
2866 stac_input_src_temp.name, 0);
2869 knew->count = spec->num_adcs;
2873 /* check whether the line-input can be used as line-out */
2874 static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2876 struct sigmatel_spec *spec = codec->spec;
2877 struct auto_pin_cfg *cfg = &spec->autocfg;
2879 unsigned int pincap;
2882 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2884 for (i = 0; i < cfg->num_inputs; i++) {
2885 if (cfg->inputs[i].type == AUTO_PIN_LINE_IN) {
2886 nid = cfg->inputs[i].pin;
2887 pincap = snd_hda_query_pin_caps(codec, nid);
2888 if (pincap & AC_PINCAP_OUT)
2895 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid);
2897 /* check whether the mic-input can be used as line-out */
2898 static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac)
2900 struct sigmatel_spec *spec = codec->spec;
2901 struct auto_pin_cfg *cfg = &spec->autocfg;
2902 unsigned int def_conf, pincap;
2906 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2908 for (i = 0; i < cfg->num_inputs; i++) {
2909 hda_nid_t nid = cfg->inputs[i].pin;
2910 if (cfg->inputs[i].type != AUTO_PIN_MIC)
2912 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2913 /* some laptops have an internal analog microphone
2914 * which can't be used as a output */
2915 if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
2916 pincap = snd_hda_query_pin_caps(codec, nid);
2917 if (pincap & AC_PINCAP_OUT) {
2918 *dac = get_unassigned_dac(codec, nid);
2927 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2931 for (i = 0; i < spec->multiout.num_dacs; i++) {
2932 if (spec->multiout.dac_nids[i] == nid)
2939 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2942 if (is_in_dac_nids(spec, nid))
2944 for (i = 0; i < spec->autocfg.hp_outs; i++)
2945 if (spec->hp_dacs[i] == nid)
2947 for (i = 0; i < spec->autocfg.speaker_outs; i++)
2948 if (spec->speaker_dacs[i] == nid)
2953 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2955 struct sigmatel_spec *spec = codec->spec;
2956 struct auto_pin_cfg *cfg = &spec->autocfg;
2958 hda_nid_t conn[HDA_MAX_CONNECTIONS], fallback_dac;
2959 unsigned int wcaps, wtype;
2961 conn_len = snd_hda_get_connections(codec, nid, conn,
2962 HDA_MAX_CONNECTIONS);
2963 /* 92HD88: trace back up the link of nids to find the DAC */
2964 while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0]))
2965 != AC_WID_AUD_OUT)) {
2967 conn_len = snd_hda_get_connections(codec, nid, conn,
2968 HDA_MAX_CONNECTIONS);
2970 for (j = 0; j < conn_len; j++) {
2971 wcaps = get_wcaps(codec, conn[j]);
2972 wtype = get_wcaps_type(wcaps);
2973 /* we check only analog outputs */
2974 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2976 /* if this route has a free DAC, assign it */
2977 if (!check_all_dac_nids(spec, conn[j])) {
2979 /* select this DAC in the pin's input mux */
2980 snd_hda_codec_write_cache(codec, nid, 0,
2981 AC_VERB_SET_CONNECT_SEL, j);
2987 /* if all DACs are already assigned, connect to the primary DAC,
2988 unless we're assigning a secondary headphone */
2989 fallback_dac = spec->multiout.dac_nids[0];
2990 if (spec->multiout.hp_nid) {
2991 for (j = 0; j < cfg->hp_outs; j++)
2992 if (cfg->hp_pins[j] == nid) {
2993 fallback_dac = spec->multiout.hp_nid;
2999 for (j = 0; j < conn_len; j++) {
3000 if (conn[j] == fallback_dac) {
3001 snd_hda_codec_write_cache(codec, nid, 0,
3002 AC_VERB_SET_CONNECT_SEL, j);
3010 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
3011 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
3014 * Fill in the dac_nids table from the parsed pin configuration
3015 * This function only works when every pin in line_out_pins[]
3016 * contains atleast one DAC in its connection list. Some 92xx
3017 * codecs are not connected directly to a DAC, such as the 9200
3018 * and 9202/925x. For those, dac_nids[] must be hard-coded.
3020 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
3022 struct sigmatel_spec *spec = codec->spec;
3023 struct auto_pin_cfg *cfg = &spec->autocfg;
3027 for (i = 0; i < cfg->line_outs; i++) {
3028 nid = cfg->line_out_pins[i];
3029 dac = get_unassigned_dac(codec, nid);
3031 if (spec->multiout.num_dacs > 0) {
3032 /* we have already working output pins,
3033 * so let's drop the broken ones again
3035 cfg->line_outs = spec->multiout.num_dacs;
3038 /* error out, no available DAC found */
3040 "%s: No available DAC for pin 0x%x\n",
3044 add_spec_dacs(spec, dac);
3047 for (i = 0; i < cfg->hp_outs; i++) {
3048 nid = cfg->hp_pins[i];
3049 dac = get_unassigned_dac(codec, nid);
3051 if (!spec->multiout.hp_nid)
3052 spec->multiout.hp_nid = dac;
3054 add_spec_extra_dacs(spec, dac);
3056 spec->hp_dacs[i] = dac;
3059 for (i = 0; i < cfg->speaker_outs; i++) {
3060 nid = cfg->speaker_pins[i];
3061 dac = get_unassigned_dac(codec, nid);
3063 add_spec_extra_dacs(spec, dac);
3064 spec->speaker_dacs[i] = dac;
3067 /* add line-in as output */
3068 nid = check_line_out_switch(codec);
3070 dac = get_unassigned_dac(codec, nid);
3072 snd_printdd("STAC: Add line-in 0x%x as output %d\n",
3073 nid, cfg->line_outs);
3074 cfg->line_out_pins[cfg->line_outs] = nid;
3076 spec->line_switch = nid;
3077 add_spec_dacs(spec, dac);
3080 /* add mic as output */
3081 nid = check_mic_out_switch(codec, &dac);
3083 snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
3084 nid, cfg->line_outs);
3085 cfg->line_out_pins[cfg->line_outs] = nid;
3087 spec->mic_switch = nid;
3088 add_spec_dacs(spec, dac);
3091 snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3092 spec->multiout.num_dacs,
3093 spec->multiout.dac_nids[0],
3094 spec->multiout.dac_nids[1],
3095 spec->multiout.dac_nids[2],
3096 spec->multiout.dac_nids[3],
3097 spec->multiout.dac_nids[4]);
3102 /* create volume control/switch for the given prefx type */
3103 static int create_controls_idx(struct hda_codec *codec, const char *pfx,
3104 int idx, hda_nid_t nid, int chs)
3106 struct sigmatel_spec *spec = codec->spec;
3110 if (!spec->check_volume_offset) {
3111 unsigned int caps, step, nums, db_scale;
3112 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3113 step = (caps & AC_AMPCAP_STEP_SIZE) >>
3114 AC_AMPCAP_STEP_SIZE_SHIFT;
3115 step = (step + 1) * 25; /* in .01dB unit */
3116 nums = (caps & AC_AMPCAP_NUM_STEPS) >>
3117 AC_AMPCAP_NUM_STEPS_SHIFT;
3118 db_scale = nums * step;
3119 /* if dB scale is over -64dB, and finer enough,
3120 * let's reduce it to half
3122 if (db_scale > 6400 && nums >= 0x1f)
3123 spec->volume_offset = nums / 2;
3124 spec->check_volume_offset = 1;
3127 sprintf(name, "%s Playback Volume", pfx);
3128 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
3129 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3130 spec->volume_offset));
3133 sprintf(name, "%s Playback Switch", pfx);
3134 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
3135 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3141 #define create_controls(codec, pfx, nid, chs) \
3142 create_controls_idx(codec, pfx, 0, nid, chs)
3144 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3146 if (spec->multiout.num_dacs > 4) {
3147 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3150 snd_BUG_ON(spec->multiout.dac_nids != spec->dac_nids);
3151 spec->dac_nids[spec->multiout.num_dacs] = nid;
3152 spec->multiout.num_dacs++;
3157 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3160 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3161 if (!spec->multiout.extra_out_nid[i]) {
3162 spec->multiout.extra_out_nid[i] = nid;
3166 printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3170 /* Create output controls
3171 * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
3173 static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
3174 const hda_nid_t *pins,
3175 const hda_nid_t *dac_nids,
3178 struct sigmatel_spec *spec = codec->spec;
3179 static const char * const chname[4] = {
3180 "Front", "Surround", NULL /*CLFE*/, "Side"
3184 unsigned int wid_caps;
3186 for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
3187 if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3188 if (is_jack_detectable(codec, pins[i]))
3189 spec->hp_detect = 1;
3194 if (type != AUTO_PIN_HP_OUT && i == 2) {
3196 err = create_controls(codec, "Center", nid, 1);
3199 err = create_controls(codec, "LFE", nid, 2);
3203 wid_caps = get_wcaps(codec, nid);
3205 if (wid_caps & AC_WCAP_LR_SWAP) {
3206 err = stac92xx_add_control(spec,
3207 STAC_CTL_WIDGET_CLFE_SWITCH,
3208 "Swap Center/LFE Playback Switch", nid);
3218 case AUTO_PIN_HP_OUT:
3222 case AUTO_PIN_SPEAKER_OUT:
3231 err = create_controls_idx(codec, name, idx, nid, 3);
3239 static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol,
3240 unsigned long sw, int idx)
3243 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx,
3244 "Capture Volume", vol);
3247 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_MUTE, idx,
3248 "Capture Switch", sw);
3254 /* add playback controls from the parsed DAC table */
3255 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3256 const struct auto_pin_cfg *cfg)
3258 struct sigmatel_spec *spec = codec->spec;
3263 err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
3264 spec->multiout.dac_nids,
3265 cfg->line_out_type);
3269 if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3270 err = stac92xx_add_control(spec,
3271 STAC_CTL_WIDGET_HP_SWITCH,
3272 "Headphone as Line Out Switch",
3273 cfg->hp_pins[cfg->hp_outs - 1]);
3278 for (idx = 0; idx < cfg->num_inputs; idx++) {
3279 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3281 nid = cfg->inputs[idx].pin;
3282 err = stac92xx_add_jack_mode_control(codec, nid, idx);
3290 /* add playback controls for Speaker and HP outputs */
3291 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3292 struct auto_pin_cfg *cfg)
3294 struct sigmatel_spec *spec = codec->spec;
3297 err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
3298 spec->hp_dacs, AUTO_PIN_HP_OUT);
3302 err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
3303 spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
3310 /* labels for mono mux outputs */
3311 static const char * const stac92xx_mono_labels[4] = {
3312 "DAC0", "DAC1", "Mixer", "DAC2"
3315 /* create mono mux for mono out on capable codecs */
3316 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3318 struct sigmatel_spec *spec = codec->spec;
3319 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3321 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3323 num_cons = snd_hda_get_connections(codec,
3326 HDA_MAX_NUM_INPUTS);
3327 if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3330 for (i = 0; i < num_cons; i++)
3331 snd_hda_add_imux_item(mono_mux, stac92xx_mono_labels[i], i,
3334 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3335 "Mono Mux", spec->mono_nid);
3338 /* create PC beep volume controls */
3339 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3342 struct sigmatel_spec *spec = codec->spec;
3343 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3344 int err, type = STAC_CTL_WIDGET_MUTE_BEEP;
3346 if (spec->anabeep_nid == nid)
3347 type = STAC_CTL_WIDGET_MUTE;
3349 /* check for mute support for the the amp */
3350 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3351 err = stac92xx_add_control(spec, type,
3352 "Beep Playback Switch",
3353 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3358 /* check to see if there is volume support for the amp */
3359 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3360 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3361 "Beep Playback Volume",
3362 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3369 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3370 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3372 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3373 struct snd_ctl_elem_value *ucontrol)
3375 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3376 ucontrol->value.integer.value[0] = codec->beep->enabled;
3380 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3381 struct snd_ctl_elem_value *ucontrol)
3383 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3384 return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
3387 static const struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3388 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3389 .info = stac92xx_dig_beep_switch_info,
3390 .get = stac92xx_dig_beep_switch_get,
3391 .put = stac92xx_dig_beep_switch_put,
3394 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3396 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3397 0, "Beep Playback Switch", 0);
3401 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3403 struct sigmatel_spec *spec = codec->spec;
3406 for (i = 0; i < spec->num_muxes; i++) {
3411 nid = spec->mux_nids[i];
3412 wcaps = get_wcaps(codec, nid);
3413 if (!(wcaps & AC_WCAP_OUT_AMP))
3416 /* check whether already the same control was created as
3417 * normal Capture Volume.
3419 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3420 for (j = 0; j < spec->num_caps; j++) {
3421 if (spec->capvols[j] == val)
3424 if (j < spec->num_caps)
3427 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i,
3428 "Mux Capture Volume", val);
3435 static const char * const stac92xx_spdif_labels[3] = {
3436 "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3439 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3441 struct sigmatel_spec *spec = codec->spec;
3442 struct hda_input_mux *spdif_mux = &spec->private_smux;
3443 const char * const *labels = spec->spdif_labels;
3445 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3447 num_cons = snd_hda_get_connections(codec,
3450 HDA_MAX_NUM_INPUTS);
3455 labels = stac92xx_spdif_labels;
3457 for (i = 0; i < num_cons; i++)
3458 snd_hda_add_imux_item(spdif_mux, labels[i], i, NULL);
3463 /* labels for dmic mux inputs */
3464 static const char * const stac92xx_dmic_labels[5] = {
3465 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3466 "Digital Mic 3", "Digital Mic 4"
3469 static hda_nid_t get_connected_node(struct hda_codec *codec, hda_nid_t mux,
3472 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3474 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3475 if (idx >= 0 && idx < nums)
3480 /* look for NID recursively */
3481 #define get_connection_index(codec, mux, nid) \
3482 snd_hda_get_conn_index(codec, mux, nid, 1)
3484 /* create a volume assigned to the given pin (only if supported) */
3485 /* return 1 if the volume control is created */
3486 static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
3487 const char *label, int idx, int direction)
3489 unsigned int caps, nums;
3493 if (direction == HDA_OUTPUT)
3494 caps = AC_WCAP_OUT_AMP;
3496 caps = AC_WCAP_IN_AMP;
3497 if (!(get_wcaps(codec, nid) & caps))
3499 caps = query_amp_caps(codec, nid, direction);
3500 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
3503 snprintf(name, sizeof(name), "%s Capture Volume", label);
3504 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, name,
3505 HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction));
3511 /* create playback/capture controls for input pins on dmic capable codecs */
3512 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3513 const struct auto_pin_cfg *cfg)
3515 struct sigmatel_spec *spec = codec->spec;
3516 struct hda_input_mux *imux = &spec->private_imux;
3517 struct hda_input_mux *dimux = &spec->private_dimux;
3519 unsigned int def_conf;
3521 snd_hda_add_imux_item(dimux, stac92xx_dmic_labels[0], 0, NULL);
3523 for (i = 0; i < spec->num_dmics; i++) {
3525 int index, type_idx;
3528 nid = spec->dmic_nids[i];
3529 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
3531 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3532 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3535 index = get_connection_index(codec, spec->dmux_nids[0], nid);
3539 snd_hda_get_pin_label(codec, nid, &spec->autocfg,
3540 label, sizeof(label), NULL);
3541 snd_hda_add_imux_item(dimux, label, index, &type_idx);
3542 if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1)
3543 snd_hda_add_imux_item(imux, label, index, &type_idx);
3545 err = create_elem_capture_vol(codec, nid, label, type_idx,
3550 err = create_elem_capture_vol(codec, nid, label,
3551 type_idx, HDA_OUTPUT);
3555 nid = get_connected_node(codec,
3556 spec->dmux_nids[0], index);
3558 err = create_elem_capture_vol(codec,
3560 type_idx, HDA_INPUT);
3570 static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid,
3571 hda_nid_t *fixed, hda_nid_t *ext, hda_nid_t *dock)
3578 cfg = snd_hda_codec_get_pincfg(codec, nid);
3579 type = get_defcfg_device(cfg);
3580 switch (snd_hda_get_input_pin_attr(cfg)) {
3581 case INPUT_PIN_ATTR_INT:
3583 return 1; /* already occupied */
3584 if (type != AC_JACK_MIC_IN)
3585 return 1; /* invalid type */
3588 case INPUT_PIN_ATTR_UNUSED:
3590 case INPUT_PIN_ATTR_DOCK:
3592 return 1; /* already occupied */
3593 if (type != AC_JACK_MIC_IN && type != AC_JACK_LINE_IN)
3594 return 1; /* invalid type */
3599 return 1; /* already occupied */
3600 if (type != AC_JACK_MIC_IN)
3601 return 1; /* invalid type */
3608 static int set_mic_route(struct hda_codec *codec,
3609 struct sigmatel_mic_route *mic,
3612 struct sigmatel_spec *spec = codec->spec;
3613 struct auto_pin_cfg *cfg = &spec->autocfg;
3619 for (i = 0; i < cfg->num_inputs; i++) {
3620 if (pin == cfg->inputs[i].pin)
3623 if (i < cfg->num_inputs && cfg->inputs[i].type == AUTO_PIN_MIC) {
3625 i = get_connection_index(codec, spec->mux_nids[0], pin);
3630 if (spec->dmux_nids)
3631 mic->dmux_idx = get_connection_index(codec,
3634 } else if (spec->dmux_nids) {
3636 i = get_connection_index(codec, spec->dmux_nids[0], pin);
3642 mic->mux_idx = get_connection_index(codec,
3644 spec->dmux_nids[0]);
3649 /* return non-zero if the device is for automatic mic switch */
3650 static int stac_check_auto_mic(struct hda_codec *codec)
3652 struct sigmatel_spec *spec = codec->spec;
3653 struct auto_pin_cfg *cfg = &spec->autocfg;
3654 hda_nid_t fixed, ext, dock;
3657 fixed = ext = dock = 0;
3658 for (i = 0; i < cfg->num_inputs; i++)
3659 if (check_mic_pin(codec, cfg->inputs[i].pin,
3660 &fixed, &ext, &dock))
3662 for (i = 0; i < spec->num_dmics; i++)
3663 if (check_mic_pin(codec, spec->dmic_nids[i],
3664 &fixed, &ext, &dock))
3666 if (!fixed || (!ext && !dock))
3667 return 0; /* no input to switch */
3668 if (!is_jack_detectable(codec, ext))
3669 return 0; /* no unsol support */
3670 if (set_mic_route(codec, &spec->ext_mic, ext) ||
3671 set_mic_route(codec, &spec->int_mic, fixed) ||
3672 set_mic_route(codec, &spec->dock_mic, dock))
3673 return 0; /* something is wrong */
3677 /* create playback/capture controls for input pins */
3678 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3680 struct sigmatel_spec *spec = codec->spec;
3681 struct hda_input_mux *imux = &spec->private_imux;
3685 for (i = 0; i < cfg->num_inputs; i++) {
3686 hda_nid_t nid = cfg->inputs[i].pin;
3687 int index, err, type_idx;
3690 for (j = 0; j < spec->num_muxes; j++) {
3691 index = get_connection_index(codec, spec->mux_nids[j],
3699 label = hda_get_autocfg_input_label(codec, cfg, i);
3700 snd_hda_add_imux_item(imux, label, index, &type_idx);
3702 err = create_elem_capture_vol(codec, nid,
3708 spec->num_analog_muxes = imux->num_items;
3710 if (imux->num_items) {
3712 * Set the current input for the muxes.
3713 * The STAC9221 has two input muxes with identical source
3714 * NID lists. Hopefully this won't get confused.
3716 for (i = 0; i < spec->num_muxes; i++) {
3717 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3718 AC_VERB_SET_CONNECT_SEL,
3719 imux->items[0].index);
3726 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3728 struct sigmatel_spec *spec = codec->spec;
3731 for (i = 0; i < spec->autocfg.line_outs; i++) {
3732 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3733 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3737 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3739 struct sigmatel_spec *spec = codec->spec;
3742 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3744 pin = spec->autocfg.hp_pins[i];
3745 if (pin) /* connect to front */
3746 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3748 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3750 pin = spec->autocfg.speaker_pins[i];
3751 if (pin) /* connect to front */
3752 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3756 static int is_dual_headphones(struct hda_codec *codec)
3758 struct sigmatel_spec *spec = codec->spec;
3761 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT ||
3762 spec->autocfg.hp_outs <= 1)
3765 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3766 hda_nid_t nid = spec->autocfg.hp_pins[i];
3767 unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid);
3768 if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE)
3772 return (valid_hps > 1);
3776 static int stac92xx_parse_auto_config(struct hda_codec *codec)
3778 struct sigmatel_spec *spec = codec->spec;
3779 hda_nid_t dig_out = 0, dig_in = 0;
3783 if ((err = snd_hda_parse_pin_def_config(codec,
3785 spec->dmic_nids)) < 0)
3787 if (! spec->autocfg.line_outs)
3788 return 0; /* can't find valid pin config */
3790 /* If we have no real line-out pin and multiple hp-outs, HPs should
3791 * be set up as multi-channel outputs.
3793 if (is_dual_headphones(codec)) {
3794 /* Copy hp_outs to line_outs, backup line_outs in
3795 * speaker_outs so that the following routines can handle
3796 * HP pins as primary outputs.
3798 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3799 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3800 sizeof(spec->autocfg.line_out_pins));
3801 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3802 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3803 sizeof(spec->autocfg.hp_pins));
3804 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3805 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3806 spec->autocfg.hp_outs = 0;
3809 if (spec->autocfg.mono_out_pin) {
3810 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3811 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3812 u32 caps = query_amp_caps(codec,
3813 spec->autocfg.mono_out_pin, dir);
3814 hda_nid_t conn_list[1];
3816 /* get the mixer node and then the mono mux if it exists */
3817 if (snd_hda_get_connections(codec,
3818 spec->autocfg.mono_out_pin, conn_list, 1) &&
3819 snd_hda_get_connections(codec, conn_list[0],
3820 conn_list, 1) > 0) {
3822 int wcaps = get_wcaps(codec, conn_list[0]);
3823 int wid_type = get_wcaps_type(wcaps);
3824 /* LR swap check, some stac925x have a mux that
3825 * changes the DACs output path instead of the
3828 if (wid_type == AC_WID_AUD_SEL &&
3829 !(wcaps & AC_WCAP_LR_SWAP))
3830 spec->mono_nid = conn_list[0];
3833 hda_nid_t nid = spec->autocfg.mono_out_pin;
3835 /* most mono outs have a least a mute/unmute switch */
3836 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3837 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3838 "Mono Playback Switch",
3839 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3842 /* check for volume support for the amp */
3843 if ((caps & AC_AMPCAP_NUM_STEPS)
3844 >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3845 err = stac92xx_add_control(spec,
3846 STAC_CTL_WIDGET_VOL,
3847 "Mono Playback Volume",
3848 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3854 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3858 if (!spec->multiout.num_dacs) {
3859 err = stac92xx_auto_fill_dac_nids(codec);
3862 err = stac92xx_auto_create_multi_out_ctls(codec,
3868 /* setup analog beep controls */
3869 if (spec->anabeep_nid > 0) {
3870 err = stac92xx_auto_create_beep_ctls(codec,
3876 /* setup digital beep controls and input device */
3877 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3878 if (spec->digbeep_nid > 0) {
3879 hda_nid_t nid = spec->digbeep_nid;
3882 err = stac92xx_auto_create_beep_ctls(codec, nid);
3885 err = snd_hda_attach_beep_device(codec, nid);
3889 /* IDT/STAC codecs have linear beep tone parameter */
3890 codec->beep->linear_tone = spec->linear_tone_beep;
3891 /* if no beep switch is available, make its own one */
3892 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3893 if (!(caps & AC_AMPCAP_MUTE)) {
3894 err = stac92xx_beep_switch_ctl(codec);
3902 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3906 /* All output parsing done, now restore the swapped hp pins */
3908 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3909 sizeof(spec->autocfg.hp_pins));
3910 spec->autocfg.hp_outs = spec->autocfg.line_outs;
3911 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3912 spec->autocfg.line_outs = 0;
3915 if (stac_check_auto_mic(codec)) {
3917 /* only one capture for auto-mic */
3920 spec->num_muxes = 1;
3923 for (i = 0; i < spec->num_caps; i++) {
3924 err = stac92xx_add_capvol_ctls(codec, spec->capvols[i],
3925 spec->capsws[i], i);
3930 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3934 if (spec->mono_nid > 0) {
3935 err = stac92xx_auto_create_mono_output_ctls(codec);
3939 if (spec->num_dmics > 0 && !spec->dinput_mux)
3940 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3941 &spec->autocfg)) < 0)
3943 if (spec->num_muxes > 0) {
3944 err = stac92xx_auto_create_mux_input_ctls(codec);
3948 if (spec->num_smuxes > 0) {
3949 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3954 err = stac92xx_add_input_source(spec);
3958 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3959 if (spec->multiout.max_channels > 2)
3960 spec->surr_switch = 1;
3962 /* find digital out and in converters */
3963 for (i = codec->start_nid; i < codec->start_nid + codec->num_nodes; i++) {
3964 unsigned int wid_caps = get_wcaps(codec, i);
3965 if (wid_caps & AC_WCAP_DIGITAL) {
3966 switch (get_wcaps_type(wid_caps)) {
3967 case AC_WID_AUD_OUT:
3978 if (spec->autocfg.dig_outs)
3979 spec->multiout.dig_out_nid = dig_out;
3980 if (dig_in && spec->autocfg.dig_in_pin)
3981 spec->dig_in_nid = dig_in;
3983 if (spec->kctls.list)
3984 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3986 spec->input_mux = &spec->private_imux;
3987 if (!spec->dinput_mux)
3988 spec->dinput_mux = &spec->private_dimux;
3989 spec->sinput_mux = &spec->private_smux;
3990 spec->mono_mux = &spec->private_mono_mux;
3994 /* add playback controls for HP output */
3995 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3996 struct auto_pin_cfg *cfg)
3998 struct sigmatel_spec *spec = codec->spec;
3999 hda_nid_t pin = cfg->hp_pins[0];
4004 if (is_jack_detectable(codec, pin))
4005 spec->hp_detect = 1;
4010 /* add playback controls for LFE output */
4011 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
4012 struct auto_pin_cfg *cfg)
4014 struct sigmatel_spec *spec = codec->spec;
4016 hda_nid_t lfe_pin = 0x0;
4020 * search speaker outs and line outs for a mono speaker pin
4021 * with an amp. If one is found, add LFE controls
4024 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
4025 hda_nid_t pin = spec->autocfg.speaker_pins[i];
4026 unsigned int wcaps = get_wcaps(codec, pin);
4027 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
4028 if (wcaps == AC_WCAP_OUT_AMP)
4029 /* found a mono speaker with an amp, must be lfe */
4033 /* if speaker_outs is 0, then speakers may be in line_outs */
4034 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
4035 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
4036 hda_nid_t pin = spec->autocfg.line_out_pins[i];
4037 unsigned int defcfg;
4038 defcfg = snd_hda_codec_get_pincfg(codec, pin);
4039 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
4040 unsigned int wcaps = get_wcaps(codec, pin);
4041 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
4042 if (wcaps == AC_WCAP_OUT_AMP)
4043 /* found a mono speaker with an amp,
4051 err = create_controls(codec, "LFE", lfe_pin, 1);
4059 static int stac9200_parse_auto_config(struct hda_codec *codec)
4061 struct sigmatel_spec *spec = codec->spec;
4064 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
4067 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
4070 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
4073 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
4076 if (spec->num_muxes > 0) {
4077 err = stac92xx_auto_create_mux_input_ctls(codec);
4082 err = stac92xx_add_input_source(spec);
4086 if (spec->autocfg.dig_outs)
4087 spec->multiout.dig_out_nid = 0x05;
4088 if (spec->autocfg.dig_in_pin)
4089 spec->dig_in_nid = 0x04;
4091 if (spec->kctls.list)
4092 spec->mixers[spec->num_mixers++] = spec->kctls.list;
4094 spec->input_mux = &spec->private_imux;
4095 spec->dinput_mux = &spec->private_dimux;
4101 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
4102 * funky external mute control using GPIO pins.
4105 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
4106 unsigned int dir_mask, unsigned int data)
4108 unsigned int gpiostate, gpiomask, gpiodir;
4110 snd_printdd("%s msk %x dir %x gpio %x\n", __func__, mask, dir_mask, data);
4112 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4113 AC_VERB_GET_GPIO_DATA, 0);
4114 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
4116 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4117 AC_VERB_GET_GPIO_MASK, 0);
4120 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4121 AC_VERB_GET_GPIO_DIRECTION, 0);
4122 gpiodir |= dir_mask;
4124 /* Configure GPIOx as CMOS */
4125 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
4127 snd_hda_codec_write(codec, codec->afg, 0,
4128 AC_VERB_SET_GPIO_MASK, gpiomask);
4129 snd_hda_codec_read(codec, codec->afg, 0,
4130 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
4134 snd_hda_codec_read(codec, codec->afg, 0,
4135 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
4138 static int stac_add_event(struct hda_codec *codec, hda_nid_t nid,
4139 unsigned char type, int data)
4141 struct hda_jack_tbl *event;
4143 event = snd_hda_jack_tbl_new(codec, nid);
4146 event->action = type;
4147 event->private_data = data;
4152 /* check if given nid is a valid pin and no other events are assigned
4153 * to it. If OK, assign the event, set the unsol flag, and returns 1.
4154 * Otherwise, returns zero.
4156 static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
4159 struct hda_jack_tbl *event;
4161 if (!is_jack_detectable(codec, nid))
4163 event = snd_hda_jack_tbl_new(codec, nid);
4166 if (event->action && event->action != type)
4168 event->action = type;
4169 snd_hda_jack_detect_enable(codec, nid, 0);
4173 static int is_nid_out_jack_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
4176 for (i = 0; i < cfg->hp_outs; i++)
4177 if (cfg->hp_pins[i] == nid)
4178 return 1; /* nid is a HP-Out */
4179 for (i = 0; i < cfg->line_outs; i++)
4180 if (cfg->line_out_pins[i] == nid)
4181 return 1; /* nid is a line-Out */
4182 return 0; /* nid is not a HP-Out */
4185 static void stac92xx_power_down(struct hda_codec *codec)
4187 struct sigmatel_spec *spec = codec->spec;
4189 /* power down inactive DACs */
4190 const hda_nid_t *dac;
4191 for (dac = spec->dac_list; *dac; dac++)
4192 if (!check_all_dac_nids(spec, *dac))
4193 snd_hda_codec_write(codec, *dac, 0,
4194 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4197 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4200 static inline int get_int_hint(struct hda_codec *codec, const char *key,
4204 p = snd_hda_get_hint(codec, key);
4207 if (!strict_strtoul(p, 0, &val)) {
4215 /* override some hints from the hwdep entry */
4216 static void stac_store_hints(struct hda_codec *codec)
4218 struct sigmatel_spec *spec = codec->spec;
4221 val = snd_hda_get_bool_hint(codec, "hp_detect");
4223 spec->hp_detect = val;
4224 if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) {
4225 spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
4228 if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir))
4229 spec->gpio_mask &= spec->gpio_mask;
4230 if (get_int_hint(codec, "gpio_data", &spec->gpio_data))
4231 spec->gpio_dir &= spec->gpio_mask;
4232 if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask))
4233 spec->eapd_mask &= spec->gpio_mask;
4234 if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute))
4235 spec->gpio_mute &= spec->gpio_mask;
4236 val = snd_hda_get_bool_hint(codec, "eapd_switch");
4238 spec->eapd_switch = val;
4241 static void stac_issue_unsol_events(struct hda_codec *codec, int num_pins,
4242 const hda_nid_t *pins)
4245 stac_issue_unsol_event(codec, *pins++);
4248 /* fake event to set up pins */
4249 static void stac_fake_hp_events(struct hda_codec *codec)
4251 struct sigmatel_spec *spec = codec->spec;
4253 if (spec->autocfg.hp_outs)
4254 stac_issue_unsol_events(codec, spec->autocfg.hp_outs,
4255 spec->autocfg.hp_pins);
4256 if (spec->autocfg.line_outs &&
4257 spec->autocfg.line_out_pins[0] != spec->autocfg.hp_pins[0])
4258 stac_issue_unsol_events(codec, spec->autocfg.line_outs,
4259 spec->autocfg.line_out_pins);
4262 static int stac92xx_init(struct hda_codec *codec)
4264 struct sigmatel_spec *spec = codec->spec;
4265 struct auto_pin_cfg *cfg = &spec->autocfg;
4269 snd_hda_sequence_write(codec, spec->init);
4271 /* power down adcs initially */
4272 if (spec->powerdown_adcs)
4273 for (i = 0; i < spec->num_adcs; i++)
4274 snd_hda_codec_write(codec,
4275 spec->adc_nids[i], 0,
4276 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4278 /* override some hints */
4279 stac_store_hints(codec);
4282 gpio = spec->gpio_data;
4283 /* turn on EAPD statically when spec->eapd_switch isn't set.
4284 * otherwise, unsol event will turn it on/off dynamically
4286 if (!spec->eapd_switch)
4287 gpio |= spec->eapd_mask;
4288 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
4291 if (spec->hp_detect) {
4292 /* Enable unsolicited responses on the HP widget */
4293 for (i = 0; i < cfg->hp_outs; i++) {
4294 hda_nid_t nid = cfg->hp_pins[i];
4295 enable_pin_detect(codec, nid, STAC_HP_EVENT);
4297 if (cfg->line_out_type == AUTO_PIN_LINE_OUT &&
4298 cfg->speaker_outs > 0) {
4299 /* enable pin-detect for line-outs as well */
4300 for (i = 0; i < cfg->line_outs; i++) {
4301 hda_nid_t nid = cfg->line_out_pins[i];
4302 enable_pin_detect(codec, nid, STAC_LO_EVENT);
4306 /* force to enable the first line-out; the others are set up
4309 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
4311 /* fake event to set up pins */
4312 stac_fake_hp_events(codec);
4314 stac92xx_auto_init_multi_out(codec);
4315 stac92xx_auto_init_hp_out(codec);
4316 for (i = 0; i < cfg->hp_outs; i++)
4317 stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
4319 if (spec->auto_mic) {
4320 /* initialize connection to analog input */
4321 if (spec->dmux_nids)
4322 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4323 AC_VERB_SET_CONNECT_SEL, 0);
4324 if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT))
4325 stac_issue_unsol_event(codec, spec->ext_mic.pin);
4326 if (enable_pin_detect(codec, spec->dock_mic.pin,
4328 stac_issue_unsol_event(codec, spec->dock_mic.pin);
4330 for (i = 0; i < cfg->num_inputs; i++) {
4331 hda_nid_t nid = cfg->inputs[i].pin;
4332 int type = cfg->inputs[i].type;
4333 unsigned int pinctl, conf;
4334 if (type == AUTO_PIN_MIC) {
4335 /* for mic pins, force to initialize */
4336 pinctl = snd_hda_get_default_vref(codec, nid);
4337 pinctl |= AC_PINCTL_IN_EN;
4338 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4340 pinctl = snd_hda_codec_read(codec, nid, 0,
4341 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4342 /* if PINCTL already set then skip */
4343 /* Also, if both INPUT and OUTPUT are set,
4344 * it must be a BIOS bug; need to override, too
4346 if (!(pinctl & AC_PINCTL_IN_EN) ||
4347 (pinctl & AC_PINCTL_OUT_EN)) {
4348 pinctl &= ~AC_PINCTL_OUT_EN;
4349 pinctl |= AC_PINCTL_IN_EN;
4350 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4353 conf = snd_hda_codec_get_pincfg(codec, nid);
4354 if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
4355 if (enable_pin_detect(codec, nid, STAC_INSERT_EVENT))
4356 stac_issue_unsol_event(codec, nid);
4359 for (i = 0; i < spec->num_dmics; i++)
4360 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4362 if (cfg->dig_out_pins[0])
4363 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0],
4365 if (cfg->dig_in_pin)
4366 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4368 for (i = 0; i < spec->num_pwrs; i++) {
4369 hda_nid_t nid = spec->pwr_nids[i];
4370 unsigned int pinctl, def_conf;
4372 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4373 def_conf = get_defcfg_connect(def_conf);
4374 if (def_conf == AC_JACK_PORT_NONE) {
4375 /* power off unused ports */
4376 stac_toggle_power_map(codec, nid, 0);
4379 if (def_conf == AC_JACK_PORT_FIXED) {
4380 /* no need for jack detection for fixed pins */
4381 stac_toggle_power_map(codec, nid, 1);
4384 /* power on when no jack detection is available */
4385 /* or when the VREF is used for controlling LED */
4386 if (!spec->hp_detect ||
4387 spec->vref_mute_led_nid == nid ||
4388 !is_jack_detectable(codec, nid)) {
4389 stac_toggle_power_map(codec, nid, 1);
4393 if (is_nid_out_jack_pin(cfg, nid))
4394 continue; /* already has an unsol event */
4396 pinctl = snd_hda_codec_read(codec, nid, 0,
4397 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4398 /* outputs are only ports capable of power management
4399 * any attempts on powering down a input port cause the
4400 * referenced VREF to act quirky.
4402 if (pinctl & AC_PINCTL_IN_EN) {
4403 stac_toggle_power_map(codec, nid, 1);
4406 if (enable_pin_detect(codec, nid, STAC_PWR_EVENT)) {
4407 stac_issue_unsol_event(codec, nid);
4410 /* none of the above, turn the port OFF */
4411 stac_toggle_power_map(codec, nid, 0);
4414 snd_hda_jack_report_sync(codec);
4417 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
4419 /* sync the power-map */
4421 snd_hda_codec_write(codec, codec->afg, 0,
4422 AC_VERB_IDT_SET_POWER_MAP,
4423 spec->power_map_bits);
4425 stac92xx_power_down(codec);
4429 static void stac92xx_free_kctls(struct hda_codec *codec)
4431 struct sigmatel_spec *spec = codec->spec;
4433 if (spec->kctls.list) {
4434 struct snd_kcontrol_new *kctl = spec->kctls.list;
4436 for (i = 0; i < spec->kctls.used; i++)
4437 kfree(kctl[i].name);
4439 snd_array_free(&spec->kctls);
4442 static void stac92xx_shutup_pins(struct hda_codec *codec)
4444 unsigned int i, def_conf;
4446 if (codec->bus->shutdown)
4448 for (i = 0; i < codec->init_pins.used; i++) {
4449 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
4450 def_conf = snd_hda_codec_get_pincfg(codec, pin->nid);
4451 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)
4452 snd_hda_set_pin_ctl(codec, pin->nid, 0);
4456 static void stac92xx_shutup(struct hda_codec *codec)
4458 struct sigmatel_spec *spec = codec->spec;
4460 stac92xx_shutup_pins(codec);
4462 if (spec->eapd_mask)
4463 stac_gpio_set(codec, spec->gpio_mask,
4464 spec->gpio_dir, spec->gpio_data &
4468 static void stac92xx_free(struct hda_codec *codec)
4470 struct sigmatel_spec *spec = codec->spec;
4475 stac92xx_shutup(codec);
4478 snd_hda_detach_beep_device(codec);
4481 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4484 unsigned int old_ctl, pin_ctl;
4486 pin_ctl = snd_hda_codec_read(codec, nid,
4487 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4489 if (pin_ctl & AC_PINCTL_IN_EN) {
4491 * we need to check the current set-up direction of
4492 * shared input pins since they can be switched via
4493 * "xxx as Output" mixer switch
4495 struct sigmatel_spec *spec = codec->spec;
4496 if (nid == spec->line_switch || nid == spec->mic_switch)
4501 /* if setting pin direction bits, clear the current
4502 direction bits first */
4503 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4504 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4507 if (old_ctl != pin_ctl)
4508 snd_hda_set_pin_ctl_cache(codec, nid, pin_ctl);
4511 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4514 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4515 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4517 snd_hda_set_pin_ctl_cache(codec, nid, pin_ctl & ~flag);
4520 static inline int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4524 return snd_hda_jack_detect(codec, nid);
4527 static void stac92xx_line_out_detect(struct hda_codec *codec,
4530 struct sigmatel_spec *spec = codec->spec;
4531 struct auto_pin_cfg *cfg = &spec->autocfg;
4534 for (i = 0; i < cfg->line_outs; i++) {
4537 presence = get_pin_presence(codec, cfg->line_out_pins[i]);
4539 unsigned int pinctl;
4540 pinctl = snd_hda_codec_read(codec,
4541 cfg->line_out_pins[i], 0,
4542 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4543 if (pinctl & AC_PINCTL_IN_EN)
4544 presence = 0; /* mic- or line-input */
4549 /* disable speakers */
4550 for (i = 0; i < cfg->speaker_outs; i++)
4551 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4553 if (spec->eapd_mask && spec->eapd_switch)
4554 stac_gpio_set(codec, spec->gpio_mask,
4555 spec->gpio_dir, spec->gpio_data &
4558 /* enable speakers */
4559 for (i = 0; i < cfg->speaker_outs; i++)
4560 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4562 if (spec->eapd_mask && spec->eapd_switch)
4563 stac_gpio_set(codec, spec->gpio_mask,
4564 spec->gpio_dir, spec->gpio_data |
4569 /* return non-zero if the hp-pin of the given array index isn't
4570 * a jack-detection target
4572 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4574 struct auto_pin_cfg *cfg = &spec->autocfg;
4576 /* ignore sensing of shared line and mic jacks */
4577 if (cfg->hp_pins[i] == spec->line_switch)
4579 if (cfg->hp_pins[i] == spec->mic_switch)
4581 /* ignore if the pin is set as line-out */
4582 if (cfg->hp_pins[i] == spec->hp_switch)
4587 static void stac92xx_hp_detect(struct hda_codec *codec)
4589 struct sigmatel_spec *spec = codec->spec;
4590 struct auto_pin_cfg *cfg = &spec->autocfg;
4594 if (spec->gpio_mute)
4595 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4596 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4598 for (i = 0; i < cfg->hp_outs; i++) {
4601 if (no_hp_sensing(spec, i))
4603 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4605 unsigned int pinctl;
4606 pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4607 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4608 if (pinctl & AC_PINCTL_IN_EN)
4609 presence = 0; /* mic- or line-input */
4614 /* disable lineouts */
4615 if (spec->hp_switch)
4616 stac92xx_reset_pinctl(codec, spec->hp_switch,
4618 for (i = 0; i < cfg->line_outs; i++)
4619 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4622 /* enable lineouts */
4623 if (spec->hp_switch)
4624 stac92xx_set_pinctl(codec, spec->hp_switch,
4626 for (i = 0; i < cfg->line_outs; i++)
4627 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4630 stac92xx_line_out_detect(codec, presence);
4631 /* toggle hp outs */
4632 for (i = 0; i < cfg->hp_outs; i++) {
4633 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4634 if (no_hp_sensing(spec, i))
4637 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4639 /* Resetting the pinctl like below may lead to (a sort of) regressions
4640 * on some devices since they use the HP pin actually for line/speaker
4641 * outs although the default pin config shows a different pin (that is
4642 * wrong and useless).
4644 * So, it's basically a problem of default pin configs, likely a BIOS issue.
4645 * But, disabling the code below just works around it, and I'm too tired of
4646 * bug reports with such devices...
4649 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4654 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4657 struct sigmatel_spec *spec = codec->spec;
4658 unsigned int idx, val;
4660 for (idx = 0; idx < spec->num_pwrs; idx++) {
4661 if (spec->pwr_nids[idx] == nid)
4664 if (idx >= spec->num_pwrs)
4669 val = spec->power_map_bits;
4675 /* power down unused output ports */
4676 if (val != spec->power_map_bits) {
4677 spec->power_map_bits = val;
4678 snd_hda_codec_write(codec, codec->afg, 0,
4679 AC_VERB_IDT_SET_POWER_MAP, val);
4683 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4685 stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4688 /* get the pin connection (fixed, none, etc) */
4689 static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
4691 struct sigmatel_spec *spec = codec->spec;
4694 cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]);
4695 return get_defcfg_connect(cfg);
4698 static int stac92xx_connected_ports(struct hda_codec *codec,
4699 const hda_nid_t *nids, int num_nids)
4701 struct sigmatel_spec *spec = codec->spec;
4703 unsigned int def_conf;
4705 for (num = 0; num < num_nids; num++) {
4706 for (idx = 0; idx < spec->num_pins; idx++)
4707 if (spec->pin_nids[idx] == nids[num])
4709 if (idx >= spec->num_pins)
4711 def_conf = stac_get_defcfg_connect(codec, idx);
4712 if (def_conf == AC_JACK_PORT_NONE)
4718 static void stac92xx_mic_detect(struct hda_codec *codec)
4720 struct sigmatel_spec *spec = codec->spec;
4721 struct sigmatel_mic_route *mic;
4723 if (get_pin_presence(codec, spec->ext_mic.pin))
4724 mic = &spec->ext_mic;
4725 else if (get_pin_presence(codec, spec->dock_mic.pin))
4726 mic = &spec->dock_mic;
4728 mic = &spec->int_mic;
4729 if (mic->dmux_idx >= 0)
4730 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4731 AC_VERB_SET_CONNECT_SEL,
4733 if (mic->mux_idx >= 0)
4734 snd_hda_codec_write_cache(codec, spec->mux_nids[0], 0,
4735 AC_VERB_SET_CONNECT_SEL,
4739 static void handle_unsol_event(struct hda_codec *codec,
4740 struct hda_jack_tbl *event)
4742 struct sigmatel_spec *spec = codec->spec;
4745 switch (event->action) {
4748 stac92xx_hp_detect(codec);
4750 case STAC_MIC_EVENT:
4751 stac92xx_mic_detect(codec);
4755 switch (event->action) {
4758 case STAC_MIC_EVENT:
4759 case STAC_INSERT_EVENT:
4760 case STAC_PWR_EVENT:
4761 if (spec->num_pwrs > 0)
4762 stac92xx_pin_sense(codec, event->nid);
4764 switch (codec->subsystem_id) {
4766 if (event->nid == 0xb) {
4767 int pin = AC_PINCTL_IN_EN;
4769 if (get_pin_presence(codec, 0xa)
4770 && get_pin_presence(codec, 0xb))
4771 pin |= AC_PINCTL_VREF_80;
4772 if (!get_pin_presence(codec, 0xb))
4773 pin |= AC_PINCTL_VREF_80;
4775 /* toggle VREF state based on mic + hp pin
4778 stac92xx_auto_set_pinctl(codec, 0x0a, pin);
4782 case STAC_VREF_EVENT:
4783 data = snd_hda_codec_read(codec, codec->afg, 0,
4784 AC_VERB_GET_GPIO_DATA, 0);
4785 /* toggle VREF state based on GPIOx status */
4786 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4787 !!(data & (1 << event->private_data)));
4792 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid)
4794 struct hda_jack_tbl *event = snd_hda_jack_tbl_get(codec, nid);
4797 handle_unsol_event(codec, event);
4800 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4802 struct hda_jack_tbl *event;
4805 tag = (res >> 26) & 0x7f;
4806 event = snd_hda_jack_tbl_get_from_tag(codec, tag);
4809 event->jack_dirty = 1;
4810 handle_unsol_event(codec, event);
4811 snd_hda_jack_report_sync(codec);
4814 static int hp_blike_system(u32 subsystem_id);
4816 static void set_hp_led_gpio(struct hda_codec *codec)
4818 struct sigmatel_spec *spec = codec->spec;
4824 gpio = snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP);
4825 gpio &= AC_GPIO_IO_COUNT;
4827 spec->gpio_led = 0x08; /* GPIO 3 */
4829 spec->gpio_led = 0x01; /* GPIO 0 */
4833 * This method searches for the mute LED GPIO configuration
4834 * provided as OEM string in SMBIOS. The format of that string
4835 * is HP_Mute_LED_P_G or HP_Mute_LED_P
4836 * where P can be 0 or 1 and defines mute LED GPIO control state (low/high)
4837 * that corresponds to the NOT muted state of the master volume
4838 * and G is the index of the GPIO to use as the mute LED control (0..9)
4839 * If _G portion is missing it is assigned based on the codec ID
4841 * So, HP B-series like systems may have HP_Mute_LED_0 (current models)
4842 * or HP_Mute_LED_0_3 (future models) OEM SMBIOS strings
4845 * The dv-series laptops don't seem to have the HP_Mute_LED* strings in
4846 * SMBIOS - at least the ones I have seen do not have them - which include
4847 * my own system (HP Pavilion dv6-1110ax) and my cousin's
4848 * HP Pavilion dv9500t CTO.
4849 * Need more information on whether it is true across the entire series.
4852 static int find_mute_led_cfg(struct hda_codec *codec, int default_polarity)
4854 struct sigmatel_spec *spec = codec->spec;
4855 const struct dmi_device *dev = NULL;
4857 if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) {
4858 get_int_hint(codec, "gpio_led_polarity",
4859 &spec->gpio_led_polarity);
4862 if ((codec->subsystem_id >> 16) == PCI_VENDOR_ID_HP) {
4863 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING,
4865 if (sscanf(dev->name, "HP_Mute_LED_%d_%x",
4866 &spec->gpio_led_polarity,
4867 &spec->gpio_led) == 2) {
4868 unsigned int max_gpio;
4869 max_gpio = snd_hda_param_read(codec, codec->afg,
4871 max_gpio &= AC_GPIO_IO_COUNT;
4872 if (spec->gpio_led < max_gpio)
4873 spec->gpio_led = 1 << spec->gpio_led;
4875 spec->vref_mute_led_nid = spec->gpio_led;
4878 if (sscanf(dev->name, "HP_Mute_LED_%d",
4879 &spec->gpio_led_polarity) == 1) {
4880 set_hp_led_gpio(codec);
4883 /* BIOS bug: unfilled OEM string */
4884 if (strstr(dev->name, "HP_Mute_LED_P_G")) {
4885 set_hp_led_gpio(codec);
4886 switch (codec->subsystem_id) {
4888 spec->gpio_led_polarity = 0;
4891 spec->gpio_led_polarity = 1;
4899 * Fallback case - if we don't find the DMI strings,
4900 * we statically set the GPIO - if not a B-series system
4901 * and default polarity is provided
4903 if (!hp_blike_system(codec->subsystem_id) &&
4904 (default_polarity == 0 || default_polarity == 1)) {
4905 set_hp_led_gpio(codec);
4906 spec->gpio_led_polarity = default_polarity;
4913 static int hp_blike_system(u32 subsystem_id)
4915 switch (subsystem_id) {
4942 #ifdef CONFIG_PROC_FS
4943 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4944 struct hda_codec *codec, hda_nid_t nid)
4946 if (nid == codec->afg)
4947 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4948 snd_hda_codec_read(codec, nid, 0,
4949 AC_VERB_IDT_GET_POWER_MAP, 0));
4952 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4953 struct hda_codec *codec,
4956 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4957 snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
4960 /* stac92hd71bxx, stac92hd73xx */
4961 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4962 struct hda_codec *codec, hda_nid_t nid)
4964 stac92hd_proc_hook(buffer, codec, nid);
4965 if (nid == codec->afg)
4966 analog_loop_proc_hook(buffer, codec, 0xfa0);
4969 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4970 struct hda_codec *codec, hda_nid_t nid)
4972 if (nid == codec->afg)
4973 analog_loop_proc_hook(buffer, codec, 0xfe0);
4976 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4977 struct hda_codec *codec, hda_nid_t nid)
4979 if (nid == codec->afg)
4980 analog_loop_proc_hook(buffer, codec, 0xfeb);
4983 #define stac92hd_proc_hook NULL
4984 #define stac92hd7x_proc_hook NULL
4985 #define stac9205_proc_hook NULL
4986 #define stac927x_proc_hook NULL
4990 static int stac92xx_resume(struct hda_codec *codec)
4992 stac92xx_init(codec);
4993 snd_hda_codec_resume_amp(codec);
4994 snd_hda_codec_resume_cache(codec);
4995 /* fake event to set up pins again to override cached values */
4996 stac_fake_hp_events(codec);
5000 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
5002 stac92xx_shutup(codec);
5006 static void stac92xx_set_power_state(struct hda_codec *codec, hda_nid_t fg,
5007 unsigned int power_state)
5009 unsigned int afg_power_state = power_state;
5010 struct sigmatel_spec *spec = codec->spec;
5012 if (power_state == AC_PWRST_D3) {
5013 if (spec->vref_mute_led_nid) {
5014 /* with vref-out pin used for mute led control
5015 * codec AFG is prevented from D3 state
5017 afg_power_state = AC_PWRST_D1;
5019 /* this delay seems necessary to avoid click noise at power-down */
5022 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
5024 snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
5027 #define stac92xx_suspend NULL
5028 #define stac92xx_resume NULL
5029 #define stac92xx_set_power_state NULL
5030 #endif /* CONFIG_PM */
5032 /* update mute-LED accoring to the master switch */
5033 static void stac92xx_update_led_status(struct hda_codec *codec, int enabled)
5035 struct sigmatel_spec *spec = codec->spec;
5036 int muted = !enabled;
5038 if (!spec->gpio_led)
5041 /* LED state is inverted on these systems */
5042 if (spec->gpio_led_polarity)
5045 if (!spec->vref_mute_led_nid) {
5047 spec->gpio_data |= spec->gpio_led;
5049 spec->gpio_data &= ~spec->gpio_led;
5050 stac_gpio_set(codec, spec->gpio_mask,
5051 spec->gpio_dir, spec->gpio_data);
5053 spec->vref_led = muted ? AC_PINCTL_VREF_50 : AC_PINCTL_VREF_GRD;
5054 stac_vrefout_set(codec, spec->vref_mute_led_nid,
5059 static const struct hda_codec_ops stac92xx_patch_ops = {
5060 .build_controls = stac92xx_build_controls,
5061 .build_pcms = stac92xx_build_pcms,
5062 .init = stac92xx_init,
5063 .free = stac92xx_free,
5064 .unsol_event = stac92xx_unsol_event,
5066 .suspend = stac92xx_suspend,
5067 .resume = stac92xx_resume,
5069 .reboot_notify = stac92xx_shutup,
5072 static int patch_stac9200(struct hda_codec *codec)
5074 struct sigmatel_spec *spec;
5077 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5081 codec->no_trigger_sense = 1;
5083 spec->linear_tone_beep = 1;
5084 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
5085 spec->pin_nids = stac9200_pin_nids;
5086 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
5089 if (spec->board_config < 0)
5090 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5093 stac92xx_set_config_regs(codec,
5094 stac9200_brd_tbl[spec->board_config]);
5096 spec->multiout.max_channels = 2;
5097 spec->multiout.num_dacs = 1;
5098 spec->multiout.dac_nids = stac9200_dac_nids;
5099 spec->adc_nids = stac9200_adc_nids;
5100 spec->mux_nids = stac9200_mux_nids;
5101 spec->num_muxes = 1;
5102 spec->num_dmics = 0;
5106 if (spec->board_config == STAC_9200_M4 ||
5107 spec->board_config == STAC_9200_M4_2 ||
5108 spec->board_config == STAC_9200_OQO)
5109 spec->init = stac9200_eapd_init;
5111 spec->init = stac9200_core_init;
5112 spec->mixer = stac9200_mixer;
5114 if (spec->board_config == STAC_9200_PANASONIC) {
5115 spec->gpio_mask = spec->gpio_dir = 0x09;
5116 spec->gpio_data = 0x00;
5119 err = stac9200_parse_auto_config(codec);
5121 stac92xx_free(codec);
5125 /* CF-74 has no headphone detection, and the driver should *NOT*
5126 * do detection and HP/speaker toggle because the hardware does it.
5128 if (spec->board_config == STAC_9200_PANASONIC)
5129 spec->hp_detect = 0;
5131 codec->patch_ops = stac92xx_patch_ops;
5136 static int patch_stac925x(struct hda_codec *codec)
5138 struct sigmatel_spec *spec;
5141 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5145 codec->no_trigger_sense = 1;
5147 spec->linear_tone_beep = 1;
5148 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
5149 spec->pin_nids = stac925x_pin_nids;
5151 /* Check first for codec ID */
5152 spec->board_config = snd_hda_check_board_codec_sid_config(codec,
5155 stac925x_codec_id_cfg_tbl);
5157 /* Now checks for PCI ID, if codec ID is not found */
5158 if (spec->board_config < 0)
5159 spec->board_config = snd_hda_check_board_config(codec,
5164 if (spec->board_config < 0)
5165 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5168 stac92xx_set_config_regs(codec,
5169 stac925x_brd_tbl[spec->board_config]);
5171 spec->multiout.max_channels = 2;
5172 spec->multiout.num_dacs = 1;
5173 spec->multiout.dac_nids = stac925x_dac_nids;
5174 spec->adc_nids = stac925x_adc_nids;
5175 spec->mux_nids = stac925x_mux_nids;
5176 spec->num_muxes = 1;
5179 switch (codec->vendor_id) {
5180 case 0x83847632: /* STAC9202 */
5181 case 0x83847633: /* STAC9202D */
5182 case 0x83847636: /* STAC9251 */
5183 case 0x83847637: /* STAC9251D */
5184 spec->num_dmics = STAC925X_NUM_DMICS;
5185 spec->dmic_nids = stac925x_dmic_nids;
5186 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
5187 spec->dmux_nids = stac925x_dmux_nids;
5190 spec->num_dmics = 0;
5194 spec->init = stac925x_core_init;
5195 spec->mixer = stac925x_mixer;
5197 spec->capvols = stac925x_capvols;
5198 spec->capsws = stac925x_capsws;
5200 err = stac92xx_parse_auto_config(codec);
5202 if (spec->board_config < 0) {
5203 printk(KERN_WARNING "hda_codec: No auto-config is "
5204 "available, default to model=ref\n");
5205 spec->board_config = STAC_925x_REF;
5211 stac92xx_free(codec);
5215 codec->patch_ops = stac92xx_patch_ops;
5220 static int patch_stac92hd73xx(struct hda_codec *codec)
5222 struct sigmatel_spec *spec;
5223 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
5227 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5231 codec->no_trigger_sense = 1;
5233 spec->linear_tone_beep = 0;
5234 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
5235 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
5236 spec->pin_nids = stac92hd73xx_pin_nids;
5237 spec->board_config = snd_hda_check_board_config(codec,
5238 STAC_92HD73XX_MODELS,
5239 stac92hd73xx_models,
5240 stac92hd73xx_cfg_tbl);
5241 /* check codec subsystem id if not found */
5242 if (spec->board_config < 0)
5243 spec->board_config =
5244 snd_hda_check_board_codec_sid_config(codec,
5245 STAC_92HD73XX_MODELS, stac92hd73xx_models,
5246 stac92hd73xx_codec_id_cfg_tbl);
5248 if (spec->board_config < 0)
5249 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5252 stac92xx_set_config_regs(codec,
5253 stac92hd73xx_brd_tbl[spec->board_config]);
5255 num_dacs = snd_hda_get_connections(codec, 0x0a,
5256 conn, STAC92HD73_DAC_COUNT + 2) - 1;
5258 if (num_dacs < 3 || num_dacs > 5) {
5259 printk(KERN_WARNING "hda_codec: Could not determine "
5260 "number of channels defaulting to DAC count\n");
5261 num_dacs = STAC92HD73_DAC_COUNT;
5263 spec->init = stac92hd73xx_core_init;
5265 case 0x3: /* 6 Channel */
5266 spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
5268 case 0x4: /* 8 Channel */
5269 spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
5271 case 0x5: /* 10 Channel */
5272 spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
5275 spec->multiout.dac_nids = spec->dac_nids;
5277 spec->aloopback_mask = 0x01;
5278 spec->aloopback_shift = 8;
5280 spec->digbeep_nid = 0x1c;
5281 spec->mux_nids = stac92hd73xx_mux_nids;
5282 spec->adc_nids = stac92hd73xx_adc_nids;
5283 spec->dmic_nids = stac92hd73xx_dmic_nids;
5284 spec->dmux_nids = stac92hd73xx_dmux_nids;
5285 spec->smux_nids = stac92hd73xx_smux_nids;
5287 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
5288 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
5289 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
5291 spec->num_caps = STAC92HD73XX_NUM_CAPS;
5292 spec->capvols = stac92hd73xx_capvols;
5293 spec->capsws = stac92hd73xx_capsws;
5295 switch (spec->board_config) {
5297 spec->init = dell_eq_core_init;
5299 case STAC_DELL_M6_AMIC:
5300 case STAC_DELL_M6_DMIC:
5301 case STAC_DELL_M6_BOTH:
5302 spec->num_smuxes = 0;
5303 spec->eapd_switch = 0;
5305 switch (spec->board_config) {
5306 case STAC_DELL_M6_AMIC: /* Analog Mics */
5307 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5308 spec->num_dmics = 0;
5310 case STAC_DELL_M6_DMIC: /* Digital Mics */
5311 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5312 spec->num_dmics = 1;
5314 case STAC_DELL_M6_BOTH: /* Both */
5315 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5316 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5317 spec->num_dmics = 1;
5321 case STAC_ALIENWARE_M17X:
5322 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
5323 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
5324 spec->eapd_switch = 0;
5327 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
5328 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
5329 spec->eapd_switch = 1;
5332 if (spec->board_config != STAC_92HD73XX_REF) {
5333 /* GPIO0 High = Enable EAPD */
5334 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5335 spec->gpio_data = 0x01;
5338 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
5339 spec->pwr_nids = stac92hd73xx_pwr_nids;
5341 err = stac92xx_parse_auto_config(codec);
5344 if (spec->board_config < 0) {
5345 printk(KERN_WARNING "hda_codec: No auto-config is "
5346 "available, default to model=ref\n");
5347 spec->board_config = STAC_92HD73XX_REF;
5354 stac92xx_free(codec);
5358 if (spec->board_config == STAC_92HD73XX_NO_JD)
5359 spec->hp_detect = 0;
5361 codec->patch_ops = stac92xx_patch_ops;
5363 codec->proc_widget_hook = stac92hd7x_proc_hook;
5368 static int hp_bnb2011_with_dock(struct hda_codec *codec)
5370 if (codec->vendor_id != 0x111d7605 &&
5371 codec->vendor_id != 0x111d76d1)
5374 switch (codec->subsystem_id) {
5408 static void stac92hd8x_add_pin(struct hda_codec *codec, hda_nid_t nid)
5410 struct sigmatel_spec *spec = codec->spec;
5411 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5414 spec->auto_pin_nids[spec->auto_pin_cnt] = nid;
5415 spec->auto_pin_cnt++;
5417 if (get_defcfg_device(def_conf) == AC_JACK_MIC_IN &&
5418 get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE) {
5419 for (i = 0; i < ARRAY_SIZE(stac92hd83xxx_dmic_nids); i++) {
5420 if (nid == stac92hd83xxx_dmic_nids[i]) {
5421 spec->auto_dmic_nids[spec->auto_dmic_cnt] = nid;
5422 spec->auto_dmic_cnt++;
5428 static void stac92hd8x_add_adc(struct hda_codec *codec, hda_nid_t nid)
5430 struct sigmatel_spec *spec = codec->spec;
5432 spec->auto_adc_nids[spec->auto_adc_cnt] = nid;
5433 spec->auto_adc_cnt++;
5436 static void stac92hd8x_add_mux(struct hda_codec *codec, hda_nid_t nid)
5439 struct sigmatel_spec *spec = codec->spec;
5441 for (i = 0; i < spec->auto_adc_cnt; i++) {
5442 if (get_connection_index(codec,
5443 spec->auto_adc_nids[i], nid) >= 0) {
5444 /* mux and volume for adc_nids[i] */
5445 if (!spec->auto_mux_nids[i]) {
5446 spec->auto_mux_nids[i] = nid;
5447 /* 92hd codecs capture volume is in mux */
5448 spec->auto_capvols[i] = HDA_COMPOSE_AMP_VAL(nid,
5451 for (j = 0; j < spec->auto_dmic_cnt; j++) {
5452 if (get_connection_index(codec, nid,
5453 spec->auto_dmic_nids[j]) >= 0) {
5454 /* dmux for adc_nids[i] */
5455 if (!spec->auto_dmux_nids[i])
5456 spec->auto_dmux_nids[i] = nid;
5465 static void stac92hd8x_fill_auto_spec(struct hda_codec *codec)
5467 hda_nid_t nid, end_nid;
5468 unsigned int wid_caps, wid_type;
5469 struct sigmatel_spec *spec = codec->spec;
5471 end_nid = codec->start_nid + codec->num_nodes;
5473 for (nid = codec->start_nid; nid < end_nid; nid++) {
5474 wid_caps = get_wcaps(codec, nid);
5475 wid_type = get_wcaps_type(wid_caps);
5477 if (wid_type == AC_WID_PIN)
5478 stac92hd8x_add_pin(codec, nid);
5480 if (wid_type == AC_WID_AUD_IN && !(wid_caps & AC_WCAP_DIGITAL))
5481 stac92hd8x_add_adc(codec, nid);
5484 for (nid = codec->start_nid; nid < end_nid; nid++) {
5485 wid_caps = get_wcaps(codec, nid);
5486 wid_type = get_wcaps_type(wid_caps);
5488 if (wid_type == AC_WID_AUD_SEL)
5489 stac92hd8x_add_mux(codec, nid);
5492 spec->pin_nids = spec->auto_pin_nids;
5493 spec->num_pins = spec->auto_pin_cnt;
5494 spec->adc_nids = spec->auto_adc_nids;
5495 spec->num_adcs = spec->auto_adc_cnt;
5496 spec->capvols = spec->auto_capvols;
5497 spec->capsws = spec->auto_capvols;
5498 spec->num_caps = spec->auto_adc_cnt;
5499 spec->mux_nids = spec->auto_mux_nids;
5500 spec->num_muxes = spec->auto_adc_cnt;
5501 spec->dmux_nids = spec->auto_dmux_nids;
5502 spec->num_dmuxes = spec->auto_adc_cnt;
5503 spec->dmic_nids = spec->auto_dmic_nids;
5504 spec->num_dmics = spec->auto_dmic_cnt;
5507 static int patch_stac92hd83xxx(struct hda_codec *codec)
5509 struct sigmatel_spec *spec;
5512 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5516 if (hp_bnb2011_with_dock(codec)) {
5517 snd_hda_codec_set_pincfg(codec, 0xa, 0x2101201f);
5518 snd_hda_codec_set_pincfg(codec, 0xf, 0x2181205e);
5521 codec->no_trigger_sense = 1;
5524 stac92hd8x_fill_auto_spec(codec);
5526 spec->linear_tone_beep = 0;
5527 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
5528 spec->digbeep_nid = 0x21;
5529 spec->pwr_nids = stac92hd83xxx_pwr_nids;
5530 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
5531 spec->multiout.dac_nids = spec->dac_nids;
5532 spec->init = stac92hd83xxx_core_init;
5534 spec->board_config = snd_hda_check_board_config(codec,
5535 STAC_92HD83XXX_MODELS,
5536 stac92hd83xxx_models,
5537 stac92hd83xxx_cfg_tbl);
5538 /* check codec subsystem id if not found */
5539 if (spec->board_config < 0)
5540 spec->board_config =
5541 snd_hda_check_board_codec_sid_config(codec,
5542 STAC_92HD83XXX_MODELS, stac92hd83xxx_models,
5543 stac92hd83xxx_codec_id_cfg_tbl);
5545 if (spec->board_config < 0)
5546 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5549 stac92xx_set_config_regs(codec,
5550 stac92hd83xxx_brd_tbl[spec->board_config]);
5552 codec->patch_ops = stac92xx_patch_ops;
5554 switch (spec->board_config) {
5555 case STAC_HP_ZEPHYR:
5556 spec->init = stac92hd83xxx_hp_zephyr_init;
5560 if (find_mute_led_cfg(codec, -1/*no default cfg*/))
5561 snd_printd("mute LED gpio %d polarity %d\n",
5563 spec->gpio_led_polarity);
5565 if (spec->gpio_led) {
5566 if (!spec->vref_mute_led_nid) {
5567 spec->gpio_mask |= spec->gpio_led;
5568 spec->gpio_dir |= spec->gpio_led;
5569 spec->gpio_data |= spec->gpio_led;
5571 codec->patch_ops.set_power_state =
5572 stac92xx_set_power_state;
5576 err = stac92xx_parse_auto_config(codec);
5578 if (spec->board_config < 0) {
5579 printk(KERN_WARNING "hda_codec: No auto-config is "
5580 "available, default to model=ref\n");
5581 spec->board_config = STAC_92HD83XXX_REF;
5588 stac92xx_free(codec);
5592 codec->proc_widget_hook = stac92hd_proc_hook;
5597 static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
5600 struct sigmatel_spec *spec = codec->spec;
5603 for (idx = 0; idx < spec->num_pins; idx++)
5604 if (spec->pin_nids[idx] == dig0pin)
5606 if ((idx + 2) >= spec->num_pins)
5610 if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE)
5613 /* dig0pin + dig2pin case */
5614 if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE)
5616 if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE)
5622 /* HP dv7 bass switch - GPIO5 */
5623 #define stac_hp_bass_gpio_info snd_ctl_boolean_mono_info
5624 static int stac_hp_bass_gpio_get(struct snd_kcontrol *kcontrol,
5625 struct snd_ctl_elem_value *ucontrol)
5627 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5628 struct sigmatel_spec *spec = codec->spec;
5629 ucontrol->value.integer.value[0] = !!(spec->gpio_data & 0x20);
5633 static int stac_hp_bass_gpio_put(struct snd_kcontrol *kcontrol,
5634 struct snd_ctl_elem_value *ucontrol)
5636 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5637 struct sigmatel_spec *spec = codec->spec;
5638 unsigned int gpio_data;
5640 gpio_data = (spec->gpio_data & ~0x20) |
5641 (ucontrol->value.integer.value[0] ? 0x20 : 0);
5642 if (gpio_data == spec->gpio_data)
5644 spec->gpio_data = gpio_data;
5645 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
5649 static const struct snd_kcontrol_new stac_hp_bass_sw_ctrl = {
5650 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5651 .info = stac_hp_bass_gpio_info,
5652 .get = stac_hp_bass_gpio_get,
5653 .put = stac_hp_bass_gpio_put,
5656 static int stac_add_hp_bass_switch(struct hda_codec *codec)
5658 struct sigmatel_spec *spec = codec->spec;
5660 if (!stac_control_new(spec, &stac_hp_bass_sw_ctrl,
5661 "Bass Speaker Playback Switch", 0))
5664 spec->gpio_mask |= 0x20;
5665 spec->gpio_dir |= 0x20;
5666 spec->gpio_data |= 0x20;
5670 static int patch_stac92hd71bxx(struct hda_codec *codec)
5672 struct sigmatel_spec *spec;
5673 const struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
5674 unsigned int pin_cfg;
5677 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5681 codec->no_trigger_sense = 1;
5683 spec->linear_tone_beep = 0;
5684 codec->patch_ops = stac92xx_patch_ops;
5685 spec->num_pins = STAC92HD71BXX_NUM_PINS;
5686 switch (codec->vendor_id) {
5689 spec->pin_nids = stac92hd71bxx_pin_nids_4port;
5693 /* On 92HD75Bx 0x27 isn't a pin nid */
5697 spec->pin_nids = stac92hd71bxx_pin_nids_6port;
5699 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
5700 spec->board_config = snd_hda_check_board_config(codec,
5701 STAC_92HD71BXX_MODELS,
5702 stac92hd71bxx_models,
5703 stac92hd71bxx_cfg_tbl);
5705 if (spec->board_config < 0)
5706 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5709 stac92xx_set_config_regs(codec,
5710 stac92hd71bxx_brd_tbl[spec->board_config]);
5712 if (spec->board_config != STAC_92HD71BXX_REF) {
5714 spec->gpio_mask = 0x01;
5715 spec->gpio_dir = 0x01;
5716 spec->gpio_data = 0x01;
5719 spec->dmic_nids = stac92hd71bxx_dmic_nids;
5720 spec->dmux_nids = stac92hd71bxx_dmux_nids;
5722 spec->num_caps = STAC92HD71BXX_NUM_CAPS;
5723 spec->capvols = stac92hd71bxx_capvols;
5724 spec->capsws = stac92hd71bxx_capsws;
5726 switch (codec->vendor_id) {
5727 case 0x111d76b6: /* 4 Port without Analog Mixer */
5731 case 0x111d76b4: /* 6 Port without Analog Mixer */
5733 spec->init = stac92hd71bxx_core_init;
5734 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5735 spec->num_dmics = stac92xx_connected_ports(codec,
5736 stac92hd71bxx_dmic_nids,
5737 STAC92HD71BXX_NUM_DMICS);
5739 case 0x111d7608: /* 5 Port with Analog Mixer */
5740 switch (spec->board_config) {
5742 /* Enable VREF power saving on GPIO1 detect */
5743 err = stac_add_event(codec, codec->afg,
5744 STAC_VREF_EVENT, 0x02);
5747 snd_hda_codec_write_cache(codec, codec->afg, 0,
5748 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
5749 snd_hda_jack_detect_enable(codec, codec->afg, 0);
5750 spec->gpio_mask |= 0x02;
5753 if ((codec->revision_id & 0xf) == 0 ||
5754 (codec->revision_id & 0xf) == 1)
5755 spec->stream_delay = 40; /* 40 milliseconds */
5758 spec->init = stac92hd71bxx_core_init;
5760 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
5761 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
5762 spec->dmic_nids = stac92hd71bxx_dmic_5port_nids;
5763 spec->num_dmics = stac92xx_connected_ports(codec,
5764 stac92hd71bxx_dmic_5port_nids,
5765 STAC92HD71BXX_NUM_DMICS - 1);
5767 case 0x111d7603: /* 6 Port with Analog Mixer */
5768 if ((codec->revision_id & 0xf) == 1)
5769 spec->stream_delay = 40; /* 40 milliseconds */
5773 spec->init = stac92hd71bxx_core_init;
5774 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5775 spec->num_dmics = stac92xx_connected_ports(codec,
5776 stac92hd71bxx_dmic_nids,
5777 STAC92HD71BXX_NUM_DMICS);
5781 if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
5782 snd_hda_sequence_write_cache(codec, unmute_init);
5784 spec->aloopback_ctl = stac92hd71bxx_loopback;
5785 spec->aloopback_mask = 0x50;
5786 spec->aloopback_shift = 0;
5788 spec->powerdown_adcs = 1;
5789 spec->digbeep_nid = 0x26;
5790 spec->mux_nids = stac92hd71bxx_mux_nids;
5791 spec->adc_nids = stac92hd71bxx_adc_nids;
5792 spec->smux_nids = stac92hd71bxx_smux_nids;
5793 spec->pwr_nids = stac92hd71bxx_pwr_nids;
5795 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
5796 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
5797 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5798 spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
5800 snd_printdd("Found board config: %d\n", spec->board_config);
5802 switch (spec->board_config) {
5804 /* enable internal microphone */
5805 snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
5806 stac92xx_auto_set_pinctl(codec, 0x0e,
5807 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
5809 case STAC_DELL_M4_2:
5810 spec->num_dmics = 0;
5811 spec->num_smuxes = 0;
5812 spec->num_dmuxes = 0;
5814 case STAC_DELL_M4_1:
5815 case STAC_DELL_M4_3:
5816 spec->num_dmics = 1;
5817 spec->num_smuxes = 0;
5818 spec->num_dmuxes = 1;
5820 case STAC_HP_DV4_1222NR:
5821 spec->num_dmics = 1;
5822 /* I don't know if it needs 1 or 2 smuxes - will wait for
5823 * bug reports to fix if needed
5825 spec->num_smuxes = 1;
5826 spec->num_dmuxes = 1;
5829 spec->gpio_led = 0x01;
5832 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
5833 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
5834 /* HP dv6 gives the headphone pin as a line-out. Thus we
5835 * need to set hp_detect flag here to force to enable HP
5838 spec->hp_detect = 1;
5841 spec->num_dmics = 1;
5842 spec->num_dmuxes = 1;
5843 spec->num_smuxes = 1;
5844 spec->gpio_led = 0x08;
5848 if (hp_blike_system(codec->subsystem_id)) {
5849 pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f);
5850 if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT ||
5851 get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER ||
5852 get_defcfg_device(pin_cfg) == AC_JACK_HP_OUT) {
5853 /* It was changed in the BIOS to just satisfy MS DTM.
5854 * Lets turn it back into slaved HP
5856 pin_cfg = (pin_cfg & (~AC_DEFCFG_DEVICE))
5857 | (AC_JACK_HP_OUT <<
5858 AC_DEFCFG_DEVICE_SHIFT);
5859 pin_cfg = (pin_cfg & (~(AC_DEFCFG_DEF_ASSOC
5860 | AC_DEFCFG_SEQUENCE)))
5862 snd_hda_codec_set_pincfg(codec, 0x0f, pin_cfg);
5866 if (find_mute_led_cfg(codec, 1))
5867 snd_printd("mute LED gpio %d polarity %d\n",
5869 spec->gpio_led_polarity);
5871 if (spec->gpio_led) {
5872 if (!spec->vref_mute_led_nid) {
5873 spec->gpio_mask |= spec->gpio_led;
5874 spec->gpio_dir |= spec->gpio_led;
5875 spec->gpio_data |= spec->gpio_led;
5877 codec->patch_ops.set_power_state =
5878 stac92xx_set_power_state;
5882 spec->multiout.dac_nids = spec->dac_nids;
5884 err = stac92xx_parse_auto_config(codec);
5886 if (spec->board_config < 0) {
5887 printk(KERN_WARNING "hda_codec: No auto-config is "
5888 "available, default to model=ref\n");
5889 spec->board_config = STAC_92HD71BXX_REF;
5896 stac92xx_free(codec);
5900 /* enable bass on HP dv7 */
5901 if (spec->board_config == STAC_HP_DV4 ||
5902 spec->board_config == STAC_HP_DV5) {
5904 cap = snd_hda_param_read(codec, 0x1, AC_PAR_GPIO_CAP);
5905 cap &= AC_GPIO_IO_COUNT;
5907 stac_add_hp_bass_switch(codec);
5910 codec->proc_widget_hook = stac92hd7x_proc_hook;
5915 static int patch_stac922x(struct hda_codec *codec)
5917 struct sigmatel_spec *spec;
5920 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5924 codec->no_trigger_sense = 1;
5926 spec->linear_tone_beep = 1;
5927 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
5928 spec->pin_nids = stac922x_pin_nids;
5929 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
5932 if (spec->board_config == STAC_INTEL_MAC_AUTO) {
5933 spec->gpio_mask = spec->gpio_dir = 0x03;
5934 spec->gpio_data = 0x03;
5935 /* Intel Macs have all same PCI SSID, so we need to check
5936 * codec SSID to distinguish the exact models
5938 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
5939 switch (codec->subsystem_id) {
5942 spec->board_config = STAC_INTEL_MAC_V1;
5946 spec->board_config = STAC_INTEL_MAC_V2;
5954 spec->board_config = STAC_INTEL_MAC_V3;
5958 spec->board_config = STAC_INTEL_MAC_V4;
5962 spec->board_config = STAC_INTEL_MAC_V5;
5965 spec->board_config = STAC_INTEL_MAC_V3;
5971 if (spec->board_config < 0)
5972 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5975 stac92xx_set_config_regs(codec,
5976 stac922x_brd_tbl[spec->board_config]);
5978 spec->adc_nids = stac922x_adc_nids;
5979 spec->mux_nids = stac922x_mux_nids;
5980 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
5981 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
5982 spec->num_dmics = 0;
5985 spec->init = stac922x_core_init;
5987 spec->num_caps = STAC922X_NUM_CAPS;
5988 spec->capvols = stac922x_capvols;
5989 spec->capsws = stac922x_capsws;
5991 spec->multiout.dac_nids = spec->dac_nids;
5993 err = stac92xx_parse_auto_config(codec);
5995 if (spec->board_config < 0) {
5996 printk(KERN_WARNING "hda_codec: No auto-config is "
5997 "available, default to model=ref\n");
5998 spec->board_config = STAC_D945_REF;
6004 stac92xx_free(codec);
6008 codec->patch_ops = stac92xx_patch_ops;
6010 /* Fix Mux capture level; max to 2 */
6011 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
6012 (0 << AC_AMPCAP_OFFSET_SHIFT) |
6013 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
6014 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
6015 (0 << AC_AMPCAP_MUTE_SHIFT));
6020 static int patch_stac927x(struct hda_codec *codec)
6022 struct sigmatel_spec *spec;
6025 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6029 codec->no_trigger_sense = 1;
6031 spec->linear_tone_beep = 1;
6032 codec->slave_dig_outs = stac927x_slave_dig_outs;
6033 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
6034 spec->pin_nids = stac927x_pin_nids;
6035 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
6039 if (spec->board_config < 0)
6040 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6043 stac92xx_set_config_regs(codec,
6044 stac927x_brd_tbl[spec->board_config]);
6046 spec->digbeep_nid = 0x23;
6047 spec->adc_nids = stac927x_adc_nids;
6048 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
6049 spec->mux_nids = stac927x_mux_nids;
6050 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
6051 spec->smux_nids = stac927x_smux_nids;
6052 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
6053 spec->spdif_labels = stac927x_spdif_labels;
6054 spec->dac_list = stac927x_dac_nids;
6055 spec->multiout.dac_nids = spec->dac_nids;
6057 if (spec->board_config != STAC_D965_REF) {
6058 /* GPIO0 High = Enable EAPD */
6059 spec->eapd_mask = spec->gpio_mask = 0x01;
6060 spec->gpio_dir = spec->gpio_data = 0x01;
6063 switch (spec->board_config) {
6066 /* GPIO0 High = Enable EAPD */
6067 spec->num_dmics = 0;
6068 spec->init = d965_core_init;
6070 case STAC_DELL_BIOS:
6071 switch (codec->subsystem_id) {
6074 /* correct the device field to SPDIF out */
6075 snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
6078 /* configure the analog microphone on some laptops */
6079 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
6080 /* correct the front output jack as a hp out */
6081 snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f);
6082 /* correct the front input jack as a mic */
6083 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
6086 if (codec->subsystem_id != 0x1028022f) {
6087 /* GPIO2 High = Enable EAPD */
6088 spec->eapd_mask = spec->gpio_mask = 0x04;
6089 spec->gpio_dir = spec->gpio_data = 0x04;
6091 spec->dmic_nids = stac927x_dmic_nids;
6092 spec->num_dmics = STAC927X_NUM_DMICS;
6094 spec->init = dell_3st_core_init;
6095 spec->dmux_nids = stac927x_dmux_nids;
6096 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
6098 case STAC_927X_VOLKNOB:
6099 spec->num_dmics = 0;
6100 spec->init = stac927x_volknob_core_init;
6103 spec->num_dmics = 0;
6104 spec->init = stac927x_core_init;
6108 spec->num_caps = STAC927X_NUM_CAPS;
6109 spec->capvols = stac927x_capvols;
6110 spec->capsws = stac927x_capsws;
6113 spec->aloopback_ctl = stac927x_loopback;
6114 spec->aloopback_mask = 0x40;
6115 spec->aloopback_shift = 0;
6116 spec->eapd_switch = 1;
6118 err = stac92xx_parse_auto_config(codec);
6120 if (spec->board_config < 0) {
6121 printk(KERN_WARNING "hda_codec: No auto-config is "
6122 "available, default to model=ref\n");
6123 spec->board_config = STAC_D965_REF;
6129 stac92xx_free(codec);
6133 codec->patch_ops = stac92xx_patch_ops;
6135 codec->proc_widget_hook = stac927x_proc_hook;
6139 * The STAC927x seem to require fairly long delays for certain
6140 * command sequences. With too short delays (even if the answer
6141 * is set to RIRB properly), it results in the silence output
6142 * on some hardwares like Dell.
6144 * The below flag enables the longer delay (see get_response
6147 codec->bus->needs_damn_long_delay = 1;
6149 /* no jack detecion for ref-no-jd model */
6150 if (spec->board_config == STAC_D965_REF_NO_JD)
6151 spec->hp_detect = 0;
6156 static int patch_stac9205(struct hda_codec *codec)
6158 struct sigmatel_spec *spec;
6161 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6165 codec->no_trigger_sense = 1;
6167 spec->linear_tone_beep = 1;
6168 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
6169 spec->pin_nids = stac9205_pin_nids;
6170 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
6174 if (spec->board_config < 0)
6175 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6178 stac92xx_set_config_regs(codec,
6179 stac9205_brd_tbl[spec->board_config]);
6181 spec->digbeep_nid = 0x23;
6182 spec->adc_nids = stac9205_adc_nids;
6183 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
6184 spec->mux_nids = stac9205_mux_nids;
6185 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
6186 spec->smux_nids = stac9205_smux_nids;
6187 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
6188 spec->dmic_nids = stac9205_dmic_nids;
6189 spec->num_dmics = STAC9205_NUM_DMICS;
6190 spec->dmux_nids = stac9205_dmux_nids;
6191 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
6194 spec->init = stac9205_core_init;
6195 spec->aloopback_ctl = stac9205_loopback;
6197 spec->num_caps = STAC9205_NUM_CAPS;
6198 spec->capvols = stac9205_capvols;
6199 spec->capsws = stac9205_capsws;
6201 spec->aloopback_mask = 0x40;
6202 spec->aloopback_shift = 0;
6203 /* Turn on/off EAPD per HP plugging */
6204 if (spec->board_config != STAC_9205_EAPD)
6205 spec->eapd_switch = 1;
6206 spec->multiout.dac_nids = spec->dac_nids;
6208 switch (spec->board_config){
6209 case STAC_9205_DELL_M43:
6210 /* Enable SPDIF in/out */
6211 snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030);
6212 snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030);
6214 /* Enable unsol response for GPIO4/Dock HP connection */
6215 err = stac_add_event(codec, codec->afg, STAC_VREF_EVENT, 0x01);
6218 snd_hda_codec_write_cache(codec, codec->afg, 0,
6219 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
6220 snd_hda_jack_detect_enable(codec, codec->afg, 0);
6222 spec->gpio_dir = 0x0b;
6223 spec->eapd_mask = 0x01;
6224 spec->gpio_mask = 0x1b;
6225 spec->gpio_mute = 0x10;
6226 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
6229 spec->gpio_data = 0x01;
6232 /* SPDIF-In enabled */
6235 /* GPIO0 High = EAPD */
6236 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
6237 spec->gpio_data = 0x01;
6241 err = stac92xx_parse_auto_config(codec);
6243 if (spec->board_config < 0) {
6244 printk(KERN_WARNING "hda_codec: No auto-config is "
6245 "available, default to model=ref\n");
6246 spec->board_config = STAC_9205_REF;
6252 stac92xx_free(codec);
6256 codec->patch_ops = stac92xx_patch_ops;
6258 codec->proc_widget_hook = stac9205_proc_hook;
6267 static const struct hda_verb stac9872_core_init[] = {
6268 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
6269 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
6273 static const hda_nid_t stac9872_pin_nids[] = {
6274 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
6278 static const hda_nid_t stac9872_adc_nids[] = {
6282 static const hda_nid_t stac9872_mux_nids[] = {
6286 static const unsigned long stac9872_capvols[] = {
6287 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
6289 #define stac9872_capsws stac9872_capvols
6291 static const unsigned int stac9872_vaio_pin_configs[9] = {
6292 0x03211020, 0x411111f0, 0x411111f0, 0x03a15030,
6293 0x411111f0, 0x90170110, 0x411111f0, 0x411111f0,
6297 static const char * const stac9872_models[STAC_9872_MODELS] = {
6298 [STAC_9872_AUTO] = "auto",
6299 [STAC_9872_VAIO] = "vaio",
6302 static const unsigned int *stac9872_brd_tbl[STAC_9872_MODELS] = {
6303 [STAC_9872_VAIO] = stac9872_vaio_pin_configs,
6306 static const struct snd_pci_quirk stac9872_cfg_tbl[] = {
6307 SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0,
6308 "Sony VAIO F/S", STAC_9872_VAIO),
6312 static int patch_stac9872(struct hda_codec *codec)
6314 struct sigmatel_spec *spec;
6317 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6320 codec->no_trigger_sense = 1;
6322 spec->linear_tone_beep = 1;
6323 spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
6324 spec->pin_nids = stac9872_pin_nids;
6326 spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
6329 if (spec->board_config < 0)
6330 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6333 stac92xx_set_config_regs(codec,
6334 stac9872_brd_tbl[spec->board_config]);
6336 spec->multiout.dac_nids = spec->dac_nids;
6337 spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
6338 spec->adc_nids = stac9872_adc_nids;
6339 spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
6340 spec->mux_nids = stac9872_mux_nids;
6341 spec->init = stac9872_core_init;
6343 spec->capvols = stac9872_capvols;
6344 spec->capsws = stac9872_capsws;
6346 err = stac92xx_parse_auto_config(codec);
6348 stac92xx_free(codec);
6351 spec->input_mux = &spec->private_imux;
6352 codec->patch_ops = stac92xx_patch_ops;
6360 static const struct hda_codec_preset snd_hda_preset_sigmatel[] = {
6361 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
6362 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
6363 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
6364 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
6365 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
6366 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
6367 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
6368 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
6369 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
6370 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
6371 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
6372 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
6373 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
6374 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
6375 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
6376 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
6377 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
6378 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
6379 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
6380 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
6381 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
6382 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
6383 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
6384 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
6385 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
6386 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
6387 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
6388 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
6389 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
6390 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
6391 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
6392 /* The following does not take into account .id=0x83847661 when subsys =
6393 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
6394 * currently not fully supported.
6396 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
6397 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
6398 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
6399 { .id = 0x83847698, .name = "STAC9205", .patch = patch_stac9205 },
6400 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
6401 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
6402 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
6403 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
6404 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
6405 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
6406 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
6407 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
6408 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
6409 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
6410 { .id = 0x111d76d4, .name = "92HD83C1C5", .patch = patch_stac92hd83xxx},
6411 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
6412 { .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx},
6413 { .id = 0x111d76d1, .name = "92HD87B1/3", .patch = patch_stac92hd83xxx},
6414 { .id = 0x111d76d9, .name = "92HD87B2/4", .patch = patch_stac92hd83xxx},
6415 { .id = 0x111d7666, .name = "92HD88B3", .patch = patch_stac92hd83xxx},
6416 { .id = 0x111d7667, .name = "92HD88B1", .patch = patch_stac92hd83xxx},
6417 { .id = 0x111d7668, .name = "92HD88B2", .patch = patch_stac92hd83xxx},
6418 { .id = 0x111d7669, .name = "92HD88B4", .patch = patch_stac92hd83xxx},
6419 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
6420 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
6421 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
6422 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
6423 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
6424 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
6425 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
6426 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
6427 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
6428 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
6429 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
6430 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
6431 { .id = 0x111d76c0, .name = "92HD89C3", .patch = patch_stac92hd73xx },
6432 { .id = 0x111d76c1, .name = "92HD89C2", .patch = patch_stac92hd73xx },
6433 { .id = 0x111d76c2, .name = "92HD89C1", .patch = patch_stac92hd73xx },
6434 { .id = 0x111d76c3, .name = "92HD89B3", .patch = patch_stac92hd73xx },
6435 { .id = 0x111d76c4, .name = "92HD89B2", .patch = patch_stac92hd73xx },
6436 { .id = 0x111d76c5, .name = "92HD89B1", .patch = patch_stac92hd73xx },
6437 { .id = 0x111d76c6, .name = "92HD89E3", .patch = patch_stac92hd73xx },
6438 { .id = 0x111d76c7, .name = "92HD89E2", .patch = patch_stac92hd73xx },
6439 { .id = 0x111d76c8, .name = "92HD89E1", .patch = patch_stac92hd73xx },
6440 { .id = 0x111d76c9, .name = "92HD89D3", .patch = patch_stac92hd73xx },
6441 { .id = 0x111d76ca, .name = "92HD89D2", .patch = patch_stac92hd73xx },
6442 { .id = 0x111d76cb, .name = "92HD89D1", .patch = patch_stac92hd73xx },
6443 { .id = 0x111d76cc, .name = "92HD89F3", .patch = patch_stac92hd73xx },
6444 { .id = 0x111d76cd, .name = "92HD89F2", .patch = patch_stac92hd73xx },
6445 { .id = 0x111d76ce, .name = "92HD89F1", .patch = patch_stac92hd73xx },
6446 { .id = 0x111d76df, .name = "92HD93BXX", .patch = patch_stac92hd83xxx},
6447 { .id = 0x111d76e0, .name = "92HD91BXX", .patch = patch_stac92hd83xxx},
6448 { .id = 0x111d76e3, .name = "92HD98BXX", .patch = patch_stac92hd83xxx},
6449 { .id = 0x111d76e5, .name = "92HD99BXX", .patch = patch_stac92hd83xxx},
6450 { .id = 0x111d76e7, .name = "92HD90BXX", .patch = patch_stac92hd83xxx},
6451 { .id = 0x111d76e8, .name = "92HD66B1X5", .patch = patch_stac92hd83xxx},
6452 { .id = 0x111d76e9, .name = "92HD66B2X5", .patch = patch_stac92hd83xxx},
6453 { .id = 0x111d76ea, .name = "92HD66B3X5", .patch = patch_stac92hd83xxx},
6454 { .id = 0x111d76eb, .name = "92HD66C1X5", .patch = patch_stac92hd83xxx},
6455 { .id = 0x111d76ec, .name = "92HD66C2X5", .patch = patch_stac92hd83xxx},
6456 { .id = 0x111d76ed, .name = "92HD66C3X5", .patch = patch_stac92hd83xxx},
6457 { .id = 0x111d76ee, .name = "92HD66B1X3", .patch = patch_stac92hd83xxx},
6458 { .id = 0x111d76ef, .name = "92HD66B2X3", .patch = patch_stac92hd83xxx},
6459 { .id = 0x111d76f0, .name = "92HD66B3X3", .patch = patch_stac92hd83xxx},
6460 { .id = 0x111d76f1, .name = "92HD66C1X3", .patch = patch_stac92hd83xxx},
6461 { .id = 0x111d76f2, .name = "92HD66C2X3", .patch = patch_stac92hd83xxx},
6462 { .id = 0x111d76f3, .name = "92HD66C3/65", .patch = patch_stac92hd83xxx},
6466 MODULE_ALIAS("snd-hda-codec-id:8384*");
6467 MODULE_ALIAS("snd-hda-codec-id:111d*");
6469 MODULE_LICENSE("GPL");
6470 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
6472 static struct hda_codec_preset_list sigmatel_list = {
6473 .preset = snd_hda_preset_sigmatel,
6474 .owner = THIS_MODULE,
6477 static int __init patch_sigmatel_init(void)
6479 return snd_hda_add_codec_preset(&sigmatel_list);
6482 static void __exit patch_sigmatel_exit(void)
6484 snd_hda_delete_codec_preset(&sigmatel_list);
6487 module_init(patch_sigmatel_init)
6488 module_exit(patch_sigmatel_exit)