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"
82 STAC_92HD73XX_NO_JD, /* no jack-detection */
96 STAC_92HD83XXX_PWR_REF,
98 STAC_DELL_VOSTRO_3500,
100 STAC_92HD83XXX_HP_cNB11_INTQUAD,
102 STAC_92HD83XXX_MODELS
116 STAC_92HD71BXX_MODELS
142 STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
143 * is given, one of the above models will be
144 * chosen according to the subsystem id. */
145 /* for backward compatibility */
162 STAC_D965_REF_NO_JD, /* no jack-detection */
179 struct sigmatel_event {
186 struct sigmatel_mic_route {
189 signed char dmux_idx;
192 #define MAX_PINS_NUM 16
193 #define MAX_ADCS_NUM 4
194 #define MAX_DMICS_NUM 4
196 struct sigmatel_spec {
197 struct snd_kcontrol_new *mixers[4];
198 unsigned int num_mixers;
201 unsigned int eapd_switch: 1;
202 unsigned int surr_switch: 1;
203 unsigned int alt_switch: 1;
204 unsigned int hp_detect: 1;
205 unsigned int spdif_mute: 1;
206 unsigned int check_volume_offset:1;
207 unsigned int auto_mic:1;
208 unsigned int linear_tone_beep:1;
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_led;
221 unsigned int stream_delay;
223 /* analog loopback */
224 const struct snd_kcontrol_new *aloopback_ctl;
225 unsigned char aloopback_mask;
226 unsigned char aloopback_shift;
228 /* power management */
229 unsigned int num_pwrs;
230 const unsigned int *pwr_mapping;
231 const hda_nid_t *pwr_nids;
232 const hda_nid_t *dac_list;
235 struct snd_array events;
238 struct hda_input_mux *mono_mux;
239 unsigned int cur_mmux;
240 struct hda_multi_out multiout;
241 hda_nid_t dac_nids[5];
242 hda_nid_t hp_dacs[5];
243 hda_nid_t speaker_dacs[5];
248 const hda_nid_t *adc_nids;
249 unsigned int num_adcs;
250 const hda_nid_t *mux_nids;
251 unsigned int num_muxes;
252 const hda_nid_t *dmic_nids;
253 unsigned int num_dmics;
254 const hda_nid_t *dmux_nids;
255 unsigned int num_dmuxes;
256 const hda_nid_t *smux_nids;
257 unsigned int num_smuxes;
258 unsigned int num_analog_muxes;
260 const unsigned long *capvols; /* amp-volume attr: HDA_COMPOSE_AMP_VAL() */
261 const unsigned long *capsws; /* amp-mute attr: HDA_COMPOSE_AMP_VAL() */
262 unsigned int num_caps; /* number of capture volume/switch elements */
264 struct sigmatel_mic_route ext_mic;
265 struct sigmatel_mic_route int_mic;
266 struct sigmatel_mic_route dock_mic;
268 const char * const *spdif_labels;
270 hda_nid_t dig_in_nid;
272 hda_nid_t anabeep_nid;
273 hda_nid_t digbeep_nid;
276 const hda_nid_t *pin_nids;
277 unsigned int num_pins;
279 /* codec specific stuff */
280 const struct hda_verb *init;
281 const struct snd_kcontrol_new *mixer;
284 struct hda_input_mux *dinput_mux;
285 unsigned int cur_dmux[2];
286 struct hda_input_mux *input_mux;
287 unsigned int cur_mux[3];
288 struct hda_input_mux *sinput_mux;
289 unsigned int cur_smux[2];
290 unsigned int cur_amux;
292 unsigned int powerdown_adcs;
295 unsigned int io_switch[2];
296 unsigned int clfe_swap;
297 hda_nid_t line_switch; /* shared line-in for input and output */
298 hda_nid_t mic_switch; /* shared mic-in for input and output */
299 hda_nid_t hp_switch; /* NID of HP as line-out */
300 unsigned int aloopback;
302 struct hda_pcm pcm_rec[2]; /* PCM information */
304 /* dynamic controls and input_mux */
305 struct auto_pin_cfg autocfg;
306 struct snd_array kctls;
307 struct hda_input_mux private_dimux;
308 struct hda_input_mux private_imux;
309 struct hda_input_mux private_smux;
310 struct hda_input_mux private_mono_mux;
313 unsigned auto_pin_cnt;
314 hda_nid_t auto_pin_nids[MAX_PINS_NUM];
315 unsigned auto_adc_cnt;
316 hda_nid_t auto_adc_nids[MAX_ADCS_NUM];
317 hda_nid_t auto_mux_nids[MAX_ADCS_NUM];
318 hda_nid_t auto_dmux_nids[MAX_ADCS_NUM];
319 unsigned long auto_capvols[MAX_ADCS_NUM];
320 unsigned auto_dmic_cnt;
321 hda_nid_t auto_dmic_nids[MAX_DMICS_NUM];
324 static const hda_nid_t stac9200_adc_nids[1] = {
328 static const hda_nid_t stac9200_mux_nids[1] = {
332 static const hda_nid_t stac9200_dac_nids[1] = {
336 static const hda_nid_t stac92hd73xx_pwr_nids[8] = {
337 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
341 static const hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
345 static const hda_nid_t stac92hd73xx_adc_nids[2] = {
349 #define STAC92HD73XX_NUM_DMICS 2
350 static const hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
354 #define STAC92HD73_DAC_COUNT 5
356 static const hda_nid_t stac92hd73xx_mux_nids[2] = {
360 static const hda_nid_t stac92hd73xx_dmux_nids[2] = {
364 static const hda_nid_t stac92hd73xx_smux_nids[2] = {
368 #define STAC92HD73XX_NUM_CAPS 2
369 static const unsigned long stac92hd73xx_capvols[] = {
370 HDA_COMPOSE_AMP_VAL(0x20, 3, 0, HDA_OUTPUT),
371 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
373 #define stac92hd73xx_capsws stac92hd73xx_capvols
375 #define STAC92HD83_DAC_COUNT 3
377 static const hda_nid_t stac92hd83xxx_pwr_nids[4] = {
381 static const hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
385 static const unsigned int stac92hd83xxx_pwr_mapping[4] = {
386 0x03, 0x0c, 0x20, 0x40,
389 static const hda_nid_t stac92hd83xxx_dmic_nids[] = {
393 static const hda_nid_t stac92hd71bxx_pwr_nids[3] = {
397 static const hda_nid_t stac92hd71bxx_adc_nids[2] = {
401 static const hda_nid_t stac92hd71bxx_mux_nids[2] = {
405 static const hda_nid_t stac92hd71bxx_dmux_nids[2] = {
409 static const hda_nid_t stac92hd71bxx_smux_nids[2] = {
413 #define STAC92HD71BXX_NUM_DMICS 2
414 static const hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
418 static const hda_nid_t stac92hd71bxx_dmic_5port_nids[STAC92HD71BXX_NUM_DMICS] = {
422 static const hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
426 #define STAC92HD71BXX_NUM_CAPS 2
427 static const unsigned long stac92hd71bxx_capvols[] = {
428 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
429 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
431 #define stac92hd71bxx_capsws stac92hd71bxx_capvols
433 static const hda_nid_t stac925x_adc_nids[1] = {
437 static const hda_nid_t stac925x_mux_nids[1] = {
441 static const hda_nid_t stac925x_dac_nids[1] = {
445 #define STAC925X_NUM_DMICS 1
446 static const hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
450 static const hda_nid_t stac925x_dmux_nids[1] = {
454 static const unsigned long stac925x_capvols[] = {
455 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
457 static const unsigned long stac925x_capsws[] = {
458 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
461 static const hda_nid_t stac922x_adc_nids[2] = {
465 static const hda_nid_t stac922x_mux_nids[2] = {
469 #define STAC922X_NUM_CAPS 2
470 static const unsigned long stac922x_capvols[] = {
471 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_INPUT),
472 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
474 #define stac922x_capsws stac922x_capvols
476 static const hda_nid_t stac927x_slave_dig_outs[2] = {
480 static const hda_nid_t stac927x_adc_nids[3] = {
484 static const hda_nid_t stac927x_mux_nids[3] = {
488 static const hda_nid_t stac927x_smux_nids[1] = {
492 static const hda_nid_t stac927x_dac_nids[6] = {
493 0x02, 0x03, 0x04, 0x05, 0x06, 0
496 static const hda_nid_t stac927x_dmux_nids[1] = {
500 #define STAC927X_NUM_DMICS 2
501 static const hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
505 #define STAC927X_NUM_CAPS 3
506 static const unsigned long stac927x_capvols[] = {
507 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
508 HDA_COMPOSE_AMP_VAL(0x19, 3, 0, HDA_INPUT),
509 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_INPUT),
511 static const unsigned long stac927x_capsws[] = {
512 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
513 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
514 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
517 static const char * const stac927x_spdif_labels[5] = {
518 "Digital Playback", "ADAT", "Analog Mux 1",
519 "Analog Mux 2", "Analog Mux 3"
522 static const hda_nid_t stac9205_adc_nids[2] = {
526 static const hda_nid_t stac9205_mux_nids[2] = {
530 static const hda_nid_t stac9205_dmux_nids[1] = {
534 static const hda_nid_t stac9205_smux_nids[1] = {
538 #define STAC9205_NUM_DMICS 2
539 static const hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
543 #define STAC9205_NUM_CAPS 2
544 static const unsigned long stac9205_capvols[] = {
545 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_INPUT),
546 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_INPUT),
548 static const unsigned long stac9205_capsws[] = {
549 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
550 HDA_COMPOSE_AMP_VAL(0x1e, 3, 0, HDA_OUTPUT),
553 static const hda_nid_t stac9200_pin_nids[8] = {
554 0x08, 0x09, 0x0d, 0x0e,
555 0x0f, 0x10, 0x11, 0x12,
558 static const hda_nid_t stac925x_pin_nids[8] = {
559 0x07, 0x08, 0x0a, 0x0b,
560 0x0c, 0x0d, 0x10, 0x11,
563 static const hda_nid_t stac922x_pin_nids[10] = {
564 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
565 0x0f, 0x10, 0x11, 0x15, 0x1b,
568 static const hda_nid_t stac92hd73xx_pin_nids[13] = {
569 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
570 0x0f, 0x10, 0x11, 0x12, 0x13,
574 #define STAC92HD71BXX_NUM_PINS 13
575 static const hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
576 0x0a, 0x0b, 0x0c, 0x0d, 0x00,
577 0x00, 0x14, 0x18, 0x19, 0x1e,
580 static const hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
581 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
582 0x0f, 0x14, 0x18, 0x19, 0x1e,
586 static const hda_nid_t stac927x_pin_nids[14] = {
587 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
588 0x0f, 0x10, 0x11, 0x12, 0x13,
589 0x14, 0x21, 0x22, 0x23,
592 static const hda_nid_t stac9205_pin_nids[12] = {
593 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
594 0x0f, 0x14, 0x16, 0x17, 0x18,
598 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
599 struct snd_ctl_elem_info *uinfo)
601 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
602 struct sigmatel_spec *spec = codec->spec;
603 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
606 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
607 struct snd_ctl_elem_value *ucontrol)
609 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
610 struct sigmatel_spec *spec = codec->spec;
611 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
613 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
617 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
618 struct snd_ctl_elem_value *ucontrol)
620 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
621 struct sigmatel_spec *spec = codec->spec;
622 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
624 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
625 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
628 static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
629 struct snd_ctl_elem_info *uinfo)
631 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
632 struct sigmatel_spec *spec = codec->spec;
633 return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
636 static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
637 struct snd_ctl_elem_value *ucontrol)
639 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
640 struct sigmatel_spec *spec = codec->spec;
641 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
643 ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
647 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
648 struct snd_ctl_elem_value *ucontrol)
650 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
651 struct sigmatel_spec *spec = codec->spec;
652 struct hda_input_mux *smux = &spec->private_smux;
653 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
657 err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
658 spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
662 if (spec->spdif_mute) {
664 nid = spec->multiout.dig_out_nid;
666 nid = codec->slave_dig_outs[smux_idx - 1];
667 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
671 /* un/mute SPDIF out */
672 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
678 #ifdef CONFIG_SND_HDA_POWER_SAVE
679 static int stac_vrefout_set(struct hda_codec *codec,
680 hda_nid_t nid, unsigned int new_vref)
684 snd_printdd("%s, nid %x ctl %x\n", __func__, nid, new_vref);
685 pinctl = snd_hda_codec_read(codec, nid, 0,
686 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
692 pinctl &= ~AC_PINCTL_VREFEN;
693 pinctl |= (new_vref & AC_PINCTL_VREFEN);
695 error = snd_hda_codec_write_cache(codec, nid, 0,
696 AC_VERB_SET_PIN_WIDGET_CONTROL, 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_codec_write_cache(codec, nid, 0,
722 AC_VERB_SET_PIN_WIDGET_CONTROL, pincfg);
729 static unsigned int stac92xx_vref_get(struct hda_codec *codec, hda_nid_t nid)
732 vref = snd_hda_codec_read(codec, nid, 0,
733 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
734 vref &= AC_PINCTL_VREFEN;
738 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
740 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
741 struct sigmatel_spec *spec = codec->spec;
742 return snd_hda_input_mux_info(spec->input_mux, uinfo);
745 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
747 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
748 struct sigmatel_spec *spec = codec->spec;
749 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
751 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
755 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
757 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
758 struct sigmatel_spec *spec = codec->spec;
759 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
760 const struct hda_input_mux *imux = spec->input_mux;
761 unsigned int idx, prev_idx, didx;
763 idx = ucontrol->value.enumerated.item[0];
764 if (idx >= imux->num_items)
765 idx = imux->num_items - 1;
766 prev_idx = spec->cur_mux[adc_idx];
769 if (idx < spec->num_analog_muxes) {
770 snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0,
771 AC_VERB_SET_CONNECT_SEL,
772 imux->items[idx].index);
773 if (prev_idx >= spec->num_analog_muxes &&
774 spec->mux_nids[adc_idx] != spec->dmux_nids[adc_idx]) {
775 imux = spec->dinput_mux;
777 snd_hda_codec_write_cache(codec,
778 spec->dmux_nids[adc_idx], 0,
779 AC_VERB_SET_CONNECT_SEL,
780 imux->items[0].index);
783 imux = spec->dinput_mux;
784 /* first dimux item is hardcoded to select analog imux,
787 didx = idx - spec->num_analog_muxes + 1;
788 snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0,
789 AC_VERB_SET_CONNECT_SEL,
790 imux->items[didx].index);
792 spec->cur_mux[adc_idx] = idx;
796 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
797 struct snd_ctl_elem_info *uinfo)
799 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
800 struct sigmatel_spec *spec = codec->spec;
801 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
804 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
805 struct snd_ctl_elem_value *ucontrol)
807 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
808 struct sigmatel_spec *spec = codec->spec;
810 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
814 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
815 struct snd_ctl_elem_value *ucontrol)
817 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
818 struct sigmatel_spec *spec = codec->spec;
820 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
821 spec->mono_nid, &spec->cur_mmux);
824 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
826 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
827 struct snd_ctl_elem_value *ucontrol)
829 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
830 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
831 struct sigmatel_spec *spec = codec->spec;
833 ucontrol->value.integer.value[0] = !!(spec->aloopback &
834 (spec->aloopback_mask << idx));
838 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
839 struct snd_ctl_elem_value *ucontrol)
841 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
842 struct sigmatel_spec *spec = codec->spec;
843 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
844 unsigned int dac_mode;
845 unsigned int val, idx_val;
847 idx_val = spec->aloopback_mask << idx;
848 if (ucontrol->value.integer.value[0])
849 val = spec->aloopback | idx_val;
851 val = spec->aloopback & ~idx_val;
852 if (spec->aloopback == val)
855 spec->aloopback = val;
857 /* Only return the bits defined by the shift value of the
858 * first two bytes of the mask
860 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
861 kcontrol->private_value & 0xFFFF, 0x0);
862 dac_mode >>= spec->aloopback_shift;
864 if (spec->aloopback & idx_val) {
865 snd_hda_power_up(codec);
868 snd_hda_power_down(codec);
869 dac_mode &= ~idx_val;
872 snd_hda_codec_write_cache(codec, codec->afg, 0,
873 kcontrol->private_value >> 16, dac_mode);
878 static const struct hda_verb stac9200_core_init[] = {
879 /* set dac0mux for dac converter */
880 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
884 static const struct hda_verb stac9200_eapd_init[] = {
885 /* set dac0mux for dac converter */
886 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
887 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
891 static const struct hda_verb dell_eq_core_init[] = {
892 /* set master volume to max value without distortion
893 * and direct control */
894 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
898 static const struct hda_verb stac92hd73xx_core_init[] = {
899 /* set master volume and direct control */
900 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
904 static const struct hda_verb stac92hd83xxx_core_init[] = {
905 /* power state controls amps */
906 { 0x01, AC_VERB_SET_EAPD, 1 << 2},
910 static const struct hda_verb stac92hd71bxx_core_init[] = {
911 /* set master volume and direct control */
912 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
916 static const struct hda_verb stac92hd71bxx_unmute_core_init[] = {
917 /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
918 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
919 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
920 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
924 static const struct hda_verb stac925x_core_init[] = {
925 /* set dac0mux for dac converter */
926 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
927 /* mute the master volume */
928 { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
932 static const struct hda_verb stac922x_core_init[] = {
933 /* set master volume and direct control */
934 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
938 static const struct hda_verb d965_core_init[] = {
939 /* set master volume and direct control */
940 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
941 /* unmute node 0x1b */
942 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
943 /* select node 0x03 as DAC */
944 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
948 static const struct hda_verb dell_3st_core_init[] = {
949 /* don't set delta bit */
950 {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
951 /* unmute node 0x1b */
952 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
953 /* select node 0x03 as DAC */
954 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
958 static const struct hda_verb stac927x_core_init[] = {
959 /* set master volume and direct control */
960 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
961 /* enable analog pc beep path */
962 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
966 static const struct hda_verb stac927x_volknob_core_init[] = {
967 /* don't set delta bit */
968 {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
969 /* enable analog pc beep path */
970 {0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
974 static const struct hda_verb stac9205_core_init[] = {
975 /* set master volume and direct control */
976 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
977 /* enable analog pc beep path */
978 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
982 #define STAC_MONO_MUX \
984 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
985 .name = "Mono Mux", \
987 .info = stac92xx_mono_mux_enum_info, \
988 .get = stac92xx_mono_mux_enum_get, \
989 .put = stac92xx_mono_mux_enum_put, \
992 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
994 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
995 .name = "Analog Loopback", \
997 .info = stac92xx_aloopback_info, \
998 .get = stac92xx_aloopback_get, \
999 .put = stac92xx_aloopback_put, \
1000 .private_value = verb_read | (verb_write << 16), \
1003 #define DC_BIAS(xname, idx, nid) \
1005 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1008 .info = stac92xx_dc_bias_info, \
1009 .get = stac92xx_dc_bias_get, \
1010 .put = stac92xx_dc_bias_put, \
1011 .private_value = nid, \
1014 static const struct snd_kcontrol_new stac9200_mixer[] = {
1015 HDA_CODEC_VOLUME_MIN_MUTE("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
1016 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
1017 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
1018 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
1022 static const struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
1023 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
1027 static const struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = {
1028 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1032 static const struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
1033 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1038 static const struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
1039 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
1042 static const struct snd_kcontrol_new stac925x_mixer[] = {
1043 HDA_CODEC_VOLUME_MIN_MUTE("Master Playback Volume", 0xe, 0, HDA_OUTPUT),
1044 HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
1048 static const struct snd_kcontrol_new stac9205_loopback[] = {
1049 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1053 static const struct snd_kcontrol_new stac927x_loopback[] = {
1054 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1058 static struct snd_kcontrol_new stac_dmux_mixer = {
1059 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1060 .name = "Digital Input Source",
1061 /* count set later */
1062 .info = stac92xx_dmux_enum_info,
1063 .get = stac92xx_dmux_enum_get,
1064 .put = stac92xx_dmux_enum_put,
1067 static struct snd_kcontrol_new stac_smux_mixer = {
1068 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1069 .name = "IEC958 Playback Source",
1070 /* count set later */
1071 .info = stac92xx_smux_enum_info,
1072 .get = stac92xx_smux_enum_get,
1073 .put = stac92xx_smux_enum_put,
1076 static const char * const slave_vols[] = {
1077 "Front Playback Volume",
1078 "Surround Playback Volume",
1079 "Center Playback Volume",
1080 "LFE Playback Volume",
1081 "Side Playback Volume",
1082 "Headphone Playback Volume",
1083 "Speaker Playback Volume",
1087 static const char * const slave_sws[] = {
1088 "Front Playback Switch",
1089 "Surround Playback Switch",
1090 "Center Playback Switch",
1091 "LFE Playback Switch",
1092 "Side Playback Switch",
1093 "Headphone Playback Switch",
1094 "Speaker Playback Switch",
1095 "IEC958 Playback Switch",
1099 static void stac92xx_free_kctls(struct hda_codec *codec);
1100 static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
1102 static int stac92xx_build_controls(struct hda_codec *codec)
1104 struct sigmatel_spec *spec = codec->spec;
1105 struct auto_pin_cfg *cfg = &spec->autocfg;
1111 err = snd_hda_add_new_ctls(codec, spec->mixer);
1116 for (i = 0; i < spec->num_mixers; i++) {
1117 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1121 if (!spec->auto_mic && spec->num_dmuxes > 0 &&
1122 snd_hda_get_bool_hint(codec, "separate_dmux") == 1) {
1123 stac_dmux_mixer.count = spec->num_dmuxes;
1124 err = snd_hda_ctl_add(codec, 0,
1125 snd_ctl_new1(&stac_dmux_mixer, codec));
1129 if (spec->num_smuxes > 0) {
1130 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1131 struct hda_input_mux *smux = &spec->private_smux;
1132 /* check for mute support on SPDIF out */
1133 if (wcaps & AC_WCAP_OUT_AMP) {
1134 snd_hda_add_imux_item(smux, "Off", 0, NULL);
1135 spec->spdif_mute = 1;
1137 stac_smux_mixer.count = spec->num_smuxes;
1138 err = snd_hda_ctl_add(codec, 0,
1139 snd_ctl_new1(&stac_smux_mixer, codec));
1144 if (spec->multiout.dig_out_nid) {
1145 err = snd_hda_create_spdif_out_ctls(codec,
1146 spec->multiout.dig_out_nid,
1147 spec->multiout.dig_out_nid);
1150 err = snd_hda_create_spdif_share_sw(codec,
1154 spec->multiout.share_spdif = 1;
1156 if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1157 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1162 /* if we have no master control, let's create it */
1163 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1164 unsigned int vmaster_tlv[4];
1165 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1166 HDA_OUTPUT, vmaster_tlv);
1167 /* correct volume offset */
1168 vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
1169 /* minimum value is actually mute */
1170 vmaster_tlv[3] |= TLV_DB_SCALE_MUTE;
1171 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1172 vmaster_tlv, slave_vols);
1176 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1177 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
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 /* create jack input elements */
1193 if (spec->hp_detect) {
1194 for (i = 0; i < cfg->hp_outs; i++) {
1195 int type = SND_JACK_HEADPHONE;
1196 nid = cfg->hp_pins[i];
1197 /* jack detection */
1198 if (cfg->hp_outs == i)
1199 type |= SND_JACK_LINEOUT;
1200 err = stac92xx_add_jack(codec, nid, type);
1205 for (i = 0; i < cfg->line_outs; i++) {
1206 err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
1211 for (i = 0; i < cfg->num_inputs; i++) {
1212 nid = cfg->inputs[i].pin;
1213 err = stac92xx_add_jack(codec, nid, SND_JACK_MICROPHONE);
1221 static const unsigned int ref9200_pin_configs[8] = {
1222 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1223 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1226 static const unsigned int gateway9200_m4_pin_configs[8] = {
1227 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1228 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1230 static const unsigned int gateway9200_m4_2_pin_configs[8] = {
1231 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1232 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1236 STAC 9200 pin configs for
1241 static const unsigned int dell9200_d21_pin_configs[8] = {
1242 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
1243 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1247 STAC 9200 pin configs for
1251 static const unsigned int dell9200_d22_pin_configs[8] = {
1252 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1253 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1257 STAC 9200 pin configs for
1258 102801C4 (Dell Dimension E310)
1265 static const unsigned int dell9200_d23_pin_configs[8] = {
1266 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1267 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
1272 STAC 9200-32 pin configs for
1273 102801B5 (Dell Inspiron 630m)
1274 102801D8 (Dell Inspiron 640m)
1276 static const unsigned int dell9200_m21_pin_configs[8] = {
1277 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1278 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1282 STAC 9200-32 pin configs for
1283 102801C2 (Dell Latitude D620)
1285 102801CC (Dell Latitude D820)
1289 static const unsigned int dell9200_m22_pin_configs[8] = {
1290 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1291 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1295 STAC 9200-32 pin configs for
1296 102801CE (Dell XPS M1710)
1297 102801CF (Dell Precision M90)
1299 static const unsigned int dell9200_m23_pin_configs[8] = {
1300 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1301 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1305 STAC 9200-32 pin configs for
1308 102801CB (Dell Latitude 120L)
1311 static const unsigned int dell9200_m24_pin_configs[8] = {
1312 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1313 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1317 STAC 9200-32 pin configs for
1318 102801BD (Dell Inspiron E1505n)
1322 static const unsigned int dell9200_m25_pin_configs[8] = {
1323 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1324 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1328 STAC 9200-32 pin configs for
1329 102801F5 (Dell Inspiron 1501)
1332 static const unsigned int dell9200_m26_pin_configs[8] = {
1333 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1334 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1339 102801CD (Dell Inspiron E1705/9400)
1341 static const unsigned int dell9200_m27_pin_configs[8] = {
1342 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1343 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1346 static const unsigned int oqo9200_pin_configs[8] = {
1347 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1348 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1352 static const unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1353 [STAC_REF] = ref9200_pin_configs,
1354 [STAC_9200_OQO] = oqo9200_pin_configs,
1355 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1356 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1357 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1358 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1359 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1360 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1361 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1362 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1363 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1364 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1365 [STAC_9200_M4] = gateway9200_m4_pin_configs,
1366 [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1367 [STAC_9200_PANASONIC] = ref9200_pin_configs,
1370 static const char * const stac9200_models[STAC_9200_MODELS] = {
1371 [STAC_AUTO] = "auto",
1373 [STAC_9200_OQO] = "oqo",
1374 [STAC_9200_DELL_D21] = "dell-d21",
1375 [STAC_9200_DELL_D22] = "dell-d22",
1376 [STAC_9200_DELL_D23] = "dell-d23",
1377 [STAC_9200_DELL_M21] = "dell-m21",
1378 [STAC_9200_DELL_M22] = "dell-m22",
1379 [STAC_9200_DELL_M23] = "dell-m23",
1380 [STAC_9200_DELL_M24] = "dell-m24",
1381 [STAC_9200_DELL_M25] = "dell-m25",
1382 [STAC_9200_DELL_M26] = "dell-m26",
1383 [STAC_9200_DELL_M27] = "dell-m27",
1384 [STAC_9200_M4] = "gateway-m4",
1385 [STAC_9200_M4_2] = "gateway-m4-2",
1386 [STAC_9200_PANASONIC] = "panasonic",
1389 static const struct snd_pci_quirk stac9200_cfg_tbl[] = {
1390 /* SigmaTel reference board */
1391 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1392 "DFI LanParty", STAC_REF),
1393 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1394 "DFI LanParty", STAC_REF),
1395 /* Dell laptops have BIOS problem */
1396 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1397 "unknown Dell", STAC_9200_DELL_D21),
1398 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1399 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1400 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1401 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1402 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1403 "unknown Dell", STAC_9200_DELL_D22),
1404 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1405 "unknown Dell", STAC_9200_DELL_D22),
1406 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1407 "Dell Latitude D620", STAC_9200_DELL_M22),
1408 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1409 "unknown Dell", STAC_9200_DELL_D23),
1410 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1411 "unknown Dell", STAC_9200_DELL_D23),
1412 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1413 "unknown Dell", STAC_9200_DELL_M22),
1414 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1415 "unknown Dell", STAC_9200_DELL_M24),
1416 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1417 "unknown Dell", STAC_9200_DELL_M24),
1418 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1419 "Dell Latitude 120L", STAC_9200_DELL_M24),
1420 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1421 "Dell Latitude D820", STAC_9200_DELL_M22),
1422 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1423 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1424 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1425 "Dell XPS M1710", STAC_9200_DELL_M23),
1426 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1427 "Dell Precision M90", STAC_9200_DELL_M23),
1428 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1429 "unknown Dell", STAC_9200_DELL_M22),
1430 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1431 "unknown Dell", STAC_9200_DELL_M22),
1432 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1433 "unknown Dell", STAC_9200_DELL_M22),
1434 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1435 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1436 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1437 "unknown Dell", STAC_9200_DELL_D23),
1438 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1439 "unknown Dell", STAC_9200_DELL_D23),
1440 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1441 "unknown Dell", STAC_9200_DELL_D21),
1442 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1443 "unknown Dell", STAC_9200_DELL_D23),
1444 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1445 "unknown Dell", STAC_9200_DELL_D21),
1446 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1447 "unknown Dell", STAC_9200_DELL_M25),
1448 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1449 "unknown Dell", STAC_9200_DELL_M25),
1450 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1451 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1452 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1453 "unknown Dell", STAC_9200_DELL_M26),
1455 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1456 /* Gateway machines needs EAPD to be set on resume */
1457 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1458 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1459 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1461 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1465 static const unsigned int ref925x_pin_configs[8] = {
1466 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1467 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1470 static const unsigned int stac925xM1_pin_configs[8] = {
1471 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1472 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1475 static const unsigned int stac925xM1_2_pin_configs[8] = {
1476 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1477 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1480 static const unsigned int stac925xM2_pin_configs[8] = {
1481 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1482 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1485 static const unsigned int stac925xM2_2_pin_configs[8] = {
1486 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1487 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1490 static const unsigned int stac925xM3_pin_configs[8] = {
1491 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1492 0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1495 static const unsigned int stac925xM5_pin_configs[8] = {
1496 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1497 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1500 static const unsigned int stac925xM6_pin_configs[8] = {
1501 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1502 0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1505 static const unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1506 [STAC_REF] = ref925x_pin_configs,
1507 [STAC_M1] = stac925xM1_pin_configs,
1508 [STAC_M1_2] = stac925xM1_2_pin_configs,
1509 [STAC_M2] = stac925xM2_pin_configs,
1510 [STAC_M2_2] = stac925xM2_2_pin_configs,
1511 [STAC_M3] = stac925xM3_pin_configs,
1512 [STAC_M5] = stac925xM5_pin_configs,
1513 [STAC_M6] = stac925xM6_pin_configs,
1516 static const char * const stac925x_models[STAC_925x_MODELS] = {
1517 [STAC_925x_AUTO] = "auto",
1520 [STAC_M1_2] = "m1-2",
1522 [STAC_M2_2] = "m2-2",
1528 static const struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1529 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1530 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1531 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1532 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1533 SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1534 /* Not sure about the brand name for those */
1535 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1536 SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1537 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1538 SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1542 static const struct snd_pci_quirk stac925x_cfg_tbl[] = {
1543 /* SigmaTel reference board */
1544 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1545 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
1546 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1548 /* Default table for unknown ID */
1549 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1554 static const unsigned int ref92hd73xx_pin_configs[13] = {
1555 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1556 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1557 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1561 static const unsigned int dell_m6_pin_configs[13] = {
1562 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1563 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1564 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1568 static const unsigned int alienware_m17x_pin_configs[13] = {
1569 0x0321101f, 0x0321101f, 0x03a11020, 0x03014020,
1570 0x90170110, 0x4f0000f0, 0x4f0000f0, 0x4f0000f0,
1571 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1575 static const unsigned int intel_dg45id_pin_configs[13] = {
1576 0x02214230, 0x02A19240, 0x01013214, 0x01014210,
1577 0x01A19250, 0x01011212, 0x01016211
1580 static const unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1581 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1582 [STAC_DELL_M6_AMIC] = dell_m6_pin_configs,
1583 [STAC_DELL_M6_DMIC] = dell_m6_pin_configs,
1584 [STAC_DELL_M6_BOTH] = dell_m6_pin_configs,
1585 [STAC_DELL_EQ] = dell_m6_pin_configs,
1586 [STAC_ALIENWARE_M17X] = alienware_m17x_pin_configs,
1587 [STAC_92HD73XX_INTEL] = intel_dg45id_pin_configs,
1590 static const char * const stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1591 [STAC_92HD73XX_AUTO] = "auto",
1592 [STAC_92HD73XX_NO_JD] = "no-jd",
1593 [STAC_92HD73XX_REF] = "ref",
1594 [STAC_92HD73XX_INTEL] = "intel",
1595 [STAC_DELL_M6_AMIC] = "dell-m6-amic",
1596 [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1597 [STAC_DELL_M6_BOTH] = "dell-m6",
1598 [STAC_DELL_EQ] = "dell-eq",
1599 [STAC_ALIENWARE_M17X] = "alienware",
1602 static const struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1603 /* SigmaTel reference board */
1604 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1605 "DFI LanParty", STAC_92HD73XX_REF),
1606 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1607 "DFI LanParty", STAC_92HD73XX_REF),
1608 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
1609 "Intel DG45ID", STAC_92HD73XX_INTEL),
1610 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
1611 "Intel DG45FC", STAC_92HD73XX_INTEL),
1612 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1613 "Dell Studio 1535", STAC_DELL_M6_DMIC),
1614 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1615 "unknown Dell", STAC_DELL_M6_DMIC),
1616 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1617 "unknown Dell", STAC_DELL_M6_BOTH),
1618 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1619 "unknown Dell", STAC_DELL_M6_BOTH),
1620 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1621 "unknown Dell", STAC_DELL_M6_AMIC),
1622 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1623 "unknown Dell", STAC_DELL_M6_AMIC),
1624 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1625 "unknown Dell", STAC_DELL_M6_DMIC),
1626 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1627 "unknown Dell", STAC_DELL_M6_DMIC),
1628 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1629 "Dell Studio 1537", STAC_DELL_M6_DMIC),
1630 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1631 "Dell Studio 17", STAC_DELL_M6_DMIC),
1632 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
1633 "Dell Studio 1555", STAC_DELL_M6_DMIC),
1634 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd,
1635 "Dell Studio 1557", STAC_DELL_M6_DMIC),
1636 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe,
1637 "Dell Studio XPS 1645", STAC_DELL_M6_BOTH),
1638 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413,
1639 "Dell Studio 1558", STAC_DELL_M6_DMIC),
1643 static const struct snd_pci_quirk stac92hd73xx_codec_id_cfg_tbl[] = {
1644 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1,
1645 "Alienware M17x", STAC_ALIENWARE_M17X),
1646 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x043a,
1647 "Alienware M17x", STAC_ALIENWARE_M17X),
1651 static const unsigned int ref92hd83xxx_pin_configs[10] = {
1652 0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1653 0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1654 0x01451160, 0x98560170,
1657 static const unsigned int dell_s14_pin_configs[10] = {
1658 0x0221403f, 0x0221101f, 0x02a19020, 0x90170110,
1659 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a60160,
1660 0x40f000f0, 0x40f000f0,
1663 static const unsigned int dell_vostro_3500_pin_configs[10] = {
1664 0x02a11020, 0x0221101f, 0x400000f0, 0x90170110,
1665 0x400000f1, 0x400000f2, 0x400000f3, 0x90a60160,
1666 0x400000f4, 0x400000f5,
1669 static const unsigned int hp_dv7_4000_pin_configs[10] = {
1670 0x03a12050, 0x0321201f, 0x40f000f0, 0x90170110,
1671 0x40f000f0, 0x40f000f0, 0x90170110, 0xd5a30140,
1672 0x40f000f0, 0x40f000f0,
1675 static const unsigned int hp_cNB11_intquad_pin_configs[10] = {
1676 0x40f000f0, 0x0221101f, 0x02a11020, 0x92170110,
1677 0x40f000f0, 0x92170110, 0x40f000f0, 0xd5a30130,
1678 0x40f000f0, 0x40f000f0,
1681 static const unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1682 [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1683 [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
1684 [STAC_DELL_S14] = dell_s14_pin_configs,
1685 [STAC_DELL_VOSTRO_3500] = dell_vostro_3500_pin_configs,
1686 [STAC_92HD83XXX_HP_cNB11_INTQUAD] = hp_cNB11_intquad_pin_configs,
1687 [STAC_HP_DV7_4000] = hp_dv7_4000_pin_configs,
1690 static const char * const stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1691 [STAC_92HD83XXX_AUTO] = "auto",
1692 [STAC_92HD83XXX_REF] = "ref",
1693 [STAC_92HD83XXX_PWR_REF] = "mic-ref",
1694 [STAC_DELL_S14] = "dell-s14",
1695 [STAC_DELL_VOSTRO_3500] = "dell-vostro-3500",
1696 [STAC_92HD83XXX_HP] = "hp",
1697 [STAC_92HD83XXX_HP_cNB11_INTQUAD] = "hp_cNB11_intquad",
1698 [STAC_HP_DV7_4000] = "hp-dv7-4000",
1701 static const struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1702 /* SigmaTel reference board */
1703 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1704 "DFI LanParty", STAC_92HD83XXX_REF),
1705 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1706 "DFI LanParty", STAC_92HD83XXX_REF),
1707 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
1708 "unknown Dell", STAC_DELL_S14),
1709 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x1028,
1710 "Dell Vostro 3500", STAC_DELL_VOSTRO_3500),
1711 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x3600,
1712 "HP", STAC_92HD83XXX_HP),
1713 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1656,
1714 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1715 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1657,
1716 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1717 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1658,
1718 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1719 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1659,
1720 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1721 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x165A,
1722 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1723 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x165B,
1724 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1725 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3388,
1726 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1727 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3389,
1728 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1729 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355B,
1730 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1731 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355C,
1732 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1733 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355D,
1734 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1735 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355E,
1736 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1737 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355F,
1738 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1739 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3560,
1740 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1741 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358B,
1742 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1743 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358C,
1744 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1745 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358D,
1746 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1747 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3591,
1748 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1749 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3592,
1750 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1751 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3593,
1752 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1756 static const unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1757 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1758 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1759 0x90a000f0, 0x01452050, 0x01452050, 0x00000000,
1763 static const unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1764 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1765 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1766 0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000,
1770 static const unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1771 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1772 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1773 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1777 static const unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1778 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1779 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1780 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1784 static const unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1785 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1786 [STAC_DELL_M4_1] = dell_m4_1_pin_configs,
1787 [STAC_DELL_M4_2] = dell_m4_2_pin_configs,
1788 [STAC_DELL_M4_3] = dell_m4_3_pin_configs,
1789 [STAC_HP_M4] = NULL,
1790 [STAC_HP_DV4] = NULL,
1791 [STAC_HP_DV5] = NULL,
1792 [STAC_HP_HDX] = NULL,
1793 [STAC_HP_DV4_1222NR] = NULL,
1796 static const char * const stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1797 [STAC_92HD71BXX_AUTO] = "auto",
1798 [STAC_92HD71BXX_REF] = "ref",
1799 [STAC_DELL_M4_1] = "dell-m4-1",
1800 [STAC_DELL_M4_2] = "dell-m4-2",
1801 [STAC_DELL_M4_3] = "dell-m4-3",
1802 [STAC_HP_M4] = "hp-m4",
1803 [STAC_HP_DV4] = "hp-dv4",
1804 [STAC_HP_DV5] = "hp-dv5",
1805 [STAC_HP_HDX] = "hp-hdx",
1806 [STAC_HP_DV4_1222NR] = "hp-dv4-1222nr",
1809 static const struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1810 /* SigmaTel reference board */
1811 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1812 "DFI LanParty", STAC_92HD71BXX_REF),
1813 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1814 "DFI LanParty", STAC_92HD71BXX_REF),
1815 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb,
1816 "HP dv4-1222nr", STAC_HP_DV4_1222NR),
1817 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720,
1819 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
1821 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
1822 "HP dv4-7", STAC_HP_DV4),
1823 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
1824 "HP dv4-7", STAC_HP_DV5),
1825 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
1826 "HP HDX", STAC_HP_HDX), /* HDX18 */
1827 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1828 "HP mini 1000", STAC_HP_M4),
1829 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
1830 "HP HDX", STAC_HP_HDX), /* HDX16 */
1831 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
1832 "HP dv6", STAC_HP_DV5),
1833 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061,
1834 "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */
1835 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x363e,
1836 "HP DV6", STAC_HP_DV5),
1837 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
1839 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1840 "unknown Dell", STAC_DELL_M4_1),
1841 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1842 "unknown Dell", STAC_DELL_M4_1),
1843 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1844 "unknown Dell", STAC_DELL_M4_1),
1845 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1846 "unknown Dell", STAC_DELL_M4_1),
1847 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1848 "unknown Dell", STAC_DELL_M4_1),
1849 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1850 "unknown Dell", STAC_DELL_M4_1),
1851 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1852 "unknown Dell", STAC_DELL_M4_1),
1853 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1854 "unknown Dell", STAC_DELL_M4_2),
1855 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1856 "unknown Dell", STAC_DELL_M4_2),
1857 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1858 "unknown Dell", STAC_DELL_M4_2),
1859 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1860 "unknown Dell", STAC_DELL_M4_2),
1861 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1862 "unknown Dell", STAC_DELL_M4_3),
1866 static const unsigned int ref922x_pin_configs[10] = {
1867 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1868 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1869 0x40000100, 0x40000100,
1873 STAC 922X pin configs for
1880 static const unsigned int dell_922x_d81_pin_configs[10] = {
1881 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1882 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1883 0x01813122, 0x400001f2,
1887 STAC 922X pin configs for
1891 static const unsigned int dell_922x_d82_pin_configs[10] = {
1892 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1893 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1894 0x01813122, 0x400001f1,
1898 STAC 922X pin configs for
1901 static const unsigned int dell_922x_m81_pin_configs[10] = {
1902 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1903 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1904 0x40C003f1, 0x405003f0,
1908 STAC 9221 A1 pin configs for
1909 102801D7 (Dell XPS M1210)
1911 static const unsigned int dell_922x_m82_pin_configs[10] = {
1912 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1913 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1914 0x508003f3, 0x405003f4,
1917 static const unsigned int d945gtp3_pin_configs[10] = {
1918 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1919 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1920 0x02a19120, 0x40000100,
1923 static const unsigned int d945gtp5_pin_configs[10] = {
1924 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1925 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1926 0x02a19320, 0x40000100,
1929 static const unsigned int intel_mac_v1_pin_configs[10] = {
1930 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1931 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1932 0x400000fc, 0x400000fb,
1935 static const unsigned int intel_mac_v2_pin_configs[10] = {
1936 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1937 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1938 0x400000fc, 0x400000fb,
1941 static const unsigned int intel_mac_v3_pin_configs[10] = {
1942 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1943 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1944 0x400000fc, 0x400000fb,
1947 static const unsigned int intel_mac_v4_pin_configs[10] = {
1948 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1949 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1950 0x400000fc, 0x400000fb,
1953 static const unsigned int intel_mac_v5_pin_configs[10] = {
1954 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1955 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1956 0x400000fc, 0x400000fb,
1959 static const unsigned int ecs202_pin_configs[10] = {
1960 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1961 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1962 0x9037012e, 0x40e000f2,
1965 static const unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1966 [STAC_D945_REF] = ref922x_pin_configs,
1967 [STAC_D945GTP3] = d945gtp3_pin_configs,
1968 [STAC_D945GTP5] = d945gtp5_pin_configs,
1969 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1970 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1971 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1972 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1973 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1974 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1975 /* for backward compatibility */
1976 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1977 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1978 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1979 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1980 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1981 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1982 [STAC_ECS_202] = ecs202_pin_configs,
1983 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1984 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1985 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1986 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1989 static const char * const stac922x_models[STAC_922X_MODELS] = {
1990 [STAC_922X_AUTO] = "auto",
1991 [STAC_D945_REF] = "ref",
1992 [STAC_D945GTP5] = "5stack",
1993 [STAC_D945GTP3] = "3stack",
1994 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1995 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1996 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1997 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1998 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1999 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
2000 /* for backward compatibility */
2001 [STAC_MACMINI] = "macmini",
2002 [STAC_MACBOOK] = "macbook",
2003 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
2004 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
2005 [STAC_IMAC_INTEL] = "imac-intel",
2006 [STAC_IMAC_INTEL_20] = "imac-intel-20",
2007 [STAC_ECS_202] = "ecs202",
2008 [STAC_922X_DELL_D81] = "dell-d81",
2009 [STAC_922X_DELL_D82] = "dell-d82",
2010 [STAC_922X_DELL_M81] = "dell-m81",
2011 [STAC_922X_DELL_M82] = "dell-m82",
2014 static const struct snd_pci_quirk stac922x_cfg_tbl[] = {
2015 /* SigmaTel reference board */
2016 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2017 "DFI LanParty", STAC_D945_REF),
2018 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2019 "DFI LanParty", STAC_D945_REF),
2020 /* Intel 945G based systems */
2021 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
2022 "Intel D945G", STAC_D945GTP3),
2023 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
2024 "Intel D945G", STAC_D945GTP3),
2025 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
2026 "Intel D945G", STAC_D945GTP3),
2027 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
2028 "Intel D945G", STAC_D945GTP3),
2029 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
2030 "Intel D945G", STAC_D945GTP3),
2031 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
2032 "Intel D945G", STAC_D945GTP3),
2033 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
2034 "Intel D945G", STAC_D945GTP3),
2035 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
2036 "Intel D945G", STAC_D945GTP3),
2037 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
2038 "Intel D945G", STAC_D945GTP3),
2039 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
2040 "Intel D945G", STAC_D945GTP3),
2041 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
2042 "Intel D945G", STAC_D945GTP3),
2043 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
2044 "Intel D945G", STAC_D945GTP3),
2045 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
2046 "Intel D945G", STAC_D945GTP3),
2047 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
2048 "Intel D945G", STAC_D945GTP3),
2049 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
2050 "Intel D945G", STAC_D945GTP3),
2051 /* Intel D945G 5-stack systems */
2052 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
2053 "Intel D945G", STAC_D945GTP5),
2054 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
2055 "Intel D945G", STAC_D945GTP5),
2056 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
2057 "Intel D945G", STAC_D945GTP5),
2058 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
2059 "Intel D945G", STAC_D945GTP5),
2060 /* Intel 945P based systems */
2061 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
2062 "Intel D945P", STAC_D945GTP3),
2063 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
2064 "Intel D945P", STAC_D945GTP3),
2065 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
2066 "Intel D945P", STAC_D945GTP3),
2067 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
2068 "Intel D945P", STAC_D945GTP3),
2069 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
2070 "Intel D945P", STAC_D945GTP3),
2071 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
2072 "Intel D945P", STAC_D945GTP5),
2074 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
2075 "Intel D945", STAC_D945_REF),
2077 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
2078 SND_PCI_QUIRK(0x8384, 0x7680,
2079 "Mac", STAC_INTEL_MAC_AUTO),
2081 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
2082 "unknown Dell", STAC_922X_DELL_D81),
2083 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
2084 "unknown Dell", STAC_922X_DELL_D81),
2085 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
2086 "unknown Dell", STAC_922X_DELL_D81),
2087 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
2088 "unknown Dell", STAC_922X_DELL_D82),
2089 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
2090 "unknown Dell", STAC_922X_DELL_M81),
2091 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
2092 "unknown Dell", STAC_922X_DELL_D82),
2093 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
2094 "unknown Dell", STAC_922X_DELL_D81),
2095 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
2096 "unknown Dell", STAC_922X_DELL_D81),
2097 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
2098 "Dell XPS M1210", STAC_922X_DELL_M82),
2099 /* ECS/PC Chips boards */
2100 SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
2101 "ECS/PC chips", STAC_ECS_202),
2105 static const unsigned int ref927x_pin_configs[14] = {
2106 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2107 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
2108 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2109 0x01c42190, 0x40000100,
2112 static const unsigned int d965_3st_pin_configs[14] = {
2113 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2114 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2115 0x40000100, 0x40000100, 0x40000100, 0x40000100,
2116 0x40000100, 0x40000100
2119 static const unsigned int d965_5st_pin_configs[14] = {
2120 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2121 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2122 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2123 0x40000100, 0x40000100
2126 static const unsigned int d965_5st_no_fp_pin_configs[14] = {
2127 0x40000100, 0x40000100, 0x0181304e, 0x01014010,
2128 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2129 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2130 0x40000100, 0x40000100
2133 static const unsigned int dell_3st_pin_configs[14] = {
2134 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2135 0x01111212, 0x01116211, 0x01813050, 0x01112214,
2136 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2137 0x40c003fc, 0x40000100
2140 static const unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2141 [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2142 [STAC_D965_REF] = ref927x_pin_configs,
2143 [STAC_D965_3ST] = d965_3st_pin_configs,
2144 [STAC_D965_5ST] = d965_5st_pin_configs,
2145 [STAC_D965_5ST_NO_FP] = d965_5st_no_fp_pin_configs,
2146 [STAC_DELL_3ST] = dell_3st_pin_configs,
2147 [STAC_DELL_BIOS] = NULL,
2148 [STAC_927X_VOLKNOB] = NULL,
2151 static const char * const stac927x_models[STAC_927X_MODELS] = {
2152 [STAC_927X_AUTO] = "auto",
2153 [STAC_D965_REF_NO_JD] = "ref-no-jd",
2154 [STAC_D965_REF] = "ref",
2155 [STAC_D965_3ST] = "3stack",
2156 [STAC_D965_5ST] = "5stack",
2157 [STAC_D965_5ST_NO_FP] = "5stack-no-fp",
2158 [STAC_DELL_3ST] = "dell-3stack",
2159 [STAC_DELL_BIOS] = "dell-bios",
2160 [STAC_927X_VOLKNOB] = "volknob",
2163 static const struct snd_pci_quirk stac927x_cfg_tbl[] = {
2164 /* SigmaTel reference board */
2165 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2166 "DFI LanParty", STAC_D965_REF),
2167 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2168 "DFI LanParty", STAC_D965_REF),
2169 /* Intel 946 based systems */
2170 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2171 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2172 /* 965 based 3 stack systems */
2173 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
2174 "Intel D965", STAC_D965_3ST),
2175 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
2176 "Intel D965", STAC_D965_3ST),
2177 /* Dell 3 stack systems */
2178 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2179 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
2180 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
2181 /* Dell 3 stack systems with verb table in BIOS */
2182 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2183 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_BIOS),
2184 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
2185 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
2186 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
2187 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
2188 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
2189 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
2190 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2191 /* 965 based 5 stack systems */
2192 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
2193 "Intel D965", STAC_D965_5ST),
2194 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
2195 "Intel D965", STAC_D965_5ST),
2196 /* volume-knob fixes */
2197 SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB),
2201 static const unsigned int ref9205_pin_configs[12] = {
2202 0x40000100, 0x40000100, 0x01016011, 0x01014010,
2203 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2204 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2208 STAC 9205 pin configs for
2215 10280228 (Dell Vostro 1500)
2216 10280229 (Dell Vostro 1700)
2218 static const unsigned int dell_9205_m42_pin_configs[12] = {
2219 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2220 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2221 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2225 STAC 9205 pin configs for
2229 102801FF (Dell Precision M4300)
2234 static const unsigned int dell_9205_m43_pin_configs[12] = {
2235 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2236 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2237 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2240 static const unsigned int dell_9205_m44_pin_configs[12] = {
2241 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2242 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2243 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2246 static const unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2247 [STAC_9205_REF] = ref9205_pin_configs,
2248 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2249 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2250 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2251 [STAC_9205_EAPD] = NULL,
2254 static const char * const stac9205_models[STAC_9205_MODELS] = {
2255 [STAC_9205_AUTO] = "auto",
2256 [STAC_9205_REF] = "ref",
2257 [STAC_9205_DELL_M42] = "dell-m42",
2258 [STAC_9205_DELL_M43] = "dell-m43",
2259 [STAC_9205_DELL_M44] = "dell-m44",
2260 [STAC_9205_EAPD] = "eapd",
2263 static const struct snd_pci_quirk stac9205_cfg_tbl[] = {
2264 /* SigmaTel reference board */
2265 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2266 "DFI LanParty", STAC_9205_REF),
2267 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
2268 "SigmaTel", STAC_9205_REF),
2269 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2270 "DFI LanParty", STAC_9205_REF),
2272 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2273 "unknown Dell", STAC_9205_DELL_M42),
2274 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2275 "unknown Dell", STAC_9205_DELL_M42),
2276 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2277 "Dell Precision", STAC_9205_DELL_M43),
2278 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2279 "Dell Precision", STAC_9205_DELL_M43),
2280 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2281 "Dell Precision", STAC_9205_DELL_M43),
2282 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2283 "unknown Dell", STAC_9205_DELL_M42),
2284 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2285 "unknown Dell", STAC_9205_DELL_M42),
2286 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2287 "Dell Precision", STAC_9205_DELL_M43),
2288 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2289 "Dell Precision M4300", STAC_9205_DELL_M43),
2290 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2291 "unknown Dell", STAC_9205_DELL_M42),
2292 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2293 "Dell Precision", STAC_9205_DELL_M43),
2294 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2295 "Dell Precision", STAC_9205_DELL_M43),
2296 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2297 "Dell Precision", STAC_9205_DELL_M43),
2298 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2299 "Dell Inspiron", STAC_9205_DELL_M44),
2300 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2301 "Dell Vostro 1500", STAC_9205_DELL_M42),
2302 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229,
2303 "Dell Vostro 1700", STAC_9205_DELL_M42),
2305 SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
2306 SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
2310 static void stac92xx_set_config_regs(struct hda_codec *codec,
2311 const unsigned int *pincfgs)
2314 struct sigmatel_spec *spec = codec->spec;
2319 for (i = 0; i < spec->num_pins; i++)
2320 if (spec->pin_nids[i] && pincfgs[i])
2321 snd_hda_codec_set_pincfg(codec, spec->pin_nids[i],
2326 * Analog playback callbacks
2328 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2329 struct hda_codec *codec,
2330 struct snd_pcm_substream *substream)
2332 struct sigmatel_spec *spec = codec->spec;
2333 if (spec->stream_delay)
2334 msleep(spec->stream_delay);
2335 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2339 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2340 struct hda_codec *codec,
2341 unsigned int stream_tag,
2342 unsigned int format,
2343 struct snd_pcm_substream *substream)
2345 struct sigmatel_spec *spec = codec->spec;
2346 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2349 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2350 struct hda_codec *codec,
2351 struct snd_pcm_substream *substream)
2353 struct sigmatel_spec *spec = codec->spec;
2354 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2358 * Digital playback callbacks
2360 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2361 struct hda_codec *codec,
2362 struct snd_pcm_substream *substream)
2364 struct sigmatel_spec *spec = codec->spec;
2365 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2368 static int stac92xx_dig_playback_pcm_close(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_dig_close(codec, &spec->multiout);
2376 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2377 struct hda_codec *codec,
2378 unsigned int stream_tag,
2379 unsigned int format,
2380 struct snd_pcm_substream *substream)
2382 struct sigmatel_spec *spec = codec->spec;
2383 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2384 stream_tag, format, substream);
2387 static int stac92xx_dig_playback_pcm_cleanup(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_cleanup(codec, &spec->multiout);
2397 * Analog capture callbacks
2399 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2400 struct hda_codec *codec,
2401 unsigned int stream_tag,
2402 unsigned int format,
2403 struct snd_pcm_substream *substream)
2405 struct sigmatel_spec *spec = codec->spec;
2406 hda_nid_t nid = spec->adc_nids[substream->number];
2408 if (spec->powerdown_adcs) {
2410 snd_hda_codec_write(codec, nid, 0,
2411 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2413 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2417 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2418 struct hda_codec *codec,
2419 struct snd_pcm_substream *substream)
2421 struct sigmatel_spec *spec = codec->spec;
2422 hda_nid_t nid = spec->adc_nids[substream->number];
2424 snd_hda_codec_cleanup_stream(codec, nid);
2425 if (spec->powerdown_adcs)
2426 snd_hda_codec_write(codec, nid, 0,
2427 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2431 static const struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2435 /* NID is set in stac92xx_build_pcms */
2437 .open = stac92xx_dig_playback_pcm_open,
2438 .close = stac92xx_dig_playback_pcm_close,
2439 .prepare = stac92xx_dig_playback_pcm_prepare,
2440 .cleanup = stac92xx_dig_playback_pcm_cleanup
2444 static const struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2448 /* NID is set in stac92xx_build_pcms */
2451 static const struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2455 .nid = 0x02, /* NID to query formats and rates */
2457 .open = stac92xx_playback_pcm_open,
2458 .prepare = stac92xx_playback_pcm_prepare,
2459 .cleanup = stac92xx_playback_pcm_cleanup
2463 static const struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2467 .nid = 0x06, /* NID to query formats and rates */
2469 .open = stac92xx_playback_pcm_open,
2470 .prepare = stac92xx_playback_pcm_prepare,
2471 .cleanup = stac92xx_playback_pcm_cleanup
2475 static const struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2478 /* NID + .substreams is set in stac92xx_build_pcms */
2480 .prepare = stac92xx_capture_pcm_prepare,
2481 .cleanup = stac92xx_capture_pcm_cleanup
2485 static int stac92xx_build_pcms(struct hda_codec *codec)
2487 struct sigmatel_spec *spec = codec->spec;
2488 struct hda_pcm *info = spec->pcm_rec;
2490 codec->num_pcms = 1;
2491 codec->pcm_info = info;
2493 info->name = "STAC92xx Analog";
2494 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2495 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2496 spec->multiout.dac_nids[0];
2497 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2498 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2499 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2501 if (spec->alt_switch) {
2504 info->name = "STAC92xx Analog Alt";
2505 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2508 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2511 info->name = "STAC92xx Digital";
2512 info->pcm_type = spec->autocfg.dig_out_type[0];
2513 if (spec->multiout.dig_out_nid) {
2514 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2515 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2517 if (spec->dig_in_nid) {
2518 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2519 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2526 static unsigned int stac92xx_get_default_vref(struct hda_codec *codec,
2529 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2530 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2531 if (pincap & AC_PINCAP_VREF_100)
2532 return AC_PINCTL_VREF_100;
2533 if (pincap & AC_PINCAP_VREF_80)
2534 return AC_PINCTL_VREF_80;
2535 if (pincap & AC_PINCAP_VREF_50)
2536 return AC_PINCTL_VREF_50;
2537 if (pincap & AC_PINCAP_VREF_GRD)
2538 return AC_PINCTL_VREF_GRD;
2542 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2545 snd_hda_codec_write_cache(codec, nid, 0,
2546 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2549 #define stac92xx_hp_switch_info snd_ctl_boolean_mono_info
2551 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2552 struct snd_ctl_elem_value *ucontrol)
2554 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2555 struct sigmatel_spec *spec = codec->spec;
2557 ucontrol->value.integer.value[0] = !!spec->hp_switch;
2561 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid);
2563 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2564 struct snd_ctl_elem_value *ucontrol)
2566 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2567 struct sigmatel_spec *spec = codec->spec;
2568 int nid = kcontrol->private_value;
2570 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2572 /* check to be sure that the ports are up to date with
2575 stac_issue_unsol_event(codec, nid);
2580 static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol,
2581 struct snd_ctl_elem_info *uinfo)
2584 static const char * const texts[] = {
2585 "Mic In", "Line In", "Line Out"
2588 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2589 struct sigmatel_spec *spec = codec->spec;
2590 hda_nid_t nid = kcontrol->private_value;
2592 if (nid == spec->mic_switch || nid == spec->line_switch)
2597 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2598 uinfo->value.enumerated.items = i;
2600 if (uinfo->value.enumerated.item >= i)
2601 uinfo->value.enumerated.item = i-1;
2602 strcpy(uinfo->value.enumerated.name,
2603 texts[uinfo->value.enumerated.item]);
2608 static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol,
2609 struct snd_ctl_elem_value *ucontrol)
2611 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2612 hda_nid_t nid = kcontrol->private_value;
2613 unsigned int vref = stac92xx_vref_get(codec, nid);
2615 if (vref == stac92xx_get_default_vref(codec, nid))
2616 ucontrol->value.enumerated.item[0] = 0;
2617 else if (vref == AC_PINCTL_VREF_GRD)
2618 ucontrol->value.enumerated.item[0] = 1;
2619 else if (vref == AC_PINCTL_VREF_HIZ)
2620 ucontrol->value.enumerated.item[0] = 2;
2625 static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol,
2626 struct snd_ctl_elem_value *ucontrol)
2628 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2629 unsigned int new_vref = 0;
2631 hda_nid_t nid = kcontrol->private_value;
2633 if (ucontrol->value.enumerated.item[0] == 0)
2634 new_vref = stac92xx_get_default_vref(codec, nid);
2635 else if (ucontrol->value.enumerated.item[0] == 1)
2636 new_vref = AC_PINCTL_VREF_GRD;
2637 else if (ucontrol->value.enumerated.item[0] == 2)
2638 new_vref = AC_PINCTL_VREF_HIZ;
2642 if (new_vref != stac92xx_vref_get(codec, nid)) {
2643 error = stac92xx_vref_set(codec, nid, new_vref);
2650 static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol,
2651 struct snd_ctl_elem_info *uinfo)
2654 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2655 struct sigmatel_spec *spec = codec->spec;
2657 if (kcontrol->private_value == spec->line_switch)
2658 texts[0] = "Line In";
2660 texts[0] = "Mic In";
2661 texts[1] = "Line Out";
2662 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2663 uinfo->value.enumerated.items = 2;
2666 if (uinfo->value.enumerated.item >= 2)
2667 uinfo->value.enumerated.item = 1;
2668 strcpy(uinfo->value.enumerated.name,
2669 texts[uinfo->value.enumerated.item]);
2674 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2676 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2677 struct sigmatel_spec *spec = codec->spec;
2678 hda_nid_t nid = kcontrol->private_value;
2679 int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2681 ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx];
2685 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2687 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2688 struct sigmatel_spec *spec = codec->spec;
2689 hda_nid_t nid = kcontrol->private_value;
2690 int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2691 unsigned short val = !!ucontrol->value.enumerated.item[0];
2693 spec->io_switch[io_idx] = val;
2696 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2698 unsigned int pinctl = AC_PINCTL_IN_EN;
2699 if (io_idx) /* set VREF for mic */
2700 pinctl |= stac92xx_get_default_vref(codec, nid);
2701 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2704 /* check the auto-mute again: we need to mute/unmute the speaker
2705 * appropriately according to the pin direction
2707 if (spec->hp_detect)
2708 stac_issue_unsol_event(codec, nid);
2713 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2715 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2716 struct snd_ctl_elem_value *ucontrol)
2718 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2719 struct sigmatel_spec *spec = codec->spec;
2721 ucontrol->value.integer.value[0] = spec->clfe_swap;
2725 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2726 struct snd_ctl_elem_value *ucontrol)
2728 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2729 struct sigmatel_spec *spec = codec->spec;
2730 hda_nid_t nid = kcontrol->private_value & 0xff;
2731 unsigned int val = !!ucontrol->value.integer.value[0];
2733 if (spec->clfe_swap == val)
2736 spec->clfe_swap = val;
2738 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2739 spec->clfe_swap ? 0x4 : 0x0);
2744 #define STAC_CODEC_HP_SWITCH(xname) \
2745 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2748 .info = stac92xx_hp_switch_info, \
2749 .get = stac92xx_hp_switch_get, \
2750 .put = stac92xx_hp_switch_put, \
2753 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2754 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2757 .info = stac92xx_io_switch_info, \
2758 .get = stac92xx_io_switch_get, \
2759 .put = stac92xx_io_switch_put, \
2760 .private_value = xpval, \
2763 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2764 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2767 .info = stac92xx_clfe_switch_info, \
2768 .get = stac92xx_clfe_switch_get, \
2769 .put = stac92xx_clfe_switch_put, \
2770 .private_value = xpval, \
2774 STAC_CTL_WIDGET_VOL,
2775 STAC_CTL_WIDGET_MUTE,
2776 STAC_CTL_WIDGET_MUTE_BEEP,
2777 STAC_CTL_WIDGET_MONO_MUX,
2778 STAC_CTL_WIDGET_HP_SWITCH,
2779 STAC_CTL_WIDGET_IO_SWITCH,
2780 STAC_CTL_WIDGET_CLFE_SWITCH,
2781 STAC_CTL_WIDGET_DC_BIAS
2784 static const struct snd_kcontrol_new stac92xx_control_templates[] = {
2785 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2786 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2787 HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0),
2789 STAC_CODEC_HP_SWITCH(NULL),
2790 STAC_CODEC_IO_SWITCH(NULL, 0),
2791 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2792 DC_BIAS(NULL, 0, 0),
2795 /* add dynamic controls */
2796 static struct snd_kcontrol_new *
2797 stac_control_new(struct sigmatel_spec *spec,
2798 const struct snd_kcontrol_new *ktemp,
2800 unsigned int subdev)
2802 struct snd_kcontrol_new *knew;
2804 snd_array_init(&spec->kctls, sizeof(*knew), 32);
2805 knew = snd_array_new(&spec->kctls);
2809 knew->name = kstrdup(name, GFP_KERNEL);
2812 memset(knew, 0, sizeof(*knew));
2813 spec->kctls.alloced--;
2816 knew->subdevice = subdev;
2820 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2821 const struct snd_kcontrol_new *ktemp,
2822 int idx, const char *name,
2825 struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name,
2826 HDA_SUBDEV_AMP_FLAG);
2830 knew->private_value = val;
2834 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2835 int type, int idx, const char *name,
2838 return stac92xx_add_control_temp(spec,
2839 &stac92xx_control_templates[type],
2844 /* add dynamic controls */
2845 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2846 const char *name, unsigned long val)
2848 return stac92xx_add_control_idx(spec, type, 0, name, val);
2851 static const struct snd_kcontrol_new stac_input_src_temp = {
2852 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2853 .name = "Input Source",
2854 .info = stac92xx_mux_enum_info,
2855 .get = stac92xx_mux_enum_get,
2856 .put = stac92xx_mux_enum_put,
2859 static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
2860 hda_nid_t nid, int idx)
2862 int def_conf = snd_hda_codec_get_pincfg(codec, nid);
2864 struct sigmatel_spec *spec = codec->spec;
2867 if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
2868 if (stac92xx_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
2869 && nid == spec->line_switch)
2870 control = STAC_CTL_WIDGET_IO_SWITCH;
2871 else if (snd_hda_query_pin_caps(codec, nid)
2872 & (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT))
2873 control = STAC_CTL_WIDGET_DC_BIAS;
2874 else if (nid == spec->mic_switch)
2875 control = STAC_CTL_WIDGET_IO_SWITCH;
2879 strcpy(name, hda_get_input_pin_label(codec, nid, 1));
2880 return stac92xx_add_control(codec->spec, control,
2881 strcat(name, " Jack Mode"), nid);
2887 static int stac92xx_add_input_source(struct sigmatel_spec *spec)
2889 struct snd_kcontrol_new *knew;
2890 struct hda_input_mux *imux = &spec->private_imux;
2893 return 0; /* no need for input source */
2894 if (!spec->num_adcs || imux->num_items <= 1)
2895 return 0; /* no need for input source control */
2896 knew = stac_control_new(spec, &stac_input_src_temp,
2897 stac_input_src_temp.name, 0);
2900 knew->count = spec->num_adcs;
2904 /* check whether the line-input can be used as line-out */
2905 static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2907 struct sigmatel_spec *spec = codec->spec;
2908 struct auto_pin_cfg *cfg = &spec->autocfg;
2910 unsigned int pincap;
2913 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2915 for (i = 0; i < cfg->num_inputs; i++) {
2916 if (cfg->inputs[i].type == AUTO_PIN_LINE_IN) {
2917 nid = cfg->inputs[i].pin;
2918 pincap = snd_hda_query_pin_caps(codec, nid);
2919 if (pincap & AC_PINCAP_OUT)
2926 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid);
2928 /* check whether the mic-input can be used as line-out */
2929 static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac)
2931 struct sigmatel_spec *spec = codec->spec;
2932 struct auto_pin_cfg *cfg = &spec->autocfg;
2933 unsigned int def_conf, pincap;
2937 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2939 for (i = 0; i < cfg->num_inputs; i++) {
2940 hda_nid_t nid = cfg->inputs[i].pin;
2941 if (cfg->inputs[i].type != AUTO_PIN_MIC)
2943 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2944 /* some laptops have an internal analog microphone
2945 * which can't be used as a output */
2946 if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
2947 pincap = snd_hda_query_pin_caps(codec, nid);
2948 if (pincap & AC_PINCAP_OUT) {
2949 *dac = get_unassigned_dac(codec, nid);
2958 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2962 for (i = 0; i < spec->multiout.num_dacs; i++) {
2963 if (spec->multiout.dac_nids[i] == nid)
2970 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2973 if (is_in_dac_nids(spec, nid))
2975 for (i = 0; i < spec->autocfg.hp_outs; i++)
2976 if (spec->hp_dacs[i] == nid)
2978 for (i = 0; i < spec->autocfg.speaker_outs; i++)
2979 if (spec->speaker_dacs[i] == nid)
2984 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2986 struct sigmatel_spec *spec = codec->spec;
2987 struct auto_pin_cfg *cfg = &spec->autocfg;
2989 hda_nid_t conn[HDA_MAX_CONNECTIONS], fallback_dac;
2990 unsigned int wcaps, wtype;
2992 conn_len = snd_hda_get_connections(codec, nid, conn,
2993 HDA_MAX_CONNECTIONS);
2994 /* 92HD88: trace back up the link of nids to find the DAC */
2995 while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0]))
2996 != AC_WID_AUD_OUT)) {
2998 conn_len = snd_hda_get_connections(codec, nid, conn,
2999 HDA_MAX_CONNECTIONS);
3001 for (j = 0; j < conn_len; j++) {
3002 wcaps = get_wcaps(codec, conn[j]);
3003 wtype = get_wcaps_type(wcaps);
3004 /* we check only analog outputs */
3005 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
3007 /* if this route has a free DAC, assign it */
3008 if (!check_all_dac_nids(spec, conn[j])) {
3010 /* select this DAC in the pin's input mux */
3011 snd_hda_codec_write_cache(codec, nid, 0,
3012 AC_VERB_SET_CONNECT_SEL, j);
3018 /* if all DACs are already assigned, connect to the primary DAC,
3019 unless we're assigning a secondary headphone */
3020 fallback_dac = spec->multiout.dac_nids[0];
3021 if (spec->multiout.hp_nid) {
3022 for (j = 0; j < cfg->hp_outs; j++)
3023 if (cfg->hp_pins[j] == nid) {
3024 fallback_dac = spec->multiout.hp_nid;
3030 for (j = 0; j < conn_len; j++) {
3031 if (conn[j] == fallback_dac) {
3032 snd_hda_codec_write_cache(codec, nid, 0,
3033 AC_VERB_SET_CONNECT_SEL, j);
3041 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
3042 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
3045 * Fill in the dac_nids table from the parsed pin configuration
3046 * This function only works when every pin in line_out_pins[]
3047 * contains atleast one DAC in its connection list. Some 92xx
3048 * codecs are not connected directly to a DAC, such as the 9200
3049 * and 9202/925x. For those, dac_nids[] must be hard-coded.
3051 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
3053 struct sigmatel_spec *spec = codec->spec;
3054 struct auto_pin_cfg *cfg = &spec->autocfg;
3058 for (i = 0; i < cfg->line_outs; i++) {
3059 nid = cfg->line_out_pins[i];
3060 dac = get_unassigned_dac(codec, nid);
3062 if (spec->multiout.num_dacs > 0) {
3063 /* we have already working output pins,
3064 * so let's drop the broken ones again
3066 cfg->line_outs = spec->multiout.num_dacs;
3069 /* error out, no available DAC found */
3071 "%s: No available DAC for pin 0x%x\n",
3075 add_spec_dacs(spec, dac);
3078 for (i = 0; i < cfg->hp_outs; i++) {
3079 nid = cfg->hp_pins[i];
3080 dac = get_unassigned_dac(codec, nid);
3082 if (!spec->multiout.hp_nid)
3083 spec->multiout.hp_nid = dac;
3085 add_spec_extra_dacs(spec, dac);
3087 spec->hp_dacs[i] = dac;
3090 for (i = 0; i < cfg->speaker_outs; i++) {
3091 nid = cfg->speaker_pins[i];
3092 dac = get_unassigned_dac(codec, nid);
3094 add_spec_extra_dacs(spec, dac);
3095 spec->speaker_dacs[i] = dac;
3098 /* add line-in as output */
3099 nid = check_line_out_switch(codec);
3101 dac = get_unassigned_dac(codec, nid);
3103 snd_printdd("STAC: Add line-in 0x%x as output %d\n",
3104 nid, cfg->line_outs);
3105 cfg->line_out_pins[cfg->line_outs] = nid;
3107 spec->line_switch = nid;
3108 add_spec_dacs(spec, dac);
3111 /* add mic as output */
3112 nid = check_mic_out_switch(codec, &dac);
3114 snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
3115 nid, cfg->line_outs);
3116 cfg->line_out_pins[cfg->line_outs] = nid;
3118 spec->mic_switch = nid;
3119 add_spec_dacs(spec, dac);
3122 snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3123 spec->multiout.num_dacs,
3124 spec->multiout.dac_nids[0],
3125 spec->multiout.dac_nids[1],
3126 spec->multiout.dac_nids[2],
3127 spec->multiout.dac_nids[3],
3128 spec->multiout.dac_nids[4]);
3133 /* create volume control/switch for the given prefx type */
3134 static int create_controls_idx(struct hda_codec *codec, const char *pfx,
3135 int idx, hda_nid_t nid, int chs)
3137 struct sigmatel_spec *spec = codec->spec;
3141 if (!spec->check_volume_offset) {
3142 unsigned int caps, step, nums, db_scale;
3143 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3144 step = (caps & AC_AMPCAP_STEP_SIZE) >>
3145 AC_AMPCAP_STEP_SIZE_SHIFT;
3146 step = (step + 1) * 25; /* in .01dB unit */
3147 nums = (caps & AC_AMPCAP_NUM_STEPS) >>
3148 AC_AMPCAP_NUM_STEPS_SHIFT;
3149 db_scale = nums * step;
3150 /* if dB scale is over -64dB, and finer enough,
3151 * let's reduce it to half
3153 if (db_scale > 6400 && nums >= 0x1f)
3154 spec->volume_offset = nums / 2;
3155 spec->check_volume_offset = 1;
3158 sprintf(name, "%s Playback Volume", pfx);
3159 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
3160 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3161 spec->volume_offset));
3164 sprintf(name, "%s Playback Switch", pfx);
3165 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
3166 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3172 #define create_controls(codec, pfx, nid, chs) \
3173 create_controls_idx(codec, pfx, 0, nid, chs)
3175 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3177 if (spec->multiout.num_dacs > 4) {
3178 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3181 snd_BUG_ON(spec->multiout.dac_nids != spec->dac_nids);
3182 spec->dac_nids[spec->multiout.num_dacs] = nid;
3183 spec->multiout.num_dacs++;
3188 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3191 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3192 if (!spec->multiout.extra_out_nid[i]) {
3193 spec->multiout.extra_out_nid[i] = nid;
3197 printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3201 /* Create output controls
3202 * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
3204 static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
3205 const hda_nid_t *pins,
3206 const hda_nid_t *dac_nids,
3209 struct sigmatel_spec *spec = codec->spec;
3210 static const char * const chname[4] = {
3211 "Front", "Surround", NULL /*CLFE*/, "Side"
3215 unsigned int wid_caps;
3217 for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
3218 if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3219 if (is_jack_detectable(codec, pins[i]))
3220 spec->hp_detect = 1;
3225 if (type != AUTO_PIN_HP_OUT && i == 2) {
3227 err = create_controls(codec, "Center", nid, 1);
3230 err = create_controls(codec, "LFE", nid, 2);
3234 wid_caps = get_wcaps(codec, nid);
3236 if (wid_caps & AC_WCAP_LR_SWAP) {
3237 err = stac92xx_add_control(spec,
3238 STAC_CTL_WIDGET_CLFE_SWITCH,
3239 "Swap Center/LFE Playback Switch", nid);
3249 case AUTO_PIN_HP_OUT:
3253 case AUTO_PIN_SPEAKER_OUT:
3262 err = create_controls_idx(codec, name, idx, nid, 3);
3270 static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol,
3271 unsigned long sw, int idx)
3274 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx,
3275 "Capture Volume", vol);
3278 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_MUTE, idx,
3279 "Capture Switch", sw);
3285 /* add playback controls from the parsed DAC table */
3286 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3287 const struct auto_pin_cfg *cfg)
3289 struct sigmatel_spec *spec = codec->spec;
3294 err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
3295 spec->multiout.dac_nids,
3296 cfg->line_out_type);
3300 if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3301 err = stac92xx_add_control(spec,
3302 STAC_CTL_WIDGET_HP_SWITCH,
3303 "Headphone as Line Out Switch",
3304 cfg->hp_pins[cfg->hp_outs - 1]);
3309 for (idx = 0; idx < cfg->num_inputs; idx++) {
3310 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3312 nid = cfg->inputs[idx].pin;
3313 err = stac92xx_add_jack_mode_control(codec, nid, idx);
3321 /* add playback controls for Speaker and HP outputs */
3322 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3323 struct auto_pin_cfg *cfg)
3325 struct sigmatel_spec *spec = codec->spec;
3328 err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
3329 spec->hp_dacs, AUTO_PIN_HP_OUT);
3333 err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
3334 spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
3341 /* labels for mono mux outputs */
3342 static const char * const stac92xx_mono_labels[4] = {
3343 "DAC0", "DAC1", "Mixer", "DAC2"
3346 /* create mono mux for mono out on capable codecs */
3347 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3349 struct sigmatel_spec *spec = codec->spec;
3350 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3352 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3354 num_cons = snd_hda_get_connections(codec,
3357 HDA_MAX_NUM_INPUTS);
3358 if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3361 for (i = 0; i < num_cons; i++)
3362 snd_hda_add_imux_item(mono_mux, stac92xx_mono_labels[i], i,
3365 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3366 "Mono Mux", spec->mono_nid);
3369 /* create PC beep volume controls */
3370 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3373 struct sigmatel_spec *spec = codec->spec;
3374 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3375 int err, type = STAC_CTL_WIDGET_MUTE_BEEP;
3377 if (spec->anabeep_nid == nid)
3378 type = STAC_CTL_WIDGET_MUTE;
3380 /* check for mute support for the the amp */
3381 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3382 err = stac92xx_add_control(spec, type,
3383 "Beep Playback Switch",
3384 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3389 /* check to see if there is volume support for the amp */
3390 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3391 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3392 "Beep Playback Volume",
3393 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3400 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3401 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3403 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3404 struct snd_ctl_elem_value *ucontrol)
3406 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3407 ucontrol->value.integer.value[0] = codec->beep->enabled;
3411 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3412 struct snd_ctl_elem_value *ucontrol)
3414 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3415 return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
3418 static const struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3419 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3420 .info = stac92xx_dig_beep_switch_info,
3421 .get = stac92xx_dig_beep_switch_get,
3422 .put = stac92xx_dig_beep_switch_put,
3425 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3427 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3428 0, "Beep Playback Switch", 0);
3432 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3434 struct sigmatel_spec *spec = codec->spec;
3437 for (i = 0; i < spec->num_muxes; i++) {
3442 nid = spec->mux_nids[i];
3443 wcaps = get_wcaps(codec, nid);
3444 if (!(wcaps & AC_WCAP_OUT_AMP))
3447 /* check whether already the same control was created as
3448 * normal Capture Volume.
3450 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3451 for (j = 0; j < spec->num_caps; j++) {
3452 if (spec->capvols[j] == val)
3455 if (j < spec->num_caps)
3458 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i,
3459 "Mux Capture Volume", val);
3466 static const char * const stac92xx_spdif_labels[3] = {
3467 "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3470 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3472 struct sigmatel_spec *spec = codec->spec;
3473 struct hda_input_mux *spdif_mux = &spec->private_smux;
3474 const char * const *labels = spec->spdif_labels;
3476 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3478 num_cons = snd_hda_get_connections(codec,
3481 HDA_MAX_NUM_INPUTS);
3486 labels = stac92xx_spdif_labels;
3488 for (i = 0; i < num_cons; i++)
3489 snd_hda_add_imux_item(spdif_mux, labels[i], i, NULL);
3494 /* labels for dmic mux inputs */
3495 static const char * const stac92xx_dmic_labels[5] = {
3496 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3497 "Digital Mic 3", "Digital Mic 4"
3500 static hda_nid_t get_connected_node(struct hda_codec *codec, hda_nid_t mux,
3503 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3505 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3506 if (idx >= 0 && idx < nums)
3511 /* look for NID recursively */
3512 #define get_connection_index(codec, mux, nid) \
3513 snd_hda_get_conn_index(codec, mux, nid, 1)
3515 /* create a volume assigned to the given pin (only if supported) */
3516 /* return 1 if the volume control is created */
3517 static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
3518 const char *label, int idx, int direction)
3520 unsigned int caps, nums;
3524 if (direction == HDA_OUTPUT)
3525 caps = AC_WCAP_OUT_AMP;
3527 caps = AC_WCAP_IN_AMP;
3528 if (!(get_wcaps(codec, nid) & caps))
3530 caps = query_amp_caps(codec, nid, direction);
3531 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
3534 snprintf(name, sizeof(name), "%s Capture Volume", label);
3535 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, name,
3536 HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction));
3542 /* create playback/capture controls for input pins on dmic capable codecs */
3543 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3544 const struct auto_pin_cfg *cfg)
3546 struct sigmatel_spec *spec = codec->spec;
3547 struct hda_input_mux *imux = &spec->private_imux;
3548 struct hda_input_mux *dimux = &spec->private_dimux;
3550 unsigned int def_conf;
3552 snd_hda_add_imux_item(dimux, stac92xx_dmic_labels[0], 0, NULL);
3554 for (i = 0; i < spec->num_dmics; i++) {
3556 int index, type_idx;
3559 nid = spec->dmic_nids[i];
3560 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
3562 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3563 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3566 index = get_connection_index(codec, spec->dmux_nids[0], nid);
3570 label = hda_get_input_pin_label(codec, nid, 1);
3571 snd_hda_add_imux_item(dimux, label, index, &type_idx);
3572 if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1)
3573 snd_hda_add_imux_item(imux, label, index, &type_idx);
3575 err = create_elem_capture_vol(codec, nid, label, type_idx,
3580 err = create_elem_capture_vol(codec, nid, label,
3581 type_idx, HDA_OUTPUT);
3585 nid = get_connected_node(codec,
3586 spec->dmux_nids[0], index);
3588 err = create_elem_capture_vol(codec,
3590 type_idx, HDA_INPUT);
3600 static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid,
3601 hda_nid_t *fixed, hda_nid_t *ext, hda_nid_t *dock)
3608 cfg = snd_hda_codec_get_pincfg(codec, nid);
3609 type = get_defcfg_device(cfg);
3610 switch (snd_hda_get_input_pin_attr(cfg)) {
3611 case INPUT_PIN_ATTR_INT:
3613 return 1; /* already occupied */
3614 if (type != AC_JACK_MIC_IN)
3615 return 1; /* invalid type */
3618 case INPUT_PIN_ATTR_UNUSED:
3620 case INPUT_PIN_ATTR_DOCK:
3622 return 1; /* already occupied */
3623 if (type != AC_JACK_MIC_IN && type != AC_JACK_LINE_IN)
3624 return 1; /* invalid type */
3629 return 1; /* already occupied */
3630 if (type != AC_JACK_MIC_IN)
3631 return 1; /* invalid type */
3638 static int set_mic_route(struct hda_codec *codec,
3639 struct sigmatel_mic_route *mic,
3642 struct sigmatel_spec *spec = codec->spec;
3643 struct auto_pin_cfg *cfg = &spec->autocfg;
3649 for (i = 0; i < cfg->num_inputs; i++) {
3650 if (pin == cfg->inputs[i].pin)
3653 if (i < cfg->num_inputs && cfg->inputs[i].type == AUTO_PIN_MIC) {
3655 i = get_connection_index(codec, spec->mux_nids[0], pin);
3660 if (spec->dmux_nids)
3661 mic->dmux_idx = get_connection_index(codec,
3664 } else if (spec->dmux_nids) {
3666 i = get_connection_index(codec, spec->dmux_nids[0], pin);
3672 mic->mux_idx = get_connection_index(codec,
3674 spec->dmux_nids[0]);
3679 /* return non-zero if the device is for automatic mic switch */
3680 static int stac_check_auto_mic(struct hda_codec *codec)
3682 struct sigmatel_spec *spec = codec->spec;
3683 struct auto_pin_cfg *cfg = &spec->autocfg;
3684 hda_nid_t fixed, ext, dock;
3687 fixed = ext = dock = 0;
3688 for (i = 0; i < cfg->num_inputs; i++)
3689 if (check_mic_pin(codec, cfg->inputs[i].pin,
3690 &fixed, &ext, &dock))
3692 for (i = 0; i < spec->num_dmics; i++)
3693 if (check_mic_pin(codec, spec->dmic_nids[i],
3694 &fixed, &ext, &dock))
3696 if (!fixed || (!ext && !dock))
3697 return 0; /* no input to switch */
3698 if (!is_jack_detectable(codec, ext))
3699 return 0; /* no unsol support */
3700 if (set_mic_route(codec, &spec->ext_mic, ext) ||
3701 set_mic_route(codec, &spec->int_mic, fixed) ||
3702 set_mic_route(codec, &spec->dock_mic, dock))
3703 return 0; /* something is wrong */
3707 /* create playback/capture controls for input pins */
3708 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3710 struct sigmatel_spec *spec = codec->spec;
3711 struct hda_input_mux *imux = &spec->private_imux;
3715 for (i = 0; i < cfg->num_inputs; i++) {
3716 hda_nid_t nid = cfg->inputs[i].pin;
3717 int index, err, type_idx;
3720 for (j = 0; j < spec->num_muxes; j++) {
3721 index = get_connection_index(codec, spec->mux_nids[j],
3729 label = hda_get_autocfg_input_label(codec, cfg, i);
3730 snd_hda_add_imux_item(imux, label, index, &type_idx);
3732 err = create_elem_capture_vol(codec, nid,
3738 spec->num_analog_muxes = imux->num_items;
3740 if (imux->num_items) {
3742 * Set the current input for the muxes.
3743 * The STAC9221 has two input muxes with identical source
3744 * NID lists. Hopefully this won't get confused.
3746 for (i = 0; i < spec->num_muxes; i++) {
3747 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3748 AC_VERB_SET_CONNECT_SEL,
3749 imux->items[0].index);
3756 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3758 struct sigmatel_spec *spec = codec->spec;
3761 for (i = 0; i < spec->autocfg.line_outs; i++) {
3762 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3763 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3767 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3769 struct sigmatel_spec *spec = codec->spec;
3772 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3774 pin = spec->autocfg.hp_pins[i];
3775 if (pin) /* connect to front */
3776 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3778 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3780 pin = spec->autocfg.speaker_pins[i];
3781 if (pin) /* connect to front */
3782 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3786 static int is_dual_headphones(struct hda_codec *codec)
3788 struct sigmatel_spec *spec = codec->spec;
3791 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT ||
3792 spec->autocfg.hp_outs <= 1)
3795 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3796 hda_nid_t nid = spec->autocfg.hp_pins[i];
3797 unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid);
3798 if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE)
3802 return (valid_hps > 1);
3806 static int stac92xx_parse_auto_config(struct hda_codec *codec)
3808 struct sigmatel_spec *spec = codec->spec;
3809 hda_nid_t dig_out = 0, dig_in = 0;
3813 if ((err = snd_hda_parse_pin_def_config(codec,
3815 spec->dmic_nids)) < 0)
3817 if (! spec->autocfg.line_outs)
3818 return 0; /* can't find valid pin config */
3820 /* If we have no real line-out pin and multiple hp-outs, HPs should
3821 * be set up as multi-channel outputs.
3823 if (is_dual_headphones(codec)) {
3824 /* Copy hp_outs to line_outs, backup line_outs in
3825 * speaker_outs so that the following routines can handle
3826 * HP pins as primary outputs.
3828 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3829 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3830 sizeof(spec->autocfg.line_out_pins));
3831 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3832 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3833 sizeof(spec->autocfg.hp_pins));
3834 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3835 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3836 spec->autocfg.hp_outs = 0;
3839 if (spec->autocfg.mono_out_pin) {
3840 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3841 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3842 u32 caps = query_amp_caps(codec,
3843 spec->autocfg.mono_out_pin, dir);
3844 hda_nid_t conn_list[1];
3846 /* get the mixer node and then the mono mux if it exists */
3847 if (snd_hda_get_connections(codec,
3848 spec->autocfg.mono_out_pin, conn_list, 1) &&
3849 snd_hda_get_connections(codec, conn_list[0],
3850 conn_list, 1) > 0) {
3852 int wcaps = get_wcaps(codec, conn_list[0]);
3853 int wid_type = get_wcaps_type(wcaps);
3854 /* LR swap check, some stac925x have a mux that
3855 * changes the DACs output path instead of the
3858 if (wid_type == AC_WID_AUD_SEL &&
3859 !(wcaps & AC_WCAP_LR_SWAP))
3860 spec->mono_nid = conn_list[0];
3863 hda_nid_t nid = spec->autocfg.mono_out_pin;
3865 /* most mono outs have a least a mute/unmute switch */
3866 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3867 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3868 "Mono Playback Switch",
3869 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3872 /* check for volume support for the amp */
3873 if ((caps & AC_AMPCAP_NUM_STEPS)
3874 >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3875 err = stac92xx_add_control(spec,
3876 STAC_CTL_WIDGET_VOL,
3877 "Mono Playback Volume",
3878 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3884 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3888 if (!spec->multiout.num_dacs) {
3889 err = stac92xx_auto_fill_dac_nids(codec);
3892 err = stac92xx_auto_create_multi_out_ctls(codec,
3898 /* setup analog beep controls */
3899 if (spec->anabeep_nid > 0) {
3900 err = stac92xx_auto_create_beep_ctls(codec,
3906 /* setup digital beep controls and input device */
3907 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3908 if (spec->digbeep_nid > 0) {
3909 hda_nid_t nid = spec->digbeep_nid;
3912 err = stac92xx_auto_create_beep_ctls(codec, nid);
3915 err = snd_hda_attach_beep_device(codec, nid);
3919 /* IDT/STAC codecs have linear beep tone parameter */
3920 codec->beep->linear_tone = spec->linear_tone_beep;
3921 /* if no beep switch is available, make its own one */
3922 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3923 if (!(caps & AC_AMPCAP_MUTE)) {
3924 err = stac92xx_beep_switch_ctl(codec);
3932 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3936 /* All output parsing done, now restore the swapped hp pins */
3938 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3939 sizeof(spec->autocfg.hp_pins));
3940 spec->autocfg.hp_outs = spec->autocfg.line_outs;
3941 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3942 spec->autocfg.line_outs = 0;
3945 if (stac_check_auto_mic(codec)) {
3947 /* only one capture for auto-mic */
3950 spec->num_muxes = 1;
3953 for (i = 0; i < spec->num_caps; i++) {
3954 err = stac92xx_add_capvol_ctls(codec, spec->capvols[i],
3955 spec->capsws[i], i);
3960 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3964 if (spec->mono_nid > 0) {
3965 err = stac92xx_auto_create_mono_output_ctls(codec);
3969 if (spec->num_dmics > 0 && !spec->dinput_mux)
3970 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3971 &spec->autocfg)) < 0)
3973 if (spec->num_muxes > 0) {
3974 err = stac92xx_auto_create_mux_input_ctls(codec);
3978 if (spec->num_smuxes > 0) {
3979 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3984 err = stac92xx_add_input_source(spec);
3988 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3989 if (spec->multiout.max_channels > 2)
3990 spec->surr_switch = 1;
3992 /* find digital out and in converters */
3993 for (i = codec->start_nid; i < codec->start_nid + codec->num_nodes; i++) {
3994 unsigned int wid_caps = get_wcaps(codec, i);
3995 if (wid_caps & AC_WCAP_DIGITAL) {
3996 switch (get_wcaps_type(wid_caps)) {
3997 case AC_WID_AUD_OUT:
4008 if (spec->autocfg.dig_outs)
4009 spec->multiout.dig_out_nid = dig_out;
4010 if (dig_in && spec->autocfg.dig_in_pin)
4011 spec->dig_in_nid = dig_in;
4013 if (spec->kctls.list)
4014 spec->mixers[spec->num_mixers++] = spec->kctls.list;
4016 spec->input_mux = &spec->private_imux;
4017 if (!spec->dinput_mux)
4018 spec->dinput_mux = &spec->private_dimux;
4019 spec->sinput_mux = &spec->private_smux;
4020 spec->mono_mux = &spec->private_mono_mux;
4024 /* add playback controls for HP output */
4025 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
4026 struct auto_pin_cfg *cfg)
4028 struct sigmatel_spec *spec = codec->spec;
4029 hda_nid_t pin = cfg->hp_pins[0];
4034 if (is_jack_detectable(codec, pin))
4035 spec->hp_detect = 1;
4040 /* add playback controls for LFE output */
4041 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
4042 struct auto_pin_cfg *cfg)
4044 struct sigmatel_spec *spec = codec->spec;
4046 hda_nid_t lfe_pin = 0x0;
4050 * search speaker outs and line outs for a mono speaker pin
4051 * with an amp. If one is found, add LFE controls
4054 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
4055 hda_nid_t pin = spec->autocfg.speaker_pins[i];
4056 unsigned int wcaps = get_wcaps(codec, pin);
4057 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
4058 if (wcaps == AC_WCAP_OUT_AMP)
4059 /* found a mono speaker with an amp, must be lfe */
4063 /* if speaker_outs is 0, then speakers may be in line_outs */
4064 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
4065 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
4066 hda_nid_t pin = spec->autocfg.line_out_pins[i];
4067 unsigned int defcfg;
4068 defcfg = snd_hda_codec_get_pincfg(codec, pin);
4069 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
4070 unsigned int wcaps = get_wcaps(codec, pin);
4071 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
4072 if (wcaps == AC_WCAP_OUT_AMP)
4073 /* found a mono speaker with an amp,
4081 err = create_controls(codec, "LFE", lfe_pin, 1);
4089 static int stac9200_parse_auto_config(struct hda_codec *codec)
4091 struct sigmatel_spec *spec = codec->spec;
4094 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
4097 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
4100 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
4103 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
4106 if (spec->num_muxes > 0) {
4107 err = stac92xx_auto_create_mux_input_ctls(codec);
4112 err = stac92xx_add_input_source(spec);
4116 if (spec->autocfg.dig_outs)
4117 spec->multiout.dig_out_nid = 0x05;
4118 if (spec->autocfg.dig_in_pin)
4119 spec->dig_in_nid = 0x04;
4121 if (spec->kctls.list)
4122 spec->mixers[spec->num_mixers++] = spec->kctls.list;
4124 spec->input_mux = &spec->private_imux;
4125 spec->dinput_mux = &spec->private_dimux;
4131 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
4132 * funky external mute control using GPIO pins.
4135 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
4136 unsigned int dir_mask, unsigned int data)
4138 unsigned int gpiostate, gpiomask, gpiodir;
4140 snd_printdd("%s msk %x dir %x gpio %x\n", __func__, mask, dir_mask, data);
4142 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4143 AC_VERB_GET_GPIO_DATA, 0);
4144 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
4146 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4147 AC_VERB_GET_GPIO_MASK, 0);
4150 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4151 AC_VERB_GET_GPIO_DIRECTION, 0);
4152 gpiodir |= dir_mask;
4154 /* Configure GPIOx as CMOS */
4155 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
4157 snd_hda_codec_write(codec, codec->afg, 0,
4158 AC_VERB_SET_GPIO_MASK, gpiomask);
4159 snd_hda_codec_read(codec, codec->afg, 0,
4160 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
4164 snd_hda_codec_read(codec, codec->afg, 0,
4165 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
4168 static int stac92xx_add_jack(struct hda_codec *codec,
4169 hda_nid_t nid, int type)
4171 #ifdef CONFIG_SND_HDA_INPUT_JACK
4172 int def_conf = snd_hda_codec_get_pincfg(codec, nid);
4173 int connectivity = get_defcfg_connect(def_conf);
4175 if (connectivity && connectivity != AC_JACK_PORT_FIXED)
4178 return snd_hda_input_jack_add(codec, nid, type, NULL);
4181 #endif /* CONFIG_SND_HDA_INPUT_JACK */
4184 static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
4185 unsigned char type, int data)
4187 struct sigmatel_event *event;
4189 snd_array_init(&spec->events, sizeof(*event), 32);
4190 event = snd_array_new(&spec->events);
4195 event->tag = spec->events.used;
4201 static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
4204 struct sigmatel_spec *spec = codec->spec;
4205 struct sigmatel_event *event = spec->events.list;
4208 for (i = 0; i < spec->events.used; i++, event++) {
4209 if (event->nid == nid)
4215 static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
4218 struct sigmatel_spec *spec = codec->spec;
4219 struct sigmatel_event *event = spec->events.list;
4222 for (i = 0; i < spec->events.used; i++, event++) {
4223 if (event->tag == tag)
4229 /* check if given nid is a valid pin and no other events are assigned
4230 * to it. If OK, assign the event, set the unsol flag, and returns 1.
4231 * Otherwise, returns zero.
4233 static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
4236 struct sigmatel_event *event;
4239 if (!is_jack_detectable(codec, nid))
4241 event = stac_get_event(codec, nid);
4243 if (event->type != type)
4247 tag = stac_add_event(codec->spec, nid, type, 0);
4251 snd_hda_codec_write_cache(codec, nid, 0,
4252 AC_VERB_SET_UNSOLICITED_ENABLE,
4257 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
4260 for (i = 0; i < cfg->hp_outs; i++)
4261 if (cfg->hp_pins[i] == nid)
4262 return 1; /* nid is a HP-Out */
4264 return 0; /* nid is not a HP-Out */
4267 static void stac92xx_power_down(struct hda_codec *codec)
4269 struct sigmatel_spec *spec = codec->spec;
4271 /* power down inactive DACs */
4272 const hda_nid_t *dac;
4273 for (dac = spec->dac_list; *dac; dac++)
4274 if (!check_all_dac_nids(spec, *dac))
4275 snd_hda_codec_write(codec, *dac, 0,
4276 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4279 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4282 static inline int get_int_hint(struct hda_codec *codec, const char *key,
4286 p = snd_hda_get_hint(codec, key);
4289 if (!strict_strtoul(p, 0, &val)) {
4297 /* override some hints from the hwdep entry */
4298 static void stac_store_hints(struct hda_codec *codec)
4300 struct sigmatel_spec *spec = codec->spec;
4303 val = snd_hda_get_bool_hint(codec, "hp_detect");
4305 spec->hp_detect = val;
4306 if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) {
4307 spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
4310 if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir))
4311 spec->gpio_mask &= spec->gpio_mask;
4312 if (get_int_hint(codec, "gpio_data", &spec->gpio_data))
4313 spec->gpio_dir &= spec->gpio_mask;
4314 if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask))
4315 spec->eapd_mask &= spec->gpio_mask;
4316 if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute))
4317 spec->gpio_mute &= spec->gpio_mask;
4318 val = snd_hda_get_bool_hint(codec, "eapd_switch");
4320 spec->eapd_switch = val;
4321 get_int_hint(codec, "gpio_led_polarity", &spec->gpio_led_polarity);
4322 if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) {
4323 if (spec->gpio_led <= 8) {
4324 spec->gpio_mask |= spec->gpio_led;
4325 spec->gpio_dir |= spec->gpio_led;
4326 if (spec->gpio_led_polarity)
4327 spec->gpio_data |= spec->gpio_led;
4332 static int stac92xx_init(struct hda_codec *codec)
4334 struct sigmatel_spec *spec = codec->spec;
4335 struct auto_pin_cfg *cfg = &spec->autocfg;
4339 snd_hda_sequence_write(codec, spec->init);
4341 /* power down adcs initially */
4342 if (spec->powerdown_adcs)
4343 for (i = 0; i < spec->num_adcs; i++)
4344 snd_hda_codec_write(codec,
4345 spec->adc_nids[i], 0,
4346 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4348 /* override some hints */
4349 stac_store_hints(codec);
4352 gpio = spec->gpio_data;
4353 /* turn on EAPD statically when spec->eapd_switch isn't set.
4354 * otherwise, unsol event will turn it on/off dynamically
4356 if (!spec->eapd_switch)
4357 gpio |= spec->eapd_mask;
4358 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
4361 if (spec->hp_detect) {
4362 /* Enable unsolicited responses on the HP widget */
4363 for (i = 0; i < cfg->hp_outs; i++) {
4364 hda_nid_t nid = cfg->hp_pins[i];
4365 enable_pin_detect(codec, nid, STAC_HP_EVENT);
4367 if (cfg->line_out_type == AUTO_PIN_LINE_OUT &&
4368 cfg->speaker_outs > 0) {
4369 /* enable pin-detect for line-outs as well */
4370 for (i = 0; i < cfg->line_outs; i++) {
4371 hda_nid_t nid = cfg->line_out_pins[i];
4372 enable_pin_detect(codec, nid, STAC_LO_EVENT);
4376 /* force to enable the first line-out; the others are set up
4379 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
4381 /* fake event to set up pins */
4382 if (cfg->hp_pins[0])
4383 stac_issue_unsol_event(codec, cfg->hp_pins[0]);
4384 else if (cfg->line_out_pins[0])
4385 stac_issue_unsol_event(codec, cfg->line_out_pins[0]);
4387 stac92xx_auto_init_multi_out(codec);
4388 stac92xx_auto_init_hp_out(codec);
4389 for (i = 0; i < cfg->hp_outs; i++)
4390 stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
4392 if (spec->auto_mic) {
4393 /* initialize connection to analog input */
4394 if (spec->dmux_nids)
4395 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4396 AC_VERB_SET_CONNECT_SEL, 0);
4397 if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT))
4398 stac_issue_unsol_event(codec, spec->ext_mic.pin);
4399 if (enable_pin_detect(codec, spec->dock_mic.pin,
4401 stac_issue_unsol_event(codec, spec->dock_mic.pin);
4403 for (i = 0; i < cfg->num_inputs; i++) {
4404 hda_nid_t nid = cfg->inputs[i].pin;
4405 int type = cfg->inputs[i].type;
4406 unsigned int pinctl, conf;
4407 if (type == AUTO_PIN_MIC) {
4408 /* for mic pins, force to initialize */
4409 pinctl = stac92xx_get_default_vref(codec, nid);
4410 pinctl |= AC_PINCTL_IN_EN;
4411 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4413 pinctl = snd_hda_codec_read(codec, nid, 0,
4414 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4415 /* if PINCTL already set then skip */
4416 /* Also, if both INPUT and OUTPUT are set,
4417 * it must be a BIOS bug; need to override, too
4419 if (!(pinctl & AC_PINCTL_IN_EN) ||
4420 (pinctl & AC_PINCTL_OUT_EN)) {
4421 pinctl &= ~AC_PINCTL_OUT_EN;
4422 pinctl |= AC_PINCTL_IN_EN;
4423 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4426 conf = snd_hda_codec_get_pincfg(codec, nid);
4427 if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
4428 if (enable_pin_detect(codec, nid, STAC_INSERT_EVENT))
4429 stac_issue_unsol_event(codec, nid);
4432 for (i = 0; i < spec->num_dmics; i++)
4433 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4435 if (cfg->dig_out_pins[0])
4436 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0],
4438 if (cfg->dig_in_pin)
4439 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4441 for (i = 0; i < spec->num_pwrs; i++) {
4442 hda_nid_t nid = spec->pwr_nids[i];
4443 int pinctl, def_conf;
4445 /* power on when no jack detection is available */
4446 if (!spec->hp_detect) {
4447 stac_toggle_power_map(codec, nid, 1);
4451 if (is_nid_hp_pin(cfg, nid))
4452 continue; /* already has an unsol event */
4454 pinctl = snd_hda_codec_read(codec, nid, 0,
4455 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4456 /* outputs are only ports capable of power management
4457 * any attempts on powering down a input port cause the
4458 * referenced VREF to act quirky.
4460 if (pinctl & AC_PINCTL_IN_EN) {
4461 stac_toggle_power_map(codec, nid, 1);
4464 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4465 def_conf = get_defcfg_connect(def_conf);
4466 /* skip any ports that don't have jacks since presence
4467 * detection is useless */
4468 if (def_conf != AC_JACK_PORT_COMPLEX) {
4469 if (def_conf != AC_JACK_PORT_NONE)
4470 stac_toggle_power_map(codec, nid, 1);
4473 if (enable_pin_detect(codec, nid, STAC_PWR_EVENT))
4474 stac_issue_unsol_event(codec, nid);
4479 hda_call_check_power_status(codec, 0x01);
4481 stac92xx_power_down(codec);
4485 static void stac92xx_free_kctls(struct hda_codec *codec)
4487 struct sigmatel_spec *spec = codec->spec;
4489 if (spec->kctls.list) {
4490 struct snd_kcontrol_new *kctl = spec->kctls.list;
4492 for (i = 0; i < spec->kctls.used; i++)
4493 kfree(kctl[i].name);
4495 snd_array_free(&spec->kctls);
4498 static void stac92xx_shutup_pins(struct hda_codec *codec)
4500 unsigned int i, def_conf;
4502 if (codec->bus->shutdown)
4504 for (i = 0; i < codec->init_pins.used; i++) {
4505 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
4506 def_conf = snd_hda_codec_get_pincfg(codec, pin->nid);
4507 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)
4508 snd_hda_codec_write(codec, pin->nid, 0,
4509 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
4513 static void stac92xx_shutup(struct hda_codec *codec)
4515 struct sigmatel_spec *spec = codec->spec;
4517 stac92xx_shutup_pins(codec);
4519 if (spec->eapd_mask)
4520 stac_gpio_set(codec, spec->gpio_mask,
4521 spec->gpio_dir, spec->gpio_data &
4525 static void stac92xx_free(struct hda_codec *codec)
4527 struct sigmatel_spec *spec = codec->spec;
4532 stac92xx_shutup(codec);
4533 snd_hda_input_jack_free(codec);
4534 snd_array_free(&spec->events);
4537 snd_hda_detach_beep_device(codec);
4540 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4543 unsigned int old_ctl, pin_ctl;
4545 pin_ctl = snd_hda_codec_read(codec, nid,
4546 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4548 if (pin_ctl & AC_PINCTL_IN_EN) {
4550 * we need to check the current set-up direction of
4551 * shared input pins since they can be switched via
4552 * "xxx as Output" mixer switch
4554 struct sigmatel_spec *spec = codec->spec;
4555 if (nid == spec->line_switch || nid == spec->mic_switch)
4560 /* if setting pin direction bits, clear the current
4561 direction bits first */
4562 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4563 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4566 if (old_ctl != pin_ctl)
4567 snd_hda_codec_write_cache(codec, nid, 0,
4568 AC_VERB_SET_PIN_WIDGET_CONTROL,
4572 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4575 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4576 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4578 snd_hda_codec_write_cache(codec, nid, 0,
4579 AC_VERB_SET_PIN_WIDGET_CONTROL,
4583 static inline int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4587 return snd_hda_jack_detect(codec, nid);
4590 static void stac92xx_line_out_detect(struct hda_codec *codec,
4593 struct sigmatel_spec *spec = codec->spec;
4594 struct auto_pin_cfg *cfg = &spec->autocfg;
4597 for (i = 0; i < cfg->line_outs; i++) {
4600 presence = get_pin_presence(codec, cfg->line_out_pins[i]);
4602 unsigned int pinctl;
4603 pinctl = snd_hda_codec_read(codec,
4604 cfg->line_out_pins[i], 0,
4605 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4606 if (pinctl & AC_PINCTL_IN_EN)
4607 presence = 0; /* mic- or line-input */
4612 /* disable speakers */
4613 for (i = 0; i < cfg->speaker_outs; i++)
4614 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4616 if (spec->eapd_mask && spec->eapd_switch)
4617 stac_gpio_set(codec, spec->gpio_mask,
4618 spec->gpio_dir, spec->gpio_data &
4621 /* enable speakers */
4622 for (i = 0; i < cfg->speaker_outs; i++)
4623 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4625 if (spec->eapd_mask && spec->eapd_switch)
4626 stac_gpio_set(codec, spec->gpio_mask,
4627 spec->gpio_dir, spec->gpio_data |
4632 /* return non-zero if the hp-pin of the given array index isn't
4633 * a jack-detection target
4635 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4637 struct auto_pin_cfg *cfg = &spec->autocfg;
4639 /* ignore sensing of shared line and mic jacks */
4640 if (cfg->hp_pins[i] == spec->line_switch)
4642 if (cfg->hp_pins[i] == spec->mic_switch)
4644 /* ignore if the pin is set as line-out */
4645 if (cfg->hp_pins[i] == spec->hp_switch)
4650 static void stac92xx_hp_detect(struct hda_codec *codec)
4652 struct sigmatel_spec *spec = codec->spec;
4653 struct auto_pin_cfg *cfg = &spec->autocfg;
4657 if (spec->gpio_mute)
4658 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4659 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4661 for (i = 0; i < cfg->hp_outs; i++) {
4664 if (no_hp_sensing(spec, i))
4666 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4668 unsigned int pinctl;
4669 pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4670 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4671 if (pinctl & AC_PINCTL_IN_EN)
4672 presence = 0; /* mic- or line-input */
4677 /* disable lineouts */
4678 if (spec->hp_switch)
4679 stac92xx_reset_pinctl(codec, spec->hp_switch,
4681 for (i = 0; i < cfg->line_outs; i++)
4682 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4685 /* enable lineouts */
4686 if (spec->hp_switch)
4687 stac92xx_set_pinctl(codec, spec->hp_switch,
4689 for (i = 0; i < cfg->line_outs; i++)
4690 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4693 stac92xx_line_out_detect(codec, presence);
4694 /* toggle hp outs */
4695 for (i = 0; i < cfg->hp_outs; i++) {
4696 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4697 if (no_hp_sensing(spec, i))
4700 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4702 /* Resetting the pinctl like below may lead to (a sort of) regressions
4703 * on some devices since they use the HP pin actually for line/speaker
4704 * outs although the default pin config shows a different pin (that is
4705 * wrong and useless).
4707 * So, it's basically a problem of default pin configs, likely a BIOS issue.
4708 * But, disabling the code below just works around it, and I'm too tired of
4709 * bug reports with such devices...
4712 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4717 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4720 struct sigmatel_spec *spec = codec->spec;
4721 unsigned int idx, val;
4723 for (idx = 0; idx < spec->num_pwrs; idx++) {
4724 if (spec->pwr_nids[idx] == nid)
4727 if (idx >= spec->num_pwrs)
4730 /* several codecs have two power down bits */
4731 if (spec->pwr_mapping)
4732 idx = spec->pwr_mapping[idx];
4736 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
4742 /* power down unused output ports */
4743 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4746 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4748 stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4751 /* get the pin connection (fixed, none, etc) */
4752 static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
4754 struct sigmatel_spec *spec = codec->spec;
4757 cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]);
4758 return get_defcfg_connect(cfg);
4761 static int stac92xx_connected_ports(struct hda_codec *codec,
4762 const hda_nid_t *nids, int num_nids)
4764 struct sigmatel_spec *spec = codec->spec;
4766 unsigned int def_conf;
4768 for (num = 0; num < num_nids; num++) {
4769 for (idx = 0; idx < spec->num_pins; idx++)
4770 if (spec->pin_nids[idx] == nids[num])
4772 if (idx >= spec->num_pins)
4774 def_conf = stac_get_defcfg_connect(codec, idx);
4775 if (def_conf == AC_JACK_PORT_NONE)
4781 static void stac92xx_mic_detect(struct hda_codec *codec)
4783 struct sigmatel_spec *spec = codec->spec;
4784 struct sigmatel_mic_route *mic;
4786 if (get_pin_presence(codec, spec->ext_mic.pin))
4787 mic = &spec->ext_mic;
4788 else if (get_pin_presence(codec, spec->dock_mic.pin))
4789 mic = &spec->dock_mic;
4791 mic = &spec->int_mic;
4792 if (mic->dmux_idx >= 0)
4793 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4794 AC_VERB_SET_CONNECT_SEL,
4796 if (mic->mux_idx >= 0)
4797 snd_hda_codec_write_cache(codec, spec->mux_nids[0], 0,
4798 AC_VERB_SET_CONNECT_SEL,
4802 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid)
4804 struct sigmatel_event *event = stac_get_event(codec, nid);
4807 codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
4810 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4812 struct sigmatel_spec *spec = codec->spec;
4813 struct sigmatel_event *event;
4816 tag = (res >> 26) & 0x7f;
4817 event = stac_get_event_from_tag(codec, tag);
4821 switch (event->type) {
4824 stac92xx_hp_detect(codec);
4826 case STAC_MIC_EVENT:
4827 stac92xx_mic_detect(codec);
4831 switch (event->type) {
4834 case STAC_MIC_EVENT:
4835 case STAC_INSERT_EVENT:
4836 case STAC_PWR_EVENT:
4837 if (spec->num_pwrs > 0)
4838 stac92xx_pin_sense(codec, event->nid);
4839 snd_hda_input_jack_report(codec, event->nid);
4841 switch (codec->subsystem_id) {
4843 if (event->nid == 0xb) {
4844 int pin = AC_PINCTL_IN_EN;
4846 if (get_pin_presence(codec, 0xa)
4847 && get_pin_presence(codec, 0xb))
4848 pin |= AC_PINCTL_VREF_80;
4849 if (!get_pin_presence(codec, 0xb))
4850 pin |= AC_PINCTL_VREF_80;
4852 /* toggle VREF state based on mic + hp pin
4855 stac92xx_auto_set_pinctl(codec, 0x0a, pin);
4859 case STAC_VREF_EVENT:
4860 data = snd_hda_codec_read(codec, codec->afg, 0,
4861 AC_VERB_GET_GPIO_DATA, 0);
4862 /* toggle VREF state based on GPIOx status */
4863 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4864 !!(data & (1 << event->data)));
4869 static int hp_blike_system(u32 subsystem_id);
4871 static void set_hp_led_gpio(struct hda_codec *codec)
4873 struct sigmatel_spec *spec = codec->spec;
4879 gpio = snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP);
4880 gpio &= AC_GPIO_IO_COUNT;
4882 spec->gpio_led = 0x08; /* GPIO 3 */
4884 spec->gpio_led = 0x01; /* GPIO 0 */
4888 * This method searches for the mute LED GPIO configuration
4889 * provided as OEM string in SMBIOS. The format of that string
4890 * is HP_Mute_LED_P_G or HP_Mute_LED_P
4891 * where P can be 0 or 1 and defines mute LED GPIO control state (low/high)
4892 * that corresponds to the NOT muted state of the master volume
4893 * and G is the index of the GPIO to use as the mute LED control (0..9)
4894 * If _G portion is missing it is assigned based on the codec ID
4896 * So, HP B-series like systems may have HP_Mute_LED_0 (current models)
4897 * or HP_Mute_LED_0_3 (future models) OEM SMBIOS strings
4900 * The dv-series laptops don't seem to have the HP_Mute_LED* strings in
4901 * SMBIOS - at least the ones I have seen do not have them - which include
4902 * my own system (HP Pavilion dv6-1110ax) and my cousin's
4903 * HP Pavilion dv9500t CTO.
4904 * Need more information on whether it is true across the entire series.
4907 static int find_mute_led_gpio(struct hda_codec *codec, int default_polarity)
4909 struct sigmatel_spec *spec = codec->spec;
4910 const struct dmi_device *dev = NULL;
4912 if ((codec->subsystem_id >> 16) == PCI_VENDOR_ID_HP) {
4913 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING,
4915 if (sscanf(dev->name, "HP_Mute_LED_%d_%x",
4916 &spec->gpio_led_polarity,
4917 &spec->gpio_led) == 2) {
4918 if (spec->gpio_led < 4)
4919 spec->gpio_led = 1 << spec->gpio_led;
4922 if (sscanf(dev->name, "HP_Mute_LED_%d",
4923 &spec->gpio_led_polarity) == 1) {
4924 set_hp_led_gpio(codec);
4930 * Fallback case - if we don't find the DMI strings,
4931 * we statically set the GPIO - if not a B-series system.
4933 if (!hp_blike_system(codec->subsystem_id)) {
4934 set_hp_led_gpio(codec);
4935 spec->gpio_led_polarity = default_polarity;
4942 static int hp_blike_system(u32 subsystem_id)
4944 switch (subsystem_id) {
4971 #ifdef CONFIG_PROC_FS
4972 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4973 struct hda_codec *codec, hda_nid_t nid)
4975 if (nid == codec->afg)
4976 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4977 snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
4980 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4981 struct hda_codec *codec,
4984 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4985 snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
4988 /* stac92hd71bxx, stac92hd73xx */
4989 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4990 struct hda_codec *codec, hda_nid_t nid)
4992 stac92hd_proc_hook(buffer, codec, nid);
4993 if (nid == codec->afg)
4994 analog_loop_proc_hook(buffer, codec, 0xfa0);
4997 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4998 struct hda_codec *codec, hda_nid_t nid)
5000 if (nid == codec->afg)
5001 analog_loop_proc_hook(buffer, codec, 0xfe0);
5004 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
5005 struct hda_codec *codec, hda_nid_t nid)
5007 if (nid == codec->afg)
5008 analog_loop_proc_hook(buffer, codec, 0xfeb);
5011 #define stac92hd_proc_hook NULL
5012 #define stac92hd7x_proc_hook NULL
5013 #define stac9205_proc_hook NULL
5014 #define stac927x_proc_hook NULL
5018 static int stac92xx_resume(struct hda_codec *codec)
5020 struct sigmatel_spec *spec = codec->spec;
5022 stac92xx_init(codec);
5023 snd_hda_codec_resume_amp(codec);
5024 snd_hda_codec_resume_cache(codec);
5025 /* fake event to set up pins again to override cached values */
5026 if (spec->hp_detect) {
5027 if (spec->autocfg.hp_pins[0])
5028 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0]);
5029 else if (spec->autocfg.line_out_pins[0])
5030 stac_issue_unsol_event(codec,
5031 spec->autocfg.line_out_pins[0]);
5036 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
5038 stac92xx_shutup(codec);
5042 #ifdef CONFIG_SND_HDA_POWER_SAVE
5043 static int stac92xx_pre_resume(struct hda_codec *codec)
5045 struct sigmatel_spec *spec = codec->spec;
5048 if (spec->gpio_led) {
5049 if (spec->gpio_led <= 8) {
5050 stac_gpio_set(codec, spec->gpio_mask,
5051 spec->gpio_dir, spec->gpio_data);
5053 stac_vrefout_set(codec,
5054 spec->gpio_led, spec->vref_led);
5060 static int stac92xx_post_suspend(struct hda_codec *codec)
5062 struct sigmatel_spec *spec = codec->spec;
5063 if (spec->gpio_led > 8) {
5064 /* with vref-out pin used for mute led control
5065 * codec AFG is prevented from D3 state, but on
5066 * system suspend it can (and should) be used
5068 snd_hda_codec_read(codec, codec->afg, 0,
5069 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
5074 static void stac92xx_set_power_state(struct hda_codec *codec, hda_nid_t fg,
5075 unsigned int power_state)
5077 unsigned int afg_power_state = power_state;
5078 struct sigmatel_spec *spec = codec->spec;
5080 if (power_state == AC_PWRST_D3) {
5081 if (spec->gpio_led > 8) {
5082 /* with vref-out pin used for mute led control
5083 * codec AFG is prevented from D3 state
5085 afg_power_state = AC_PWRST_D1;
5087 /* this delay seems necessary to avoid click noise at power-down */
5090 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
5092 snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
5096 * For this feature CONFIG_SND_HDA_POWER_SAVE is needed
5097 * as mute LED state is updated in check_power_status hook
5099 static int stac92xx_update_led_status(struct hda_codec *codec)
5101 struct sigmatel_spec *spec = codec->spec;
5102 int i, num_ext_dacs, muted = 1;
5103 unsigned int muted_lvl, notmtd_lvl;
5106 if (!spec->gpio_led)
5109 for (i = 0; i < spec->multiout.num_dacs; i++) {
5110 nid = spec->multiout.dac_nids[i];
5111 if (!(snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
5113 muted = 0; /* something heard */
5117 if (muted && spec->multiout.hp_nid)
5118 if (!(snd_hda_codec_amp_read(codec,
5119 spec->multiout.hp_nid, 0, HDA_OUTPUT, 0) &
5121 muted = 0; /* HP is not muted */
5123 num_ext_dacs = ARRAY_SIZE(spec->multiout.extra_out_nid);
5124 for (i = 0; muted && i < num_ext_dacs; i++) {
5125 nid = spec->multiout.extra_out_nid[i];
5128 if (!(snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
5130 muted = 0; /* extra output is not muted */
5133 /*polarity defines *not* muted state level*/
5134 if (spec->gpio_led <= 8) {
5136 spec->gpio_data &= ~spec->gpio_led; /* orange */
5138 spec->gpio_data |= spec->gpio_led; /* white */
5140 if (!spec->gpio_led_polarity) {
5141 /* LED state is inverted on these systems */
5142 spec->gpio_data ^= spec->gpio_led;
5144 stac_gpio_set(codec, spec->gpio_mask,
5145 spec->gpio_dir, spec->gpio_data);
5147 notmtd_lvl = spec->gpio_led_polarity ?
5148 AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_GRD;
5149 muted_lvl = spec->gpio_led_polarity ?
5150 AC_PINCTL_VREF_GRD : AC_PINCTL_VREF_HIZ;
5151 spec->vref_led = muted ? muted_lvl : notmtd_lvl;
5152 stac_vrefout_set(codec, spec->gpio_led, spec->vref_led);
5158 * use power check for controlling mute led of HP notebooks
5160 static int stac92xx_check_power_status(struct hda_codec *codec,
5163 stac92xx_update_led_status(codec);
5167 #endif /* CONFIG_SND_HDA_POWER_SAVE */
5168 #endif /* CONFIG_PM */
5170 static const struct hda_codec_ops stac92xx_patch_ops = {
5171 .build_controls = stac92xx_build_controls,
5172 .build_pcms = stac92xx_build_pcms,
5173 .init = stac92xx_init,
5174 .free = stac92xx_free,
5175 .unsol_event = stac92xx_unsol_event,
5177 .suspend = stac92xx_suspend,
5178 .resume = stac92xx_resume,
5180 .reboot_notify = stac92xx_shutup,
5183 static int patch_stac9200(struct hda_codec *codec)
5185 struct sigmatel_spec *spec;
5188 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5192 codec->no_trigger_sense = 1;
5194 spec->linear_tone_beep = 1;
5195 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
5196 spec->pin_nids = stac9200_pin_nids;
5197 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
5200 if (spec->board_config < 0)
5201 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5204 stac92xx_set_config_regs(codec,
5205 stac9200_brd_tbl[spec->board_config]);
5207 spec->multiout.max_channels = 2;
5208 spec->multiout.num_dacs = 1;
5209 spec->multiout.dac_nids = stac9200_dac_nids;
5210 spec->adc_nids = stac9200_adc_nids;
5211 spec->mux_nids = stac9200_mux_nids;
5212 spec->num_muxes = 1;
5213 spec->num_dmics = 0;
5217 if (spec->board_config == STAC_9200_M4 ||
5218 spec->board_config == STAC_9200_M4_2 ||
5219 spec->board_config == STAC_9200_OQO)
5220 spec->init = stac9200_eapd_init;
5222 spec->init = stac9200_core_init;
5223 spec->mixer = stac9200_mixer;
5225 if (spec->board_config == STAC_9200_PANASONIC) {
5226 spec->gpio_mask = spec->gpio_dir = 0x09;
5227 spec->gpio_data = 0x00;
5230 err = stac9200_parse_auto_config(codec);
5232 stac92xx_free(codec);
5236 /* CF-74 has no headphone detection, and the driver should *NOT*
5237 * do detection and HP/speaker toggle because the hardware does it.
5239 if (spec->board_config == STAC_9200_PANASONIC)
5240 spec->hp_detect = 0;
5242 codec->patch_ops = stac92xx_patch_ops;
5247 static int patch_stac925x(struct hda_codec *codec)
5249 struct sigmatel_spec *spec;
5252 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5256 codec->no_trigger_sense = 1;
5258 spec->linear_tone_beep = 1;
5259 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
5260 spec->pin_nids = stac925x_pin_nids;
5262 /* Check first for codec ID */
5263 spec->board_config = snd_hda_check_board_codec_sid_config(codec,
5266 stac925x_codec_id_cfg_tbl);
5268 /* Now checks for PCI ID, if codec ID is not found */
5269 if (spec->board_config < 0)
5270 spec->board_config = snd_hda_check_board_config(codec,
5275 if (spec->board_config < 0)
5276 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5279 stac92xx_set_config_regs(codec,
5280 stac925x_brd_tbl[spec->board_config]);
5282 spec->multiout.max_channels = 2;
5283 spec->multiout.num_dacs = 1;
5284 spec->multiout.dac_nids = stac925x_dac_nids;
5285 spec->adc_nids = stac925x_adc_nids;
5286 spec->mux_nids = stac925x_mux_nids;
5287 spec->num_muxes = 1;
5290 switch (codec->vendor_id) {
5291 case 0x83847632: /* STAC9202 */
5292 case 0x83847633: /* STAC9202D */
5293 case 0x83847636: /* STAC9251 */
5294 case 0x83847637: /* STAC9251D */
5295 spec->num_dmics = STAC925X_NUM_DMICS;
5296 spec->dmic_nids = stac925x_dmic_nids;
5297 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
5298 spec->dmux_nids = stac925x_dmux_nids;
5301 spec->num_dmics = 0;
5305 spec->init = stac925x_core_init;
5306 spec->mixer = stac925x_mixer;
5308 spec->capvols = stac925x_capvols;
5309 spec->capsws = stac925x_capsws;
5311 err = stac92xx_parse_auto_config(codec);
5313 if (spec->board_config < 0) {
5314 printk(KERN_WARNING "hda_codec: No auto-config is "
5315 "available, default to model=ref\n");
5316 spec->board_config = STAC_925x_REF;
5322 stac92xx_free(codec);
5326 codec->patch_ops = stac92xx_patch_ops;
5331 static int patch_stac92hd73xx(struct hda_codec *codec)
5333 struct sigmatel_spec *spec;
5334 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
5338 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5342 codec->no_trigger_sense = 1;
5344 spec->linear_tone_beep = 0;
5345 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
5346 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
5347 spec->pin_nids = stac92hd73xx_pin_nids;
5348 spec->board_config = snd_hda_check_board_config(codec,
5349 STAC_92HD73XX_MODELS,
5350 stac92hd73xx_models,
5351 stac92hd73xx_cfg_tbl);
5352 /* check codec subsystem id if not found */
5353 if (spec->board_config < 0)
5354 spec->board_config =
5355 snd_hda_check_board_codec_sid_config(codec,
5356 STAC_92HD73XX_MODELS, stac92hd73xx_models,
5357 stac92hd73xx_codec_id_cfg_tbl);
5359 if (spec->board_config < 0)
5360 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5363 stac92xx_set_config_regs(codec,
5364 stac92hd73xx_brd_tbl[spec->board_config]);
5366 num_dacs = snd_hda_get_connections(codec, 0x0a,
5367 conn, STAC92HD73_DAC_COUNT + 2) - 1;
5369 if (num_dacs < 3 || num_dacs > 5) {
5370 printk(KERN_WARNING "hda_codec: Could not determine "
5371 "number of channels defaulting to DAC count\n");
5372 num_dacs = STAC92HD73_DAC_COUNT;
5374 spec->init = stac92hd73xx_core_init;
5376 case 0x3: /* 6 Channel */
5377 spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
5379 case 0x4: /* 8 Channel */
5380 spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
5382 case 0x5: /* 10 Channel */
5383 spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
5386 spec->multiout.dac_nids = spec->dac_nids;
5388 spec->aloopback_mask = 0x01;
5389 spec->aloopback_shift = 8;
5391 spec->digbeep_nid = 0x1c;
5392 spec->mux_nids = stac92hd73xx_mux_nids;
5393 spec->adc_nids = stac92hd73xx_adc_nids;
5394 spec->dmic_nids = stac92hd73xx_dmic_nids;
5395 spec->dmux_nids = stac92hd73xx_dmux_nids;
5396 spec->smux_nids = stac92hd73xx_smux_nids;
5398 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
5399 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
5400 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
5402 spec->num_caps = STAC92HD73XX_NUM_CAPS;
5403 spec->capvols = stac92hd73xx_capvols;
5404 spec->capsws = stac92hd73xx_capsws;
5406 switch (spec->board_config) {
5408 spec->init = dell_eq_core_init;
5410 case STAC_DELL_M6_AMIC:
5411 case STAC_DELL_M6_DMIC:
5412 case STAC_DELL_M6_BOTH:
5413 spec->num_smuxes = 0;
5414 spec->eapd_switch = 0;
5416 switch (spec->board_config) {
5417 case STAC_DELL_M6_AMIC: /* Analog Mics */
5418 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5419 spec->num_dmics = 0;
5421 case STAC_DELL_M6_DMIC: /* Digital Mics */
5422 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5423 spec->num_dmics = 1;
5425 case STAC_DELL_M6_BOTH: /* Both */
5426 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5427 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5428 spec->num_dmics = 1;
5432 case STAC_ALIENWARE_M17X:
5433 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
5434 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
5435 spec->eapd_switch = 0;
5438 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
5439 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
5440 spec->eapd_switch = 1;
5443 if (spec->board_config != STAC_92HD73XX_REF) {
5444 /* GPIO0 High = Enable EAPD */
5445 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5446 spec->gpio_data = 0x01;
5449 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
5450 spec->pwr_nids = stac92hd73xx_pwr_nids;
5452 err = stac92xx_parse_auto_config(codec);
5455 if (spec->board_config < 0) {
5456 printk(KERN_WARNING "hda_codec: No auto-config is "
5457 "available, default to model=ref\n");
5458 spec->board_config = STAC_92HD73XX_REF;
5465 stac92xx_free(codec);
5469 if (spec->board_config == STAC_92HD73XX_NO_JD)
5470 spec->hp_detect = 0;
5472 codec->patch_ops = stac92xx_patch_ops;
5474 codec->proc_widget_hook = stac92hd7x_proc_hook;
5479 static int hp_bnb2011_with_dock(struct hda_codec *codec)
5481 if (codec->vendor_id != 0x111d7605 &&
5482 codec->vendor_id != 0x111d76d1)
5485 switch (codec->subsystem_id) {
5519 static void stac92hd8x_add_pin(struct hda_codec *codec, hda_nid_t nid)
5521 struct sigmatel_spec *spec = codec->spec;
5522 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5525 spec->auto_pin_nids[spec->auto_pin_cnt] = nid;
5526 spec->auto_pin_cnt++;
5528 if (get_defcfg_device(def_conf) == AC_JACK_MIC_IN &&
5529 get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE) {
5530 for (i = 0; i < ARRAY_SIZE(stac92hd83xxx_dmic_nids); i++) {
5531 if (nid == stac92hd83xxx_dmic_nids[i]) {
5532 spec->auto_dmic_nids[spec->auto_dmic_cnt] = nid;
5533 spec->auto_dmic_cnt++;
5539 static void stac92hd8x_add_adc(struct hda_codec *codec, hda_nid_t nid)
5541 struct sigmatel_spec *spec = codec->spec;
5543 spec->auto_adc_nids[spec->auto_adc_cnt] = nid;
5544 spec->auto_adc_cnt++;
5547 static void stac92hd8x_add_mux(struct hda_codec *codec, hda_nid_t nid)
5550 struct sigmatel_spec *spec = codec->spec;
5552 for (i = 0; i < spec->auto_adc_cnt; i++) {
5553 if (get_connection_index(codec,
5554 spec->auto_adc_nids[i], nid) >= 0) {
5555 /* mux and volume for adc_nids[i] */
5556 if (!spec->auto_mux_nids[i]) {
5557 spec->auto_mux_nids[i] = nid;
5558 /* 92hd codecs capture volume is in mux */
5559 spec->auto_capvols[i] = HDA_COMPOSE_AMP_VAL(nid,
5562 for (j = 0; j < spec->auto_dmic_cnt; j++) {
5563 if (get_connection_index(codec, nid,
5564 spec->auto_dmic_nids[j]) >= 0) {
5565 /* dmux for adc_nids[i] */
5566 if (!spec->auto_dmux_nids[i])
5567 spec->auto_dmux_nids[i] = nid;
5576 static void stac92hd8x_fill_auto_spec(struct hda_codec *codec)
5578 hda_nid_t nid, end_nid;
5579 unsigned int wid_caps, wid_type;
5580 struct sigmatel_spec *spec = codec->spec;
5582 end_nid = codec->start_nid + codec->num_nodes;
5584 for (nid = codec->start_nid; nid < end_nid; nid++) {
5585 wid_caps = get_wcaps(codec, nid);
5586 wid_type = get_wcaps_type(wid_caps);
5588 if (wid_type == AC_WID_PIN)
5589 stac92hd8x_add_pin(codec, nid);
5591 if (wid_type == AC_WID_AUD_IN && !(wid_caps & AC_WCAP_DIGITAL))
5592 stac92hd8x_add_adc(codec, nid);
5595 for (nid = codec->start_nid; nid < end_nid; nid++) {
5596 wid_caps = get_wcaps(codec, nid);
5597 wid_type = get_wcaps_type(wid_caps);
5599 if (wid_type == AC_WID_AUD_SEL)
5600 stac92hd8x_add_mux(codec, nid);
5603 spec->pin_nids = spec->auto_pin_nids;
5604 spec->num_pins = spec->auto_pin_cnt;
5605 spec->adc_nids = spec->auto_adc_nids;
5606 spec->num_adcs = spec->auto_adc_cnt;
5607 spec->capvols = spec->auto_capvols;
5608 spec->capsws = spec->auto_capvols;
5609 spec->num_caps = spec->auto_adc_cnt;
5610 spec->mux_nids = spec->auto_mux_nids;
5611 spec->num_muxes = spec->auto_adc_cnt;
5612 spec->dmux_nids = spec->auto_dmux_nids;
5613 spec->num_dmuxes = spec->auto_adc_cnt;
5614 spec->dmic_nids = spec->auto_dmic_nids;
5615 spec->num_dmics = spec->auto_dmic_cnt;
5618 static int patch_stac92hd83xxx(struct hda_codec *codec)
5620 struct sigmatel_spec *spec;
5623 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5627 if (hp_bnb2011_with_dock(codec)) {
5628 snd_hda_codec_set_pincfg(codec, 0xa, 0x2101201f);
5629 snd_hda_codec_set_pincfg(codec, 0xf, 0x2181205e);
5632 /* reset pin power-down; Windows may leave these bits after reboot */
5633 snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7EC, 0);
5634 snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7ED, 0);
5635 codec->no_trigger_sense = 1;
5638 stac92hd8x_fill_auto_spec(codec);
5640 spec->linear_tone_beep = 0;
5641 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
5642 spec->digbeep_nid = 0x21;
5643 spec->pwr_nids = stac92hd83xxx_pwr_nids;
5644 spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
5645 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
5646 spec->multiout.dac_nids = spec->dac_nids;
5647 spec->init = stac92hd83xxx_core_init;
5649 spec->board_config = snd_hda_check_board_config(codec,
5650 STAC_92HD83XXX_MODELS,
5651 stac92hd83xxx_models,
5652 stac92hd83xxx_cfg_tbl);
5654 if (spec->board_config < 0)
5655 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5658 stac92xx_set_config_regs(codec,
5659 stac92hd83xxx_brd_tbl[spec->board_config]);
5661 if (spec->board_config != STAC_92HD83XXX_PWR_REF)
5664 codec->patch_ops = stac92xx_patch_ops;
5666 if (find_mute_led_gpio(codec, 0))
5667 snd_printd("mute LED gpio %d polarity %d\n",
5669 spec->gpio_led_polarity);
5671 #ifdef CONFIG_SND_HDA_POWER_SAVE
5672 if (spec->gpio_led) {
5673 if (spec->gpio_led <= 8) {
5674 spec->gpio_mask |= spec->gpio_led;
5675 spec->gpio_dir |= spec->gpio_led;
5676 spec->gpio_data |= spec->gpio_led;
5678 codec->patch_ops.set_power_state =
5679 stac92xx_set_power_state;
5680 codec->patch_ops.post_suspend =
5681 stac92xx_post_suspend;
5683 codec->patch_ops.pre_resume = stac92xx_pre_resume;
5684 codec->patch_ops.check_power_status =
5685 stac92xx_check_power_status;
5689 err = stac92xx_parse_auto_config(codec);
5691 if (spec->board_config < 0) {
5692 printk(KERN_WARNING "hda_codec: No auto-config is "
5693 "available, default to model=ref\n");
5694 spec->board_config = STAC_92HD83XXX_REF;
5701 stac92xx_free(codec);
5705 codec->proc_widget_hook = stac92hd_proc_hook;
5710 static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
5713 struct sigmatel_spec *spec = codec->spec;
5716 for (idx = 0; idx < spec->num_pins; idx++)
5717 if (spec->pin_nids[idx] == dig0pin)
5719 if ((idx + 2) >= spec->num_pins)
5723 if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE)
5726 /* dig0pin + dig2pin case */
5727 if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE)
5729 if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE)
5735 /* HP dv7 bass switch - GPIO5 */
5736 #define stac_hp_bass_gpio_info snd_ctl_boolean_mono_info
5737 static int stac_hp_bass_gpio_get(struct snd_kcontrol *kcontrol,
5738 struct snd_ctl_elem_value *ucontrol)
5740 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5741 struct sigmatel_spec *spec = codec->spec;
5742 ucontrol->value.integer.value[0] = !!(spec->gpio_data & 0x20);
5746 static int stac_hp_bass_gpio_put(struct snd_kcontrol *kcontrol,
5747 struct snd_ctl_elem_value *ucontrol)
5749 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5750 struct sigmatel_spec *spec = codec->spec;
5751 unsigned int gpio_data;
5753 gpio_data = (spec->gpio_data & ~0x20) |
5754 (ucontrol->value.integer.value[0] ? 0x20 : 0);
5755 if (gpio_data == spec->gpio_data)
5757 spec->gpio_data = gpio_data;
5758 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
5762 static const struct snd_kcontrol_new stac_hp_bass_sw_ctrl = {
5763 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5764 .info = stac_hp_bass_gpio_info,
5765 .get = stac_hp_bass_gpio_get,
5766 .put = stac_hp_bass_gpio_put,
5769 static int stac_add_hp_bass_switch(struct hda_codec *codec)
5771 struct sigmatel_spec *spec = codec->spec;
5773 if (!stac_control_new(spec, &stac_hp_bass_sw_ctrl,
5774 "Bass Speaker Playback Switch", 0))
5777 spec->gpio_mask |= 0x20;
5778 spec->gpio_dir |= 0x20;
5779 spec->gpio_data |= 0x20;
5783 static int patch_stac92hd71bxx(struct hda_codec *codec)
5785 struct sigmatel_spec *spec;
5786 const struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
5787 unsigned int pin_cfg;
5790 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5794 codec->no_trigger_sense = 1;
5796 spec->linear_tone_beep = 0;
5797 codec->patch_ops = stac92xx_patch_ops;
5798 spec->num_pins = STAC92HD71BXX_NUM_PINS;
5799 switch (codec->vendor_id) {
5802 spec->pin_nids = stac92hd71bxx_pin_nids_4port;
5806 /* On 92HD75Bx 0x27 isn't a pin nid */
5810 spec->pin_nids = stac92hd71bxx_pin_nids_6port;
5812 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
5813 spec->board_config = snd_hda_check_board_config(codec,
5814 STAC_92HD71BXX_MODELS,
5815 stac92hd71bxx_models,
5816 stac92hd71bxx_cfg_tbl);
5818 if (spec->board_config < 0)
5819 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5822 stac92xx_set_config_regs(codec,
5823 stac92hd71bxx_brd_tbl[spec->board_config]);
5825 if (spec->board_config != STAC_92HD71BXX_REF) {
5827 spec->gpio_mask = 0x01;
5828 spec->gpio_dir = 0x01;
5829 spec->gpio_data = 0x01;
5832 spec->dmic_nids = stac92hd71bxx_dmic_nids;
5833 spec->dmux_nids = stac92hd71bxx_dmux_nids;
5835 spec->num_caps = STAC92HD71BXX_NUM_CAPS;
5836 spec->capvols = stac92hd71bxx_capvols;
5837 spec->capsws = stac92hd71bxx_capsws;
5839 switch (codec->vendor_id) {
5840 case 0x111d76b6: /* 4 Port without Analog Mixer */
5844 case 0x111d76b4: /* 6 Port without Analog Mixer */
5846 spec->init = stac92hd71bxx_core_init;
5847 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5848 spec->num_dmics = stac92xx_connected_ports(codec,
5849 stac92hd71bxx_dmic_nids,
5850 STAC92HD71BXX_NUM_DMICS);
5852 case 0x111d7608: /* 5 Port with Analog Mixer */
5853 switch (spec->board_config) {
5855 /* Enable VREF power saving on GPIO1 detect */
5856 err = stac_add_event(spec, codec->afg,
5857 STAC_VREF_EVENT, 0x02);
5860 snd_hda_codec_write_cache(codec, codec->afg, 0,
5861 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
5862 snd_hda_codec_write_cache(codec, codec->afg, 0,
5863 AC_VERB_SET_UNSOLICITED_ENABLE,
5865 spec->gpio_mask |= 0x02;
5868 if ((codec->revision_id & 0xf) == 0 ||
5869 (codec->revision_id & 0xf) == 1)
5870 spec->stream_delay = 40; /* 40 milliseconds */
5872 /* no output amps */
5875 spec->init = stac92hd71bxx_core_init;
5877 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
5878 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
5879 spec->dmic_nids = stac92hd71bxx_dmic_5port_nids;
5880 spec->num_dmics = stac92xx_connected_ports(codec,
5881 stac92hd71bxx_dmic_5port_nids,
5882 STAC92HD71BXX_NUM_DMICS - 1);
5884 case 0x111d7603: /* 6 Port with Analog Mixer */
5885 if ((codec->revision_id & 0xf) == 1)
5886 spec->stream_delay = 40; /* 40 milliseconds */
5888 /* no output amps */
5892 spec->init = stac92hd71bxx_core_init;
5893 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5894 spec->num_dmics = stac92xx_connected_ports(codec,
5895 stac92hd71bxx_dmic_nids,
5896 STAC92HD71BXX_NUM_DMICS);
5900 if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
5901 snd_hda_sequence_write_cache(codec, unmute_init);
5903 spec->aloopback_ctl = stac92hd71bxx_loopback;
5904 spec->aloopback_mask = 0x50;
5905 spec->aloopback_shift = 0;
5907 spec->powerdown_adcs = 1;
5908 spec->digbeep_nid = 0x26;
5909 spec->mux_nids = stac92hd71bxx_mux_nids;
5910 spec->adc_nids = stac92hd71bxx_adc_nids;
5911 spec->smux_nids = stac92hd71bxx_smux_nids;
5912 spec->pwr_nids = stac92hd71bxx_pwr_nids;
5914 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
5915 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
5916 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5917 spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
5919 snd_printdd("Found board config: %d\n", spec->board_config);
5921 switch (spec->board_config) {
5923 /* enable internal microphone */
5924 snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
5925 stac92xx_auto_set_pinctl(codec, 0x0e,
5926 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
5928 case STAC_DELL_M4_2:
5929 spec->num_dmics = 0;
5930 spec->num_smuxes = 0;
5931 spec->num_dmuxes = 0;
5933 case STAC_DELL_M4_1:
5934 case STAC_DELL_M4_3:
5935 spec->num_dmics = 1;
5936 spec->num_smuxes = 0;
5937 spec->num_dmuxes = 1;
5939 case STAC_HP_DV4_1222NR:
5940 spec->num_dmics = 1;
5941 /* I don't know if it needs 1 or 2 smuxes - will wait for
5942 * bug reports to fix if needed
5944 spec->num_smuxes = 1;
5945 spec->num_dmuxes = 1;
5948 spec->gpio_led = 0x01;
5951 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
5952 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
5953 /* HP dv6 gives the headphone pin as a line-out. Thus we
5954 * need to set hp_detect flag here to force to enable HP
5957 spec->hp_detect = 1;
5960 spec->num_dmics = 1;
5961 spec->num_dmuxes = 1;
5962 spec->num_smuxes = 1;
5963 spec->gpio_led = 0x08;
5967 if (hp_blike_system(codec->subsystem_id)) {
5968 pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f);
5969 if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT ||
5970 get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER ||
5971 get_defcfg_device(pin_cfg) == AC_JACK_HP_OUT) {
5972 /* It was changed in the BIOS to just satisfy MS DTM.
5973 * Lets turn it back into slaved HP
5975 pin_cfg = (pin_cfg & (~AC_DEFCFG_DEVICE))
5976 | (AC_JACK_HP_OUT <<
5977 AC_DEFCFG_DEVICE_SHIFT);
5978 pin_cfg = (pin_cfg & (~(AC_DEFCFG_DEF_ASSOC
5979 | AC_DEFCFG_SEQUENCE)))
5981 snd_hda_codec_set_pincfg(codec, 0x0f, pin_cfg);
5985 if (find_mute_led_gpio(codec, 1))
5986 snd_printd("mute LED gpio %d polarity %d\n",
5988 spec->gpio_led_polarity);
5990 #ifdef CONFIG_SND_HDA_POWER_SAVE
5991 if (spec->gpio_led) {
5992 if (spec->gpio_led <= 8) {
5993 spec->gpio_mask |= spec->gpio_led;
5994 spec->gpio_dir |= spec->gpio_led;
5995 spec->gpio_data |= spec->gpio_led;
5997 codec->patch_ops.set_power_state =
5998 stac92xx_set_power_state;
5999 codec->patch_ops.post_suspend =
6000 stac92xx_post_suspend;
6002 codec->patch_ops.pre_resume = stac92xx_pre_resume;
6003 codec->patch_ops.check_power_status =
6004 stac92xx_check_power_status;
6008 spec->multiout.dac_nids = spec->dac_nids;
6010 err = stac92xx_parse_auto_config(codec);
6012 if (spec->board_config < 0) {
6013 printk(KERN_WARNING "hda_codec: No auto-config is "
6014 "available, default to model=ref\n");
6015 spec->board_config = STAC_92HD71BXX_REF;
6022 stac92xx_free(codec);
6026 /* enable bass on HP dv7 */
6027 if (spec->board_config == STAC_HP_DV4 ||
6028 spec->board_config == STAC_HP_DV5) {
6030 cap = snd_hda_param_read(codec, 0x1, AC_PAR_GPIO_CAP);
6031 cap &= AC_GPIO_IO_COUNT;
6033 stac_add_hp_bass_switch(codec);
6036 codec->proc_widget_hook = stac92hd7x_proc_hook;
6041 static int patch_stac922x(struct hda_codec *codec)
6043 struct sigmatel_spec *spec;
6046 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6050 codec->no_trigger_sense = 1;
6052 spec->linear_tone_beep = 1;
6053 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
6054 spec->pin_nids = stac922x_pin_nids;
6055 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
6058 if (spec->board_config == STAC_INTEL_MAC_AUTO) {
6059 spec->gpio_mask = spec->gpio_dir = 0x03;
6060 spec->gpio_data = 0x03;
6061 /* Intel Macs have all same PCI SSID, so we need to check
6062 * codec SSID to distinguish the exact models
6064 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
6065 switch (codec->subsystem_id) {
6068 spec->board_config = STAC_INTEL_MAC_V1;
6072 spec->board_config = STAC_INTEL_MAC_V2;
6080 spec->board_config = STAC_INTEL_MAC_V3;
6084 spec->board_config = STAC_INTEL_MAC_V4;
6088 spec->board_config = STAC_INTEL_MAC_V5;
6091 spec->board_config = STAC_INTEL_MAC_V3;
6097 if (spec->board_config < 0)
6098 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6101 stac92xx_set_config_regs(codec,
6102 stac922x_brd_tbl[spec->board_config]);
6104 spec->adc_nids = stac922x_adc_nids;
6105 spec->mux_nids = stac922x_mux_nids;
6106 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
6107 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
6108 spec->num_dmics = 0;
6111 spec->init = stac922x_core_init;
6113 spec->num_caps = STAC922X_NUM_CAPS;
6114 spec->capvols = stac922x_capvols;
6115 spec->capsws = stac922x_capsws;
6117 spec->multiout.dac_nids = spec->dac_nids;
6119 err = stac92xx_parse_auto_config(codec);
6121 if (spec->board_config < 0) {
6122 printk(KERN_WARNING "hda_codec: No auto-config is "
6123 "available, default to model=ref\n");
6124 spec->board_config = STAC_D945_REF;
6130 stac92xx_free(codec);
6134 codec->patch_ops = stac92xx_patch_ops;
6136 /* Fix Mux capture level; max to 2 */
6137 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
6138 (0 << AC_AMPCAP_OFFSET_SHIFT) |
6139 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
6140 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
6141 (0 << AC_AMPCAP_MUTE_SHIFT));
6146 static int patch_stac927x(struct hda_codec *codec)
6148 struct sigmatel_spec *spec;
6151 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6155 codec->no_trigger_sense = 1;
6157 spec->linear_tone_beep = 1;
6158 codec->slave_dig_outs = stac927x_slave_dig_outs;
6159 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
6160 spec->pin_nids = stac927x_pin_nids;
6161 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
6165 if (spec->board_config < 0)
6166 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6169 stac92xx_set_config_regs(codec,
6170 stac927x_brd_tbl[spec->board_config]);
6172 spec->digbeep_nid = 0x23;
6173 spec->adc_nids = stac927x_adc_nids;
6174 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
6175 spec->mux_nids = stac927x_mux_nids;
6176 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
6177 spec->smux_nids = stac927x_smux_nids;
6178 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
6179 spec->spdif_labels = stac927x_spdif_labels;
6180 spec->dac_list = stac927x_dac_nids;
6181 spec->multiout.dac_nids = spec->dac_nids;
6183 if (spec->board_config != STAC_D965_REF) {
6184 /* GPIO0 High = Enable EAPD */
6185 spec->eapd_mask = spec->gpio_mask = 0x01;
6186 spec->gpio_dir = spec->gpio_data = 0x01;
6189 switch (spec->board_config) {
6192 /* GPIO0 High = Enable EAPD */
6193 spec->num_dmics = 0;
6194 spec->init = d965_core_init;
6196 case STAC_DELL_BIOS:
6197 switch (codec->subsystem_id) {
6200 /* correct the device field to SPDIF out */
6201 snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
6204 /* configure the analog microphone on some laptops */
6205 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
6206 /* correct the front output jack as a hp out */
6207 snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f);
6208 /* correct the front input jack as a mic */
6209 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
6212 if (codec->subsystem_id != 0x1028022f) {
6213 /* GPIO2 High = Enable EAPD */
6214 spec->eapd_mask = spec->gpio_mask = 0x04;
6215 spec->gpio_dir = spec->gpio_data = 0x04;
6217 spec->dmic_nids = stac927x_dmic_nids;
6218 spec->num_dmics = STAC927X_NUM_DMICS;
6220 spec->init = dell_3st_core_init;
6221 spec->dmux_nids = stac927x_dmux_nids;
6222 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
6224 case STAC_927X_VOLKNOB:
6225 spec->num_dmics = 0;
6226 spec->init = stac927x_volknob_core_init;
6229 spec->num_dmics = 0;
6230 spec->init = stac927x_core_init;
6234 spec->num_caps = STAC927X_NUM_CAPS;
6235 spec->capvols = stac927x_capvols;
6236 spec->capsws = stac927x_capsws;
6239 spec->aloopback_ctl = stac927x_loopback;
6240 spec->aloopback_mask = 0x40;
6241 spec->aloopback_shift = 0;
6242 spec->eapd_switch = 1;
6244 err = stac92xx_parse_auto_config(codec);
6246 if (spec->board_config < 0) {
6247 printk(KERN_WARNING "hda_codec: No auto-config is "
6248 "available, default to model=ref\n");
6249 spec->board_config = STAC_D965_REF;
6255 stac92xx_free(codec);
6259 codec->patch_ops = stac92xx_patch_ops;
6261 codec->proc_widget_hook = stac927x_proc_hook;
6265 * The STAC927x seem to require fairly long delays for certain
6266 * command sequences. With too short delays (even if the answer
6267 * is set to RIRB properly), it results in the silence output
6268 * on some hardwares like Dell.
6270 * The below flag enables the longer delay (see get_response
6273 codec->bus->needs_damn_long_delay = 1;
6275 /* no jack detecion for ref-no-jd model */
6276 if (spec->board_config == STAC_D965_REF_NO_JD)
6277 spec->hp_detect = 0;
6282 static int patch_stac9205(struct hda_codec *codec)
6284 struct sigmatel_spec *spec;
6287 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6291 codec->no_trigger_sense = 1;
6293 spec->linear_tone_beep = 1;
6294 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
6295 spec->pin_nids = stac9205_pin_nids;
6296 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
6300 if (spec->board_config < 0)
6301 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6304 stac92xx_set_config_regs(codec,
6305 stac9205_brd_tbl[spec->board_config]);
6307 spec->digbeep_nid = 0x23;
6308 spec->adc_nids = stac9205_adc_nids;
6309 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
6310 spec->mux_nids = stac9205_mux_nids;
6311 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
6312 spec->smux_nids = stac9205_smux_nids;
6313 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
6314 spec->dmic_nids = stac9205_dmic_nids;
6315 spec->num_dmics = STAC9205_NUM_DMICS;
6316 spec->dmux_nids = stac9205_dmux_nids;
6317 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
6320 spec->init = stac9205_core_init;
6321 spec->aloopback_ctl = stac9205_loopback;
6323 spec->num_caps = STAC9205_NUM_CAPS;
6324 spec->capvols = stac9205_capvols;
6325 spec->capsws = stac9205_capsws;
6327 spec->aloopback_mask = 0x40;
6328 spec->aloopback_shift = 0;
6329 /* Turn on/off EAPD per HP plugging */
6330 if (spec->board_config != STAC_9205_EAPD)
6331 spec->eapd_switch = 1;
6332 spec->multiout.dac_nids = spec->dac_nids;
6334 switch (spec->board_config){
6335 case STAC_9205_DELL_M43:
6336 /* Enable SPDIF in/out */
6337 snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030);
6338 snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030);
6340 /* Enable unsol response for GPIO4/Dock HP connection */
6341 err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
6344 snd_hda_codec_write_cache(codec, codec->afg, 0,
6345 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
6346 snd_hda_codec_write_cache(codec, codec->afg, 0,
6347 AC_VERB_SET_UNSOLICITED_ENABLE,
6350 spec->gpio_dir = 0x0b;
6351 spec->eapd_mask = 0x01;
6352 spec->gpio_mask = 0x1b;
6353 spec->gpio_mute = 0x10;
6354 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
6357 spec->gpio_data = 0x01;
6360 /* SPDIF-In enabled */
6363 /* GPIO0 High = EAPD */
6364 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
6365 spec->gpio_data = 0x01;
6369 err = stac92xx_parse_auto_config(codec);
6371 if (spec->board_config < 0) {
6372 printk(KERN_WARNING "hda_codec: No auto-config is "
6373 "available, default to model=ref\n");
6374 spec->board_config = STAC_9205_REF;
6380 stac92xx_free(codec);
6384 codec->patch_ops = stac92xx_patch_ops;
6386 codec->proc_widget_hook = stac9205_proc_hook;
6395 static const struct hda_verb stac9872_core_init[] = {
6396 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
6397 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
6401 static const hda_nid_t stac9872_pin_nids[] = {
6402 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
6406 static const hda_nid_t stac9872_adc_nids[] = {
6410 static const hda_nid_t stac9872_mux_nids[] = {
6414 static const unsigned long stac9872_capvols[] = {
6415 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
6417 #define stac9872_capsws stac9872_capvols
6419 static const unsigned int stac9872_vaio_pin_configs[9] = {
6420 0x03211020, 0x411111f0, 0x411111f0, 0x03a15030,
6421 0x411111f0, 0x90170110, 0x411111f0, 0x411111f0,
6425 static const char * const stac9872_models[STAC_9872_MODELS] = {
6426 [STAC_9872_AUTO] = "auto",
6427 [STAC_9872_VAIO] = "vaio",
6430 static const unsigned int *stac9872_brd_tbl[STAC_9872_MODELS] = {
6431 [STAC_9872_VAIO] = stac9872_vaio_pin_configs,
6434 static const struct snd_pci_quirk stac9872_cfg_tbl[] = {
6435 SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0,
6436 "Sony VAIO F/S", STAC_9872_VAIO),
6440 static int patch_stac9872(struct hda_codec *codec)
6442 struct sigmatel_spec *spec;
6445 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6448 codec->no_trigger_sense = 1;
6450 spec->linear_tone_beep = 1;
6451 spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
6452 spec->pin_nids = stac9872_pin_nids;
6454 spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
6457 if (spec->board_config < 0)
6458 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6461 stac92xx_set_config_regs(codec,
6462 stac9872_brd_tbl[spec->board_config]);
6464 spec->multiout.dac_nids = spec->dac_nids;
6465 spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
6466 spec->adc_nids = stac9872_adc_nids;
6467 spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
6468 spec->mux_nids = stac9872_mux_nids;
6469 spec->init = stac9872_core_init;
6471 spec->capvols = stac9872_capvols;
6472 spec->capsws = stac9872_capsws;
6474 err = stac92xx_parse_auto_config(codec);
6476 stac92xx_free(codec);
6479 spec->input_mux = &spec->private_imux;
6480 codec->patch_ops = stac92xx_patch_ops;
6488 static const struct hda_codec_preset snd_hda_preset_sigmatel[] = {
6489 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
6490 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
6491 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
6492 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
6493 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
6494 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
6495 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
6496 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
6497 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
6498 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
6499 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
6500 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
6501 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
6502 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
6503 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
6504 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
6505 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
6506 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
6507 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
6508 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
6509 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
6510 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
6511 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
6512 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
6513 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
6514 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
6515 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
6516 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
6517 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
6518 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
6519 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
6520 /* The following does not take into account .id=0x83847661 when subsys =
6521 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
6522 * currently not fully supported.
6524 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
6525 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
6526 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
6527 { .id = 0x83847698, .name = "STAC9205", .patch = patch_stac9205 },
6528 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
6529 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
6530 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
6531 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
6532 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
6533 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
6534 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
6535 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
6536 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
6537 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
6538 { .id = 0x111d76d4, .name = "92HD83C1C5", .patch = patch_stac92hd83xxx},
6539 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
6540 { .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx},
6541 { .id = 0x111d76d1, .name = "92HD87B1/3", .patch = patch_stac92hd83xxx},
6542 { .id = 0x111d76d9, .name = "92HD87B2/4", .patch = patch_stac92hd83xxx},
6543 { .id = 0x111d7666, .name = "92HD88B3", .patch = patch_stac92hd83xxx},
6544 { .id = 0x111d7667, .name = "92HD88B1", .patch = patch_stac92hd83xxx},
6545 { .id = 0x111d7668, .name = "92HD88B2", .patch = patch_stac92hd83xxx},
6546 { .id = 0x111d7669, .name = "92HD88B4", .patch = patch_stac92hd83xxx},
6547 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
6548 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
6549 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
6550 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
6551 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
6552 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
6553 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
6554 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
6555 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
6556 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
6557 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
6558 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
6559 { .id = 0x111d76c0, .name = "92HD89C3", .patch = patch_stac92hd73xx },
6560 { .id = 0x111d76c1, .name = "92HD89C2", .patch = patch_stac92hd73xx },
6561 { .id = 0x111d76c2, .name = "92HD89C1", .patch = patch_stac92hd73xx },
6562 { .id = 0x111d76c3, .name = "92HD89B3", .patch = patch_stac92hd73xx },
6563 { .id = 0x111d76c4, .name = "92HD89B2", .patch = patch_stac92hd73xx },
6564 { .id = 0x111d76c5, .name = "92HD89B1", .patch = patch_stac92hd73xx },
6565 { .id = 0x111d76c6, .name = "92HD89E3", .patch = patch_stac92hd73xx },
6566 { .id = 0x111d76c7, .name = "92HD89E2", .patch = patch_stac92hd73xx },
6567 { .id = 0x111d76c8, .name = "92HD89E1", .patch = patch_stac92hd73xx },
6568 { .id = 0x111d76c9, .name = "92HD89D3", .patch = patch_stac92hd73xx },
6569 { .id = 0x111d76ca, .name = "92HD89D2", .patch = patch_stac92hd73xx },
6570 { .id = 0x111d76cb, .name = "92HD89D1", .patch = patch_stac92hd73xx },
6571 { .id = 0x111d76cc, .name = "92HD89F3", .patch = patch_stac92hd73xx },
6572 { .id = 0x111d76cd, .name = "92HD89F2", .patch = patch_stac92hd73xx },
6573 { .id = 0x111d76ce, .name = "92HD89F1", .patch = patch_stac92hd73xx },
6574 { .id = 0x111d76df, .name = "92HD93BXX", .patch = patch_stac92hd83xxx},
6575 { .id = 0x111d76e0, .name = "92HD91BXX", .patch = patch_stac92hd83xxx},
6576 { .id = 0x111d76e3, .name = "92HD98BXX", .patch = patch_stac92hd83xxx},
6577 { .id = 0x111d76e5, .name = "92HD99BXX", .patch = patch_stac92hd83xxx},
6578 { .id = 0x111d76e7, .name = "92HD90BXX", .patch = patch_stac92hd83xxx},
6579 { .id = 0x111d76e8, .name = "92HD66B1X5", .patch = patch_stac92hd83xxx},
6580 { .id = 0x111d76e9, .name = "92HD66B2X5", .patch = patch_stac92hd83xxx},
6581 { .id = 0x111d76ea, .name = "92HD66B3X5", .patch = patch_stac92hd83xxx},
6582 { .id = 0x111d76eb, .name = "92HD66C1X5", .patch = patch_stac92hd83xxx},
6583 { .id = 0x111d76ec, .name = "92HD66C2X5", .patch = patch_stac92hd83xxx},
6584 { .id = 0x111d76ed, .name = "92HD66C3X5", .patch = patch_stac92hd83xxx},
6585 { .id = 0x111d76ee, .name = "92HD66B1X3", .patch = patch_stac92hd83xxx},
6586 { .id = 0x111d76ef, .name = "92HD66B2X3", .patch = patch_stac92hd83xxx},
6587 { .id = 0x111d76f0, .name = "92HD66B3X3", .patch = patch_stac92hd83xxx},
6588 { .id = 0x111d76f1, .name = "92HD66C1X3", .patch = patch_stac92hd83xxx},
6589 { .id = 0x111d76f2, .name = "92HD66C2X3", .patch = patch_stac92hd83xxx},
6590 { .id = 0x111d76f3, .name = "92HD66C3/65", .patch = patch_stac92hd83xxx},
6594 MODULE_ALIAS("snd-hda-codec-id:8384*");
6595 MODULE_ALIAS("snd-hda-codec-id:111d*");
6597 MODULE_LICENSE("GPL");
6598 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
6600 static struct hda_codec_preset_list sigmatel_list = {
6601 .preset = snd_hda_preset_sigmatel,
6602 .owner = THIS_MODULE,
6605 static int __init patch_sigmatel_init(void)
6607 return snd_hda_add_codec_preset(&sigmatel_list);
6610 static void __exit patch_sigmatel_exit(void)
6612 snd_hda_delete_codec_preset(&sigmatel_list);
6615 module_init(patch_sigmatel_init)
6616 module_exit(patch_sigmatel_exit)