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_HP_LED,
105 STAC_92HD83XXX_HP_INV_LED,
106 STAC_92HD83XXX_HP_MIC_LED,
107 STAC_92HD83XXX_HEADSET_JACK,
108 STAC_92HD83XXX_MODELS
122 STAC_92HD71BXX_MODELS
148 STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
149 * is given, one of the above models will be
150 * chosen according to the subsystem id. */
151 /* for backward compatibility */
168 STAC_D965_REF_NO_JD, /* no jack-detection */
185 struct sigmatel_mic_route {
188 signed char dmux_idx;
191 #define MAX_PINS_NUM 16
192 #define MAX_ADCS_NUM 4
193 #define MAX_DMICS_NUM 4
195 struct sigmatel_spec {
196 struct snd_kcontrol_new *mixers[4];
197 unsigned int num_mixers;
200 unsigned int eapd_switch: 1;
201 unsigned int surr_switch: 1;
202 unsigned int alt_switch: 1;
203 unsigned int hp_detect: 1;
204 unsigned int spdif_mute: 1;
205 unsigned int check_volume_offset:1;
206 unsigned int auto_mic:1;
207 unsigned int linear_tone_beep:1;
208 unsigned int headset_jack:1; /* 4-pin headset jack (hp + mono mic) */
211 unsigned int eapd_mask;
212 unsigned int gpio_mask;
213 unsigned int gpio_dir;
214 unsigned int gpio_data;
215 unsigned int gpio_mute;
216 unsigned int gpio_led;
217 unsigned int gpio_led_polarity;
218 unsigned int vref_mute_led_nid; /* pin NID for mute-LED vref control */
219 unsigned int vref_led;
221 unsigned int mic_mute_led_gpio; /* capture mute LED GPIO */
222 bool mic_mute_led_on; /* current mic mute state */
225 unsigned int stream_delay;
227 /* analog loopback */
228 const struct snd_kcontrol_new *aloopback_ctl;
229 unsigned char aloopback_mask;
230 unsigned char aloopback_shift;
232 /* power management */
233 unsigned int power_map_bits;
234 unsigned int num_pwrs;
235 const hda_nid_t *pwr_nids;
236 const hda_nid_t *dac_list;
239 struct hda_input_mux *mono_mux;
240 unsigned int cur_mmux;
241 struct hda_multi_out multiout;
242 hda_nid_t dac_nids[5];
243 hda_nid_t hp_dacs[5];
244 hda_nid_t speaker_dacs[5];
249 const hda_nid_t *adc_nids;
250 unsigned int num_adcs;
251 const hda_nid_t *mux_nids;
252 unsigned int num_muxes;
253 const hda_nid_t *dmic_nids;
254 unsigned int num_dmics;
255 const hda_nid_t *dmux_nids;
256 unsigned int num_dmuxes;
257 const hda_nid_t *smux_nids;
258 unsigned int num_smuxes;
259 unsigned int num_analog_muxes;
261 const unsigned long *capvols; /* amp-volume attr: HDA_COMPOSE_AMP_VAL() */
262 const unsigned long *capsws; /* amp-mute attr: HDA_COMPOSE_AMP_VAL() */
263 unsigned int num_caps; /* number of capture volume/switch elements */
265 struct sigmatel_mic_route ext_mic;
266 struct sigmatel_mic_route int_mic;
267 struct sigmatel_mic_route dock_mic;
269 const char * const *spdif_labels;
271 hda_nid_t dig_in_nid;
273 hda_nid_t anabeep_nid;
274 hda_nid_t digbeep_nid;
277 const hda_nid_t *pin_nids;
278 unsigned int num_pins;
280 /* codec specific stuff */
281 const struct hda_verb *init;
282 const struct snd_kcontrol_new *mixer;
285 struct hda_input_mux *dinput_mux;
286 unsigned int cur_dmux[2];
287 struct hda_input_mux *input_mux;
288 unsigned int cur_mux[3];
289 struct hda_input_mux *sinput_mux;
290 unsigned int cur_smux[2];
291 unsigned int cur_amux;
293 unsigned int powerdown_adcs;
296 unsigned int io_switch[2];
297 unsigned int clfe_swap;
298 hda_nid_t line_switch; /* shared line-in for input and output */
299 hda_nid_t mic_switch; /* shared mic-in for input and output */
300 hda_nid_t hp_switch; /* NID of HP as line-out */
301 unsigned int aloopback;
303 struct hda_pcm pcm_rec[2]; /* PCM information */
305 /* dynamic controls and input_mux */
306 struct auto_pin_cfg autocfg;
307 struct snd_array kctls;
308 struct hda_input_mux private_dimux;
309 struct hda_input_mux private_imux;
310 struct hda_input_mux private_smux;
311 struct hda_input_mux private_mono_mux;
314 unsigned auto_pin_cnt;
315 hda_nid_t auto_pin_nids[MAX_PINS_NUM];
316 unsigned auto_adc_cnt;
317 hda_nid_t auto_adc_nids[MAX_ADCS_NUM];
318 hda_nid_t auto_mux_nids[MAX_ADCS_NUM];
319 hda_nid_t auto_dmux_nids[MAX_ADCS_NUM];
320 unsigned long auto_capvols[MAX_ADCS_NUM];
321 unsigned auto_dmic_cnt;
322 hda_nid_t auto_dmic_nids[MAX_DMICS_NUM];
324 struct hda_vmaster_mute_hook vmaster_mute;
327 #define AC_VERB_IDT_SET_POWER_MAP 0x7ec
328 #define AC_VERB_IDT_GET_POWER_MAP 0xfec
330 static const hda_nid_t stac9200_adc_nids[1] = {
334 static const hda_nid_t stac9200_mux_nids[1] = {
338 static const hda_nid_t stac9200_dac_nids[1] = {
342 static const hda_nid_t stac92hd73xx_pwr_nids[8] = {
343 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
347 static const hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
351 static const hda_nid_t stac92hd73xx_adc_nids[2] = {
355 #define STAC92HD73XX_NUM_DMICS 2
356 static const hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
360 #define STAC92HD73_DAC_COUNT 5
362 static const hda_nid_t stac92hd73xx_mux_nids[2] = {
366 static const hda_nid_t stac92hd73xx_dmux_nids[2] = {
370 static const hda_nid_t stac92hd73xx_smux_nids[2] = {
374 #define STAC92HD73XX_NUM_CAPS 2
375 static const unsigned long stac92hd73xx_capvols[] = {
376 HDA_COMPOSE_AMP_VAL(0x20, 3, 0, HDA_OUTPUT),
377 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
379 #define stac92hd73xx_capsws stac92hd73xx_capvols
381 #define STAC92HD83_DAC_COUNT 3
383 static const hda_nid_t stac92hd83xxx_pwr_nids[7] = {
384 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
388 static const hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
392 static const hda_nid_t stac92hd83xxx_dmic_nids[] = {
396 static const hda_nid_t stac92hd71bxx_pwr_nids[3] = {
400 static const hda_nid_t stac92hd71bxx_adc_nids[2] = {
404 static const hda_nid_t stac92hd71bxx_mux_nids[2] = {
408 static const hda_nid_t stac92hd71bxx_dmux_nids[2] = {
412 static const hda_nid_t stac92hd71bxx_smux_nids[2] = {
416 #define STAC92HD71BXX_NUM_DMICS 2
417 static const hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
421 static const hda_nid_t stac92hd71bxx_dmic_5port_nids[STAC92HD71BXX_NUM_DMICS] = {
425 static const hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
429 #define STAC92HD71BXX_NUM_CAPS 2
430 static const unsigned long stac92hd71bxx_capvols[] = {
431 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
432 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
434 #define stac92hd71bxx_capsws stac92hd71bxx_capvols
436 static const hda_nid_t stac925x_adc_nids[1] = {
440 static const hda_nid_t stac925x_mux_nids[1] = {
444 static const hda_nid_t stac925x_dac_nids[1] = {
448 #define STAC925X_NUM_DMICS 1
449 static const hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
453 static const hda_nid_t stac925x_dmux_nids[1] = {
457 static const unsigned long stac925x_capvols[] = {
458 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
460 static const unsigned long stac925x_capsws[] = {
461 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
464 static const hda_nid_t stac922x_adc_nids[2] = {
468 static const hda_nid_t stac922x_mux_nids[2] = {
472 #define STAC922X_NUM_CAPS 2
473 static const unsigned long stac922x_capvols[] = {
474 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_INPUT),
475 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
477 #define stac922x_capsws stac922x_capvols
479 static const hda_nid_t stac927x_slave_dig_outs[2] = {
483 static const hda_nid_t stac927x_adc_nids[3] = {
487 static const hda_nid_t stac927x_mux_nids[3] = {
491 static const hda_nid_t stac927x_smux_nids[1] = {
495 static const hda_nid_t stac927x_dac_nids[6] = {
496 0x02, 0x03, 0x04, 0x05, 0x06, 0
499 static const hda_nid_t stac927x_dmux_nids[1] = {
503 #define STAC927X_NUM_DMICS 2
504 static const hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
508 #define STAC927X_NUM_CAPS 3
509 static const unsigned long stac927x_capvols[] = {
510 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
511 HDA_COMPOSE_AMP_VAL(0x19, 3, 0, HDA_INPUT),
512 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_INPUT),
514 static const unsigned long stac927x_capsws[] = {
515 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
516 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
517 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
520 static const char * const stac927x_spdif_labels[5] = {
521 "Digital Playback", "ADAT", "Analog Mux 1",
522 "Analog Mux 2", "Analog Mux 3"
525 static const hda_nid_t stac9205_adc_nids[2] = {
529 static const hda_nid_t stac9205_mux_nids[2] = {
533 static const hda_nid_t stac9205_dmux_nids[1] = {
537 static const hda_nid_t stac9205_smux_nids[1] = {
541 #define STAC9205_NUM_DMICS 2
542 static const hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
546 #define STAC9205_NUM_CAPS 2
547 static const unsigned long stac9205_capvols[] = {
548 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_INPUT),
549 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_INPUT),
551 static const unsigned long stac9205_capsws[] = {
552 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
553 HDA_COMPOSE_AMP_VAL(0x1e, 3, 0, HDA_OUTPUT),
556 static const hda_nid_t stac9200_pin_nids[8] = {
557 0x08, 0x09, 0x0d, 0x0e,
558 0x0f, 0x10, 0x11, 0x12,
561 static const hda_nid_t stac925x_pin_nids[8] = {
562 0x07, 0x08, 0x0a, 0x0b,
563 0x0c, 0x0d, 0x10, 0x11,
566 static const hda_nid_t stac922x_pin_nids[10] = {
567 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
568 0x0f, 0x10, 0x11, 0x15, 0x1b,
571 static const hda_nid_t stac92hd73xx_pin_nids[13] = {
572 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
573 0x0f, 0x10, 0x11, 0x12, 0x13,
577 #define STAC92HD71BXX_NUM_PINS 13
578 static const hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
579 0x0a, 0x0b, 0x0c, 0x0d, 0x00,
580 0x00, 0x14, 0x18, 0x19, 0x1e,
583 static const hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
584 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
585 0x0f, 0x14, 0x18, 0x19, 0x1e,
589 static const hda_nid_t stac927x_pin_nids[14] = {
590 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
591 0x0f, 0x10, 0x11, 0x12, 0x13,
592 0x14, 0x21, 0x22, 0x23,
595 static const hda_nid_t stac9205_pin_nids[12] = {
596 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
597 0x0f, 0x14, 0x16, 0x17, 0x18,
601 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
602 struct snd_ctl_elem_info *uinfo)
604 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
605 struct sigmatel_spec *spec = codec->spec;
606 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
609 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
610 struct snd_ctl_elem_value *ucontrol)
612 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
613 struct sigmatel_spec *spec = codec->spec;
614 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
616 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
620 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
621 struct snd_ctl_elem_value *ucontrol)
623 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
624 struct sigmatel_spec *spec = codec->spec;
625 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
627 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
628 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
631 static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
632 struct snd_ctl_elem_info *uinfo)
634 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
635 struct sigmatel_spec *spec = codec->spec;
636 return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
639 static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
640 struct snd_ctl_elem_value *ucontrol)
642 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
643 struct sigmatel_spec *spec = codec->spec;
644 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
646 ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
650 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
651 struct snd_ctl_elem_value *ucontrol)
653 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
654 struct sigmatel_spec *spec = codec->spec;
655 struct hda_input_mux *smux = &spec->private_smux;
656 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
660 err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
661 spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
665 if (spec->spdif_mute) {
667 nid = spec->multiout.dig_out_nid;
669 nid = codec->slave_dig_outs[smux_idx - 1];
670 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
674 /* un/mute SPDIF out */
675 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
681 static int stac_vrefout_set(struct hda_codec *codec,
682 hda_nid_t nid, unsigned int new_vref)
686 snd_printdd("%s, nid %x ctl %x\n", __func__, nid, new_vref);
687 pinctl = snd_hda_codec_read(codec, nid, 0,
688 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
694 pinctl &= ~AC_PINCTL_VREFEN;
695 pinctl |= (new_vref & AC_PINCTL_VREFEN);
697 error = snd_hda_set_pin_ctl_cache(codec, nid, pinctl);
704 static unsigned int stac92xx_vref_set(struct hda_codec *codec,
705 hda_nid_t nid, unsigned int new_vref)
709 pincfg = snd_hda_codec_read(codec, nid, 0,
710 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
713 pincfg &= ~(AC_PINCTL_VREFEN | AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
716 if (new_vref == AC_PINCTL_VREF_HIZ)
717 pincfg |= AC_PINCTL_OUT_EN;
719 pincfg |= AC_PINCTL_IN_EN;
721 error = snd_hda_set_pin_ctl_cache(codec, nid, pincfg);
728 static unsigned int stac92xx_vref_get(struct hda_codec *codec, hda_nid_t nid)
731 vref = snd_hda_codec_read(codec, nid, 0,
732 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
733 vref &= AC_PINCTL_VREFEN;
737 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
739 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
740 struct sigmatel_spec *spec = codec->spec;
741 return snd_hda_input_mux_info(spec->input_mux, uinfo);
744 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
746 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
747 struct sigmatel_spec *spec = codec->spec;
748 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
750 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
754 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
756 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
757 struct sigmatel_spec *spec = codec->spec;
758 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
759 const struct hda_input_mux *imux = spec->input_mux;
760 unsigned int idx, prev_idx, didx;
762 idx = ucontrol->value.enumerated.item[0];
763 if (idx >= imux->num_items)
764 idx = imux->num_items - 1;
765 prev_idx = spec->cur_mux[adc_idx];
768 if (idx < spec->num_analog_muxes) {
769 snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0,
770 AC_VERB_SET_CONNECT_SEL,
771 imux->items[idx].index);
772 if (prev_idx >= spec->num_analog_muxes &&
773 spec->mux_nids[adc_idx] != spec->dmux_nids[adc_idx]) {
774 imux = spec->dinput_mux;
776 snd_hda_codec_write_cache(codec,
777 spec->dmux_nids[adc_idx], 0,
778 AC_VERB_SET_CONNECT_SEL,
779 imux->items[0].index);
782 imux = spec->dinput_mux;
783 /* first dimux item is hardcoded to select analog imux,
786 didx = idx - spec->num_analog_muxes + 1;
787 snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0,
788 AC_VERB_SET_CONNECT_SEL,
789 imux->items[didx].index);
791 spec->cur_mux[adc_idx] = idx;
795 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
796 struct snd_ctl_elem_info *uinfo)
798 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
799 struct sigmatel_spec *spec = codec->spec;
800 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
803 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
804 struct snd_ctl_elem_value *ucontrol)
806 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
807 struct sigmatel_spec *spec = codec->spec;
809 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
813 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
814 struct snd_ctl_elem_value *ucontrol)
816 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
817 struct sigmatel_spec *spec = codec->spec;
819 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
820 spec->mono_nid, &spec->cur_mmux);
823 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
825 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
826 struct snd_ctl_elem_value *ucontrol)
828 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
829 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
830 struct sigmatel_spec *spec = codec->spec;
832 ucontrol->value.integer.value[0] = !!(spec->aloopback &
833 (spec->aloopback_mask << idx));
837 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
838 struct snd_ctl_elem_value *ucontrol)
840 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
841 struct sigmatel_spec *spec = codec->spec;
842 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
843 unsigned int dac_mode;
844 unsigned int val, idx_val;
846 idx_val = spec->aloopback_mask << idx;
847 if (ucontrol->value.integer.value[0])
848 val = spec->aloopback | idx_val;
850 val = spec->aloopback & ~idx_val;
851 if (spec->aloopback == val)
854 spec->aloopback = val;
856 /* Only return the bits defined by the shift value of the
857 * first two bytes of the mask
859 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
860 kcontrol->private_value & 0xFFFF, 0x0);
861 dac_mode >>= spec->aloopback_shift;
863 if (spec->aloopback & idx_val) {
864 snd_hda_power_up(codec);
867 snd_hda_power_down(codec);
868 dac_mode &= ~idx_val;
871 snd_hda_codec_write_cache(codec, codec->afg, 0,
872 kcontrol->private_value >> 16, dac_mode);
877 static const struct hda_verb stac9200_core_init[] = {
878 /* set dac0mux for dac converter */
879 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
883 static const struct hda_verb stac9200_eapd_init[] = {
884 /* set dac0mux for dac converter */
885 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
886 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
890 static const struct hda_verb dell_eq_core_init[] = {
891 /* set master volume to max value without distortion
892 * and direct control */
893 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
897 static const struct hda_verb stac92hd73xx_core_init[] = {
898 /* set master volume and direct control */
899 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
903 static const struct hda_verb stac92hd83xxx_core_init[] = {
904 /* power state controls amps */
905 { 0x01, AC_VERB_SET_EAPD, 1 << 2},
909 static const struct hda_verb stac92hd83xxx_hp_zephyr_init[] = {
910 { 0x22, 0x785, 0x43 },
911 { 0x22, 0x782, 0xe0 },
912 { 0x22, 0x795, 0x00 },
916 static const struct hda_verb stac92hd71bxx_core_init[] = {
917 /* set master volume and direct control */
918 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
922 static const struct hda_verb stac92hd71bxx_unmute_core_init[] = {
923 /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
924 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
925 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
926 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
930 static const struct hda_verb stac925x_core_init[] = {
931 /* set dac0mux for dac converter */
932 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
933 /* mute the master volume */
934 { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
938 static const struct hda_verb stac922x_core_init[] = {
939 /* set master volume and direct control */
940 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
944 static const struct hda_verb d965_core_init[] = {
945 /* set master volume and direct control */
946 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
947 /* unmute node 0x1b */
948 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
949 /* select node 0x03 as DAC */
950 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
954 static const struct hda_verb dell_3st_core_init[] = {
955 /* don't set delta bit */
956 {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
957 /* unmute node 0x1b */
958 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
959 /* select node 0x03 as DAC */
960 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
964 static const struct hda_verb stac927x_core_init[] = {
965 /* set master volume and direct control */
966 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
967 /* enable analog pc beep path */
968 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
972 static const struct hda_verb stac927x_volknob_core_init[] = {
973 /* don't set delta bit */
974 {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
975 /* enable analog pc beep path */
976 {0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
980 static const struct hda_verb stac9205_core_init[] = {
981 /* set master volume and direct control */
982 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
983 /* enable analog pc beep path */
984 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
988 #define STAC_MONO_MUX \
990 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
991 .name = "Mono Mux", \
993 .info = stac92xx_mono_mux_enum_info, \
994 .get = stac92xx_mono_mux_enum_get, \
995 .put = stac92xx_mono_mux_enum_put, \
998 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
1000 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1001 .name = "Analog Loopback", \
1003 .info = stac92xx_aloopback_info, \
1004 .get = stac92xx_aloopback_get, \
1005 .put = stac92xx_aloopback_put, \
1006 .private_value = verb_read | (verb_write << 16), \
1009 #define DC_BIAS(xname, idx, nid) \
1011 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1014 .info = stac92xx_dc_bias_info, \
1015 .get = stac92xx_dc_bias_get, \
1016 .put = stac92xx_dc_bias_put, \
1017 .private_value = nid, \
1020 static const struct snd_kcontrol_new stac9200_mixer[] = {
1021 HDA_CODEC_VOLUME_MIN_MUTE("PCM Playback Volume", 0xb, 0, HDA_OUTPUT),
1022 HDA_CODEC_MUTE("PCM Playback Switch", 0xb, 0, HDA_OUTPUT),
1023 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
1024 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
1028 static const struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
1029 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
1033 static const struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = {
1034 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1038 static const struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
1039 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1044 static const struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
1045 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
1048 static const struct snd_kcontrol_new stac925x_mixer[] = {
1049 HDA_CODEC_VOLUME_MIN_MUTE("PCM Playback Volume", 0xe, 0, HDA_OUTPUT),
1050 HDA_CODEC_MUTE("PCM Playback Switch", 0x0e, 0, HDA_OUTPUT),
1054 static const struct snd_kcontrol_new stac9205_loopback[] = {
1055 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1059 static const struct snd_kcontrol_new stac927x_loopback[] = {
1060 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1064 static struct snd_kcontrol_new stac_dmux_mixer = {
1065 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1066 .name = "Digital Input Source",
1067 /* count set later */
1068 .info = stac92xx_dmux_enum_info,
1069 .get = stac92xx_dmux_enum_get,
1070 .put = stac92xx_dmux_enum_put,
1073 static struct snd_kcontrol_new stac_smux_mixer = {
1074 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1075 .name = "IEC958 Playback Source",
1076 /* count set later */
1077 .info = stac92xx_smux_enum_info,
1078 .get = stac92xx_smux_enum_get,
1079 .put = stac92xx_smux_enum_put,
1082 static const char * const slave_pfxs[] = {
1083 "Front", "Surround", "Center", "LFE", "Side",
1084 "Headphone", "Speaker", "IEC958", "PCM",
1088 static void stac92xx_update_led_status(struct hda_codec *codec, int enabled);
1090 static void stac92xx_vmaster_hook(void *private_data, int val)
1092 stac92xx_update_led_status(private_data, val);
1095 static void stac92xx_free_kctls(struct hda_codec *codec);
1097 static int stac92xx_build_controls(struct hda_codec *codec)
1099 struct sigmatel_spec *spec = codec->spec;
1100 unsigned int vmaster_tlv[4];
1105 err = snd_hda_add_new_ctls(codec, spec->mixer);
1110 for (i = 0; i < spec->num_mixers; i++) {
1111 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1115 if (!spec->auto_mic && spec->num_dmuxes > 0 &&
1116 snd_hda_get_bool_hint(codec, "separate_dmux") == 1) {
1117 stac_dmux_mixer.count = spec->num_dmuxes;
1118 err = snd_hda_ctl_add(codec, 0,
1119 snd_ctl_new1(&stac_dmux_mixer, codec));
1123 if (spec->num_smuxes > 0) {
1124 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1125 struct hda_input_mux *smux = &spec->private_smux;
1126 /* check for mute support on SPDIF out */
1127 if (wcaps & AC_WCAP_OUT_AMP) {
1128 snd_hda_add_imux_item(smux, "Off", 0, NULL);
1129 spec->spdif_mute = 1;
1131 stac_smux_mixer.count = spec->num_smuxes;
1132 err = snd_hda_ctl_add(codec, 0,
1133 snd_ctl_new1(&stac_smux_mixer, codec));
1138 if (spec->multiout.dig_out_nid) {
1139 err = snd_hda_create_spdif_out_ctls(codec,
1140 spec->multiout.dig_out_nid,
1141 spec->multiout.dig_out_nid);
1144 err = snd_hda_create_spdif_share_sw(codec,
1148 spec->multiout.share_spdif = 1;
1150 if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1151 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1156 /* if we have no master control, let's create it */
1157 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1158 HDA_OUTPUT, vmaster_tlv);
1159 /* correct volume offset */
1160 vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
1161 /* minimum value is actually mute */
1162 vmaster_tlv[3] |= TLV_DB_SCALE_MUTE;
1163 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1164 vmaster_tlv, slave_pfxs,
1169 err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
1171 "Playback Switch", true,
1172 &spec->vmaster_mute.sw_kctl);
1176 if (spec->gpio_led) {
1177 spec->vmaster_mute.hook = stac92xx_vmaster_hook;
1178 err = snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute, true);
1183 if (spec->aloopback_ctl &&
1184 snd_hda_get_bool_hint(codec, "loopback") == 1) {
1185 err = snd_hda_add_new_ctls(codec, spec->aloopback_ctl);
1190 stac92xx_free_kctls(codec); /* no longer needed */
1192 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
1199 static const unsigned int ref9200_pin_configs[8] = {
1200 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1201 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1204 static const unsigned int gateway9200_m4_pin_configs[8] = {
1205 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1206 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1208 static const unsigned int gateway9200_m4_2_pin_configs[8] = {
1209 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1210 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1214 STAC 9200 pin configs for
1219 static const unsigned int dell9200_d21_pin_configs[8] = {
1220 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
1221 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1225 STAC 9200 pin configs for
1229 static const unsigned int dell9200_d22_pin_configs[8] = {
1230 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1231 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1235 STAC 9200 pin configs for
1236 102801C4 (Dell Dimension E310)
1243 static const unsigned int dell9200_d23_pin_configs[8] = {
1244 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1245 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
1250 STAC 9200-32 pin configs for
1251 102801B5 (Dell Inspiron 630m)
1252 102801D8 (Dell Inspiron 640m)
1254 static const unsigned int dell9200_m21_pin_configs[8] = {
1255 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1256 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1260 STAC 9200-32 pin configs for
1261 102801C2 (Dell Latitude D620)
1263 102801CC (Dell Latitude D820)
1267 static const unsigned int dell9200_m22_pin_configs[8] = {
1268 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1269 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1273 STAC 9200-32 pin configs for
1274 102801CE (Dell XPS M1710)
1275 102801CF (Dell Precision M90)
1277 static const unsigned int dell9200_m23_pin_configs[8] = {
1278 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1279 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1283 STAC 9200-32 pin configs for
1286 102801CB (Dell Latitude 120L)
1289 static const unsigned int dell9200_m24_pin_configs[8] = {
1290 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1291 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1295 STAC 9200-32 pin configs for
1296 102801BD (Dell Inspiron E1505n)
1300 static const unsigned int dell9200_m25_pin_configs[8] = {
1301 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1302 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1306 STAC 9200-32 pin configs for
1307 102801F5 (Dell Inspiron 1501)
1310 static const unsigned int dell9200_m26_pin_configs[8] = {
1311 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1312 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1317 102801CD (Dell Inspiron E1705/9400)
1319 static const unsigned int dell9200_m27_pin_configs[8] = {
1320 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1321 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1324 static const unsigned int oqo9200_pin_configs[8] = {
1325 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1326 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1330 static const unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1331 [STAC_REF] = ref9200_pin_configs,
1332 [STAC_9200_OQO] = oqo9200_pin_configs,
1333 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1334 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1335 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1336 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1337 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1338 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1339 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1340 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1341 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1342 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1343 [STAC_9200_M4] = gateway9200_m4_pin_configs,
1344 [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1345 [STAC_9200_PANASONIC] = ref9200_pin_configs,
1348 static const char * const stac9200_models[STAC_9200_MODELS] = {
1349 [STAC_AUTO] = "auto",
1351 [STAC_9200_OQO] = "oqo",
1352 [STAC_9200_DELL_D21] = "dell-d21",
1353 [STAC_9200_DELL_D22] = "dell-d22",
1354 [STAC_9200_DELL_D23] = "dell-d23",
1355 [STAC_9200_DELL_M21] = "dell-m21",
1356 [STAC_9200_DELL_M22] = "dell-m22",
1357 [STAC_9200_DELL_M23] = "dell-m23",
1358 [STAC_9200_DELL_M24] = "dell-m24",
1359 [STAC_9200_DELL_M25] = "dell-m25",
1360 [STAC_9200_DELL_M26] = "dell-m26",
1361 [STAC_9200_DELL_M27] = "dell-m27",
1362 [STAC_9200_M4] = "gateway-m4",
1363 [STAC_9200_M4_2] = "gateway-m4-2",
1364 [STAC_9200_PANASONIC] = "panasonic",
1367 static const struct snd_pci_quirk stac9200_cfg_tbl[] = {
1368 /* SigmaTel reference board */
1369 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1370 "DFI LanParty", STAC_REF),
1371 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1372 "DFI LanParty", STAC_REF),
1373 /* Dell laptops have BIOS problem */
1374 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1375 "unknown Dell", STAC_9200_DELL_D21),
1376 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1377 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1378 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1379 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1380 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1381 "unknown Dell", STAC_9200_DELL_D22),
1382 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1383 "unknown Dell", STAC_9200_DELL_D22),
1384 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1385 "Dell Latitude D620", STAC_9200_DELL_M22),
1386 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1387 "unknown Dell", STAC_9200_DELL_D23),
1388 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1389 "unknown Dell", STAC_9200_DELL_D23),
1390 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1391 "unknown Dell", STAC_9200_DELL_M22),
1392 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1393 "unknown Dell", STAC_9200_DELL_M24),
1394 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1395 "unknown Dell", STAC_9200_DELL_M24),
1396 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1397 "Dell Latitude 120L", STAC_9200_DELL_M24),
1398 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1399 "Dell Latitude D820", STAC_9200_DELL_M22),
1400 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1401 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1402 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1403 "Dell XPS M1710", STAC_9200_DELL_M23),
1404 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1405 "Dell Precision M90", STAC_9200_DELL_M23),
1406 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1407 "unknown Dell", STAC_9200_DELL_M22),
1408 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1409 "unknown Dell", STAC_9200_DELL_M22),
1410 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1411 "unknown Dell", STAC_9200_DELL_M22),
1412 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1413 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1414 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1415 "unknown Dell", STAC_9200_DELL_D23),
1416 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1417 "unknown Dell", STAC_9200_DELL_D23),
1418 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1419 "unknown Dell", STAC_9200_DELL_D21),
1420 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1421 "unknown Dell", STAC_9200_DELL_D23),
1422 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1423 "unknown Dell", STAC_9200_DELL_D21),
1424 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1425 "unknown Dell", STAC_9200_DELL_M25),
1426 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1427 "unknown Dell", STAC_9200_DELL_M25),
1428 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1429 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1430 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1431 "unknown Dell", STAC_9200_DELL_M26),
1433 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1434 /* Gateway machines needs EAPD to be set on resume */
1435 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1436 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1437 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1439 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1443 static const unsigned int ref925x_pin_configs[8] = {
1444 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1445 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1448 static const unsigned int stac925xM1_pin_configs[8] = {
1449 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1450 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1453 static const unsigned int stac925xM1_2_pin_configs[8] = {
1454 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1455 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1458 static const unsigned int stac925xM2_pin_configs[8] = {
1459 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1460 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1463 static const unsigned int stac925xM2_2_pin_configs[8] = {
1464 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1465 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1468 static const unsigned int stac925xM3_pin_configs[8] = {
1469 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1470 0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1473 static const unsigned int stac925xM5_pin_configs[8] = {
1474 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1475 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1478 static const unsigned int stac925xM6_pin_configs[8] = {
1479 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1480 0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1483 static const unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1484 [STAC_REF] = ref925x_pin_configs,
1485 [STAC_M1] = stac925xM1_pin_configs,
1486 [STAC_M1_2] = stac925xM1_2_pin_configs,
1487 [STAC_M2] = stac925xM2_pin_configs,
1488 [STAC_M2_2] = stac925xM2_2_pin_configs,
1489 [STAC_M3] = stac925xM3_pin_configs,
1490 [STAC_M5] = stac925xM5_pin_configs,
1491 [STAC_M6] = stac925xM6_pin_configs,
1494 static const char * const stac925x_models[STAC_925x_MODELS] = {
1495 [STAC_925x_AUTO] = "auto",
1498 [STAC_M1_2] = "m1-2",
1500 [STAC_M2_2] = "m2-2",
1506 static const struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1507 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1508 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1509 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1510 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1511 SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1512 /* Not sure about the brand name for those */
1513 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1514 SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1515 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1516 SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1520 static const struct snd_pci_quirk stac925x_cfg_tbl[] = {
1521 /* SigmaTel reference board */
1522 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1523 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
1524 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1526 /* Default table for unknown ID */
1527 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1532 static const unsigned int ref92hd73xx_pin_configs[13] = {
1533 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1534 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1535 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1539 static const unsigned int dell_m6_pin_configs[13] = {
1540 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1541 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1542 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1546 static const unsigned int alienware_m17x_pin_configs[13] = {
1547 0x0321101f, 0x0321101f, 0x03a11020, 0x03014020,
1548 0x90170110, 0x4f0000f0, 0x4f0000f0, 0x4f0000f0,
1549 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1553 static const unsigned int intel_dg45id_pin_configs[13] = {
1554 0x02214230, 0x02A19240, 0x01013214, 0x01014210,
1555 0x01A19250, 0x01011212, 0x01016211
1558 static const unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1559 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1560 [STAC_DELL_M6_AMIC] = dell_m6_pin_configs,
1561 [STAC_DELL_M6_DMIC] = dell_m6_pin_configs,
1562 [STAC_DELL_M6_BOTH] = dell_m6_pin_configs,
1563 [STAC_DELL_EQ] = dell_m6_pin_configs,
1564 [STAC_ALIENWARE_M17X] = alienware_m17x_pin_configs,
1565 [STAC_92HD73XX_INTEL] = intel_dg45id_pin_configs,
1568 static const char * const stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1569 [STAC_92HD73XX_AUTO] = "auto",
1570 [STAC_92HD73XX_NO_JD] = "no-jd",
1571 [STAC_92HD73XX_REF] = "ref",
1572 [STAC_92HD73XX_INTEL] = "intel",
1573 [STAC_DELL_M6_AMIC] = "dell-m6-amic",
1574 [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1575 [STAC_DELL_M6_BOTH] = "dell-m6",
1576 [STAC_DELL_EQ] = "dell-eq",
1577 [STAC_ALIENWARE_M17X] = "alienware",
1580 static const struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1581 /* SigmaTel reference board */
1582 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1583 "DFI LanParty", STAC_92HD73XX_REF),
1584 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1585 "DFI LanParty", STAC_92HD73XX_REF),
1586 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
1587 "Intel DG45ID", STAC_92HD73XX_INTEL),
1588 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
1589 "Intel DG45FC", STAC_92HD73XX_INTEL),
1590 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1591 "Dell Studio 1535", STAC_DELL_M6_DMIC),
1592 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1593 "unknown Dell", STAC_DELL_M6_DMIC),
1594 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1595 "unknown Dell", STAC_DELL_M6_BOTH),
1596 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1597 "unknown Dell", STAC_DELL_M6_BOTH),
1598 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1599 "unknown Dell", STAC_DELL_M6_AMIC),
1600 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1601 "unknown Dell", STAC_DELL_M6_AMIC),
1602 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1603 "unknown Dell", STAC_DELL_M6_DMIC),
1604 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1605 "unknown Dell", STAC_DELL_M6_DMIC),
1606 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1607 "Dell Studio 1537", STAC_DELL_M6_DMIC),
1608 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1609 "Dell Studio 17", STAC_DELL_M6_DMIC),
1610 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
1611 "Dell Studio 1555", STAC_DELL_M6_DMIC),
1612 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd,
1613 "Dell Studio 1557", STAC_DELL_M6_DMIC),
1614 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe,
1615 "Dell Studio XPS 1645", STAC_DELL_M6_DMIC),
1616 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413,
1617 "Dell Studio 1558", STAC_DELL_M6_DMIC),
1621 static const struct snd_pci_quirk stac92hd73xx_codec_id_cfg_tbl[] = {
1622 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1,
1623 "Alienware M17x", STAC_ALIENWARE_M17X),
1624 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x043a,
1625 "Alienware M17x", STAC_ALIENWARE_M17X),
1626 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0490,
1627 "Alienware M17x R3", STAC_DELL_EQ),
1631 static const unsigned int ref92hd83xxx_pin_configs[10] = {
1632 0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1633 0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1634 0x01451160, 0x98560170,
1637 static const unsigned int dell_s14_pin_configs[10] = {
1638 0x0221403f, 0x0221101f, 0x02a19020, 0x90170110,
1639 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a60160,
1640 0x40f000f0, 0x40f000f0,
1643 static const unsigned int dell_vostro_3500_pin_configs[10] = {
1644 0x02a11020, 0x0221101f, 0x400000f0, 0x90170110,
1645 0x400000f1, 0x400000f2, 0x400000f3, 0x90a60160,
1646 0x400000f4, 0x400000f5,
1649 static const unsigned int hp_dv7_4000_pin_configs[10] = {
1650 0x03a12050, 0x0321201f, 0x40f000f0, 0x90170110,
1651 0x40f000f0, 0x40f000f0, 0x90170110, 0xd5a30140,
1652 0x40f000f0, 0x40f000f0,
1655 static const unsigned int hp_zephyr_pin_configs[10] = {
1656 0x01813050, 0x0421201f, 0x04a1205e, 0x96130310,
1657 0x96130310, 0x0101401f, 0x1111611f, 0xd5a30130,
1661 static const unsigned int hp_cNB11_intquad_pin_configs[10] = {
1662 0x40f000f0, 0x0221101f, 0x02a11020, 0x92170110,
1663 0x40f000f0, 0x92170110, 0x40f000f0, 0xd5a30130,
1664 0x40f000f0, 0x40f000f0,
1667 static const unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1668 [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1669 [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
1670 [STAC_DELL_S14] = dell_s14_pin_configs,
1671 [STAC_DELL_VOSTRO_3500] = dell_vostro_3500_pin_configs,
1672 [STAC_92HD83XXX_HP_cNB11_INTQUAD] = hp_cNB11_intquad_pin_configs,
1673 [STAC_HP_DV7_4000] = hp_dv7_4000_pin_configs,
1674 [STAC_HP_ZEPHYR] = hp_zephyr_pin_configs,
1677 static const char * const stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1678 [STAC_92HD83XXX_AUTO] = "auto",
1679 [STAC_92HD83XXX_REF] = "ref",
1680 [STAC_92HD83XXX_PWR_REF] = "mic-ref",
1681 [STAC_DELL_S14] = "dell-s14",
1682 [STAC_DELL_VOSTRO_3500] = "dell-vostro-3500",
1683 [STAC_92HD83XXX_HP_cNB11_INTQUAD] = "hp_cNB11_intquad",
1684 [STAC_HP_DV7_4000] = "hp-dv7-4000",
1685 [STAC_HP_ZEPHYR] = "hp-zephyr",
1686 [STAC_92HD83XXX_HP_LED] = "hp-led",
1687 [STAC_92HD83XXX_HP_INV_LED] = "hp-inv-led",
1688 [STAC_92HD83XXX_HP_MIC_LED] = "hp-mic-led",
1689 [STAC_92HD83XXX_HEADSET_JACK] = "headset-jack",
1692 static const struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1693 /* SigmaTel reference board */
1694 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1695 "DFI LanParty", STAC_92HD83XXX_REF),
1696 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1697 "DFI LanParty", STAC_92HD83XXX_REF),
1698 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
1699 "unknown Dell", STAC_DELL_S14),
1700 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0532,
1701 "Dell Latitude E6230", STAC_92HD83XXX_HEADSET_JACK),
1702 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0533,
1703 "Dell Latitude E6330", STAC_92HD83XXX_HEADSET_JACK),
1704 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0534,
1705 "Dell Latitude E6430", STAC_92HD83XXX_HEADSET_JACK),
1706 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0535,
1707 "Dell Latitude E6530", STAC_92HD83XXX_HEADSET_JACK),
1708 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x053c,
1709 "Dell Latitude E5430", STAC_92HD83XXX_HEADSET_JACK),
1710 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x053d,
1711 "Dell Latitude E5530", STAC_92HD83XXX_HEADSET_JACK),
1712 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0549,
1713 "Dell Latitude E5430", STAC_92HD83XXX_HEADSET_JACK),
1714 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x057d,
1715 "Dell Latitude E6430s", STAC_92HD83XXX_HEADSET_JACK),
1716 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0584,
1717 "Dell Latitude E6430U", STAC_92HD83XXX_HEADSET_JACK),
1718 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x1028,
1719 "Dell Vostro 3500", STAC_DELL_VOSTRO_3500),
1720 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1656,
1721 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1722 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1657,
1723 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1724 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1658,
1725 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1726 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1659,
1727 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1728 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x165A,
1729 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1730 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x165B,
1731 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1732 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x18df,
1733 "HP Folio", STAC_92HD83XXX_HP_MIC_LED),
1734 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3388,
1735 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1736 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3389,
1737 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1738 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355B,
1739 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1740 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355C,
1741 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1742 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355D,
1743 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1744 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355E,
1745 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1746 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355F,
1747 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1748 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3560,
1749 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1750 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358B,
1751 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1752 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358C,
1753 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1754 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358D,
1755 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1756 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3591,
1757 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1758 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3592,
1759 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1760 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3593,
1761 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1762 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3561,
1763 "HP", STAC_HP_ZEPHYR),
1764 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3660,
1765 "HP Mini", STAC_92HD83XXX_HP_LED),
1769 static const struct snd_pci_quirk stac92hd83xxx_codec_id_cfg_tbl[] = {
1770 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3561,
1771 "HP", STAC_HP_ZEPHYR),
1775 static const unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1776 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1777 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1778 0x90a000f0, 0x01452050, 0x01452050, 0x00000000,
1782 static const unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1783 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1784 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1785 0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000,
1789 static const unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1790 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1791 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1792 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1796 static const unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1797 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1798 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1799 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1803 static const unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1804 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1805 [STAC_DELL_M4_1] = dell_m4_1_pin_configs,
1806 [STAC_DELL_M4_2] = dell_m4_2_pin_configs,
1807 [STAC_DELL_M4_3] = dell_m4_3_pin_configs,
1808 [STAC_HP_M4] = NULL,
1809 [STAC_HP_DV4] = NULL,
1810 [STAC_HP_DV5] = NULL,
1811 [STAC_HP_HDX] = NULL,
1812 [STAC_HP_DV4_1222NR] = NULL,
1815 static const char * const stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1816 [STAC_92HD71BXX_AUTO] = "auto",
1817 [STAC_92HD71BXX_REF] = "ref",
1818 [STAC_DELL_M4_1] = "dell-m4-1",
1819 [STAC_DELL_M4_2] = "dell-m4-2",
1820 [STAC_DELL_M4_3] = "dell-m4-3",
1821 [STAC_HP_M4] = "hp-m4",
1822 [STAC_HP_DV4] = "hp-dv4",
1823 [STAC_HP_DV5] = "hp-dv5",
1824 [STAC_HP_HDX] = "hp-hdx",
1825 [STAC_HP_DV4_1222NR] = "hp-dv4-1222nr",
1828 static const struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1829 /* SigmaTel reference board */
1830 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1831 "DFI LanParty", STAC_92HD71BXX_REF),
1832 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1833 "DFI LanParty", STAC_92HD71BXX_REF),
1834 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb,
1835 "HP dv4-1222nr", STAC_HP_DV4_1222NR),
1836 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720,
1838 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
1840 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
1841 "HP dv4-7", STAC_HP_DV4),
1842 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
1843 "HP dv4-7", STAC_HP_DV5),
1844 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
1845 "HP HDX", STAC_HP_HDX), /* HDX18 */
1846 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1847 "HP mini 1000", STAC_HP_M4),
1848 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
1849 "HP HDX", STAC_HP_HDX), /* HDX16 */
1850 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
1851 "HP dv6", STAC_HP_DV5),
1852 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061,
1853 "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */
1854 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x363e,
1855 "HP DV6", STAC_HP_DV5),
1856 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
1858 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1859 "unknown Dell", STAC_DELL_M4_1),
1860 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1861 "unknown Dell", STAC_DELL_M4_1),
1862 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1863 "unknown Dell", STAC_DELL_M4_1),
1864 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1865 "unknown Dell", STAC_DELL_M4_1),
1866 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1867 "unknown Dell", STAC_DELL_M4_1),
1868 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1869 "unknown Dell", STAC_DELL_M4_1),
1870 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1871 "unknown Dell", STAC_DELL_M4_1),
1872 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1873 "unknown Dell", STAC_DELL_M4_2),
1874 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1875 "unknown Dell", STAC_DELL_M4_2),
1876 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1877 "unknown Dell", STAC_DELL_M4_2),
1878 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1879 "unknown Dell", STAC_DELL_M4_2),
1880 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1881 "unknown Dell", STAC_DELL_M4_3),
1885 static const unsigned int ref922x_pin_configs[10] = {
1886 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1887 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1888 0x40000100, 0x40000100,
1892 STAC 922X pin configs for
1899 static const unsigned int dell_922x_d81_pin_configs[10] = {
1900 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1901 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1902 0x01813122, 0x400001f2,
1906 STAC 922X pin configs for
1910 static const unsigned int dell_922x_d82_pin_configs[10] = {
1911 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1912 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1913 0x01813122, 0x400001f1,
1917 STAC 922X pin configs for
1920 static const unsigned int dell_922x_m81_pin_configs[10] = {
1921 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1922 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1923 0x40C003f1, 0x405003f0,
1927 STAC 9221 A1 pin configs for
1928 102801D7 (Dell XPS M1210)
1930 static const unsigned int dell_922x_m82_pin_configs[10] = {
1931 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1932 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1933 0x508003f3, 0x405003f4,
1936 static const unsigned int d945gtp3_pin_configs[10] = {
1937 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1938 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1939 0x02a19120, 0x40000100,
1942 static const unsigned int d945gtp5_pin_configs[10] = {
1943 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1944 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1945 0x02a19320, 0x40000100,
1948 static const unsigned int intel_mac_v1_pin_configs[10] = {
1949 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1950 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1951 0x400000fc, 0x400000fb,
1954 static const unsigned int intel_mac_v2_pin_configs[10] = {
1955 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1956 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1957 0x400000fc, 0x400000fb,
1960 static const unsigned int intel_mac_v3_pin_configs[10] = {
1961 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1962 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1963 0x400000fc, 0x400000fb,
1966 static const unsigned int intel_mac_v4_pin_configs[10] = {
1967 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1968 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1969 0x400000fc, 0x400000fb,
1972 static const unsigned int intel_mac_v5_pin_configs[10] = {
1973 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1974 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1975 0x400000fc, 0x400000fb,
1978 static const unsigned int ecs202_pin_configs[10] = {
1979 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1980 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1981 0x9037012e, 0x40e000f2,
1984 static const unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1985 [STAC_D945_REF] = ref922x_pin_configs,
1986 [STAC_D945GTP3] = d945gtp3_pin_configs,
1987 [STAC_D945GTP5] = d945gtp5_pin_configs,
1988 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1989 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1990 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1991 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1992 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1993 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1994 /* for backward compatibility */
1995 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1996 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1997 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1998 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1999 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
2000 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
2001 [STAC_ECS_202] = ecs202_pin_configs,
2002 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
2003 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
2004 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
2005 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
2008 static const char * const stac922x_models[STAC_922X_MODELS] = {
2009 [STAC_922X_AUTO] = "auto",
2010 [STAC_D945_REF] = "ref",
2011 [STAC_D945GTP5] = "5stack",
2012 [STAC_D945GTP3] = "3stack",
2013 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
2014 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
2015 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
2016 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
2017 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
2018 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
2019 /* for backward compatibility */
2020 [STAC_MACMINI] = "macmini",
2021 [STAC_MACBOOK] = "macbook",
2022 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
2023 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
2024 [STAC_IMAC_INTEL] = "imac-intel",
2025 [STAC_IMAC_INTEL_20] = "imac-intel-20",
2026 [STAC_ECS_202] = "ecs202",
2027 [STAC_922X_DELL_D81] = "dell-d81",
2028 [STAC_922X_DELL_D82] = "dell-d82",
2029 [STAC_922X_DELL_M81] = "dell-m81",
2030 [STAC_922X_DELL_M82] = "dell-m82",
2033 static const struct snd_pci_quirk stac922x_cfg_tbl[] = {
2034 /* SigmaTel reference board */
2035 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2036 "DFI LanParty", STAC_D945_REF),
2037 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2038 "DFI LanParty", STAC_D945_REF),
2039 /* Intel 945G based systems */
2040 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
2041 "Intel D945G", STAC_D945GTP3),
2042 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
2043 "Intel D945G", STAC_D945GTP3),
2044 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
2045 "Intel D945G", STAC_D945GTP3),
2046 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
2047 "Intel D945G", STAC_D945GTP3),
2048 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
2049 "Intel D945G", STAC_D945GTP3),
2050 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
2051 "Intel D945G", STAC_D945GTP3),
2052 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
2053 "Intel D945G", STAC_D945GTP3),
2054 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
2055 "Intel D945G", STAC_D945GTP3),
2056 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
2057 "Intel D945G", STAC_D945GTP3),
2058 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
2059 "Intel D945G", STAC_D945GTP3),
2060 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
2061 "Intel D945G", STAC_D945GTP3),
2062 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
2063 "Intel D945G", STAC_D945GTP3),
2064 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
2065 "Intel D945G", STAC_D945GTP3),
2066 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
2067 "Intel D945G", STAC_D945GTP3),
2068 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
2069 "Intel D945G", STAC_D945GTP3),
2070 /* Intel D945G 5-stack systems */
2071 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
2072 "Intel D945G", STAC_D945GTP5),
2073 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
2074 "Intel D945G", STAC_D945GTP5),
2075 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
2076 "Intel D945G", STAC_D945GTP5),
2077 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
2078 "Intel D945G", STAC_D945GTP5),
2079 /* Intel 945P based systems */
2080 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
2081 "Intel D945P", STAC_D945GTP3),
2082 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
2083 "Intel D945P", STAC_D945GTP3),
2084 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
2085 "Intel D945P", STAC_D945GTP3),
2086 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
2087 "Intel D945P", STAC_D945GTP3),
2088 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
2089 "Intel D945P", STAC_D945GTP3),
2090 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
2091 "Intel D945P", STAC_D945GTP5),
2093 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
2094 "Intel D945", STAC_D945_REF),
2096 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
2097 SND_PCI_QUIRK(0x8384, 0x7680,
2098 "Mac", STAC_INTEL_MAC_AUTO),
2100 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
2101 "unknown Dell", STAC_922X_DELL_D81),
2102 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
2103 "unknown Dell", STAC_922X_DELL_D81),
2104 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
2105 "unknown Dell", STAC_922X_DELL_D81),
2106 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
2107 "unknown Dell", STAC_922X_DELL_D82),
2108 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
2109 "unknown Dell", STAC_922X_DELL_M81),
2110 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
2111 "unknown Dell", STAC_922X_DELL_D82),
2112 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
2113 "unknown Dell", STAC_922X_DELL_D81),
2114 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
2115 "unknown Dell", STAC_922X_DELL_D81),
2116 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
2117 "Dell XPS M1210", STAC_922X_DELL_M82),
2118 /* ECS/PC Chips boards */
2119 SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
2120 "ECS/PC chips", STAC_ECS_202),
2124 static const unsigned int ref927x_pin_configs[14] = {
2125 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2126 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
2127 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2128 0x01c42190, 0x40000100,
2131 static const unsigned int d965_3st_pin_configs[14] = {
2132 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2133 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2134 0x40000100, 0x40000100, 0x40000100, 0x40000100,
2135 0x40000100, 0x40000100
2138 static const unsigned int d965_5st_pin_configs[14] = {
2139 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2140 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2141 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2142 0x40000100, 0x40000100
2145 static const unsigned int d965_5st_no_fp_pin_configs[14] = {
2146 0x40000100, 0x40000100, 0x0181304e, 0x01014010,
2147 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2148 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2149 0x40000100, 0x40000100
2152 static const unsigned int dell_3st_pin_configs[14] = {
2153 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2154 0x01111212, 0x01116211, 0x01813050, 0x01112214,
2155 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2156 0x40c003fc, 0x40000100
2159 static const unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2160 [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2161 [STAC_D965_REF] = ref927x_pin_configs,
2162 [STAC_D965_3ST] = d965_3st_pin_configs,
2163 [STAC_D965_5ST] = d965_5st_pin_configs,
2164 [STAC_D965_5ST_NO_FP] = d965_5st_no_fp_pin_configs,
2165 [STAC_DELL_3ST] = dell_3st_pin_configs,
2166 [STAC_DELL_BIOS] = NULL,
2167 [STAC_927X_VOLKNOB] = NULL,
2170 static const char * const stac927x_models[STAC_927X_MODELS] = {
2171 [STAC_927X_AUTO] = "auto",
2172 [STAC_D965_REF_NO_JD] = "ref-no-jd",
2173 [STAC_D965_REF] = "ref",
2174 [STAC_D965_3ST] = "3stack",
2175 [STAC_D965_5ST] = "5stack",
2176 [STAC_D965_5ST_NO_FP] = "5stack-no-fp",
2177 [STAC_DELL_3ST] = "dell-3stack",
2178 [STAC_DELL_BIOS] = "dell-bios",
2179 [STAC_927X_VOLKNOB] = "volknob",
2182 static const struct snd_pci_quirk stac927x_cfg_tbl[] = {
2183 /* SigmaTel reference board */
2184 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2185 "DFI LanParty", STAC_D965_REF),
2186 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2187 "DFI LanParty", STAC_D965_REF),
2188 /* Intel 946 based systems */
2189 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2190 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2191 /* 965 based 3 stack systems */
2192 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
2193 "Intel D965", STAC_D965_3ST),
2194 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
2195 "Intel D965", STAC_D965_3ST),
2196 /* Dell 3 stack systems */
2197 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2198 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
2199 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
2200 /* Dell 3 stack systems with verb table in BIOS */
2201 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2202 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_BIOS),
2203 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
2204 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
2205 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
2206 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
2207 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
2208 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
2209 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2210 /* 965 based 5 stack systems */
2211 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
2212 "Intel D965", STAC_D965_5ST),
2213 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
2214 "Intel D965", STAC_D965_5ST),
2215 /* volume-knob fixes */
2216 SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB),
2220 static const unsigned int ref9205_pin_configs[12] = {
2221 0x40000100, 0x40000100, 0x01016011, 0x01014010,
2222 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2223 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2227 STAC 9205 pin configs for
2234 10280228 (Dell Vostro 1500)
2235 10280229 (Dell Vostro 1700)
2237 static const unsigned int dell_9205_m42_pin_configs[12] = {
2238 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2239 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2240 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2244 STAC 9205 pin configs for
2248 102801FF (Dell Precision M4300)
2253 static const unsigned int dell_9205_m43_pin_configs[12] = {
2254 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2255 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2256 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2259 static const unsigned int dell_9205_m44_pin_configs[12] = {
2260 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2261 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2262 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2265 static const unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2266 [STAC_9205_REF] = ref9205_pin_configs,
2267 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2268 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2269 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2270 [STAC_9205_EAPD] = NULL,
2273 static const char * const stac9205_models[STAC_9205_MODELS] = {
2274 [STAC_9205_AUTO] = "auto",
2275 [STAC_9205_REF] = "ref",
2276 [STAC_9205_DELL_M42] = "dell-m42",
2277 [STAC_9205_DELL_M43] = "dell-m43",
2278 [STAC_9205_DELL_M44] = "dell-m44",
2279 [STAC_9205_EAPD] = "eapd",
2282 static const struct snd_pci_quirk stac9205_cfg_tbl[] = {
2283 /* SigmaTel reference board */
2284 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2285 "DFI LanParty", STAC_9205_REF),
2286 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
2287 "SigmaTel", STAC_9205_REF),
2288 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2289 "DFI LanParty", STAC_9205_REF),
2291 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2292 "unknown Dell", STAC_9205_DELL_M42),
2293 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2294 "unknown Dell", STAC_9205_DELL_M42),
2295 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2296 "Dell Precision", STAC_9205_DELL_M43),
2297 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2298 "Dell Precision", STAC_9205_DELL_M43),
2299 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2300 "Dell Precision", STAC_9205_DELL_M43),
2301 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2302 "unknown Dell", STAC_9205_DELL_M42),
2303 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2304 "unknown Dell", STAC_9205_DELL_M42),
2305 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2306 "Dell Precision", STAC_9205_DELL_M43),
2307 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2308 "Dell Precision M4300", STAC_9205_DELL_M43),
2309 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2310 "unknown Dell", STAC_9205_DELL_M42),
2311 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2312 "Dell Precision", STAC_9205_DELL_M43),
2313 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2314 "Dell Precision", STAC_9205_DELL_M43),
2315 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2316 "Dell Precision", STAC_9205_DELL_M43),
2317 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2318 "Dell Inspiron", STAC_9205_DELL_M44),
2319 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2320 "Dell Vostro 1500", STAC_9205_DELL_M42),
2321 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229,
2322 "Dell Vostro 1700", STAC_9205_DELL_M42),
2324 SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
2325 SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
2329 static void stac92xx_set_config_regs(struct hda_codec *codec,
2330 const unsigned int *pincfgs)
2333 struct sigmatel_spec *spec = codec->spec;
2338 for (i = 0; i < spec->num_pins; i++)
2339 if (spec->pin_nids[i] && pincfgs[i])
2340 snd_hda_codec_set_pincfg(codec, spec->pin_nids[i],
2345 * Analog playback callbacks
2347 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2348 struct hda_codec *codec,
2349 struct snd_pcm_substream *substream)
2351 struct sigmatel_spec *spec = codec->spec;
2352 if (spec->stream_delay)
2353 msleep(spec->stream_delay);
2354 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2358 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2359 struct hda_codec *codec,
2360 unsigned int stream_tag,
2361 unsigned int format,
2362 struct snd_pcm_substream *substream)
2364 struct sigmatel_spec *spec = codec->spec;
2365 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2368 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2369 struct hda_codec *codec,
2370 struct snd_pcm_substream *substream)
2372 struct sigmatel_spec *spec = codec->spec;
2373 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2377 * Digital playback callbacks
2379 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2380 struct hda_codec *codec,
2381 struct snd_pcm_substream *substream)
2383 struct sigmatel_spec *spec = codec->spec;
2384 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2387 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2388 struct hda_codec *codec,
2389 struct snd_pcm_substream *substream)
2391 struct sigmatel_spec *spec = codec->spec;
2392 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2395 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2396 struct hda_codec *codec,
2397 unsigned int stream_tag,
2398 unsigned int format,
2399 struct snd_pcm_substream *substream)
2401 struct sigmatel_spec *spec = codec->spec;
2402 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2403 stream_tag, format, substream);
2406 static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2407 struct hda_codec *codec,
2408 struct snd_pcm_substream *substream)
2410 struct sigmatel_spec *spec = codec->spec;
2411 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2416 * Analog capture callbacks
2418 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2419 struct hda_codec *codec,
2420 unsigned int stream_tag,
2421 unsigned int format,
2422 struct snd_pcm_substream *substream)
2424 struct sigmatel_spec *spec = codec->spec;
2425 hda_nid_t nid = spec->adc_nids[substream->number];
2427 if (spec->powerdown_adcs) {
2429 snd_hda_codec_write(codec, nid, 0,
2430 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2432 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2436 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2437 struct hda_codec *codec,
2438 struct snd_pcm_substream *substream)
2440 struct sigmatel_spec *spec = codec->spec;
2441 hda_nid_t nid = spec->adc_nids[substream->number];
2443 snd_hda_codec_cleanup_stream(codec, nid);
2444 if (spec->powerdown_adcs)
2445 snd_hda_codec_write(codec, nid, 0,
2446 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2450 static const struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2454 /* NID is set in stac92xx_build_pcms */
2456 .open = stac92xx_dig_playback_pcm_open,
2457 .close = stac92xx_dig_playback_pcm_close,
2458 .prepare = stac92xx_dig_playback_pcm_prepare,
2459 .cleanup = stac92xx_dig_playback_pcm_cleanup
2463 static const struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2467 /* NID is set in stac92xx_build_pcms */
2470 static const struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2474 .nid = 0x02, /* NID to query formats and rates */
2476 .open = stac92xx_playback_pcm_open,
2477 .prepare = stac92xx_playback_pcm_prepare,
2478 .cleanup = stac92xx_playback_pcm_cleanup
2482 static const struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2486 .nid = 0x06, /* NID to query formats and rates */
2488 .open = stac92xx_playback_pcm_open,
2489 .prepare = stac92xx_playback_pcm_prepare,
2490 .cleanup = stac92xx_playback_pcm_cleanup
2494 static const struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2497 /* NID + .substreams is set in stac92xx_build_pcms */
2499 .prepare = stac92xx_capture_pcm_prepare,
2500 .cleanup = stac92xx_capture_pcm_cleanup
2504 static int stac92xx_build_pcms(struct hda_codec *codec)
2506 struct sigmatel_spec *spec = codec->spec;
2507 struct hda_pcm *info = spec->pcm_rec;
2509 codec->num_pcms = 1;
2510 codec->pcm_info = info;
2512 info->name = "STAC92xx Analog";
2513 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2514 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2515 spec->multiout.dac_nids[0];
2516 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2517 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2518 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2520 if (spec->alt_switch) {
2523 info->name = "STAC92xx Analog Alt";
2524 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2527 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2530 info->name = "STAC92xx Digital";
2531 info->pcm_type = spec->autocfg.dig_out_type[0];
2532 if (spec->multiout.dig_out_nid) {
2533 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2534 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2536 if (spec->dig_in_nid) {
2537 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2538 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2545 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2548 snd_hda_set_pin_ctl_cache(codec, nid, pin_type);
2551 #define stac92xx_hp_switch_info snd_ctl_boolean_mono_info
2553 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2554 struct snd_ctl_elem_value *ucontrol)
2556 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2557 struct sigmatel_spec *spec = codec->spec;
2559 ucontrol->value.integer.value[0] = !!spec->hp_switch;
2563 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid);
2565 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2566 struct snd_ctl_elem_value *ucontrol)
2568 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2569 struct sigmatel_spec *spec = codec->spec;
2570 int nid = kcontrol->private_value;
2572 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2574 /* check to be sure that the ports are up to date with
2577 stac_issue_unsol_event(codec, nid);
2582 static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol,
2583 struct snd_ctl_elem_info *uinfo)
2586 static const char * const texts[] = {
2587 "Mic In", "Line In", "Line Out"
2590 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2591 struct sigmatel_spec *spec = codec->spec;
2592 hda_nid_t nid = kcontrol->private_value;
2594 if (nid == spec->mic_switch || nid == spec->line_switch)
2599 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2600 uinfo->value.enumerated.items = i;
2602 if (uinfo->value.enumerated.item >= i)
2603 uinfo->value.enumerated.item = i-1;
2604 strcpy(uinfo->value.enumerated.name,
2605 texts[uinfo->value.enumerated.item]);
2610 static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol,
2611 struct snd_ctl_elem_value *ucontrol)
2613 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2614 hda_nid_t nid = kcontrol->private_value;
2615 unsigned int vref = stac92xx_vref_get(codec, nid);
2617 if (vref == snd_hda_get_default_vref(codec, nid))
2618 ucontrol->value.enumerated.item[0] = 0;
2619 else if (vref == AC_PINCTL_VREF_GRD)
2620 ucontrol->value.enumerated.item[0] = 1;
2621 else if (vref == AC_PINCTL_VREF_HIZ)
2622 ucontrol->value.enumerated.item[0] = 2;
2627 static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol,
2628 struct snd_ctl_elem_value *ucontrol)
2630 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2631 unsigned int new_vref = 0;
2633 hda_nid_t nid = kcontrol->private_value;
2635 if (ucontrol->value.enumerated.item[0] == 0)
2636 new_vref = snd_hda_get_default_vref(codec, nid);
2637 else if (ucontrol->value.enumerated.item[0] == 1)
2638 new_vref = AC_PINCTL_VREF_GRD;
2639 else if (ucontrol->value.enumerated.item[0] == 2)
2640 new_vref = AC_PINCTL_VREF_HIZ;
2644 if (new_vref != stac92xx_vref_get(codec, nid)) {
2645 error = stac92xx_vref_set(codec, nid, new_vref);
2652 static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol,
2653 struct snd_ctl_elem_info *uinfo)
2656 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2657 struct sigmatel_spec *spec = codec->spec;
2659 if (kcontrol->private_value == spec->line_switch)
2660 texts[0] = "Line In";
2662 texts[0] = "Mic In";
2663 texts[1] = "Line Out";
2664 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2665 uinfo->value.enumerated.items = 2;
2668 if (uinfo->value.enumerated.item >= 2)
2669 uinfo->value.enumerated.item = 1;
2670 strcpy(uinfo->value.enumerated.name,
2671 texts[uinfo->value.enumerated.item]);
2676 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2678 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2679 struct sigmatel_spec *spec = codec->spec;
2680 hda_nid_t nid = kcontrol->private_value;
2681 int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2683 ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx];
2687 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2689 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2690 struct sigmatel_spec *spec = codec->spec;
2691 hda_nid_t nid = kcontrol->private_value;
2692 int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2693 unsigned short val = !!ucontrol->value.enumerated.item[0];
2695 spec->io_switch[io_idx] = val;
2698 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2700 unsigned int pinctl = AC_PINCTL_IN_EN;
2701 if (io_idx) /* set VREF for mic */
2702 pinctl |= snd_hda_get_default_vref(codec, nid);
2703 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2706 /* check the auto-mute again: we need to mute/unmute the speaker
2707 * appropriately according to the pin direction
2709 if (spec->hp_detect)
2710 stac_issue_unsol_event(codec, nid);
2715 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2717 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2718 struct snd_ctl_elem_value *ucontrol)
2720 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2721 struct sigmatel_spec *spec = codec->spec;
2723 ucontrol->value.integer.value[0] = spec->clfe_swap;
2727 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2728 struct snd_ctl_elem_value *ucontrol)
2730 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2731 struct sigmatel_spec *spec = codec->spec;
2732 hda_nid_t nid = kcontrol->private_value & 0xff;
2733 unsigned int val = !!ucontrol->value.integer.value[0];
2735 if (spec->clfe_swap == val)
2738 spec->clfe_swap = val;
2740 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2741 spec->clfe_swap ? 0x4 : 0x0);
2746 #define STAC_CODEC_HP_SWITCH(xname) \
2747 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2750 .info = stac92xx_hp_switch_info, \
2751 .get = stac92xx_hp_switch_get, \
2752 .put = stac92xx_hp_switch_put, \
2755 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2756 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2759 .info = stac92xx_io_switch_info, \
2760 .get = stac92xx_io_switch_get, \
2761 .put = stac92xx_io_switch_put, \
2762 .private_value = xpval, \
2765 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2766 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2769 .info = stac92xx_clfe_switch_info, \
2770 .get = stac92xx_clfe_switch_get, \
2771 .put = stac92xx_clfe_switch_put, \
2772 .private_value = xpval, \
2776 STAC_CTL_WIDGET_VOL,
2777 STAC_CTL_WIDGET_MUTE,
2778 STAC_CTL_WIDGET_MUTE_BEEP,
2779 STAC_CTL_WIDGET_MONO_MUX,
2780 STAC_CTL_WIDGET_HP_SWITCH,
2781 STAC_CTL_WIDGET_IO_SWITCH,
2782 STAC_CTL_WIDGET_CLFE_SWITCH,
2783 STAC_CTL_WIDGET_DC_BIAS
2786 static const struct snd_kcontrol_new stac92xx_control_templates[] = {
2787 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2788 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2789 HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0),
2791 STAC_CODEC_HP_SWITCH(NULL),
2792 STAC_CODEC_IO_SWITCH(NULL, 0),
2793 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2794 DC_BIAS(NULL, 0, 0),
2797 /* add dynamic controls */
2798 static struct snd_kcontrol_new *
2799 stac_control_new(struct sigmatel_spec *spec,
2800 const struct snd_kcontrol_new *ktemp,
2802 unsigned int subdev)
2804 struct snd_kcontrol_new *knew;
2806 snd_array_init(&spec->kctls, sizeof(*knew), 32);
2807 knew = snd_array_new(&spec->kctls);
2811 knew->name = kstrdup(name, GFP_KERNEL);
2814 memset(knew, 0, sizeof(*knew));
2815 spec->kctls.alloced--;
2818 knew->subdevice = subdev;
2822 static struct snd_kcontrol_new *
2823 add_control_temp(struct sigmatel_spec *spec,
2824 const struct snd_kcontrol_new *ktemp,
2825 int idx, const char *name,
2828 struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name,
2829 HDA_SUBDEV_AMP_FLAG);
2833 knew->private_value = val;
2837 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2838 const struct snd_kcontrol_new *ktemp,
2839 int idx, const char *name,
2842 return add_control_temp(spec, ktemp, idx, name, val) ? 0 : -ENOMEM;
2845 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2846 int type, int idx, const char *name,
2849 return stac92xx_add_control_temp(spec,
2850 &stac92xx_control_templates[type],
2855 /* add dynamic controls */
2856 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2857 const char *name, unsigned long val)
2859 return stac92xx_add_control_idx(spec, type, 0, name, val);
2862 static const struct snd_kcontrol_new stac_input_src_temp = {
2863 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2864 .name = "Input Source",
2865 .info = stac92xx_mux_enum_info,
2866 .get = stac92xx_mux_enum_get,
2867 .put = stac92xx_mux_enum_put,
2870 static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
2871 hda_nid_t nid, int idx)
2873 int def_conf = snd_hda_codec_get_pincfg(codec, nid);
2875 struct sigmatel_spec *spec = codec->spec;
2878 if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
2879 if (spec->headset_jack && snd_hda_get_input_pin_attr(def_conf)
2880 != INPUT_PIN_ATTR_DOCK)
2882 if (snd_hda_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
2883 && nid == spec->line_switch)
2884 control = STAC_CTL_WIDGET_IO_SWITCH;
2885 else if (snd_hda_query_pin_caps(codec, nid)
2886 & (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT))
2887 control = STAC_CTL_WIDGET_DC_BIAS;
2888 else if (nid == spec->mic_switch)
2889 control = STAC_CTL_WIDGET_IO_SWITCH;
2893 snd_hda_get_pin_label(codec, nid, &spec->autocfg,
2894 name, sizeof(name), NULL);
2895 return stac92xx_add_control(codec->spec, control,
2896 strcat(name, " Jack Mode"), nid);
2902 static int stac92xx_add_input_source(struct sigmatel_spec *spec)
2904 struct snd_kcontrol_new *knew;
2905 struct hda_input_mux *imux = &spec->private_imux;
2908 return 0; /* no need for input source */
2909 if (!spec->num_adcs || imux->num_items <= 1)
2910 return 0; /* no need for input source control */
2911 knew = stac_control_new(spec, &stac_input_src_temp,
2912 stac_input_src_temp.name, 0);
2915 knew->count = spec->num_adcs;
2919 /* check whether the line-input can be used as line-out */
2920 static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2922 struct sigmatel_spec *spec = codec->spec;
2923 struct auto_pin_cfg *cfg = &spec->autocfg;
2925 unsigned int pincap;
2928 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2930 for (i = 0; i < cfg->num_inputs; i++) {
2931 if (cfg->inputs[i].type == AUTO_PIN_LINE_IN) {
2932 nid = cfg->inputs[i].pin;
2933 pincap = snd_hda_query_pin_caps(codec, nid);
2934 if (pincap & AC_PINCAP_OUT)
2941 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid);
2943 /* check whether the mic-input can be used as line-out */
2944 static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac)
2946 struct sigmatel_spec *spec = codec->spec;
2947 struct auto_pin_cfg *cfg = &spec->autocfg;
2948 unsigned int def_conf, pincap;
2952 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2954 for (i = 0; i < cfg->num_inputs; i++) {
2955 hda_nid_t nid = cfg->inputs[i].pin;
2956 if (cfg->inputs[i].type != AUTO_PIN_MIC)
2958 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2959 /* some laptops have an internal analog microphone
2960 * which can't be used as a output */
2961 if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
2962 pincap = snd_hda_query_pin_caps(codec, nid);
2963 if (pincap & AC_PINCAP_OUT) {
2964 *dac = get_unassigned_dac(codec, nid);
2973 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2977 for (i = 0; i < spec->multiout.num_dacs; i++) {
2978 if (spec->multiout.dac_nids[i] == nid)
2985 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2988 if (is_in_dac_nids(spec, nid))
2990 for (i = 0; i < spec->autocfg.hp_outs; i++)
2991 if (spec->hp_dacs[i] == nid)
2993 for (i = 0; i < spec->autocfg.speaker_outs; i++)
2994 if (spec->speaker_dacs[i] == nid)
2999 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
3001 struct sigmatel_spec *spec = codec->spec;
3002 struct auto_pin_cfg *cfg = &spec->autocfg;
3004 hda_nid_t conn[HDA_MAX_CONNECTIONS], fallback_dac;
3005 unsigned int wcaps, wtype;
3007 conn_len = snd_hda_get_connections(codec, nid, conn,
3008 HDA_MAX_CONNECTIONS);
3009 /* 92HD88: trace back up the link of nids to find the DAC */
3010 while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0]))
3011 != AC_WID_AUD_OUT)) {
3013 conn_len = snd_hda_get_connections(codec, nid, conn,
3014 HDA_MAX_CONNECTIONS);
3016 for (j = 0; j < conn_len; j++) {
3017 wcaps = get_wcaps(codec, conn[j]);
3018 wtype = get_wcaps_type(wcaps);
3019 /* we check only analog outputs */
3020 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
3022 /* if this route has a free DAC, assign it */
3023 if (!check_all_dac_nids(spec, conn[j])) {
3025 /* select this DAC in the pin's input mux */
3026 snd_hda_codec_write_cache(codec, nid, 0,
3027 AC_VERB_SET_CONNECT_SEL, j);
3033 /* if all DACs are already assigned, connect to the primary DAC,
3034 unless we're assigning a secondary headphone */
3035 fallback_dac = spec->multiout.dac_nids[0];
3036 if (spec->multiout.hp_nid) {
3037 for (j = 0; j < cfg->hp_outs; j++)
3038 if (cfg->hp_pins[j] == nid) {
3039 fallback_dac = spec->multiout.hp_nid;
3045 for (j = 0; j < conn_len; j++) {
3046 if (conn[j] == fallback_dac) {
3047 snd_hda_codec_write_cache(codec, nid, 0,
3048 AC_VERB_SET_CONNECT_SEL, j);
3056 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
3057 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
3060 * Fill in the dac_nids table from the parsed pin configuration
3061 * This function only works when every pin in line_out_pins[]
3062 * contains atleast one DAC in its connection list. Some 92xx
3063 * codecs are not connected directly to a DAC, such as the 9200
3064 * and 9202/925x. For those, dac_nids[] must be hard-coded.
3066 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
3068 struct sigmatel_spec *spec = codec->spec;
3069 struct auto_pin_cfg *cfg = &spec->autocfg;
3073 for (i = 0; i < cfg->line_outs; i++) {
3074 nid = cfg->line_out_pins[i];
3075 dac = get_unassigned_dac(codec, nid);
3077 if (spec->multiout.num_dacs > 0) {
3078 /* we have already working output pins,
3079 * so let's drop the broken ones again
3081 cfg->line_outs = spec->multiout.num_dacs;
3084 /* error out, no available DAC found */
3086 "%s: No available DAC for pin 0x%x\n",
3090 add_spec_dacs(spec, dac);
3093 for (i = 0; i < cfg->hp_outs; i++) {
3094 nid = cfg->hp_pins[i];
3095 dac = get_unassigned_dac(codec, nid);
3097 if (!spec->multiout.hp_nid)
3098 spec->multiout.hp_nid = dac;
3100 add_spec_extra_dacs(spec, dac);
3102 spec->hp_dacs[i] = dac;
3105 for (i = 0; i < cfg->speaker_outs; i++) {
3106 nid = cfg->speaker_pins[i];
3107 dac = get_unassigned_dac(codec, nid);
3109 add_spec_extra_dacs(spec, dac);
3110 spec->speaker_dacs[i] = dac;
3113 /* add line-in as output */
3114 nid = check_line_out_switch(codec);
3116 dac = get_unassigned_dac(codec, nid);
3118 snd_printdd("STAC: Add line-in 0x%x as output %d\n",
3119 nid, cfg->line_outs);
3120 cfg->line_out_pins[cfg->line_outs] = nid;
3122 spec->line_switch = nid;
3123 add_spec_dacs(spec, dac);
3126 /* add mic as output */
3127 nid = check_mic_out_switch(codec, &dac);
3129 snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
3130 nid, cfg->line_outs);
3131 cfg->line_out_pins[cfg->line_outs] = nid;
3133 spec->mic_switch = nid;
3134 add_spec_dacs(spec, dac);
3137 snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3138 spec->multiout.num_dacs,
3139 spec->multiout.dac_nids[0],
3140 spec->multiout.dac_nids[1],
3141 spec->multiout.dac_nids[2],
3142 spec->multiout.dac_nids[3],
3143 spec->multiout.dac_nids[4]);
3148 /* create volume control/switch for the given prefx type */
3149 static int create_controls_idx(struct hda_codec *codec, const char *pfx,
3150 int idx, hda_nid_t nid, int chs)
3152 struct sigmatel_spec *spec = codec->spec;
3156 if (!spec->check_volume_offset) {
3157 unsigned int caps, step, nums, db_scale;
3158 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3159 step = (caps & AC_AMPCAP_STEP_SIZE) >>
3160 AC_AMPCAP_STEP_SIZE_SHIFT;
3161 step = (step + 1) * 25; /* in .01dB unit */
3162 nums = (caps & AC_AMPCAP_NUM_STEPS) >>
3163 AC_AMPCAP_NUM_STEPS_SHIFT;
3164 db_scale = nums * step;
3165 /* if dB scale is over -64dB, and finer enough,
3166 * let's reduce it to half
3168 if (db_scale > 6400 && nums >= 0x1f)
3169 spec->volume_offset = nums / 2;
3170 spec->check_volume_offset = 1;
3173 sprintf(name, "%s Playback Volume", pfx);
3174 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
3175 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3176 spec->volume_offset));
3179 sprintf(name, "%s Playback Switch", pfx);
3180 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
3181 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3187 #define create_controls(codec, pfx, nid, chs) \
3188 create_controls_idx(codec, pfx, 0, nid, chs)
3190 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3192 if (spec->multiout.num_dacs > 4) {
3193 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3196 snd_BUG_ON(spec->multiout.dac_nids != spec->dac_nids);
3197 spec->dac_nids[spec->multiout.num_dacs] = nid;
3198 spec->multiout.num_dacs++;
3203 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3206 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3207 if (!spec->multiout.extra_out_nid[i]) {
3208 spec->multiout.extra_out_nid[i] = nid;
3212 printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3216 /* Create output controls
3217 * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
3219 static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
3220 const hda_nid_t *pins,
3221 const hda_nid_t *dac_nids,
3224 struct sigmatel_spec *spec = codec->spec;
3225 static const char * const chname[4] = {
3226 "Front", "Surround", NULL /*CLFE*/, "Side"
3230 unsigned int wid_caps;
3232 for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
3233 if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3234 if (is_jack_detectable(codec, pins[i]))
3235 spec->hp_detect = 1;
3240 if (type != AUTO_PIN_HP_OUT && i == 2) {
3242 err = create_controls(codec, "Center", nid, 1);
3245 err = create_controls(codec, "LFE", nid, 2);
3249 wid_caps = get_wcaps(codec, nid);
3251 if (wid_caps & AC_WCAP_LR_SWAP) {
3252 err = stac92xx_add_control(spec,
3253 STAC_CTL_WIDGET_CLFE_SWITCH,
3254 "Swap Center/LFE Playback Switch", nid);
3264 case AUTO_PIN_HP_OUT:
3268 case AUTO_PIN_SPEAKER_OUT:
3269 if (num_outs <= 1) {
3274 /* Fall through in case of multi speaker outs */
3280 err = create_controls_idx(codec, name, idx, nid, 3);
3288 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
3289 unsigned int dir_mask, unsigned int data);
3291 /* hook for controlling mic-mute LED GPIO */
3292 static int stac92xx_capture_sw_put_led(struct snd_kcontrol *kcontrol,
3293 struct snd_ctl_elem_value *ucontrol)
3295 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3296 struct sigmatel_spec *spec = codec->spec;
3300 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
3303 mute = !(ucontrol->value.integer.value[0] &&
3304 ucontrol->value.integer.value[1]);
3305 if (spec->mic_mute_led_on != mute) {
3306 spec->mic_mute_led_on = mute;
3308 spec->gpio_data |= spec->mic_mute_led_gpio;
3310 spec->gpio_data &= ~spec->mic_mute_led_gpio;
3311 stac_gpio_set(codec, spec->gpio_mask,
3312 spec->gpio_dir, spec->gpio_data);
3317 static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol,
3318 unsigned long sw, int idx)
3320 struct sigmatel_spec *spec = codec->spec;
3321 struct snd_kcontrol_new *knew;
3324 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx,
3325 "Capture Volume", vol);
3329 knew = add_control_temp(spec,
3330 &stac92xx_control_templates[STAC_CTL_WIDGET_MUTE],
3331 idx, "Capture Switch", sw);
3334 /* add a LED hook for some HP laptops */
3335 if (spec->mic_mute_led_gpio)
3336 knew->put = stac92xx_capture_sw_put_led;
3341 /* add playback controls from the parsed DAC table */
3342 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3343 const struct auto_pin_cfg *cfg)
3345 struct sigmatel_spec *spec = codec->spec;
3350 err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
3351 spec->multiout.dac_nids,
3352 cfg->line_out_type);
3356 if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3357 err = stac92xx_add_control(spec,
3358 STAC_CTL_WIDGET_HP_SWITCH,
3359 "Headphone as Line Out Switch",
3360 cfg->hp_pins[cfg->hp_outs - 1]);
3365 for (idx = 0; idx < cfg->num_inputs; idx++) {
3366 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3368 nid = cfg->inputs[idx].pin;
3369 err = stac92xx_add_jack_mode_control(codec, nid, idx);
3377 /* add playback controls for Speaker and HP outputs */
3378 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3379 struct auto_pin_cfg *cfg)
3381 struct sigmatel_spec *spec = codec->spec;
3384 err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
3385 spec->hp_dacs, AUTO_PIN_HP_OUT);
3389 err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
3390 spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
3397 /* labels for mono mux outputs */
3398 static const char * const stac92xx_mono_labels[4] = {
3399 "DAC0", "DAC1", "Mixer", "DAC2"
3402 /* create mono mux for mono out on capable codecs */
3403 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3405 struct sigmatel_spec *spec = codec->spec;
3406 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3408 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3410 num_cons = snd_hda_get_connections(codec,
3413 HDA_MAX_NUM_INPUTS);
3414 if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3417 for (i = 0; i < num_cons; i++)
3418 snd_hda_add_imux_item(mono_mux, stac92xx_mono_labels[i], i,
3421 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3422 "Mono Mux", spec->mono_nid);
3425 /* create PC beep volume controls */
3426 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3429 struct sigmatel_spec *spec = codec->spec;
3430 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3431 int err, type = STAC_CTL_WIDGET_MUTE_BEEP;
3433 if (spec->anabeep_nid == nid)
3434 type = STAC_CTL_WIDGET_MUTE;
3436 /* check for mute support for the the amp */
3437 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3438 err = stac92xx_add_control(spec, type,
3439 "Beep Playback Switch",
3440 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3445 /* check to see if there is volume support for the amp */
3446 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3447 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3448 "Beep Playback Volume",
3449 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3456 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3457 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3459 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3460 struct snd_ctl_elem_value *ucontrol)
3462 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3463 ucontrol->value.integer.value[0] = codec->beep->enabled;
3467 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3468 struct snd_ctl_elem_value *ucontrol)
3470 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3471 return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
3474 static const struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3475 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3476 .info = stac92xx_dig_beep_switch_info,
3477 .get = stac92xx_dig_beep_switch_get,
3478 .put = stac92xx_dig_beep_switch_put,
3481 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3483 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3484 0, "Beep Playback Switch", 0);
3488 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3490 struct sigmatel_spec *spec = codec->spec;
3493 for (i = 0; i < spec->num_muxes; i++) {
3498 nid = spec->mux_nids[i];
3499 wcaps = get_wcaps(codec, nid);
3500 if (!(wcaps & AC_WCAP_OUT_AMP))
3503 /* check whether already the same control was created as
3504 * normal Capture Volume.
3506 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3507 for (j = 0; j < spec->num_caps; j++) {
3508 if (spec->capvols[j] == val)
3511 if (j < spec->num_caps)
3514 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i,
3515 "Mux Capture Volume", val);
3522 static const char * const stac92xx_spdif_labels[3] = {
3523 "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3526 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3528 struct sigmatel_spec *spec = codec->spec;
3529 struct hda_input_mux *spdif_mux = &spec->private_smux;
3530 const char * const *labels = spec->spdif_labels;
3532 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3534 num_cons = snd_hda_get_connections(codec,
3537 HDA_MAX_NUM_INPUTS);
3542 labels = stac92xx_spdif_labels;
3544 for (i = 0; i < num_cons; i++)
3545 snd_hda_add_imux_item(spdif_mux, labels[i], i, NULL);
3550 /* labels for dmic mux inputs */
3551 static const char * const stac92xx_dmic_labels[5] = {
3552 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3553 "Digital Mic 3", "Digital Mic 4"
3556 static hda_nid_t get_connected_node(struct hda_codec *codec, hda_nid_t mux,
3559 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3561 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3562 if (idx >= 0 && idx < nums)
3567 /* look for NID recursively */
3568 #define get_connection_index(codec, mux, nid) \
3569 snd_hda_get_conn_index(codec, mux, nid, 1)
3571 /* create a volume assigned to the given pin (only if supported) */
3572 /* return 1 if the volume control is created */
3573 static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
3574 const char *label, int idx, int direction)
3576 unsigned int caps, nums;
3580 if (direction == HDA_OUTPUT)
3581 caps = AC_WCAP_OUT_AMP;
3583 caps = AC_WCAP_IN_AMP;
3584 if (!(get_wcaps(codec, nid) & caps))
3586 caps = query_amp_caps(codec, nid, direction);
3587 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
3590 snprintf(name, sizeof(name), "%s Capture Volume", label);
3591 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, name,
3592 HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction));
3598 /* create playback/capture controls for input pins on dmic capable codecs */
3599 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3600 const struct auto_pin_cfg *cfg)
3602 struct sigmatel_spec *spec = codec->spec;
3603 struct hda_input_mux *imux = &spec->private_imux;
3604 struct hda_input_mux *dimux = &spec->private_dimux;
3606 unsigned int def_conf;
3608 snd_hda_add_imux_item(dimux, stac92xx_dmic_labels[0], 0, NULL);
3610 for (i = 0; i < spec->num_dmics; i++) {
3612 int index, type_idx;
3615 nid = spec->dmic_nids[i];
3616 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
3618 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3619 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3622 index = get_connection_index(codec, spec->dmux_nids[0], nid);
3626 snd_hda_get_pin_label(codec, nid, &spec->autocfg,
3627 label, sizeof(label), NULL);
3628 snd_hda_add_imux_item(dimux, label, index, &type_idx);
3629 if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1)
3630 snd_hda_add_imux_item(imux, label, index, &type_idx);
3632 err = create_elem_capture_vol(codec, nid, label, type_idx,
3637 err = create_elem_capture_vol(codec, nid, label,
3638 type_idx, HDA_OUTPUT);
3642 nid = get_connected_node(codec,
3643 spec->dmux_nids[0], index);
3645 err = create_elem_capture_vol(codec,
3647 type_idx, HDA_INPUT);
3657 static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid,
3658 hda_nid_t *fixed, hda_nid_t *ext, hda_nid_t *dock)
3665 cfg = snd_hda_codec_get_pincfg(codec, nid);
3666 type = get_defcfg_device(cfg);
3667 switch (snd_hda_get_input_pin_attr(cfg)) {
3668 case INPUT_PIN_ATTR_INT:
3670 return 1; /* already occupied */
3671 if (type != AC_JACK_MIC_IN)
3672 return 1; /* invalid type */
3675 case INPUT_PIN_ATTR_UNUSED:
3677 case INPUT_PIN_ATTR_DOCK:
3679 return 1; /* already occupied */
3680 if (type != AC_JACK_MIC_IN && type != AC_JACK_LINE_IN)
3681 return 1; /* invalid type */
3686 return 1; /* already occupied */
3687 if (type != AC_JACK_MIC_IN)
3688 return 1; /* invalid type */
3695 static int set_mic_route(struct hda_codec *codec,
3696 struct sigmatel_mic_route *mic,
3699 struct sigmatel_spec *spec = codec->spec;
3700 struct auto_pin_cfg *cfg = &spec->autocfg;
3706 for (i = 0; i < cfg->num_inputs; i++) {
3707 if (pin == cfg->inputs[i].pin)
3710 if (i < cfg->num_inputs && cfg->inputs[i].type == AUTO_PIN_MIC) {
3712 i = get_connection_index(codec, spec->mux_nids[0], pin);
3717 if (spec->dmux_nids)
3718 mic->dmux_idx = get_connection_index(codec,
3721 } else if (spec->dmux_nids) {
3723 i = get_connection_index(codec, spec->dmux_nids[0], pin);
3729 mic->mux_idx = get_connection_index(codec,
3731 spec->dmux_nids[0]);
3736 /* return non-zero if the device is for automatic mic switch */
3737 static int stac_check_auto_mic(struct hda_codec *codec)
3739 struct sigmatel_spec *spec = codec->spec;
3740 struct auto_pin_cfg *cfg = &spec->autocfg;
3741 hda_nid_t fixed, ext, dock;
3744 fixed = ext = dock = 0;
3745 for (i = 0; i < cfg->num_inputs; i++)
3746 if (check_mic_pin(codec, cfg->inputs[i].pin,
3747 &fixed, &ext, &dock))
3749 for (i = 0; i < spec->num_dmics; i++)
3750 if (check_mic_pin(codec, spec->dmic_nids[i],
3751 &fixed, &ext, &dock))
3753 if (!fixed || (!ext && !dock))
3754 return 0; /* no input to switch */
3755 if (!is_jack_detectable(codec, ext))
3756 return 0; /* no unsol support */
3757 if (set_mic_route(codec, &spec->ext_mic, ext) ||
3758 set_mic_route(codec, &spec->int_mic, fixed) ||
3759 set_mic_route(codec, &spec->dock_mic, dock))
3760 return 0; /* something is wrong */
3764 /* create playback/capture controls for input pins */
3765 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3767 struct sigmatel_spec *spec = codec->spec;
3768 struct hda_input_mux *imux = &spec->private_imux;
3772 for (i = 0; i < cfg->num_inputs; i++) {
3773 hda_nid_t nid = cfg->inputs[i].pin;
3774 int index, err, type_idx;
3777 for (j = 0; j < spec->num_muxes; j++) {
3778 index = get_connection_index(codec, spec->mux_nids[j],
3786 label = hda_get_autocfg_input_label(codec, cfg, i);
3787 snd_hda_add_imux_item(imux, label, index, &type_idx);
3789 err = create_elem_capture_vol(codec, nid,
3795 spec->num_analog_muxes = imux->num_items;
3797 if (imux->num_items) {
3799 * Set the current input for the muxes.
3800 * The STAC9221 has two input muxes with identical source
3801 * NID lists. Hopefully this won't get confused.
3803 for (i = 0; i < spec->num_muxes; i++) {
3804 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3805 AC_VERB_SET_CONNECT_SEL,
3806 imux->items[0].index);
3813 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3815 struct sigmatel_spec *spec = codec->spec;
3818 for (i = 0; i < spec->autocfg.line_outs; i++) {
3819 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3820 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3824 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3826 struct sigmatel_spec *spec = codec->spec;
3829 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3831 pin = spec->autocfg.hp_pins[i];
3832 if (pin) /* connect to front */
3833 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3835 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3837 pin = spec->autocfg.speaker_pins[i];
3838 if (pin) /* connect to front */
3839 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3843 static int is_dual_headphones(struct hda_codec *codec)
3845 struct sigmatel_spec *spec = codec->spec;
3848 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT ||
3849 spec->autocfg.hp_outs <= 1)
3852 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3853 hda_nid_t nid = spec->autocfg.hp_pins[i];
3854 unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid);
3855 if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE)
3859 return (valid_hps > 1);
3863 static int stac92xx_parse_auto_config(struct hda_codec *codec)
3865 struct sigmatel_spec *spec = codec->spec;
3866 hda_nid_t dig_out = 0, dig_in = 0;
3870 if ((err = snd_hda_parse_pin_def_config(codec,
3872 spec->dmic_nids)) < 0)
3874 if (! spec->autocfg.line_outs)
3875 return 0; /* can't find valid pin config */
3877 /* If we have no real line-out pin and multiple hp-outs, HPs should
3878 * be set up as multi-channel outputs.
3880 if (is_dual_headphones(codec)) {
3881 /* Copy hp_outs to line_outs, backup line_outs in
3882 * speaker_outs so that the following routines can handle
3883 * HP pins as primary outputs.
3885 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3886 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3887 sizeof(spec->autocfg.line_out_pins));
3888 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3889 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3890 sizeof(spec->autocfg.hp_pins));
3891 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3892 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3893 spec->autocfg.hp_outs = 0;
3896 if (spec->autocfg.mono_out_pin) {
3897 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3898 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3899 u32 caps = query_amp_caps(codec,
3900 spec->autocfg.mono_out_pin, dir);
3901 hda_nid_t conn_list[1];
3903 /* get the mixer node and then the mono mux if it exists */
3904 if (snd_hda_get_connections(codec,
3905 spec->autocfg.mono_out_pin, conn_list, 1) &&
3906 snd_hda_get_connections(codec, conn_list[0],
3907 conn_list, 1) > 0) {
3909 int wcaps = get_wcaps(codec, conn_list[0]);
3910 int wid_type = get_wcaps_type(wcaps);
3911 /* LR swap check, some stac925x have a mux that
3912 * changes the DACs output path instead of the
3915 if (wid_type == AC_WID_AUD_SEL &&
3916 !(wcaps & AC_WCAP_LR_SWAP))
3917 spec->mono_nid = conn_list[0];
3920 hda_nid_t nid = spec->autocfg.mono_out_pin;
3922 /* most mono outs have a least a mute/unmute switch */
3923 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3924 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3925 "Mono Playback Switch",
3926 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3929 /* check for volume support for the amp */
3930 if ((caps & AC_AMPCAP_NUM_STEPS)
3931 >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3932 err = stac92xx_add_control(spec,
3933 STAC_CTL_WIDGET_VOL,
3934 "Mono Playback Volume",
3935 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3941 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3945 if (!spec->multiout.num_dacs) {
3946 err = stac92xx_auto_fill_dac_nids(codec);
3949 err = stac92xx_auto_create_multi_out_ctls(codec,
3955 /* setup analog beep controls */
3956 if (spec->anabeep_nid > 0) {
3957 err = stac92xx_auto_create_beep_ctls(codec,
3963 /* setup digital beep controls and input device */
3964 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3965 if (spec->digbeep_nid > 0) {
3966 hda_nid_t nid = spec->digbeep_nid;
3969 err = stac92xx_auto_create_beep_ctls(codec, nid);
3972 err = snd_hda_attach_beep_device(codec, nid);
3976 /* IDT/STAC codecs have linear beep tone parameter */
3977 codec->beep->linear_tone = spec->linear_tone_beep;
3978 /* if no beep switch is available, make its own one */
3979 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3980 if (!(caps & AC_AMPCAP_MUTE)) {
3981 err = stac92xx_beep_switch_ctl(codec);
3989 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3993 /* All output parsing done, now restore the swapped hp pins */
3995 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3996 sizeof(spec->autocfg.hp_pins));
3997 spec->autocfg.hp_outs = spec->autocfg.line_outs;
3998 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3999 spec->autocfg.line_outs = 0;
4002 if (stac_check_auto_mic(codec)) {
4004 /* only one capture for auto-mic */
4007 spec->num_muxes = 1;
4010 for (i = 0; i < spec->num_caps; i++) {
4011 err = stac92xx_add_capvol_ctls(codec, spec->capvols[i],
4012 spec->capsws[i], i);
4017 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
4021 if (spec->mono_nid > 0) {
4022 err = stac92xx_auto_create_mono_output_ctls(codec);
4026 if (spec->num_dmics > 0 && !spec->dinput_mux)
4027 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
4028 &spec->autocfg)) < 0)
4030 if (spec->num_muxes > 0) {
4031 err = stac92xx_auto_create_mux_input_ctls(codec);
4035 if (spec->num_smuxes > 0) {
4036 err = stac92xx_auto_create_spdif_mux_ctls(codec);
4041 err = stac92xx_add_input_source(spec);
4045 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4046 if (spec->multiout.max_channels > 2)
4047 spec->surr_switch = 1;
4049 /* find digital out and in converters */
4050 for (i = codec->start_nid; i < codec->start_nid + codec->num_nodes; i++) {
4051 unsigned int wid_caps = get_wcaps(codec, i);
4052 if (wid_caps & AC_WCAP_DIGITAL) {
4053 switch (get_wcaps_type(wid_caps)) {
4054 case AC_WID_AUD_OUT:
4065 if (spec->autocfg.dig_outs)
4066 spec->multiout.dig_out_nid = dig_out;
4067 if (dig_in && spec->autocfg.dig_in_pin)
4068 spec->dig_in_nid = dig_in;
4070 if (spec->kctls.list)
4071 spec->mixers[spec->num_mixers++] = spec->kctls.list;
4073 spec->input_mux = &spec->private_imux;
4074 if (!spec->dinput_mux)
4075 spec->dinput_mux = &spec->private_dimux;
4076 spec->sinput_mux = &spec->private_smux;
4077 spec->mono_mux = &spec->private_mono_mux;
4081 /* add playback controls for HP output */
4082 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
4083 struct auto_pin_cfg *cfg)
4085 struct sigmatel_spec *spec = codec->spec;
4086 hda_nid_t pin = cfg->hp_pins[0];
4091 if (is_jack_detectable(codec, pin))
4092 spec->hp_detect = 1;
4097 /* add playback controls for LFE output */
4098 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
4099 struct auto_pin_cfg *cfg)
4101 struct sigmatel_spec *spec = codec->spec;
4103 hda_nid_t lfe_pin = 0x0;
4107 * search speaker outs and line outs for a mono speaker pin
4108 * with an amp. If one is found, add LFE controls
4111 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
4112 hda_nid_t pin = spec->autocfg.speaker_pins[i];
4113 unsigned int wcaps = get_wcaps(codec, pin);
4114 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
4115 if (wcaps == AC_WCAP_OUT_AMP)
4116 /* found a mono speaker with an amp, must be lfe */
4120 /* if speaker_outs is 0, then speakers may be in line_outs */
4121 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
4122 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
4123 hda_nid_t pin = spec->autocfg.line_out_pins[i];
4124 unsigned int defcfg;
4125 defcfg = snd_hda_codec_get_pincfg(codec, pin);
4126 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
4127 unsigned int wcaps = get_wcaps(codec, pin);
4128 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
4129 if (wcaps == AC_WCAP_OUT_AMP)
4130 /* found a mono speaker with an amp,
4138 err = create_controls(codec, "LFE", lfe_pin, 1);
4146 static int stac9200_parse_auto_config(struct hda_codec *codec)
4148 struct sigmatel_spec *spec = codec->spec;
4151 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
4154 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
4157 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
4160 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
4163 if (spec->num_muxes > 0) {
4164 err = stac92xx_auto_create_mux_input_ctls(codec);
4169 err = stac92xx_add_input_source(spec);
4173 if (spec->autocfg.dig_outs)
4174 spec->multiout.dig_out_nid = 0x05;
4175 if (spec->autocfg.dig_in_pin)
4176 spec->dig_in_nid = 0x04;
4178 if (spec->kctls.list)
4179 spec->mixers[spec->num_mixers++] = spec->kctls.list;
4181 spec->input_mux = &spec->private_imux;
4182 spec->dinput_mux = &spec->private_dimux;
4188 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
4189 * funky external mute control using GPIO pins.
4192 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
4193 unsigned int dir_mask, unsigned int data)
4195 unsigned int gpiostate, gpiomask, gpiodir;
4197 snd_printdd("%s msk %x dir %x gpio %x\n", __func__, mask, dir_mask, data);
4199 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4200 AC_VERB_GET_GPIO_DATA, 0);
4201 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
4203 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4204 AC_VERB_GET_GPIO_MASK, 0);
4207 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4208 AC_VERB_GET_GPIO_DIRECTION, 0);
4209 gpiodir |= dir_mask;
4211 /* Configure GPIOx as CMOS */
4212 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
4214 snd_hda_codec_write(codec, codec->afg, 0,
4215 AC_VERB_SET_GPIO_MASK, gpiomask);
4216 snd_hda_codec_read(codec, codec->afg, 0,
4217 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
4221 snd_hda_codec_read(codec, codec->afg, 0,
4222 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
4225 static int stac_add_event(struct hda_codec *codec, hda_nid_t nid,
4226 unsigned char type, int data)
4228 struct hda_jack_tbl *event;
4230 event = snd_hda_jack_tbl_new(codec, nid);
4233 event->action = type;
4234 event->private_data = data;
4239 static void handle_unsol_event(struct hda_codec *codec,
4240 struct hda_jack_tbl *event);
4242 /* check if given nid is a valid pin and no other events are assigned
4243 * to it. If OK, assign the event, set the unsol flag, and returns 1.
4244 * Otherwise, returns zero.
4246 static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
4249 struct hda_jack_tbl *event;
4251 if (!is_jack_detectable(codec, nid))
4253 event = snd_hda_jack_tbl_new(codec, nid);
4256 if (event->action && event->action != type)
4258 event->action = type;
4259 event->callback = handle_unsol_event;
4260 snd_hda_jack_detect_enable(codec, nid, 0);
4264 static int is_nid_out_jack_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
4267 for (i = 0; i < cfg->hp_outs; i++)
4268 if (cfg->hp_pins[i] == nid)
4269 return 1; /* nid is a HP-Out */
4270 for (i = 0; i < cfg->line_outs; i++)
4271 if (cfg->line_out_pins[i] == nid)
4272 return 1; /* nid is a line-Out */
4273 return 0; /* nid is not a HP-Out */
4276 static void stac92xx_power_down(struct hda_codec *codec)
4278 struct sigmatel_spec *spec = codec->spec;
4280 /* power down inactive DACs */
4281 const hda_nid_t *dac;
4282 for (dac = spec->dac_list; *dac; dac++)
4283 if (!check_all_dac_nids(spec, *dac))
4284 snd_hda_codec_write(codec, *dac, 0,
4285 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4288 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4291 static inline int get_int_hint(struct hda_codec *codec, const char *key,
4295 p = snd_hda_get_hint(codec, key);
4298 if (!strict_strtoul(p, 0, &val)) {
4306 /* override some hints from the hwdep entry */
4307 static void stac_store_hints(struct hda_codec *codec)
4309 struct sigmatel_spec *spec = codec->spec;
4312 val = snd_hda_get_bool_hint(codec, "hp_detect");
4314 spec->hp_detect = val;
4315 if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) {
4316 spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
4319 if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir))
4320 spec->gpio_mask &= spec->gpio_mask;
4321 if (get_int_hint(codec, "gpio_data", &spec->gpio_data))
4322 spec->gpio_dir &= spec->gpio_mask;
4323 if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask))
4324 spec->eapd_mask &= spec->gpio_mask;
4325 if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute))
4326 spec->gpio_mute &= spec->gpio_mask;
4327 val = snd_hda_get_bool_hint(codec, "eapd_switch");
4329 spec->eapd_switch = val;
4332 static void stac_issue_unsol_events(struct hda_codec *codec, int num_pins,
4333 const hda_nid_t *pins)
4336 stac_issue_unsol_event(codec, *pins++);
4339 /* fake event to set up pins */
4340 static void stac_fake_hp_events(struct hda_codec *codec)
4342 struct sigmatel_spec *spec = codec->spec;
4344 if (spec->autocfg.hp_outs)
4345 stac_issue_unsol_events(codec, spec->autocfg.hp_outs,
4346 spec->autocfg.hp_pins);
4347 if (spec->autocfg.line_outs &&
4348 spec->autocfg.line_out_pins[0] != spec->autocfg.hp_pins[0])
4349 stac_issue_unsol_events(codec, spec->autocfg.line_outs,
4350 spec->autocfg.line_out_pins);
4353 static int stac92xx_init(struct hda_codec *codec)
4355 struct sigmatel_spec *spec = codec->spec;
4356 struct auto_pin_cfg *cfg = &spec->autocfg;
4361 snd_hda_sequence_write(codec, spec->init);
4363 /* power down adcs initially */
4364 if (spec->powerdown_adcs)
4365 for (i = 0; i < spec->num_adcs; i++)
4366 snd_hda_codec_write(codec,
4367 spec->adc_nids[i], 0,
4368 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4370 /* override some hints */
4371 stac_store_hints(codec);
4374 gpio = spec->gpio_data;
4375 /* turn on EAPD statically when spec->eapd_switch isn't set.
4376 * otherwise, unsol event will turn it on/off dynamically
4378 if (!spec->eapd_switch)
4379 gpio |= spec->eapd_mask;
4380 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
4383 if (spec->hp_detect) {
4384 /* Enable unsolicited responses on the HP widget */
4385 for (i = 0; i < cfg->hp_outs; i++) {
4386 hda_nid_t nid = cfg->hp_pins[i];
4387 enable_pin_detect(codec, nid, STAC_HP_EVENT);
4389 if (cfg->line_out_type == AUTO_PIN_LINE_OUT &&
4390 cfg->speaker_outs > 0) {
4391 /* enable pin-detect for line-outs as well */
4392 for (i = 0; i < cfg->line_outs; i++) {
4393 hda_nid_t nid = cfg->line_out_pins[i];
4394 enable_pin_detect(codec, nid, STAC_LO_EVENT);
4398 /* force to enable the first line-out; the others are set up
4401 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
4403 /* fake event to set up pins */
4404 stac_fake_hp_events(codec);
4406 stac92xx_auto_init_multi_out(codec);
4407 stac92xx_auto_init_hp_out(codec);
4408 for (i = 0; i < cfg->hp_outs; i++)
4409 stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
4411 if (spec->auto_mic) {
4412 /* initialize connection to analog input */
4413 if (spec->dmux_nids)
4414 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4415 AC_VERB_SET_CONNECT_SEL, 0);
4416 if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT))
4417 stac_issue_unsol_event(codec, spec->ext_mic.pin);
4418 if (enable_pin_detect(codec, spec->dock_mic.pin,
4420 stac_issue_unsol_event(codec, spec->dock_mic.pin);
4422 for (i = 0; i < cfg->num_inputs; i++) {
4423 hda_nid_t nid = cfg->inputs[i].pin;
4424 int type = cfg->inputs[i].type;
4425 unsigned int pinctl, conf;
4426 if (type == AUTO_PIN_MIC) {
4427 /* for mic pins, force to initialize */
4428 pinctl = snd_hda_get_default_vref(codec, nid);
4429 pinctl |= AC_PINCTL_IN_EN;
4430 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4432 pinctl = snd_hda_codec_read(codec, nid, 0,
4433 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4434 /* if PINCTL already set then skip */
4435 /* Also, if both INPUT and OUTPUT are set,
4436 * it must be a BIOS bug; need to override, too
4438 if (!(pinctl & AC_PINCTL_IN_EN) ||
4439 (pinctl & AC_PINCTL_OUT_EN)) {
4440 pinctl &= ~AC_PINCTL_OUT_EN;
4441 pinctl |= AC_PINCTL_IN_EN;
4442 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4445 conf = snd_hda_codec_get_pincfg(codec, nid);
4446 if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
4447 if (enable_pin_detect(codec, nid, STAC_INSERT_EVENT))
4448 stac_issue_unsol_event(codec, nid);
4451 for (i = 0; i < spec->num_dmics; i++)
4452 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4454 if (cfg->dig_out_pins[0])
4455 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0],
4457 if (cfg->dig_in_pin)
4458 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4460 for (i = 0; i < spec->num_pwrs; i++) {
4461 hda_nid_t nid = spec->pwr_nids[i];
4462 unsigned int pinctl, def_conf;
4464 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4465 def_conf = get_defcfg_connect(def_conf);
4466 if (def_conf == AC_JACK_PORT_NONE) {
4467 /* power off unused ports */
4468 stac_toggle_power_map(codec, nid, 0);
4471 if (def_conf == AC_JACK_PORT_FIXED) {
4472 /* no need for jack detection for fixed pins */
4473 stac_toggle_power_map(codec, nid, 1);
4476 /* power on when no jack detection is available */
4477 /* or when the VREF is used for controlling LED */
4478 if (!spec->hp_detect ||
4479 spec->vref_mute_led_nid == nid ||
4480 !is_jack_detectable(codec, nid)) {
4481 stac_toggle_power_map(codec, nid, 1);
4485 if (is_nid_out_jack_pin(cfg, nid))
4486 continue; /* already has an unsol event */
4488 pinctl = snd_hda_codec_read(codec, nid, 0,
4489 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4490 /* outputs are only ports capable of power management
4491 * any attempts on powering down a input port cause the
4492 * referenced VREF to act quirky.
4494 if (pinctl & AC_PINCTL_IN_EN) {
4495 stac_toggle_power_map(codec, nid, 1);
4498 if (enable_pin_detect(codec, nid, STAC_PWR_EVENT)) {
4499 stac_issue_unsol_event(codec, nid);
4502 /* none of the above, turn the port OFF */
4503 stac_toggle_power_map(codec, nid, 0);
4507 if (spec->gpio_led) {
4508 if (spec->vmaster_mute.hook)
4509 snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
4510 else /* the very first init call doesn't have vmaster yet */
4511 stac92xx_update_led_status(codec, false);
4514 /* sync the power-map */
4516 snd_hda_codec_write(codec, codec->afg, 0,
4517 AC_VERB_IDT_SET_POWER_MAP,
4518 spec->power_map_bits);
4520 stac92xx_power_down(codec);
4524 static void stac92xx_free_kctls(struct hda_codec *codec)
4526 struct sigmatel_spec *spec = codec->spec;
4528 if (spec->kctls.list) {
4529 struct snd_kcontrol_new *kctl = spec->kctls.list;
4531 for (i = 0; i < spec->kctls.used; i++)
4532 kfree(kctl[i].name);
4534 snd_array_free(&spec->kctls);
4537 static void stac92xx_shutup_pins(struct hda_codec *codec)
4539 unsigned int i, def_conf;
4541 if (codec->bus->shutdown)
4543 for (i = 0; i < codec->init_pins.used; i++) {
4544 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
4545 def_conf = snd_hda_codec_get_pincfg(codec, pin->nid);
4546 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)
4547 snd_hda_set_pin_ctl(codec, pin->nid, 0);
4551 static void stac92xx_shutup(struct hda_codec *codec)
4553 struct sigmatel_spec *spec = codec->spec;
4555 stac92xx_shutup_pins(codec);
4557 if (spec->eapd_mask)
4558 stac_gpio_set(codec, spec->gpio_mask,
4559 spec->gpio_dir, spec->gpio_data &
4563 static void stac92xx_free(struct hda_codec *codec)
4565 struct sigmatel_spec *spec = codec->spec;
4570 stac92xx_shutup(codec);
4573 snd_hda_detach_beep_device(codec);
4576 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4579 unsigned int old_ctl, pin_ctl;
4581 pin_ctl = snd_hda_codec_read(codec, nid,
4582 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4584 if (pin_ctl & AC_PINCTL_IN_EN) {
4586 * we need to check the current set-up direction of
4587 * shared input pins since they can be switched via
4588 * "xxx as Output" mixer switch
4590 struct sigmatel_spec *spec = codec->spec;
4591 if (nid == spec->line_switch || nid == spec->mic_switch)
4596 /* if setting pin direction bits, clear the current
4597 direction bits first */
4598 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4599 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4602 if (old_ctl != pin_ctl)
4603 snd_hda_set_pin_ctl_cache(codec, nid, pin_ctl);
4606 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4609 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4610 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4612 snd_hda_set_pin_ctl_cache(codec, nid, pin_ctl & ~flag);
4615 static inline int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4619 return snd_hda_jack_detect(codec, nid);
4622 static void stac92xx_line_out_detect(struct hda_codec *codec,
4625 struct sigmatel_spec *spec = codec->spec;
4626 struct auto_pin_cfg *cfg = &spec->autocfg;
4629 if (cfg->speaker_outs == 0)
4632 for (i = 0; i < cfg->line_outs; i++) {
4635 presence = get_pin_presence(codec, cfg->line_out_pins[i]);
4637 unsigned int pinctl;
4638 pinctl = snd_hda_codec_read(codec,
4639 cfg->line_out_pins[i], 0,
4640 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4641 if (pinctl & AC_PINCTL_IN_EN)
4642 presence = 0; /* mic- or line-input */
4647 /* disable speakers */
4648 for (i = 0; i < cfg->speaker_outs; i++)
4649 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4651 if (spec->eapd_mask && spec->eapd_switch)
4652 stac_gpio_set(codec, spec->gpio_mask,
4653 spec->gpio_dir, spec->gpio_data &
4656 /* enable speakers */
4657 for (i = 0; i < cfg->speaker_outs; i++)
4658 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4660 if (spec->eapd_mask && spec->eapd_switch)
4661 stac_gpio_set(codec, spec->gpio_mask,
4662 spec->gpio_dir, spec->gpio_data |
4667 /* return non-zero if the hp-pin of the given array index isn't
4668 * a jack-detection target
4670 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4672 struct auto_pin_cfg *cfg = &spec->autocfg;
4674 /* ignore sensing of shared line and mic jacks */
4675 if (cfg->hp_pins[i] == spec->line_switch)
4677 if (cfg->hp_pins[i] == spec->mic_switch)
4679 /* ignore if the pin is set as line-out */
4680 if (cfg->hp_pins[i] == spec->hp_switch)
4685 static void stac92xx_hp_detect(struct hda_codec *codec)
4687 struct sigmatel_spec *spec = codec->spec;
4688 struct auto_pin_cfg *cfg = &spec->autocfg;
4692 if (spec->gpio_mute)
4693 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4694 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4696 for (i = 0; i < cfg->hp_outs; i++) {
4699 if (no_hp_sensing(spec, i))
4701 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4703 unsigned int pinctl;
4704 pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4705 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4706 if (pinctl & AC_PINCTL_IN_EN)
4707 presence = 0; /* mic- or line-input */
4712 /* disable lineouts */
4713 if (spec->hp_switch)
4714 stac92xx_reset_pinctl(codec, spec->hp_switch,
4716 for (i = 0; i < cfg->line_outs; i++)
4717 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4720 /* enable lineouts */
4721 if (spec->hp_switch)
4722 stac92xx_set_pinctl(codec, spec->hp_switch,
4724 for (i = 0; i < cfg->line_outs; i++)
4725 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4728 stac92xx_line_out_detect(codec, presence);
4729 /* toggle hp outs */
4730 for (i = 0; i < cfg->hp_outs; i++) {
4731 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4732 if (no_hp_sensing(spec, i))
4735 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4737 /* Resetting the pinctl like below may lead to (a sort of) regressions
4738 * on some devices since they use the HP pin actually for line/speaker
4739 * outs although the default pin config shows a different pin (that is
4740 * wrong and useless).
4742 * So, it's basically a problem of default pin configs, likely a BIOS issue.
4743 * But, disabling the code below just works around it, and I'm too tired of
4744 * bug reports with such devices...
4747 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4752 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4755 struct sigmatel_spec *spec = codec->spec;
4756 unsigned int idx, val;
4758 for (idx = 0; idx < spec->num_pwrs; idx++) {
4759 if (spec->pwr_nids[idx] == nid)
4762 if (idx >= spec->num_pwrs)
4767 val = spec->power_map_bits;
4773 /* power down unused output ports */
4774 if (val != spec->power_map_bits) {
4775 spec->power_map_bits = val;
4776 snd_hda_codec_write(codec, codec->afg, 0,
4777 AC_VERB_IDT_SET_POWER_MAP, val);
4781 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4783 stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4786 /* get the pin connection (fixed, none, etc) */
4787 static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
4789 struct sigmatel_spec *spec = codec->spec;
4792 cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]);
4793 return get_defcfg_connect(cfg);
4796 static int stac92xx_connected_ports(struct hda_codec *codec,
4797 const hda_nid_t *nids, int num_nids)
4799 struct sigmatel_spec *spec = codec->spec;
4801 unsigned int def_conf;
4803 for (num = 0; num < num_nids; num++) {
4804 for (idx = 0; idx < spec->num_pins; idx++)
4805 if (spec->pin_nids[idx] == nids[num])
4807 if (idx >= spec->num_pins)
4809 def_conf = stac_get_defcfg_connect(codec, idx);
4810 if (def_conf == AC_JACK_PORT_NONE)
4816 static void stac92xx_mic_detect(struct hda_codec *codec)
4818 struct sigmatel_spec *spec = codec->spec;
4819 struct sigmatel_mic_route *mic;
4821 if (get_pin_presence(codec, spec->ext_mic.pin))
4822 mic = &spec->ext_mic;
4823 else if (get_pin_presence(codec, spec->dock_mic.pin))
4824 mic = &spec->dock_mic;
4826 mic = &spec->int_mic;
4827 if (mic->dmux_idx >= 0)
4828 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4829 AC_VERB_SET_CONNECT_SEL,
4831 if (mic->mux_idx >= 0)
4832 snd_hda_codec_write_cache(codec, spec->mux_nids[0], 0,
4833 AC_VERB_SET_CONNECT_SEL,
4837 static void handle_unsol_event(struct hda_codec *codec,
4838 struct hda_jack_tbl *event)
4840 struct sigmatel_spec *spec = codec->spec;
4843 switch (event->action) {
4846 stac92xx_hp_detect(codec);
4848 case STAC_MIC_EVENT:
4849 stac92xx_mic_detect(codec);
4853 switch (event->action) {
4856 case STAC_MIC_EVENT:
4857 case STAC_INSERT_EVENT:
4858 case STAC_PWR_EVENT:
4859 if (spec->num_pwrs > 0)
4860 stac92xx_pin_sense(codec, event->nid);
4862 switch (codec->subsystem_id) {
4864 if (event->nid == 0xb) {
4865 int pin = AC_PINCTL_IN_EN;
4867 if (get_pin_presence(codec, 0xa)
4868 && get_pin_presence(codec, 0xb))
4869 pin |= AC_PINCTL_VREF_80;
4870 if (!get_pin_presence(codec, 0xb))
4871 pin |= AC_PINCTL_VREF_80;
4873 /* toggle VREF state based on mic + hp pin
4876 stac92xx_auto_set_pinctl(codec, 0x0a, pin);
4880 case STAC_VREF_EVENT:
4881 data = snd_hda_codec_read(codec, codec->afg, 0,
4882 AC_VERB_GET_GPIO_DATA, 0);
4883 /* toggle VREF state based on GPIOx status */
4884 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4885 !!(data & (1 << event->private_data)));
4890 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid)
4892 struct hda_jack_tbl *event = snd_hda_jack_tbl_get(codec, nid);
4895 handle_unsol_event(codec, event);
4898 static int hp_blike_system(u32 subsystem_id);
4900 static void set_hp_led_gpio(struct hda_codec *codec)
4902 struct sigmatel_spec *spec = codec->spec;
4908 gpio = snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP);
4909 gpio &= AC_GPIO_IO_COUNT;
4911 spec->gpio_led = 0x08; /* GPIO 3 */
4913 spec->gpio_led = 0x01; /* GPIO 0 */
4917 * This method searches for the mute LED GPIO configuration
4918 * provided as OEM string in SMBIOS. The format of that string
4919 * is HP_Mute_LED_P_G or HP_Mute_LED_P
4920 * where P can be 0 or 1 and defines mute LED GPIO control state (low/high)
4921 * that corresponds to the NOT muted state of the master volume
4922 * and G is the index of the GPIO to use as the mute LED control (0..9)
4923 * If _G portion is missing it is assigned based on the codec ID
4925 * So, HP B-series like systems may have HP_Mute_LED_0 (current models)
4926 * or HP_Mute_LED_0_3 (future models) OEM SMBIOS strings
4929 * The dv-series laptops don't seem to have the HP_Mute_LED* strings in
4930 * SMBIOS - at least the ones I have seen do not have them - which include
4931 * my own system (HP Pavilion dv6-1110ax) and my cousin's
4932 * HP Pavilion dv9500t CTO.
4933 * Need more information on whether it is true across the entire series.
4936 static int find_mute_led_cfg(struct hda_codec *codec, int default_polarity)
4938 struct sigmatel_spec *spec = codec->spec;
4939 const struct dmi_device *dev = NULL;
4941 if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) {
4942 get_int_hint(codec, "gpio_led_polarity",
4943 &spec->gpio_led_polarity);
4946 if ((codec->subsystem_id >> 16) == PCI_VENDOR_ID_HP) {
4947 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING,
4949 if (sscanf(dev->name, "HP_Mute_LED_%d_%x",
4950 &spec->gpio_led_polarity,
4951 &spec->gpio_led) == 2) {
4952 unsigned int max_gpio;
4953 max_gpio = snd_hda_param_read(codec, codec->afg,
4955 max_gpio &= AC_GPIO_IO_COUNT;
4956 if (spec->gpio_led < max_gpio)
4957 spec->gpio_led = 1 << spec->gpio_led;
4959 spec->vref_mute_led_nid = spec->gpio_led;
4962 if (sscanf(dev->name, "HP_Mute_LED_%d",
4963 &spec->gpio_led_polarity) == 1) {
4964 set_hp_led_gpio(codec);
4967 /* BIOS bug: unfilled OEM string */
4968 if (strstr(dev->name, "HP_Mute_LED_P_G")) {
4969 set_hp_led_gpio(codec);
4970 switch (codec->subsystem_id) {
4972 spec->gpio_led_polarity = 0;
4975 spec->gpio_led_polarity = 1;
4983 * Fallback case - if we don't find the DMI strings,
4984 * we statically set the GPIO - if not a B-series system
4985 * and default polarity is provided
4987 if (!hp_blike_system(codec->subsystem_id) &&
4988 (default_polarity == 0 || default_polarity == 1)) {
4989 set_hp_led_gpio(codec);
4990 spec->gpio_led_polarity = default_polarity;
4997 static int hp_blike_system(u32 subsystem_id)
4999 switch (subsystem_id) {
5026 #ifdef CONFIG_PROC_FS
5027 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
5028 struct hda_codec *codec, hda_nid_t nid)
5030 if (nid == codec->afg)
5031 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
5032 snd_hda_codec_read(codec, nid, 0,
5033 AC_VERB_IDT_GET_POWER_MAP, 0));
5036 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
5037 struct hda_codec *codec,
5040 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
5041 snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
5044 /* stac92hd71bxx, stac92hd73xx */
5045 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
5046 struct hda_codec *codec, hda_nid_t nid)
5048 stac92hd_proc_hook(buffer, codec, nid);
5049 if (nid == codec->afg)
5050 analog_loop_proc_hook(buffer, codec, 0xfa0);
5053 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
5054 struct hda_codec *codec, hda_nid_t nid)
5056 if (nid == codec->afg)
5057 analog_loop_proc_hook(buffer, codec, 0xfe0);
5060 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
5061 struct hda_codec *codec, hda_nid_t nid)
5063 if (nid == codec->afg)
5064 analog_loop_proc_hook(buffer, codec, 0xfeb);
5067 #define stac92hd_proc_hook NULL
5068 #define stac92hd7x_proc_hook NULL
5069 #define stac9205_proc_hook NULL
5070 #define stac927x_proc_hook NULL
5074 static int stac92xx_resume(struct hda_codec *codec)
5076 stac92xx_init(codec);
5077 snd_hda_codec_resume_amp(codec);
5078 snd_hda_codec_resume_cache(codec);
5079 /* fake event to set up pins again to override cached values */
5080 stac_fake_hp_events(codec);
5084 static int stac92xx_suspend(struct hda_codec *codec)
5086 stac92xx_shutup(codec);
5090 static void stac92xx_set_power_state(struct hda_codec *codec, hda_nid_t fg,
5091 unsigned int power_state)
5093 unsigned int afg_power_state = power_state;
5094 struct sigmatel_spec *spec = codec->spec;
5096 if (power_state == AC_PWRST_D3) {
5097 if (spec->vref_mute_led_nid) {
5098 /* with vref-out pin used for mute led control
5099 * codec AFG is prevented from D3 state
5101 afg_power_state = AC_PWRST_D1;
5103 /* this delay seems necessary to avoid click noise at power-down */
5106 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
5108 snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
5111 #define stac92xx_suspend NULL
5112 #define stac92xx_resume NULL
5113 #define stac92xx_set_power_state NULL
5114 #endif /* CONFIG_PM */
5116 /* update mute-LED accoring to the master switch */
5117 static void stac92xx_update_led_status(struct hda_codec *codec, int enabled)
5119 struct sigmatel_spec *spec = codec->spec;
5120 int muted = !enabled;
5122 if (!spec->gpio_led)
5125 /* LED state is inverted on these systems */
5126 if (spec->gpio_led_polarity)
5129 if (!spec->vref_mute_led_nid) {
5131 spec->gpio_data |= spec->gpio_led;
5133 spec->gpio_data &= ~spec->gpio_led;
5134 stac_gpio_set(codec, spec->gpio_mask,
5135 spec->gpio_dir, spec->gpio_data);
5137 spec->vref_led = muted ? AC_PINCTL_VREF_50 : AC_PINCTL_VREF_GRD;
5138 stac_vrefout_set(codec, spec->vref_mute_led_nid,
5143 static const struct hda_codec_ops stac92xx_patch_ops = {
5144 .build_controls = stac92xx_build_controls,
5145 .build_pcms = stac92xx_build_pcms,
5146 .init = stac92xx_init,
5147 .free = stac92xx_free,
5148 .unsol_event = snd_hda_jack_unsol_event,
5150 .suspend = stac92xx_suspend,
5151 .resume = stac92xx_resume,
5153 .reboot_notify = stac92xx_shutup,
5156 static int patch_stac9200(struct hda_codec *codec)
5158 struct sigmatel_spec *spec;
5161 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5165 codec->no_trigger_sense = 1;
5167 spec->linear_tone_beep = 1;
5168 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
5169 spec->pin_nids = stac9200_pin_nids;
5170 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
5173 if (spec->board_config < 0)
5174 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5177 stac92xx_set_config_regs(codec,
5178 stac9200_brd_tbl[spec->board_config]);
5180 spec->multiout.max_channels = 2;
5181 spec->multiout.num_dacs = 1;
5182 spec->multiout.dac_nids = stac9200_dac_nids;
5183 spec->adc_nids = stac9200_adc_nids;
5184 spec->mux_nids = stac9200_mux_nids;
5185 spec->num_muxes = 1;
5186 spec->num_dmics = 0;
5190 if (spec->board_config == STAC_9200_M4 ||
5191 spec->board_config == STAC_9200_M4_2 ||
5192 spec->board_config == STAC_9200_OQO)
5193 spec->init = stac9200_eapd_init;
5195 spec->init = stac9200_core_init;
5196 spec->mixer = stac9200_mixer;
5198 if (spec->board_config == STAC_9200_PANASONIC) {
5199 spec->gpio_mask = spec->gpio_dir = 0x09;
5200 spec->gpio_data = 0x00;
5203 err = stac9200_parse_auto_config(codec);
5205 stac92xx_free(codec);
5209 /* CF-74 has no headphone detection, and the driver should *NOT*
5210 * do detection and HP/speaker toggle because the hardware does it.
5212 if (spec->board_config == STAC_9200_PANASONIC)
5213 spec->hp_detect = 0;
5215 codec->patch_ops = stac92xx_patch_ops;
5220 static int patch_stac925x(struct hda_codec *codec)
5222 struct sigmatel_spec *spec;
5225 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5229 codec->no_trigger_sense = 1;
5231 spec->linear_tone_beep = 1;
5232 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
5233 spec->pin_nids = stac925x_pin_nids;
5235 /* Check first for codec ID */
5236 spec->board_config = snd_hda_check_board_codec_sid_config(codec,
5239 stac925x_codec_id_cfg_tbl);
5241 /* Now checks for PCI ID, if codec ID is not found */
5242 if (spec->board_config < 0)
5243 spec->board_config = snd_hda_check_board_config(codec,
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 stac925x_brd_tbl[spec->board_config]);
5255 spec->multiout.max_channels = 2;
5256 spec->multiout.num_dacs = 1;
5257 spec->multiout.dac_nids = stac925x_dac_nids;
5258 spec->adc_nids = stac925x_adc_nids;
5259 spec->mux_nids = stac925x_mux_nids;
5260 spec->num_muxes = 1;
5263 switch (codec->vendor_id) {
5264 case 0x83847632: /* STAC9202 */
5265 case 0x83847633: /* STAC9202D */
5266 case 0x83847636: /* STAC9251 */
5267 case 0x83847637: /* STAC9251D */
5268 spec->num_dmics = STAC925X_NUM_DMICS;
5269 spec->dmic_nids = stac925x_dmic_nids;
5270 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
5271 spec->dmux_nids = stac925x_dmux_nids;
5274 spec->num_dmics = 0;
5278 spec->init = stac925x_core_init;
5279 spec->mixer = stac925x_mixer;
5281 spec->capvols = stac925x_capvols;
5282 spec->capsws = stac925x_capsws;
5284 err = stac92xx_parse_auto_config(codec);
5286 if (spec->board_config < 0) {
5287 printk(KERN_WARNING "hda_codec: No auto-config is "
5288 "available, default to model=ref\n");
5289 spec->board_config = STAC_925x_REF;
5295 stac92xx_free(codec);
5299 codec->patch_ops = stac92xx_patch_ops;
5304 static int patch_stac92hd73xx(struct hda_codec *codec)
5306 struct sigmatel_spec *spec;
5307 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
5311 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5315 codec->no_trigger_sense = 1;
5317 spec->linear_tone_beep = 0;
5318 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
5319 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
5320 spec->pin_nids = stac92hd73xx_pin_nids;
5321 spec->board_config = snd_hda_check_board_config(codec,
5322 STAC_92HD73XX_MODELS,
5323 stac92hd73xx_models,
5324 stac92hd73xx_cfg_tbl);
5325 /* check codec subsystem id if not found */
5326 if (spec->board_config < 0)
5327 spec->board_config =
5328 snd_hda_check_board_codec_sid_config(codec,
5329 STAC_92HD73XX_MODELS, stac92hd73xx_models,
5330 stac92hd73xx_codec_id_cfg_tbl);
5332 if (spec->board_config < 0)
5333 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5336 stac92xx_set_config_regs(codec,
5337 stac92hd73xx_brd_tbl[spec->board_config]);
5339 num_dacs = snd_hda_get_connections(codec, 0x0a,
5340 conn, STAC92HD73_DAC_COUNT + 2) - 1;
5342 if (num_dacs < 3 || num_dacs > 5) {
5343 printk(KERN_WARNING "hda_codec: Could not determine "
5344 "number of channels defaulting to DAC count\n");
5345 num_dacs = STAC92HD73_DAC_COUNT;
5347 spec->init = stac92hd73xx_core_init;
5349 case 0x3: /* 6 Channel */
5350 spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
5352 case 0x4: /* 8 Channel */
5353 spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
5355 case 0x5: /* 10 Channel */
5356 spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
5359 spec->multiout.dac_nids = spec->dac_nids;
5361 spec->aloopback_mask = 0x01;
5362 spec->aloopback_shift = 8;
5364 spec->digbeep_nid = 0x1c;
5365 spec->mux_nids = stac92hd73xx_mux_nids;
5366 spec->adc_nids = stac92hd73xx_adc_nids;
5367 spec->dmic_nids = stac92hd73xx_dmic_nids;
5368 spec->dmux_nids = stac92hd73xx_dmux_nids;
5369 spec->smux_nids = stac92hd73xx_smux_nids;
5371 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
5372 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
5373 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
5375 spec->num_caps = STAC92HD73XX_NUM_CAPS;
5376 spec->capvols = stac92hd73xx_capvols;
5377 spec->capsws = stac92hd73xx_capsws;
5379 switch (spec->board_config) {
5381 spec->init = dell_eq_core_init;
5383 case STAC_DELL_M6_AMIC:
5384 case STAC_DELL_M6_DMIC:
5385 case STAC_DELL_M6_BOTH:
5386 spec->num_smuxes = 0;
5387 spec->eapd_switch = 0;
5389 switch (spec->board_config) {
5390 case STAC_DELL_M6_AMIC: /* Analog Mics */
5391 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5392 spec->num_dmics = 0;
5394 case STAC_DELL_M6_DMIC: /* Digital Mics */
5395 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5396 spec->num_dmics = 1;
5398 case STAC_DELL_M6_BOTH: /* Both */
5399 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5400 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5401 spec->num_dmics = 1;
5405 case STAC_ALIENWARE_M17X:
5406 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
5407 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
5408 spec->eapd_switch = 0;
5411 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
5412 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
5413 spec->eapd_switch = 1;
5416 if (spec->board_config != STAC_92HD73XX_REF) {
5417 /* GPIO0 High = Enable EAPD */
5418 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5419 spec->gpio_data = 0x01;
5422 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
5423 spec->pwr_nids = stac92hd73xx_pwr_nids;
5425 err = stac92xx_parse_auto_config(codec);
5428 if (spec->board_config < 0) {
5429 printk(KERN_WARNING "hda_codec: No auto-config is "
5430 "available, default to model=ref\n");
5431 spec->board_config = STAC_92HD73XX_REF;
5438 stac92xx_free(codec);
5442 if (spec->board_config == STAC_92HD73XX_NO_JD)
5443 spec->hp_detect = 0;
5445 codec->patch_ops = stac92xx_patch_ops;
5447 codec->proc_widget_hook = stac92hd7x_proc_hook;
5452 static int hp_bnb2011_with_dock(struct hda_codec *codec)
5454 if (codec->vendor_id != 0x111d7605 &&
5455 codec->vendor_id != 0x111d76d1)
5458 switch (codec->subsystem_id) {
5492 static void stac92hd8x_add_pin(struct hda_codec *codec, hda_nid_t nid)
5494 struct sigmatel_spec *spec = codec->spec;
5495 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5498 spec->auto_pin_nids[spec->auto_pin_cnt] = nid;
5499 spec->auto_pin_cnt++;
5501 if (get_defcfg_device(def_conf) == AC_JACK_MIC_IN &&
5502 get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE) {
5503 for (i = 0; i < ARRAY_SIZE(stac92hd83xxx_dmic_nids); i++) {
5504 if (nid == stac92hd83xxx_dmic_nids[i]) {
5505 spec->auto_dmic_nids[spec->auto_dmic_cnt] = nid;
5506 spec->auto_dmic_cnt++;
5512 static void stac92hd8x_add_adc(struct hda_codec *codec, hda_nid_t nid)
5514 struct sigmatel_spec *spec = codec->spec;
5516 spec->auto_adc_nids[spec->auto_adc_cnt] = nid;
5517 spec->auto_adc_cnt++;
5520 static void stac92hd8x_add_mux(struct hda_codec *codec, hda_nid_t nid)
5523 struct sigmatel_spec *spec = codec->spec;
5525 for (i = 0; i < spec->auto_adc_cnt; i++) {
5526 if (get_connection_index(codec,
5527 spec->auto_adc_nids[i], nid) >= 0) {
5528 /* mux and volume for adc_nids[i] */
5529 if (!spec->auto_mux_nids[i]) {
5530 spec->auto_mux_nids[i] = nid;
5531 /* 92hd codecs capture volume is in mux */
5532 spec->auto_capvols[i] = HDA_COMPOSE_AMP_VAL(nid,
5535 for (j = 0; j < spec->auto_dmic_cnt; j++) {
5536 if (get_connection_index(codec, nid,
5537 spec->auto_dmic_nids[j]) >= 0) {
5538 /* dmux for adc_nids[i] */
5539 if (!spec->auto_dmux_nids[i])
5540 spec->auto_dmux_nids[i] = nid;
5549 static void stac92hd8x_fill_auto_spec(struct hda_codec *codec)
5551 hda_nid_t nid, end_nid;
5552 unsigned int wid_caps, wid_type;
5553 struct sigmatel_spec *spec = codec->spec;
5555 end_nid = codec->start_nid + codec->num_nodes;
5557 for (nid = codec->start_nid; nid < end_nid; nid++) {
5558 wid_caps = get_wcaps(codec, nid);
5559 wid_type = get_wcaps_type(wid_caps);
5561 if (wid_type == AC_WID_PIN)
5562 stac92hd8x_add_pin(codec, nid);
5564 if (wid_type == AC_WID_AUD_IN && !(wid_caps & AC_WCAP_DIGITAL))
5565 stac92hd8x_add_adc(codec, nid);
5568 for (nid = codec->start_nid; nid < end_nid; nid++) {
5569 wid_caps = get_wcaps(codec, nid);
5570 wid_type = get_wcaps_type(wid_caps);
5572 if (wid_type == AC_WID_AUD_SEL)
5573 stac92hd8x_add_mux(codec, nid);
5576 spec->pin_nids = spec->auto_pin_nids;
5577 spec->num_pins = spec->auto_pin_cnt;
5578 spec->adc_nids = spec->auto_adc_nids;
5579 spec->num_adcs = spec->auto_adc_cnt;
5580 spec->capvols = spec->auto_capvols;
5581 spec->capsws = spec->auto_capvols;
5582 spec->num_caps = spec->auto_adc_cnt;
5583 spec->mux_nids = spec->auto_mux_nids;
5584 spec->num_muxes = spec->auto_adc_cnt;
5585 spec->dmux_nids = spec->auto_dmux_nids;
5586 spec->num_dmuxes = spec->auto_adc_cnt;
5587 spec->dmic_nids = spec->auto_dmic_nids;
5588 spec->num_dmics = spec->auto_dmic_cnt;
5591 static int patch_stac92hd83xxx(struct hda_codec *codec)
5593 struct sigmatel_spec *spec;
5594 int default_polarity = -1; /* no default cfg */
5597 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5601 if (hp_bnb2011_with_dock(codec)) {
5602 snd_hda_codec_set_pincfg(codec, 0xa, 0x2101201f);
5603 snd_hda_codec_set_pincfg(codec, 0xf, 0x2181205e);
5606 codec->epss = 0; /* longer delay needed for D3 */
5607 codec->no_trigger_sense = 1;
5610 stac92hd8x_fill_auto_spec(codec);
5612 spec->linear_tone_beep = 0;
5613 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
5614 spec->digbeep_nid = 0x21;
5615 spec->pwr_nids = stac92hd83xxx_pwr_nids;
5616 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
5617 spec->multiout.dac_nids = spec->dac_nids;
5618 spec->init = stac92hd83xxx_core_init;
5620 spec->board_config = snd_hda_check_board_config(codec,
5621 STAC_92HD83XXX_MODELS,
5622 stac92hd83xxx_models,
5623 stac92hd83xxx_cfg_tbl);
5624 /* check codec subsystem id if not found */
5625 if (spec->board_config < 0)
5626 spec->board_config =
5627 snd_hda_check_board_codec_sid_config(codec,
5628 STAC_92HD83XXX_MODELS, stac92hd83xxx_models,
5629 stac92hd83xxx_codec_id_cfg_tbl);
5631 if (spec->board_config < 0)
5632 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5635 stac92xx_set_config_regs(codec,
5636 stac92hd83xxx_brd_tbl[spec->board_config]);
5638 codec->patch_ops = stac92xx_patch_ops;
5640 switch (spec->board_config) {
5641 case STAC_HP_ZEPHYR:
5642 spec->init = stac92hd83xxx_hp_zephyr_init;
5644 case STAC_92HD83XXX_HP_LED:
5645 default_polarity = 0;
5647 case STAC_92HD83XXX_HP_INV_LED:
5648 default_polarity = 1;
5650 case STAC_92HD83XXX_HP_MIC_LED:
5651 spec->mic_mute_led_gpio = 0x08; /* GPIO3 */
5653 case STAC_92HD83XXX_HEADSET_JACK:
5654 spec->headset_jack = 1;
5658 if (find_mute_led_cfg(codec, default_polarity))
5659 snd_printd("mute LED gpio %d polarity %d\n",
5661 spec->gpio_led_polarity);
5663 if (spec->gpio_led) {
5664 if (!spec->vref_mute_led_nid) {
5665 spec->gpio_mask |= spec->gpio_led;
5666 spec->gpio_dir |= spec->gpio_led;
5667 spec->gpio_data |= spec->gpio_led;
5669 codec->patch_ops.set_power_state =
5670 stac92xx_set_power_state;
5674 if (spec->mic_mute_led_gpio) {
5675 spec->gpio_mask |= spec->mic_mute_led_gpio;
5676 spec->gpio_dir |= spec->mic_mute_led_gpio;
5677 spec->mic_mute_led_on = true;
5678 spec->gpio_data |= spec->mic_mute_led_gpio;
5681 err = stac92xx_parse_auto_config(codec);
5683 if (spec->board_config < 0) {
5684 printk(KERN_WARNING "hda_codec: No auto-config is "
5685 "available, default to model=ref\n");
5686 spec->board_config = STAC_92HD83XXX_REF;
5693 stac92xx_free(codec);
5697 codec->proc_widget_hook = stac92hd_proc_hook;
5702 static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
5705 struct sigmatel_spec *spec = codec->spec;
5708 for (idx = 0; idx < spec->num_pins; idx++)
5709 if (spec->pin_nids[idx] == dig0pin)
5711 if ((idx + 2) >= spec->num_pins)
5715 if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE)
5718 /* dig0pin + dig2pin case */
5719 if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE)
5721 if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE)
5727 /* HP dv7 bass switch - GPIO5 */
5728 #define stac_hp_bass_gpio_info snd_ctl_boolean_mono_info
5729 static int stac_hp_bass_gpio_get(struct snd_kcontrol *kcontrol,
5730 struct snd_ctl_elem_value *ucontrol)
5732 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5733 struct sigmatel_spec *spec = codec->spec;
5734 ucontrol->value.integer.value[0] = !!(spec->gpio_data & 0x20);
5738 static int stac_hp_bass_gpio_put(struct snd_kcontrol *kcontrol,
5739 struct snd_ctl_elem_value *ucontrol)
5741 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5742 struct sigmatel_spec *spec = codec->spec;
5743 unsigned int gpio_data;
5745 gpio_data = (spec->gpio_data & ~0x20) |
5746 (ucontrol->value.integer.value[0] ? 0x20 : 0);
5747 if (gpio_data == spec->gpio_data)
5749 spec->gpio_data = gpio_data;
5750 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
5754 static const struct snd_kcontrol_new stac_hp_bass_sw_ctrl = {
5755 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5756 .info = stac_hp_bass_gpio_info,
5757 .get = stac_hp_bass_gpio_get,
5758 .put = stac_hp_bass_gpio_put,
5761 static int stac_add_hp_bass_switch(struct hda_codec *codec)
5763 struct sigmatel_spec *spec = codec->spec;
5765 if (!stac_control_new(spec, &stac_hp_bass_sw_ctrl,
5766 "Bass Speaker Playback Switch", 0))
5769 spec->gpio_mask |= 0x20;
5770 spec->gpio_dir |= 0x20;
5771 spec->gpio_data |= 0x20;
5775 static int patch_stac92hd71bxx(struct hda_codec *codec)
5777 struct sigmatel_spec *spec;
5778 const struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
5779 unsigned int pin_cfg;
5782 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5786 codec->no_trigger_sense = 1;
5788 spec->linear_tone_beep = 0;
5789 codec->patch_ops = stac92xx_patch_ops;
5790 spec->num_pins = STAC92HD71BXX_NUM_PINS;
5791 switch (codec->vendor_id) {
5794 spec->pin_nids = stac92hd71bxx_pin_nids_4port;
5798 /* On 92HD75Bx 0x27 isn't a pin nid */
5802 spec->pin_nids = stac92hd71bxx_pin_nids_6port;
5804 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
5805 spec->board_config = snd_hda_check_board_config(codec,
5806 STAC_92HD71BXX_MODELS,
5807 stac92hd71bxx_models,
5808 stac92hd71bxx_cfg_tbl);
5810 if (spec->board_config < 0)
5811 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5814 stac92xx_set_config_regs(codec,
5815 stac92hd71bxx_brd_tbl[spec->board_config]);
5817 if (spec->board_config != STAC_92HD71BXX_REF) {
5819 spec->gpio_mask = 0x01;
5820 spec->gpio_dir = 0x01;
5821 spec->gpio_data = 0x01;
5824 spec->dmic_nids = stac92hd71bxx_dmic_nids;
5825 spec->dmux_nids = stac92hd71bxx_dmux_nids;
5827 spec->num_caps = STAC92HD71BXX_NUM_CAPS;
5828 spec->capvols = stac92hd71bxx_capvols;
5829 spec->capsws = stac92hd71bxx_capsws;
5831 switch (codec->vendor_id) {
5832 case 0x111d76b6: /* 4 Port without Analog Mixer */
5836 case 0x111d76b4: /* 6 Port without Analog Mixer */
5838 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5839 spec->num_dmics = stac92xx_connected_ports(codec,
5840 stac92hd71bxx_dmic_nids,
5841 STAC92HD71BXX_NUM_DMICS);
5843 case 0x111d7608: /* 5 Port with Analog Mixer */
5844 switch (spec->board_config) {
5846 /* Enable VREF power saving on GPIO1 detect */
5847 err = stac_add_event(codec, codec->afg,
5848 STAC_VREF_EVENT, 0x02);
5851 snd_hda_codec_write_cache(codec, codec->afg, 0,
5852 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
5853 snd_hda_jack_detect_enable(codec, codec->afg, 0);
5854 spec->gpio_mask |= 0x02;
5857 if ((codec->revision_id & 0xf) == 0 ||
5858 (codec->revision_id & 0xf) == 1)
5859 spec->stream_delay = 40; /* 40 milliseconds */
5863 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
5864 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
5865 spec->dmic_nids = stac92hd71bxx_dmic_5port_nids;
5866 spec->num_dmics = stac92xx_connected_ports(codec,
5867 stac92hd71bxx_dmic_5port_nids,
5868 STAC92HD71BXX_NUM_DMICS - 1);
5870 case 0x111d7603: /* 6 Port with Analog Mixer */
5871 if ((codec->revision_id & 0xf) == 1)
5872 spec->stream_delay = 40; /* 40 milliseconds */
5876 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5877 spec->num_dmics = stac92xx_connected_ports(codec,
5878 stac92hd71bxx_dmic_nids,
5879 STAC92HD71BXX_NUM_DMICS);
5883 if (get_wcaps_type(get_wcaps(codec, 0x28)) == AC_WID_VOL_KNB)
5884 spec->init = stac92hd71bxx_core_init;
5886 if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
5887 snd_hda_sequence_write_cache(codec, unmute_init);
5889 spec->aloopback_ctl = stac92hd71bxx_loopback;
5890 spec->aloopback_mask = 0x50;
5891 spec->aloopback_shift = 0;
5893 spec->powerdown_adcs = 1;
5894 spec->digbeep_nid = 0x26;
5895 spec->mux_nids = stac92hd71bxx_mux_nids;
5896 spec->adc_nids = stac92hd71bxx_adc_nids;
5897 spec->smux_nids = stac92hd71bxx_smux_nids;
5898 spec->pwr_nids = stac92hd71bxx_pwr_nids;
5900 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
5901 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
5902 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5903 spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
5905 snd_printdd("Found board config: %d\n", spec->board_config);
5907 switch (spec->board_config) {
5909 /* enable internal microphone */
5910 snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
5911 stac92xx_auto_set_pinctl(codec, 0x0e,
5912 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
5914 case STAC_DELL_M4_2:
5915 spec->num_dmics = 0;
5916 spec->num_smuxes = 0;
5917 spec->num_dmuxes = 0;
5919 case STAC_DELL_M4_1:
5920 case STAC_DELL_M4_3:
5921 spec->num_dmics = 1;
5922 spec->num_smuxes = 0;
5923 spec->num_dmuxes = 1;
5925 case STAC_HP_DV4_1222NR:
5926 spec->num_dmics = 1;
5927 /* I don't know if it needs 1 or 2 smuxes - will wait for
5928 * bug reports to fix if needed
5930 spec->num_smuxes = 1;
5931 spec->num_dmuxes = 1;
5934 spec->gpio_led = 0x01;
5937 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
5938 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
5939 /* HP dv6 gives the headphone pin as a line-out. Thus we
5940 * need to set hp_detect flag here to force to enable HP
5943 spec->hp_detect = 1;
5946 spec->num_dmics = 1;
5947 spec->num_dmuxes = 1;
5948 spec->num_smuxes = 1;
5949 spec->gpio_led = 0x08;
5953 if (hp_blike_system(codec->subsystem_id)) {
5954 pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f);
5955 if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT ||
5956 get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER ||
5957 get_defcfg_device(pin_cfg) == AC_JACK_HP_OUT) {
5958 /* It was changed in the BIOS to just satisfy MS DTM.
5959 * Lets turn it back into slaved HP
5961 pin_cfg = (pin_cfg & (~AC_DEFCFG_DEVICE))
5962 | (AC_JACK_HP_OUT <<
5963 AC_DEFCFG_DEVICE_SHIFT);
5964 pin_cfg = (pin_cfg & (~(AC_DEFCFG_DEF_ASSOC
5965 | AC_DEFCFG_SEQUENCE)))
5967 snd_hda_codec_set_pincfg(codec, 0x0f, pin_cfg);
5971 if (find_mute_led_cfg(codec, 1))
5972 snd_printd("mute LED gpio %d polarity %d\n",
5974 spec->gpio_led_polarity);
5976 if (spec->gpio_led) {
5977 if (!spec->vref_mute_led_nid) {
5978 spec->gpio_mask |= spec->gpio_led;
5979 spec->gpio_dir |= spec->gpio_led;
5980 spec->gpio_data |= spec->gpio_led;
5982 codec->patch_ops.set_power_state =
5983 stac92xx_set_power_state;
5987 spec->multiout.dac_nids = spec->dac_nids;
5989 err = stac92xx_parse_auto_config(codec);
5991 if (spec->board_config < 0) {
5992 printk(KERN_WARNING "hda_codec: No auto-config is "
5993 "available, default to model=ref\n");
5994 spec->board_config = STAC_92HD71BXX_REF;
6001 stac92xx_free(codec);
6005 /* enable bass on HP dv7 */
6006 if (spec->board_config == STAC_HP_DV4 ||
6007 spec->board_config == STAC_HP_DV5) {
6009 cap = snd_hda_param_read(codec, 0x1, AC_PAR_GPIO_CAP);
6010 cap &= AC_GPIO_IO_COUNT;
6012 stac_add_hp_bass_switch(codec);
6015 codec->proc_widget_hook = stac92hd7x_proc_hook;
6020 static int patch_stac922x(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 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
6033 spec->pin_nids = stac922x_pin_nids;
6034 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
6037 if (spec->board_config == STAC_INTEL_MAC_AUTO) {
6038 spec->gpio_mask = spec->gpio_dir = 0x03;
6039 spec->gpio_data = 0x03;
6040 /* Intel Macs have all same PCI SSID, so we need to check
6041 * codec SSID to distinguish the exact models
6043 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
6044 switch (codec->subsystem_id) {
6047 spec->board_config = STAC_INTEL_MAC_V1;
6051 spec->board_config = STAC_INTEL_MAC_V2;
6059 spec->board_config = STAC_INTEL_MAC_V3;
6063 spec->board_config = STAC_INTEL_MAC_V4;
6067 spec->board_config = STAC_INTEL_MAC_V5;
6070 spec->board_config = STAC_INTEL_MAC_V3;
6076 if (spec->board_config < 0)
6077 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6080 stac92xx_set_config_regs(codec,
6081 stac922x_brd_tbl[spec->board_config]);
6083 spec->adc_nids = stac922x_adc_nids;
6084 spec->mux_nids = stac922x_mux_nids;
6085 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
6086 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
6087 spec->num_dmics = 0;
6090 spec->init = stac922x_core_init;
6092 spec->num_caps = STAC922X_NUM_CAPS;
6093 spec->capvols = stac922x_capvols;
6094 spec->capsws = stac922x_capsws;
6096 spec->multiout.dac_nids = spec->dac_nids;
6098 err = stac92xx_parse_auto_config(codec);
6100 if (spec->board_config < 0) {
6101 printk(KERN_WARNING "hda_codec: No auto-config is "
6102 "available, default to model=ref\n");
6103 spec->board_config = STAC_D945_REF;
6109 stac92xx_free(codec);
6113 codec->patch_ops = stac92xx_patch_ops;
6115 /* Fix Mux capture level; max to 2 */
6116 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
6117 (0 << AC_AMPCAP_OFFSET_SHIFT) |
6118 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
6119 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
6120 (0 << AC_AMPCAP_MUTE_SHIFT));
6125 static int patch_stac927x(struct hda_codec *codec)
6127 struct sigmatel_spec *spec;
6130 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6134 codec->no_trigger_sense = 1;
6136 spec->linear_tone_beep = 1;
6137 codec->slave_dig_outs = stac927x_slave_dig_outs;
6138 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
6139 spec->pin_nids = stac927x_pin_nids;
6140 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
6144 if (spec->board_config < 0)
6145 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6148 stac92xx_set_config_regs(codec,
6149 stac927x_brd_tbl[spec->board_config]);
6151 spec->digbeep_nid = 0x23;
6152 spec->adc_nids = stac927x_adc_nids;
6153 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
6154 spec->mux_nids = stac927x_mux_nids;
6155 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
6156 spec->smux_nids = stac927x_smux_nids;
6157 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
6158 spec->spdif_labels = stac927x_spdif_labels;
6159 spec->dac_list = stac927x_dac_nids;
6160 spec->multiout.dac_nids = spec->dac_nids;
6162 if (spec->board_config != STAC_D965_REF) {
6163 /* GPIO0 High = Enable EAPD */
6164 spec->eapd_mask = spec->gpio_mask = 0x01;
6165 spec->gpio_dir = spec->gpio_data = 0x01;
6168 switch (spec->board_config) {
6171 /* GPIO0 High = Enable EAPD */
6172 spec->num_dmics = 0;
6173 spec->init = d965_core_init;
6175 case STAC_DELL_BIOS:
6176 switch (codec->subsystem_id) {
6179 /* correct the device field to SPDIF out */
6180 snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
6183 /* configure the analog microphone on some laptops */
6184 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
6185 /* correct the front output jack as a hp out */
6186 snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f);
6187 /* correct the front input jack as a mic */
6188 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
6191 if (codec->subsystem_id != 0x1028022f) {
6192 /* GPIO2 High = Enable EAPD */
6193 spec->eapd_mask = spec->gpio_mask = 0x04;
6194 spec->gpio_dir = spec->gpio_data = 0x04;
6196 spec->dmic_nids = stac927x_dmic_nids;
6197 spec->num_dmics = STAC927X_NUM_DMICS;
6199 spec->init = dell_3st_core_init;
6200 spec->dmux_nids = stac927x_dmux_nids;
6201 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
6203 case STAC_927X_VOLKNOB:
6204 spec->num_dmics = 0;
6205 spec->init = stac927x_volknob_core_init;
6208 spec->num_dmics = 0;
6209 spec->init = stac927x_core_init;
6213 spec->num_caps = STAC927X_NUM_CAPS;
6214 spec->capvols = stac927x_capvols;
6215 spec->capsws = stac927x_capsws;
6218 spec->aloopback_ctl = stac927x_loopback;
6219 spec->aloopback_mask = 0x40;
6220 spec->aloopback_shift = 0;
6221 spec->eapd_switch = 1;
6223 err = stac92xx_parse_auto_config(codec);
6225 if (spec->board_config < 0) {
6226 printk(KERN_WARNING "hda_codec: No auto-config is "
6227 "available, default to model=ref\n");
6228 spec->board_config = STAC_D965_REF;
6234 stac92xx_free(codec);
6238 codec->patch_ops = stac92xx_patch_ops;
6240 codec->proc_widget_hook = stac927x_proc_hook;
6244 * The STAC927x seem to require fairly long delays for certain
6245 * command sequences. With too short delays (even if the answer
6246 * is set to RIRB properly), it results in the silence output
6247 * on some hardwares like Dell.
6249 * The below flag enables the longer delay (see get_response
6252 codec->bus->needs_damn_long_delay = 1;
6254 /* no jack detecion for ref-no-jd model */
6255 if (spec->board_config == STAC_D965_REF_NO_JD)
6256 spec->hp_detect = 0;
6261 static int patch_stac9205(struct hda_codec *codec)
6263 struct sigmatel_spec *spec;
6266 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6270 codec->no_trigger_sense = 1;
6272 spec->linear_tone_beep = 1;
6273 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
6274 spec->pin_nids = stac9205_pin_nids;
6275 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
6279 if (spec->board_config < 0)
6280 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6283 stac92xx_set_config_regs(codec,
6284 stac9205_brd_tbl[spec->board_config]);
6286 spec->digbeep_nid = 0x23;
6287 spec->adc_nids = stac9205_adc_nids;
6288 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
6289 spec->mux_nids = stac9205_mux_nids;
6290 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
6291 spec->smux_nids = stac9205_smux_nids;
6292 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
6293 spec->dmic_nids = stac9205_dmic_nids;
6294 spec->num_dmics = STAC9205_NUM_DMICS;
6295 spec->dmux_nids = stac9205_dmux_nids;
6296 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
6299 spec->init = stac9205_core_init;
6300 spec->aloopback_ctl = stac9205_loopback;
6302 spec->num_caps = STAC9205_NUM_CAPS;
6303 spec->capvols = stac9205_capvols;
6304 spec->capsws = stac9205_capsws;
6306 spec->aloopback_mask = 0x40;
6307 spec->aloopback_shift = 0;
6308 /* Turn on/off EAPD per HP plugging */
6309 if (spec->board_config != STAC_9205_EAPD)
6310 spec->eapd_switch = 1;
6311 spec->multiout.dac_nids = spec->dac_nids;
6313 switch (spec->board_config){
6314 case STAC_9205_DELL_M43:
6315 /* Enable SPDIF in/out */
6316 snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030);
6317 snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030);
6319 /* Enable unsol response for GPIO4/Dock HP connection */
6320 err = stac_add_event(codec, codec->afg, STAC_VREF_EVENT, 0x01);
6323 snd_hda_codec_write_cache(codec, codec->afg, 0,
6324 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
6325 snd_hda_jack_detect_enable(codec, codec->afg, 0);
6327 spec->gpio_dir = 0x0b;
6328 spec->eapd_mask = 0x01;
6329 spec->gpio_mask = 0x1b;
6330 spec->gpio_mute = 0x10;
6331 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
6334 spec->gpio_data = 0x01;
6337 /* SPDIF-In enabled */
6340 /* GPIO0 High = EAPD */
6341 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
6342 spec->gpio_data = 0x01;
6346 err = stac92xx_parse_auto_config(codec);
6348 if (spec->board_config < 0) {
6349 printk(KERN_WARNING "hda_codec: No auto-config is "
6350 "available, default to model=ref\n");
6351 spec->board_config = STAC_9205_REF;
6357 stac92xx_free(codec);
6361 codec->patch_ops = stac92xx_patch_ops;
6363 codec->proc_widget_hook = stac9205_proc_hook;
6372 static const struct hda_verb stac9872_core_init[] = {
6373 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
6374 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
6378 static const hda_nid_t stac9872_pin_nids[] = {
6379 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
6383 static const hda_nid_t stac9872_adc_nids[] = {
6387 static const hda_nid_t stac9872_mux_nids[] = {
6391 static const unsigned long stac9872_capvols[] = {
6392 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
6394 #define stac9872_capsws stac9872_capvols
6396 static const unsigned int stac9872_vaio_pin_configs[9] = {
6397 0x03211020, 0x411111f0, 0x411111f0, 0x03a15030,
6398 0x411111f0, 0x90170110, 0x411111f0, 0x411111f0,
6402 static const char * const stac9872_models[STAC_9872_MODELS] = {
6403 [STAC_9872_AUTO] = "auto",
6404 [STAC_9872_VAIO] = "vaio",
6407 static const unsigned int *stac9872_brd_tbl[STAC_9872_MODELS] = {
6408 [STAC_9872_VAIO] = stac9872_vaio_pin_configs,
6411 static const struct snd_pci_quirk stac9872_cfg_tbl[] = {
6412 SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0,
6413 "Sony VAIO F/S", STAC_9872_VAIO),
6417 static int patch_stac9872(struct hda_codec *codec)
6419 struct sigmatel_spec *spec;
6422 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6425 codec->no_trigger_sense = 1;
6427 spec->linear_tone_beep = 1;
6428 spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
6429 spec->pin_nids = stac9872_pin_nids;
6431 spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
6434 if (spec->board_config < 0)
6435 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6438 stac92xx_set_config_regs(codec,
6439 stac9872_brd_tbl[spec->board_config]);
6441 spec->multiout.dac_nids = spec->dac_nids;
6442 spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
6443 spec->adc_nids = stac9872_adc_nids;
6444 spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
6445 spec->mux_nids = stac9872_mux_nids;
6446 spec->init = stac9872_core_init;
6448 spec->capvols = stac9872_capvols;
6449 spec->capsws = stac9872_capsws;
6451 err = stac92xx_parse_auto_config(codec);
6453 stac92xx_free(codec);
6456 spec->input_mux = &spec->private_imux;
6457 codec->patch_ops = stac92xx_patch_ops;
6465 static const struct hda_codec_preset snd_hda_preset_sigmatel[] = {
6466 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
6467 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
6468 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
6469 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
6470 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
6471 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
6472 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
6473 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
6474 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
6475 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
6476 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
6477 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
6478 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
6479 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
6480 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
6481 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
6482 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
6483 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
6484 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
6485 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
6486 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
6487 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
6488 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
6489 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
6490 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
6491 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
6492 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
6493 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
6494 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
6495 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
6496 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
6497 /* The following does not take into account .id=0x83847661 when subsys =
6498 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
6499 * currently not fully supported.
6501 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
6502 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
6503 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
6504 { .id = 0x83847698, .name = "STAC9205", .patch = patch_stac9205 },
6505 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
6506 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
6507 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
6508 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
6509 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
6510 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
6511 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
6512 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
6513 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
6514 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
6515 { .id = 0x111d76d4, .name = "92HD83C1C5", .patch = patch_stac92hd83xxx},
6516 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
6517 { .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx},
6518 { .id = 0x111d76d1, .name = "92HD87B1/3", .patch = patch_stac92hd83xxx},
6519 { .id = 0x111d76d9, .name = "92HD87B2/4", .patch = patch_stac92hd83xxx},
6520 { .id = 0x111d7666, .name = "92HD88B3", .patch = patch_stac92hd83xxx},
6521 { .id = 0x111d7667, .name = "92HD88B1", .patch = patch_stac92hd83xxx},
6522 { .id = 0x111d7668, .name = "92HD88B2", .patch = patch_stac92hd83xxx},
6523 { .id = 0x111d7669, .name = "92HD88B4", .patch = patch_stac92hd83xxx},
6524 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
6525 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
6526 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
6527 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
6528 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
6529 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
6530 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
6531 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
6532 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
6533 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
6534 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
6535 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
6536 { .id = 0x111d76c0, .name = "92HD89C3", .patch = patch_stac92hd73xx },
6537 { .id = 0x111d76c1, .name = "92HD89C2", .patch = patch_stac92hd73xx },
6538 { .id = 0x111d76c2, .name = "92HD89C1", .patch = patch_stac92hd73xx },
6539 { .id = 0x111d76c3, .name = "92HD89B3", .patch = patch_stac92hd73xx },
6540 { .id = 0x111d76c4, .name = "92HD89B2", .patch = patch_stac92hd73xx },
6541 { .id = 0x111d76c5, .name = "92HD89B1", .patch = patch_stac92hd73xx },
6542 { .id = 0x111d76c6, .name = "92HD89E3", .patch = patch_stac92hd73xx },
6543 { .id = 0x111d76c7, .name = "92HD89E2", .patch = patch_stac92hd73xx },
6544 { .id = 0x111d76c8, .name = "92HD89E1", .patch = patch_stac92hd73xx },
6545 { .id = 0x111d76c9, .name = "92HD89D3", .patch = patch_stac92hd73xx },
6546 { .id = 0x111d76ca, .name = "92HD89D2", .patch = patch_stac92hd73xx },
6547 { .id = 0x111d76cb, .name = "92HD89D1", .patch = patch_stac92hd73xx },
6548 { .id = 0x111d76cc, .name = "92HD89F3", .patch = patch_stac92hd73xx },
6549 { .id = 0x111d76cd, .name = "92HD89F2", .patch = patch_stac92hd73xx },
6550 { .id = 0x111d76ce, .name = "92HD89F1", .patch = patch_stac92hd73xx },
6551 { .id = 0x111d76df, .name = "92HD93BXX", .patch = patch_stac92hd83xxx},
6552 { .id = 0x111d76e0, .name = "92HD91BXX", .patch = patch_stac92hd83xxx},
6553 { .id = 0x111d76e3, .name = "92HD98BXX", .patch = patch_stac92hd83xxx},
6554 { .id = 0x111d76e5, .name = "92HD99BXX", .patch = patch_stac92hd83xxx},
6555 { .id = 0x111d76e7, .name = "92HD90BXX", .patch = patch_stac92hd83xxx},
6556 { .id = 0x111d76e8, .name = "92HD66B1X5", .patch = patch_stac92hd83xxx},
6557 { .id = 0x111d76e9, .name = "92HD66B2X5", .patch = patch_stac92hd83xxx},
6558 { .id = 0x111d76ea, .name = "92HD66B3X5", .patch = patch_stac92hd83xxx},
6559 { .id = 0x111d76eb, .name = "92HD66C1X5", .patch = patch_stac92hd83xxx},
6560 { .id = 0x111d76ec, .name = "92HD66C2X5", .patch = patch_stac92hd83xxx},
6561 { .id = 0x111d76ed, .name = "92HD66C3X5", .patch = patch_stac92hd83xxx},
6562 { .id = 0x111d76ee, .name = "92HD66B1X3", .patch = patch_stac92hd83xxx},
6563 { .id = 0x111d76ef, .name = "92HD66B2X3", .patch = patch_stac92hd83xxx},
6564 { .id = 0x111d76f0, .name = "92HD66B3X3", .patch = patch_stac92hd83xxx},
6565 { .id = 0x111d76f1, .name = "92HD66C1X3", .patch = patch_stac92hd83xxx},
6566 { .id = 0x111d76f2, .name = "92HD66C2X3", .patch = patch_stac92hd83xxx},
6567 { .id = 0x111d76f3, .name = "92HD66C3/65", .patch = patch_stac92hd83xxx},
6571 MODULE_ALIAS("snd-hda-codec-id:8384*");
6572 MODULE_ALIAS("snd-hda-codec-id:111d*");
6574 MODULE_LICENSE("GPL");
6575 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
6577 static struct hda_codec_preset_list sigmatel_list = {
6578 .preset = snd_hda_preset_sigmatel,
6579 .owner = THIS_MODULE,
6582 static int __init patch_sigmatel_init(void)
6584 return snd_hda_add_codec_preset(&sigmatel_list);
6587 static void __exit patch_sigmatel_exit(void)
6589 snd_hda_delete_codec_preset(&sigmatel_list);
6592 module_init(patch_sigmatel_init)
6593 module_exit(patch_sigmatel_exit)