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 <sound/core.h>
33 #include <sound/asoundef.h>
34 #include <sound/jack.h>
35 #include "hda_codec.h"
36 #include "hda_local.h"
80 STAC_92HD73XX_NO_JD, /* no jack-detection */
94 STAC_92HD83XXX_PWR_REF,
112 STAC_92HD71BXX_MODELS
138 STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
139 * is given, one of the above models will be
140 * chosen according to the subsystem id. */
141 /* for backward compatibility */
158 STAC_D965_REF_NO_JD, /* no jack-detection */
175 struct sigmatel_event {
182 struct sigmatel_jack {
185 struct snd_jack *jack;
188 struct sigmatel_mic_route {
191 signed char dmux_idx;
194 struct sigmatel_spec {
195 struct snd_kcontrol_new *mixers[4];
196 unsigned int num_mixers;
199 unsigned int eapd_switch: 1;
200 unsigned int surr_switch: 1;
201 unsigned int alt_switch: 1;
202 unsigned int hp_detect: 1;
203 unsigned int spdif_mute: 1;
204 unsigned int check_volume_offset:1;
205 unsigned int auto_mic:1;
206 unsigned int linear_tone_beep:1;
209 unsigned int eapd_mask;
210 unsigned int gpio_mask;
211 unsigned int gpio_dir;
212 unsigned int gpio_data;
213 unsigned int gpio_mute;
214 unsigned int gpio_led;
215 unsigned int gpio_led_polarity;
218 unsigned int stream_delay;
220 /* analog loopback */
221 struct snd_kcontrol_new *aloopback_ctl;
222 unsigned char aloopback_mask;
223 unsigned char aloopback_shift;
225 /* power management */
226 unsigned int num_pwrs;
227 unsigned int *pwr_mapping;
232 struct snd_array jacks;
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];
249 unsigned int num_adcs;
251 unsigned int num_muxes;
252 hda_nid_t *dmic_nids;
253 unsigned int num_dmics;
254 hda_nid_t *dmux_nids;
255 unsigned int num_dmuxes;
256 hda_nid_t *smux_nids;
257 unsigned int num_smuxes;
258 unsigned int num_analog_muxes;
260 unsigned long *capvols; /* amp-volume attr: HDA_COMPOSE_AMP_VAL() */
261 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;
267 const char **spdif_labels;
269 hda_nid_t dig_in_nid;
271 hda_nid_t anabeep_nid;
272 hda_nid_t digbeep_nid;
276 unsigned int num_pins;
278 /* codec specific stuff */
279 struct hda_verb *init;
280 struct snd_kcontrol_new *mixer;
283 struct hda_input_mux *dinput_mux;
284 unsigned int cur_dmux[2];
285 struct hda_input_mux *input_mux;
286 unsigned int cur_mux[3];
287 struct hda_input_mux *sinput_mux;
288 unsigned int cur_smux[2];
289 unsigned int cur_amux;
291 unsigned int powerdown_adcs;
294 unsigned int io_switch[2];
295 unsigned int clfe_swap;
296 hda_nid_t line_switch; /* shared line-in for input and output */
297 hda_nid_t mic_switch; /* shared mic-in for input and output */
298 hda_nid_t hp_switch; /* NID of HP as line-out */
299 unsigned int aloopback;
301 struct hda_pcm pcm_rec[2]; /* PCM information */
303 /* dynamic controls and input_mux */
304 struct auto_pin_cfg autocfg;
305 struct snd_array kctls;
306 struct hda_input_mux private_dimux;
307 struct hda_input_mux private_imux;
308 struct hda_input_mux private_smux;
309 struct hda_input_mux private_mono_mux;
312 static hda_nid_t stac9200_adc_nids[1] = {
316 static hda_nid_t stac9200_mux_nids[1] = {
320 static hda_nid_t stac9200_dac_nids[1] = {
324 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
325 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
329 static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
333 static hda_nid_t stac92hd73xx_adc_nids[2] = {
337 #define STAC92HD73XX_NUM_DMICS 2
338 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
342 #define STAC92HD73_DAC_COUNT 5
344 static hda_nid_t stac92hd73xx_mux_nids[2] = {
348 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
352 static hda_nid_t stac92hd73xx_smux_nids[2] = {
356 #define STAC92HD73XX_NUM_CAPS 2
357 static unsigned long stac92hd73xx_capvols[] = {
358 HDA_COMPOSE_AMP_VAL(0x20, 3, 0, HDA_OUTPUT),
359 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
361 #define stac92hd73xx_capsws stac92hd73xx_capvols
363 #define STAC92HD83_DAC_COUNT 3
365 static hda_nid_t stac92hd83xxx_mux_nids[2] = {
369 static hda_nid_t stac92hd83xxx_adc_nids[2] = {
373 static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
377 static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
381 static unsigned int stac92hd83xxx_pwr_mapping[4] = {
382 0x03, 0x0c, 0x20, 0x40,
385 #define STAC92HD83XXX_NUM_DMICS 2
386 static hda_nid_t stac92hd83xxx_dmic_nids[STAC92HD83XXX_NUM_DMICS + 1] = {
390 #define STAC92HD83XXX_NUM_CAPS 2
391 static unsigned long stac92hd83xxx_capvols[] = {
392 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
393 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_OUTPUT),
395 #define stac92hd83xxx_capsws stac92hd83xxx_capvols
397 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
401 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
405 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
409 static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
413 static hda_nid_t stac92hd71bxx_smux_nids[2] = {
417 #define STAC92HD71BXX_NUM_DMICS 2
418 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
422 static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
426 #define STAC92HD71BXX_NUM_CAPS 2
427 static 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 hda_nid_t stac925x_adc_nids[1] = {
437 static hda_nid_t stac925x_mux_nids[1] = {
441 static hda_nid_t stac925x_dac_nids[1] = {
445 #define STAC925X_NUM_DMICS 1
446 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
450 static hda_nid_t stac925x_dmux_nids[1] = {
454 static unsigned long stac925x_capvols[] = {
455 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
457 static unsigned long stac925x_capsws[] = {
458 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
461 static hda_nid_t stac922x_adc_nids[2] = {
465 static hda_nid_t stac922x_mux_nids[2] = {
469 #define STAC922X_NUM_CAPS 2
470 static 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 hda_nid_t stac927x_slave_dig_outs[2] = {
480 static hda_nid_t stac927x_adc_nids[3] = {
484 static hda_nid_t stac927x_mux_nids[3] = {
488 static hda_nid_t stac927x_smux_nids[1] = {
492 static hda_nid_t stac927x_dac_nids[6] = {
493 0x02, 0x03, 0x04, 0x05, 0x06, 0
496 static hda_nid_t stac927x_dmux_nids[1] = {
500 #define STAC927X_NUM_DMICS 2
501 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
505 #define STAC927X_NUM_CAPS 3
506 static 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 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 *stac927x_spdif_labels[5] = {
518 "Digital Playback", "ADAT", "Analog Mux 1",
519 "Analog Mux 2", "Analog Mux 3"
522 static hda_nid_t stac9205_adc_nids[2] = {
526 static hda_nid_t stac9205_mux_nids[2] = {
530 static hda_nid_t stac9205_dmux_nids[1] = {
534 static hda_nid_t stac9205_smux_nids[1] = {
538 #define STAC9205_NUM_DMICS 2
539 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
543 #define STAC9205_NUM_CAPS 2
544 static 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 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 hda_nid_t stac9200_pin_nids[8] = {
554 0x08, 0x09, 0x0d, 0x0e,
555 0x0f, 0x10, 0x11, 0x12,
558 static hda_nid_t stac925x_pin_nids[8] = {
559 0x07, 0x08, 0x0a, 0x0b,
560 0x0c, 0x0d, 0x10, 0x11,
563 static hda_nid_t stac922x_pin_nids[10] = {
564 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
565 0x0f, 0x10, 0x11, 0x15, 0x1b,
568 static hda_nid_t stac92hd73xx_pin_nids[13] = {
569 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
570 0x0f, 0x10, 0x11, 0x12, 0x13,
574 static hda_nid_t stac92hd83xxx_pin_nids[10] = {
575 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
576 0x0f, 0x10, 0x11, 0x1f, 0x20,
579 static hda_nid_t stac92hd88xxx_pin_nids[10] = {
580 0x0a, 0x0b, 0x0c, 0x0d,
581 0x0f, 0x11, 0x1f, 0x20,
584 #define STAC92HD71BXX_NUM_PINS 13
585 static hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
586 0x0a, 0x0b, 0x0c, 0x0d, 0x00,
587 0x00, 0x14, 0x18, 0x19, 0x1e,
590 static hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
591 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
592 0x0f, 0x14, 0x18, 0x19, 0x1e,
596 static hda_nid_t stac927x_pin_nids[14] = {
597 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
598 0x0f, 0x10, 0x11, 0x12, 0x13,
599 0x14, 0x21, 0x22, 0x23,
602 static hda_nid_t stac9205_pin_nids[12] = {
603 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
604 0x0f, 0x14, 0x16, 0x17, 0x18,
608 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
609 struct snd_ctl_elem_info *uinfo)
611 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
612 struct sigmatel_spec *spec = codec->spec;
613 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
616 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
617 struct snd_ctl_elem_value *ucontrol)
619 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
620 struct sigmatel_spec *spec = codec->spec;
621 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
623 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
627 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
628 struct snd_ctl_elem_value *ucontrol)
630 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
631 struct sigmatel_spec *spec = codec->spec;
632 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
634 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
635 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
638 static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
639 struct snd_ctl_elem_info *uinfo)
641 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
642 struct sigmatel_spec *spec = codec->spec;
643 return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
646 static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
647 struct snd_ctl_elem_value *ucontrol)
649 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
650 struct sigmatel_spec *spec = codec->spec;
651 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
653 ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
657 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
658 struct snd_ctl_elem_value *ucontrol)
660 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
661 struct sigmatel_spec *spec = codec->spec;
662 struct hda_input_mux *smux = &spec->private_smux;
663 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
667 err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
668 spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
672 if (spec->spdif_mute) {
674 nid = spec->multiout.dig_out_nid;
676 nid = codec->slave_dig_outs[smux_idx - 1];
677 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
681 /* un/mute SPDIF out */
682 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
688 static unsigned int stac92xx_vref_set(struct hda_codec *codec,
689 hda_nid_t nid, unsigned int new_vref)
693 pincfg = snd_hda_codec_read(codec, nid, 0,
694 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
697 pincfg &= ~(AC_PINCTL_VREFEN | AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
700 if (new_vref == AC_PINCTL_VREF_HIZ)
701 pincfg |= AC_PINCTL_OUT_EN;
703 pincfg |= AC_PINCTL_IN_EN;
705 error = snd_hda_codec_write_cache(codec, nid, 0,
706 AC_VERB_SET_PIN_WIDGET_CONTROL, pincfg);
713 static unsigned int stac92xx_vref_get(struct hda_codec *codec, hda_nid_t nid)
716 vref = snd_hda_codec_read(codec, nid, 0,
717 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
718 vref &= AC_PINCTL_VREFEN;
722 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
724 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
725 struct sigmatel_spec *spec = codec->spec;
726 return snd_hda_input_mux_info(spec->input_mux, uinfo);
729 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
731 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
732 struct sigmatel_spec *spec = codec->spec;
733 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
735 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
739 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
741 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
742 struct sigmatel_spec *spec = codec->spec;
743 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
744 const struct hda_input_mux *imux = spec->input_mux;
745 unsigned int idx, prev_idx;
747 idx = ucontrol->value.enumerated.item[0];
748 if (idx >= imux->num_items)
749 idx = imux->num_items - 1;
750 prev_idx = spec->cur_mux[adc_idx];
753 if (idx < spec->num_analog_muxes) {
754 snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0,
755 AC_VERB_SET_CONNECT_SEL,
756 imux->items[idx].index);
757 if (prev_idx >= spec->num_analog_muxes) {
758 imux = spec->dinput_mux;
760 snd_hda_codec_write_cache(codec,
761 spec->dmux_nids[adc_idx], 0,
762 AC_VERB_SET_CONNECT_SEL,
763 imux->items[0].index);
766 imux = spec->dinput_mux;
767 snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0,
768 AC_VERB_SET_CONNECT_SEL,
769 imux->items[idx - 1].index);
771 spec->cur_mux[adc_idx] = idx;
775 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
776 struct snd_ctl_elem_info *uinfo)
778 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
779 struct sigmatel_spec *spec = codec->spec;
780 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
783 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
784 struct snd_ctl_elem_value *ucontrol)
786 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
787 struct sigmatel_spec *spec = codec->spec;
789 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
793 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
794 struct snd_ctl_elem_value *ucontrol)
796 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
797 struct sigmatel_spec *spec = codec->spec;
799 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
800 spec->mono_nid, &spec->cur_mmux);
803 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
805 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
806 struct snd_ctl_elem_value *ucontrol)
808 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
809 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
810 struct sigmatel_spec *spec = codec->spec;
812 ucontrol->value.integer.value[0] = !!(spec->aloopback &
813 (spec->aloopback_mask << idx));
817 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
818 struct snd_ctl_elem_value *ucontrol)
820 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
821 struct sigmatel_spec *spec = codec->spec;
822 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
823 unsigned int dac_mode;
824 unsigned int val, idx_val;
826 idx_val = spec->aloopback_mask << idx;
827 if (ucontrol->value.integer.value[0])
828 val = spec->aloopback | idx_val;
830 val = spec->aloopback & ~idx_val;
831 if (spec->aloopback == val)
834 spec->aloopback = val;
836 /* Only return the bits defined by the shift value of the
837 * first two bytes of the mask
839 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
840 kcontrol->private_value & 0xFFFF, 0x0);
841 dac_mode >>= spec->aloopback_shift;
843 if (spec->aloopback & idx_val) {
844 snd_hda_power_up(codec);
847 snd_hda_power_down(codec);
848 dac_mode &= ~idx_val;
851 snd_hda_codec_write_cache(codec, codec->afg, 0,
852 kcontrol->private_value >> 16, dac_mode);
857 static struct hda_verb stac9200_core_init[] = {
858 /* set dac0mux for dac converter */
859 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
863 static struct hda_verb stac9200_eapd_init[] = {
864 /* set dac0mux for dac converter */
865 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
866 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
870 static struct hda_verb dell_eq_core_init[] = {
871 /* set master volume to max value without distortion
872 * and direct control */
873 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
877 static struct hda_verb stac92hd73xx_core_init[] = {
878 /* set master volume and direct control */
879 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
883 static struct hda_verb stac92hd83xxx_core_init[] = {
884 /* power state controls amps */
885 { 0x01, AC_VERB_SET_EAPD, 1 << 2},
889 static struct hda_verb stac92hd71bxx_core_init[] = {
890 /* set master volume and direct control */
891 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
895 static struct hda_verb stac92hd71bxx_unmute_core_init[] = {
896 /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
897 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
898 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
899 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
903 static struct hda_verb stac925x_core_init[] = {
904 /* set dac0mux for dac converter */
905 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
906 /* mute the master volume */
907 { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
911 static struct hda_verb stac922x_core_init[] = {
912 /* set master volume and direct control */
913 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
917 static struct hda_verb d965_core_init[] = {
918 /* set master volume and direct control */
919 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
920 /* unmute node 0x1b */
921 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
922 /* select node 0x03 as DAC */
923 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
927 static struct hda_verb dell_3st_core_init[] = {
928 /* don't set delta bit */
929 {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
930 /* unmute node 0x1b */
931 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
932 /* select node 0x03 as DAC */
933 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
937 static struct hda_verb stac927x_core_init[] = {
938 /* set master volume and direct control */
939 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
940 /* enable analog pc beep path */
941 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
945 static struct hda_verb stac927x_volknob_core_init[] = {
946 /* don't set delta bit */
947 {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
948 /* enable analog pc beep path */
949 {0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
953 static struct hda_verb stac9205_core_init[] = {
954 /* set master volume and direct control */
955 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
956 /* enable analog pc beep path */
957 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
961 #define STAC_MONO_MUX \
963 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
964 .name = "Mono Mux", \
966 .info = stac92xx_mono_mux_enum_info, \
967 .get = stac92xx_mono_mux_enum_get, \
968 .put = stac92xx_mono_mux_enum_put, \
971 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
973 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
974 .name = "Analog Loopback", \
976 .info = stac92xx_aloopback_info, \
977 .get = stac92xx_aloopback_get, \
978 .put = stac92xx_aloopback_put, \
979 .private_value = verb_read | (verb_write << 16), \
982 #define DC_BIAS(xname, idx, nid) \
984 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
987 .info = stac92xx_dc_bias_info, \
988 .get = stac92xx_dc_bias_get, \
989 .put = stac92xx_dc_bias_put, \
990 .private_value = nid, \
993 static struct snd_kcontrol_new stac9200_mixer[] = {
994 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
995 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
996 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
997 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
1001 static struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
1002 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
1006 static struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = {
1007 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1011 static struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
1012 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1017 static struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
1018 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
1021 static struct snd_kcontrol_new stac925x_mixer[] = {
1022 HDA_CODEC_VOLUME("Master Playback Volume", 0x0e, 0, HDA_OUTPUT),
1023 HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
1027 static struct snd_kcontrol_new stac9205_loopback[] = {
1028 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1032 static struct snd_kcontrol_new stac927x_loopback[] = {
1033 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1037 static struct snd_kcontrol_new stac_dmux_mixer = {
1038 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1039 .name = "Digital Input Source",
1040 /* count set later */
1041 .info = stac92xx_dmux_enum_info,
1042 .get = stac92xx_dmux_enum_get,
1043 .put = stac92xx_dmux_enum_put,
1046 static struct snd_kcontrol_new stac_smux_mixer = {
1047 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1048 .name = "IEC958 Playback Source",
1049 /* count set later */
1050 .info = stac92xx_smux_enum_info,
1051 .get = stac92xx_smux_enum_get,
1052 .put = stac92xx_smux_enum_put,
1055 static const char *slave_vols[] = {
1056 "Front Playback Volume",
1057 "Surround Playback Volume",
1058 "Center Playback Volume",
1059 "LFE Playback Volume",
1060 "Side Playback Volume",
1061 "Headphone Playback Volume",
1062 "Speaker Playback Volume",
1066 static const char *slave_sws[] = {
1067 "Front Playback Switch",
1068 "Surround Playback Switch",
1069 "Center Playback Switch",
1070 "LFE Playback Switch",
1071 "Side Playback Switch",
1072 "Headphone Playback Switch",
1073 "Speaker Playback Switch",
1074 "IEC958 Playback Switch",
1078 static void stac92xx_free_kctls(struct hda_codec *codec);
1079 static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
1081 static int stac92xx_build_controls(struct hda_codec *codec)
1083 struct sigmatel_spec *spec = codec->spec;
1084 struct auto_pin_cfg *cfg = &spec->autocfg;
1090 err = snd_hda_add_new_ctls(codec, spec->mixer);
1095 for (i = 0; i < spec->num_mixers; i++) {
1096 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1100 if (!spec->auto_mic && spec->num_dmuxes > 0 &&
1101 snd_hda_get_bool_hint(codec, "separate_dmux") == 1) {
1102 stac_dmux_mixer.count = spec->num_dmuxes;
1103 err = snd_hda_ctl_add(codec, 0,
1104 snd_ctl_new1(&stac_dmux_mixer, codec));
1108 if (spec->num_smuxes > 0) {
1109 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1110 struct hda_input_mux *smux = &spec->private_smux;
1111 /* check for mute support on SPDIF out */
1112 if (wcaps & AC_WCAP_OUT_AMP) {
1113 smux->items[smux->num_items].label = "Off";
1114 smux->items[smux->num_items].index = 0;
1116 spec->spdif_mute = 1;
1118 stac_smux_mixer.count = spec->num_smuxes;
1119 err = snd_hda_ctl_add(codec, 0,
1120 snd_ctl_new1(&stac_smux_mixer, codec));
1125 if (spec->multiout.dig_out_nid) {
1126 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1129 err = snd_hda_create_spdif_share_sw(codec,
1133 spec->multiout.share_spdif = 1;
1135 if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1136 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1141 /* if we have no master control, let's create it */
1142 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1143 unsigned int vmaster_tlv[4];
1144 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1145 HDA_OUTPUT, vmaster_tlv);
1146 /* correct volume offset */
1147 vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
1148 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1149 vmaster_tlv, slave_vols);
1153 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1154 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1160 if (spec->aloopback_ctl &&
1161 snd_hda_get_bool_hint(codec, "loopback") == 1) {
1162 err = snd_hda_add_new_ctls(codec, spec->aloopback_ctl);
1167 stac92xx_free_kctls(codec); /* no longer needed */
1169 /* create jack input elements */
1170 if (spec->hp_detect) {
1171 for (i = 0; i < cfg->hp_outs; i++) {
1172 int type = SND_JACK_HEADPHONE;
1173 nid = cfg->hp_pins[i];
1174 /* jack detection */
1175 if (cfg->hp_outs == i)
1176 type |= SND_JACK_LINEOUT;
1177 err = stac92xx_add_jack(codec, nid, type);
1182 for (i = 0; i < cfg->line_outs; i++) {
1183 err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
1188 for (i = 0; i < cfg->num_inputs; i++) {
1189 nid = cfg->inputs[i].pin;
1190 err = stac92xx_add_jack(codec, nid, SND_JACK_MICROPHONE);
1198 static unsigned int ref9200_pin_configs[8] = {
1199 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1200 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1203 static unsigned int gateway9200_m4_pin_configs[8] = {
1204 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1205 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1207 static unsigned int gateway9200_m4_2_pin_configs[8] = {
1208 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1209 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1213 STAC 9200 pin configs for
1218 static unsigned int dell9200_d21_pin_configs[8] = {
1219 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
1220 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1224 STAC 9200 pin configs for
1228 static unsigned int dell9200_d22_pin_configs[8] = {
1229 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1230 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1234 STAC 9200 pin configs for
1235 102801C4 (Dell Dimension E310)
1242 static unsigned int dell9200_d23_pin_configs[8] = {
1243 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1244 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
1249 STAC 9200-32 pin configs for
1250 102801B5 (Dell Inspiron 630m)
1251 102801D8 (Dell Inspiron 640m)
1253 static unsigned int dell9200_m21_pin_configs[8] = {
1254 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1255 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1259 STAC 9200-32 pin configs for
1260 102801C2 (Dell Latitude D620)
1262 102801CC (Dell Latitude D820)
1266 static unsigned int dell9200_m22_pin_configs[8] = {
1267 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1268 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1272 STAC 9200-32 pin configs for
1273 102801CE (Dell XPS M1710)
1274 102801CF (Dell Precision M90)
1276 static unsigned int dell9200_m23_pin_configs[8] = {
1277 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1278 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1282 STAC 9200-32 pin configs for
1285 102801CB (Dell Latitude 120L)
1288 static unsigned int dell9200_m24_pin_configs[8] = {
1289 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1290 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1294 STAC 9200-32 pin configs for
1295 102801BD (Dell Inspiron E1505n)
1299 static unsigned int dell9200_m25_pin_configs[8] = {
1300 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1301 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1305 STAC 9200-32 pin configs for
1306 102801F5 (Dell Inspiron 1501)
1309 static unsigned int dell9200_m26_pin_configs[8] = {
1310 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1311 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1316 102801CD (Dell Inspiron E1705/9400)
1318 static unsigned int dell9200_m27_pin_configs[8] = {
1319 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1320 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1323 static unsigned int oqo9200_pin_configs[8] = {
1324 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1325 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1329 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1330 [STAC_REF] = ref9200_pin_configs,
1331 [STAC_9200_OQO] = oqo9200_pin_configs,
1332 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1333 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1334 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1335 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1336 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1337 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1338 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1339 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1340 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1341 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1342 [STAC_9200_M4] = gateway9200_m4_pin_configs,
1343 [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1344 [STAC_9200_PANASONIC] = ref9200_pin_configs,
1347 static const char *stac9200_models[STAC_9200_MODELS] = {
1348 [STAC_AUTO] = "auto",
1350 [STAC_9200_OQO] = "oqo",
1351 [STAC_9200_DELL_D21] = "dell-d21",
1352 [STAC_9200_DELL_D22] = "dell-d22",
1353 [STAC_9200_DELL_D23] = "dell-d23",
1354 [STAC_9200_DELL_M21] = "dell-m21",
1355 [STAC_9200_DELL_M22] = "dell-m22",
1356 [STAC_9200_DELL_M23] = "dell-m23",
1357 [STAC_9200_DELL_M24] = "dell-m24",
1358 [STAC_9200_DELL_M25] = "dell-m25",
1359 [STAC_9200_DELL_M26] = "dell-m26",
1360 [STAC_9200_DELL_M27] = "dell-m27",
1361 [STAC_9200_M4] = "gateway-m4",
1362 [STAC_9200_M4_2] = "gateway-m4-2",
1363 [STAC_9200_PANASONIC] = "panasonic",
1366 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1367 /* SigmaTel reference board */
1368 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1369 "DFI LanParty", STAC_REF),
1370 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1371 "DFI LanParty", STAC_REF),
1372 /* Dell laptops have BIOS problem */
1373 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1374 "unknown Dell", STAC_9200_DELL_D21),
1375 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1376 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1377 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1378 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1379 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1380 "unknown Dell", STAC_9200_DELL_D22),
1381 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1382 "unknown Dell", STAC_9200_DELL_D22),
1383 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1384 "Dell Latitude D620", STAC_9200_DELL_M22),
1385 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1386 "unknown Dell", STAC_9200_DELL_D23),
1387 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1388 "unknown Dell", STAC_9200_DELL_D23),
1389 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1390 "unknown Dell", STAC_9200_DELL_M22),
1391 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1392 "unknown Dell", STAC_9200_DELL_M24),
1393 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1394 "unknown Dell", STAC_9200_DELL_M24),
1395 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1396 "Dell Latitude 120L", STAC_9200_DELL_M24),
1397 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1398 "Dell Latitude D820", STAC_9200_DELL_M22),
1399 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1400 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1401 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1402 "Dell XPS M1710", STAC_9200_DELL_M23),
1403 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1404 "Dell Precision M90", STAC_9200_DELL_M23),
1405 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1406 "unknown Dell", STAC_9200_DELL_M22),
1407 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1408 "unknown Dell", STAC_9200_DELL_M22),
1409 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1410 "unknown Dell", STAC_9200_DELL_M22),
1411 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1412 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1413 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1414 "unknown Dell", STAC_9200_DELL_D23),
1415 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1416 "unknown Dell", STAC_9200_DELL_D23),
1417 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1418 "unknown Dell", STAC_9200_DELL_D21),
1419 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1420 "unknown Dell", STAC_9200_DELL_D23),
1421 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1422 "unknown Dell", STAC_9200_DELL_D21),
1423 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1424 "unknown Dell", STAC_9200_DELL_M25),
1425 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1426 "unknown Dell", STAC_9200_DELL_M25),
1427 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1428 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1429 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1430 "unknown Dell", STAC_9200_DELL_M26),
1432 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1433 /* Gateway machines needs EAPD to be set on resume */
1434 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1435 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1436 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1438 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1442 static unsigned int ref925x_pin_configs[8] = {
1443 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1444 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1447 static unsigned int stac925xM1_pin_configs[8] = {
1448 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1449 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1452 static unsigned int stac925xM1_2_pin_configs[8] = {
1453 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1454 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1457 static unsigned int stac925xM2_pin_configs[8] = {
1458 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1459 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1462 static unsigned int stac925xM2_2_pin_configs[8] = {
1463 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1464 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1467 static unsigned int stac925xM3_pin_configs[8] = {
1468 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1469 0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1472 static unsigned int stac925xM5_pin_configs[8] = {
1473 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1474 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1477 static unsigned int stac925xM6_pin_configs[8] = {
1478 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1479 0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1482 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1483 [STAC_REF] = ref925x_pin_configs,
1484 [STAC_M1] = stac925xM1_pin_configs,
1485 [STAC_M1_2] = stac925xM1_2_pin_configs,
1486 [STAC_M2] = stac925xM2_pin_configs,
1487 [STAC_M2_2] = stac925xM2_2_pin_configs,
1488 [STAC_M3] = stac925xM3_pin_configs,
1489 [STAC_M5] = stac925xM5_pin_configs,
1490 [STAC_M6] = stac925xM6_pin_configs,
1493 static const char *stac925x_models[STAC_925x_MODELS] = {
1494 [STAC_925x_AUTO] = "auto",
1497 [STAC_M1_2] = "m1-2",
1499 [STAC_M2_2] = "m2-2",
1505 static struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1506 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1507 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1508 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1509 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1510 SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1511 /* Not sure about the brand name for those */
1512 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1513 SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1514 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1515 SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1519 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1520 /* SigmaTel reference board */
1521 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1522 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
1523 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1525 /* Default table for unknown ID */
1526 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1531 static unsigned int ref92hd73xx_pin_configs[13] = {
1532 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1533 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1534 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1538 static unsigned int dell_m6_pin_configs[13] = {
1539 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1540 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1541 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1545 static unsigned int alienware_m17x_pin_configs[13] = {
1546 0x0321101f, 0x0321101f, 0x03a11020, 0x03014020,
1547 0x90170110, 0x4f0000f0, 0x4f0000f0, 0x4f0000f0,
1548 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1552 static unsigned int intel_dg45id_pin_configs[13] = {
1553 0x02214230, 0x02A19240, 0x01013214, 0x01014210,
1554 0x01A19250, 0x01011212, 0x01016211
1557 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1558 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1559 [STAC_DELL_M6_AMIC] = dell_m6_pin_configs,
1560 [STAC_DELL_M6_DMIC] = dell_m6_pin_configs,
1561 [STAC_DELL_M6_BOTH] = dell_m6_pin_configs,
1562 [STAC_DELL_EQ] = dell_m6_pin_configs,
1563 [STAC_ALIENWARE_M17X] = alienware_m17x_pin_configs,
1564 [STAC_92HD73XX_INTEL] = intel_dg45id_pin_configs,
1567 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1568 [STAC_92HD73XX_AUTO] = "auto",
1569 [STAC_92HD73XX_NO_JD] = "no-jd",
1570 [STAC_92HD73XX_REF] = "ref",
1571 [STAC_92HD73XX_INTEL] = "intel",
1572 [STAC_DELL_M6_AMIC] = "dell-m6-amic",
1573 [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1574 [STAC_DELL_M6_BOTH] = "dell-m6",
1575 [STAC_DELL_EQ] = "dell-eq",
1576 [STAC_ALIENWARE_M17X] = "alienware",
1579 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1580 /* SigmaTel reference board */
1581 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1582 "DFI LanParty", STAC_92HD73XX_REF),
1583 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1584 "DFI LanParty", STAC_92HD73XX_REF),
1585 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
1586 "Intel DG45ID", STAC_92HD73XX_INTEL),
1587 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
1588 "Intel DG45FC", STAC_92HD73XX_INTEL),
1589 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1590 "Dell Studio 1535", STAC_DELL_M6_DMIC),
1591 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1592 "unknown Dell", STAC_DELL_M6_DMIC),
1593 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1594 "unknown Dell", STAC_DELL_M6_BOTH),
1595 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1596 "unknown Dell", STAC_DELL_M6_BOTH),
1597 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1598 "unknown Dell", STAC_DELL_M6_AMIC),
1599 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1600 "unknown Dell", STAC_DELL_M6_AMIC),
1601 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1602 "unknown Dell", STAC_DELL_M6_DMIC),
1603 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1604 "unknown Dell", STAC_DELL_M6_DMIC),
1605 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1606 "Dell Studio 1537", STAC_DELL_M6_DMIC),
1607 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1608 "Dell Studio 17", STAC_DELL_M6_DMIC),
1609 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
1610 "Dell Studio 1555", STAC_DELL_M6_DMIC),
1611 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd,
1612 "Dell Studio 1557", STAC_DELL_M6_DMIC),
1613 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe,
1614 "Dell Studio XPS 1645", STAC_DELL_M6_BOTH),
1615 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413,
1616 "Dell Studio 1558", STAC_DELL_M6_BOTH),
1620 static struct snd_pci_quirk stac92hd73xx_codec_id_cfg_tbl[] = {
1621 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1,
1622 "Alienware M17x", STAC_ALIENWARE_M17X),
1626 static unsigned int ref92hd83xxx_pin_configs[10] = {
1627 0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1628 0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1629 0x01451160, 0x98560170,
1632 static unsigned int dell_s14_pin_configs[10] = {
1633 0x0221403f, 0x0221101f, 0x02a19020, 0x90170110,
1634 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a60160,
1635 0x40f000f0, 0x40f000f0,
1638 static unsigned int hp_dv7_4000_pin_configs[10] = {
1639 0x03a12050, 0x0321201f, 0x40f000f0, 0x90170110,
1640 0x40f000f0, 0x40f000f0, 0x90170110, 0xd5a30140,
1641 0x40f000f0, 0x40f000f0,
1644 static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1645 [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1646 [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
1647 [STAC_DELL_S14] = dell_s14_pin_configs,
1648 [STAC_HP_DV7_4000] = hp_dv7_4000_pin_configs,
1651 static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1652 [STAC_92HD83XXX_AUTO] = "auto",
1653 [STAC_92HD83XXX_REF] = "ref",
1654 [STAC_92HD83XXX_PWR_REF] = "mic-ref",
1655 [STAC_DELL_S14] = "dell-s14",
1656 [STAC_92HD83XXX_HP] = "hp",
1657 [STAC_HP_DV7_4000] = "hp-dv7-4000",
1660 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1661 /* SigmaTel reference board */
1662 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1663 "DFI LanParty", STAC_92HD83XXX_REF),
1664 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1665 "DFI LanParty", STAC_92HD83XXX_REF),
1666 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
1667 "unknown Dell", STAC_DELL_S14),
1668 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x3600,
1669 "HP", STAC_92HD83XXX_HP),
1673 static unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1674 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1675 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1676 0x90a000f0, 0x01452050, 0x01452050, 0x00000000,
1680 static unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1681 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1682 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1683 0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000,
1687 static unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1688 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1689 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1690 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1694 static unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1695 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1696 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1697 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1701 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1702 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1703 [STAC_DELL_M4_1] = dell_m4_1_pin_configs,
1704 [STAC_DELL_M4_2] = dell_m4_2_pin_configs,
1705 [STAC_DELL_M4_3] = dell_m4_3_pin_configs,
1706 [STAC_HP_M4] = NULL,
1707 [STAC_HP_DV4] = NULL,
1708 [STAC_HP_DV5] = NULL,
1709 [STAC_HP_HDX] = NULL,
1710 [STAC_HP_DV4_1222NR] = NULL,
1713 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1714 [STAC_92HD71BXX_AUTO] = "auto",
1715 [STAC_92HD71BXX_REF] = "ref",
1716 [STAC_DELL_M4_1] = "dell-m4-1",
1717 [STAC_DELL_M4_2] = "dell-m4-2",
1718 [STAC_DELL_M4_3] = "dell-m4-3",
1719 [STAC_HP_M4] = "hp-m4",
1720 [STAC_HP_DV4] = "hp-dv4",
1721 [STAC_HP_DV5] = "hp-dv5",
1722 [STAC_HP_HDX] = "hp-hdx",
1723 [STAC_HP_DV4_1222NR] = "hp-dv4-1222nr",
1726 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1727 /* SigmaTel reference board */
1728 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1729 "DFI LanParty", STAC_92HD71BXX_REF),
1730 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1731 "DFI LanParty", STAC_92HD71BXX_REF),
1732 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb,
1733 "HP dv4-1222nr", STAC_HP_DV4_1222NR),
1734 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720,
1736 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
1738 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
1739 "HP dv4-7", STAC_HP_DV4),
1740 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
1741 "HP dv4-7", STAC_HP_DV5),
1742 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
1743 "HP HDX", STAC_HP_HDX), /* HDX18 */
1744 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1745 "HP mini 1000", STAC_HP_M4),
1746 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
1747 "HP HDX", STAC_HP_HDX), /* HDX16 */
1748 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
1749 "HP dv6", STAC_HP_DV5),
1750 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061,
1751 "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */
1752 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
1754 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1755 "unknown Dell", STAC_DELL_M4_1),
1756 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1757 "unknown Dell", STAC_DELL_M4_1),
1758 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1759 "unknown Dell", STAC_DELL_M4_1),
1760 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1761 "unknown Dell", STAC_DELL_M4_1),
1762 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1763 "unknown Dell", STAC_DELL_M4_1),
1764 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1765 "unknown Dell", STAC_DELL_M4_1),
1766 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1767 "unknown Dell", STAC_DELL_M4_1),
1768 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1769 "unknown Dell", STAC_DELL_M4_2),
1770 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1771 "unknown Dell", STAC_DELL_M4_2),
1772 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1773 "unknown Dell", STAC_DELL_M4_2),
1774 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1775 "unknown Dell", STAC_DELL_M4_2),
1776 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1777 "unknown Dell", STAC_DELL_M4_3),
1781 static unsigned int ref922x_pin_configs[10] = {
1782 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1783 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1784 0x40000100, 0x40000100,
1788 STAC 922X pin configs for
1795 static unsigned int dell_922x_d81_pin_configs[10] = {
1796 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1797 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1798 0x01813122, 0x400001f2,
1802 STAC 922X pin configs for
1806 static unsigned int dell_922x_d82_pin_configs[10] = {
1807 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1808 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1809 0x01813122, 0x400001f1,
1813 STAC 922X pin configs for
1816 static unsigned int dell_922x_m81_pin_configs[10] = {
1817 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1818 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1819 0x40C003f1, 0x405003f0,
1823 STAC 9221 A1 pin configs for
1824 102801D7 (Dell XPS M1210)
1826 static unsigned int dell_922x_m82_pin_configs[10] = {
1827 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1828 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1829 0x508003f3, 0x405003f4,
1832 static unsigned int d945gtp3_pin_configs[10] = {
1833 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1834 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1835 0x02a19120, 0x40000100,
1838 static unsigned int d945gtp5_pin_configs[10] = {
1839 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1840 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1841 0x02a19320, 0x40000100,
1844 static unsigned int intel_mac_v1_pin_configs[10] = {
1845 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1846 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1847 0x400000fc, 0x400000fb,
1850 static unsigned int intel_mac_v2_pin_configs[10] = {
1851 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1852 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1853 0x400000fc, 0x400000fb,
1856 static unsigned int intel_mac_v3_pin_configs[10] = {
1857 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1858 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1859 0x400000fc, 0x400000fb,
1862 static unsigned int intel_mac_v4_pin_configs[10] = {
1863 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1864 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1865 0x400000fc, 0x400000fb,
1868 static unsigned int intel_mac_v5_pin_configs[10] = {
1869 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1870 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1871 0x400000fc, 0x400000fb,
1874 static unsigned int ecs202_pin_configs[10] = {
1875 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1876 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1877 0x9037012e, 0x40e000f2,
1880 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1881 [STAC_D945_REF] = ref922x_pin_configs,
1882 [STAC_D945GTP3] = d945gtp3_pin_configs,
1883 [STAC_D945GTP5] = d945gtp5_pin_configs,
1884 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1885 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1886 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1887 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1888 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1889 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1890 /* for backward compatibility */
1891 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1892 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1893 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1894 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1895 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1896 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1897 [STAC_ECS_202] = ecs202_pin_configs,
1898 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1899 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1900 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1901 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1904 static const char *stac922x_models[STAC_922X_MODELS] = {
1905 [STAC_922X_AUTO] = "auto",
1906 [STAC_D945_REF] = "ref",
1907 [STAC_D945GTP5] = "5stack",
1908 [STAC_D945GTP3] = "3stack",
1909 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1910 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1911 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1912 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1913 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1914 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1915 /* for backward compatibility */
1916 [STAC_MACMINI] = "macmini",
1917 [STAC_MACBOOK] = "macbook",
1918 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1919 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1920 [STAC_IMAC_INTEL] = "imac-intel",
1921 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1922 [STAC_ECS_202] = "ecs202",
1923 [STAC_922X_DELL_D81] = "dell-d81",
1924 [STAC_922X_DELL_D82] = "dell-d82",
1925 [STAC_922X_DELL_M81] = "dell-m81",
1926 [STAC_922X_DELL_M82] = "dell-m82",
1929 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1930 /* SigmaTel reference board */
1931 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1932 "DFI LanParty", STAC_D945_REF),
1933 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1934 "DFI LanParty", STAC_D945_REF),
1935 /* Intel 945G based systems */
1936 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1937 "Intel D945G", STAC_D945GTP3),
1938 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1939 "Intel D945G", STAC_D945GTP3),
1940 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1941 "Intel D945G", STAC_D945GTP3),
1942 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1943 "Intel D945G", STAC_D945GTP3),
1944 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1945 "Intel D945G", STAC_D945GTP3),
1946 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1947 "Intel D945G", STAC_D945GTP3),
1948 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1949 "Intel D945G", STAC_D945GTP3),
1950 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1951 "Intel D945G", STAC_D945GTP3),
1952 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1953 "Intel D945G", STAC_D945GTP3),
1954 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1955 "Intel D945G", STAC_D945GTP3),
1956 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1957 "Intel D945G", STAC_D945GTP3),
1958 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1959 "Intel D945G", STAC_D945GTP3),
1960 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1961 "Intel D945G", STAC_D945GTP3),
1962 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1963 "Intel D945G", STAC_D945GTP3),
1964 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1965 "Intel D945G", STAC_D945GTP3),
1966 /* Intel D945G 5-stack systems */
1967 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1968 "Intel D945G", STAC_D945GTP5),
1969 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1970 "Intel D945G", STAC_D945GTP5),
1971 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1972 "Intel D945G", STAC_D945GTP5),
1973 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1974 "Intel D945G", STAC_D945GTP5),
1975 /* Intel 945P based systems */
1976 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1977 "Intel D945P", STAC_D945GTP3),
1978 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1979 "Intel D945P", STAC_D945GTP3),
1980 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1981 "Intel D945P", STAC_D945GTP3),
1982 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1983 "Intel D945P", STAC_D945GTP3),
1984 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1985 "Intel D945P", STAC_D945GTP3),
1986 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1987 "Intel D945P", STAC_D945GTP5),
1989 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
1990 "Intel D945", STAC_D945_REF),
1992 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
1993 SND_PCI_QUIRK(0x8384, 0x7680,
1994 "Mac", STAC_INTEL_MAC_AUTO),
1996 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1997 "unknown Dell", STAC_922X_DELL_D81),
1998 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1999 "unknown Dell", STAC_922X_DELL_D81),
2000 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
2001 "unknown Dell", STAC_922X_DELL_D81),
2002 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
2003 "unknown Dell", STAC_922X_DELL_D82),
2004 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
2005 "unknown Dell", STAC_922X_DELL_M81),
2006 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
2007 "unknown Dell", STAC_922X_DELL_D82),
2008 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
2009 "unknown Dell", STAC_922X_DELL_D81),
2010 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
2011 "unknown Dell", STAC_922X_DELL_D81),
2012 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
2013 "Dell XPS M1210", STAC_922X_DELL_M82),
2014 /* ECS/PC Chips boards */
2015 SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
2016 "ECS/PC chips", STAC_ECS_202),
2020 static unsigned int ref927x_pin_configs[14] = {
2021 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2022 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
2023 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2024 0x01c42190, 0x40000100,
2027 static unsigned int d965_3st_pin_configs[14] = {
2028 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2029 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2030 0x40000100, 0x40000100, 0x40000100, 0x40000100,
2031 0x40000100, 0x40000100
2034 static unsigned int d965_5st_pin_configs[14] = {
2035 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2036 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2037 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2038 0x40000100, 0x40000100
2041 static unsigned int d965_5st_no_fp_pin_configs[14] = {
2042 0x40000100, 0x40000100, 0x0181304e, 0x01014010,
2043 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2044 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2045 0x40000100, 0x40000100
2048 static unsigned int dell_3st_pin_configs[14] = {
2049 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2050 0x01111212, 0x01116211, 0x01813050, 0x01112214,
2051 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2052 0x40c003fc, 0x40000100
2055 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2056 [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2057 [STAC_D965_REF] = ref927x_pin_configs,
2058 [STAC_D965_3ST] = d965_3st_pin_configs,
2059 [STAC_D965_5ST] = d965_5st_pin_configs,
2060 [STAC_D965_5ST_NO_FP] = d965_5st_no_fp_pin_configs,
2061 [STAC_DELL_3ST] = dell_3st_pin_configs,
2062 [STAC_DELL_BIOS] = NULL,
2063 [STAC_927X_VOLKNOB] = NULL,
2066 static const char *stac927x_models[STAC_927X_MODELS] = {
2067 [STAC_927X_AUTO] = "auto",
2068 [STAC_D965_REF_NO_JD] = "ref-no-jd",
2069 [STAC_D965_REF] = "ref",
2070 [STAC_D965_3ST] = "3stack",
2071 [STAC_D965_5ST] = "5stack",
2072 [STAC_D965_5ST_NO_FP] = "5stack-no-fp",
2073 [STAC_DELL_3ST] = "dell-3stack",
2074 [STAC_DELL_BIOS] = "dell-bios",
2075 [STAC_927X_VOLKNOB] = "volknob",
2078 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2079 /* SigmaTel reference board */
2080 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2081 "DFI LanParty", STAC_D965_REF),
2082 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2083 "DFI LanParty", STAC_D965_REF),
2084 /* Intel 946 based systems */
2085 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2086 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2087 /* 965 based 3 stack systems */
2088 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
2089 "Intel D965", STAC_D965_3ST),
2090 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
2091 "Intel D965", STAC_D965_3ST),
2092 /* Dell 3 stack systems */
2093 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2094 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
2095 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
2096 /* Dell 3 stack systems with verb table in BIOS */
2097 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2098 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_BIOS),
2099 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
2100 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
2101 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
2102 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
2103 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
2104 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
2105 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2106 /* 965 based 5 stack systems */
2107 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
2108 "Intel D965", STAC_D965_5ST),
2109 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
2110 "Intel D965", STAC_D965_5ST),
2111 /* volume-knob fixes */
2112 SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB),
2116 static unsigned int ref9205_pin_configs[12] = {
2117 0x40000100, 0x40000100, 0x01016011, 0x01014010,
2118 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2119 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2123 STAC 9205 pin configs for
2130 10280228 (Dell Vostro 1500)
2131 10280229 (Dell Vostro 1700)
2133 static unsigned int dell_9205_m42_pin_configs[12] = {
2134 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2135 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2136 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2140 STAC 9205 pin configs for
2144 102801FF (Dell Precision M4300)
2149 static unsigned int dell_9205_m43_pin_configs[12] = {
2150 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2151 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2152 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2155 static unsigned int dell_9205_m44_pin_configs[12] = {
2156 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2157 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2158 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2161 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2162 [STAC_9205_REF] = ref9205_pin_configs,
2163 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2164 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2165 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2166 [STAC_9205_EAPD] = NULL,
2169 static const char *stac9205_models[STAC_9205_MODELS] = {
2170 [STAC_9205_AUTO] = "auto",
2171 [STAC_9205_REF] = "ref",
2172 [STAC_9205_DELL_M42] = "dell-m42",
2173 [STAC_9205_DELL_M43] = "dell-m43",
2174 [STAC_9205_DELL_M44] = "dell-m44",
2175 [STAC_9205_EAPD] = "eapd",
2178 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
2179 /* SigmaTel reference board */
2180 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2181 "DFI LanParty", STAC_9205_REF),
2182 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
2183 "SigmaTel", STAC_9205_REF),
2184 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2185 "DFI LanParty", STAC_9205_REF),
2187 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2188 "unknown Dell", STAC_9205_DELL_M42),
2189 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2190 "unknown Dell", STAC_9205_DELL_M42),
2191 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2192 "Dell Precision", STAC_9205_DELL_M43),
2193 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2194 "Dell Precision", STAC_9205_DELL_M43),
2195 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2196 "Dell Precision", STAC_9205_DELL_M43),
2197 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2198 "unknown Dell", STAC_9205_DELL_M42),
2199 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2200 "unknown Dell", STAC_9205_DELL_M42),
2201 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2202 "Dell Precision", STAC_9205_DELL_M43),
2203 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2204 "Dell Precision M4300", STAC_9205_DELL_M43),
2205 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2206 "unknown Dell", STAC_9205_DELL_M42),
2207 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2208 "Dell Precision", STAC_9205_DELL_M43),
2209 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2210 "Dell Precision", STAC_9205_DELL_M43),
2211 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2212 "Dell Precision", STAC_9205_DELL_M43),
2213 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2214 "Dell Inspiron", STAC_9205_DELL_M44),
2215 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2216 "Dell Vostro 1500", STAC_9205_DELL_M42),
2217 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229,
2218 "Dell Vostro 1700", STAC_9205_DELL_M42),
2220 SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
2221 SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
2225 static void stac92xx_set_config_regs(struct hda_codec *codec,
2226 unsigned int *pincfgs)
2229 struct sigmatel_spec *spec = codec->spec;
2234 for (i = 0; i < spec->num_pins; i++)
2235 if (spec->pin_nids[i] && pincfgs[i])
2236 snd_hda_codec_set_pincfg(codec, spec->pin_nids[i],
2241 * Analog playback callbacks
2243 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2244 struct hda_codec *codec,
2245 struct snd_pcm_substream *substream)
2247 struct sigmatel_spec *spec = codec->spec;
2248 if (spec->stream_delay)
2249 msleep(spec->stream_delay);
2250 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2254 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2255 struct hda_codec *codec,
2256 unsigned int stream_tag,
2257 unsigned int format,
2258 struct snd_pcm_substream *substream)
2260 struct sigmatel_spec *spec = codec->spec;
2261 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2264 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2265 struct hda_codec *codec,
2266 struct snd_pcm_substream *substream)
2268 struct sigmatel_spec *spec = codec->spec;
2269 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2273 * Digital playback callbacks
2275 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2276 struct hda_codec *codec,
2277 struct snd_pcm_substream *substream)
2279 struct sigmatel_spec *spec = codec->spec;
2280 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2283 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2284 struct hda_codec *codec,
2285 struct snd_pcm_substream *substream)
2287 struct sigmatel_spec *spec = codec->spec;
2288 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2291 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2292 struct hda_codec *codec,
2293 unsigned int stream_tag,
2294 unsigned int format,
2295 struct snd_pcm_substream *substream)
2297 struct sigmatel_spec *spec = codec->spec;
2298 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2299 stream_tag, format, substream);
2302 static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2303 struct hda_codec *codec,
2304 struct snd_pcm_substream *substream)
2306 struct sigmatel_spec *spec = codec->spec;
2307 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2312 * Analog capture callbacks
2314 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2315 struct hda_codec *codec,
2316 unsigned int stream_tag,
2317 unsigned int format,
2318 struct snd_pcm_substream *substream)
2320 struct sigmatel_spec *spec = codec->spec;
2321 hda_nid_t nid = spec->adc_nids[substream->number];
2323 if (spec->powerdown_adcs) {
2325 snd_hda_codec_write(codec, nid, 0,
2326 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2328 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2332 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2333 struct hda_codec *codec,
2334 struct snd_pcm_substream *substream)
2336 struct sigmatel_spec *spec = codec->spec;
2337 hda_nid_t nid = spec->adc_nids[substream->number];
2339 snd_hda_codec_cleanup_stream(codec, nid);
2340 if (spec->powerdown_adcs)
2341 snd_hda_codec_write(codec, nid, 0,
2342 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2346 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2350 /* NID is set in stac92xx_build_pcms */
2352 .open = stac92xx_dig_playback_pcm_open,
2353 .close = stac92xx_dig_playback_pcm_close,
2354 .prepare = stac92xx_dig_playback_pcm_prepare,
2355 .cleanup = stac92xx_dig_playback_pcm_cleanup
2359 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2363 /* NID is set in stac92xx_build_pcms */
2366 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2370 .nid = 0x02, /* NID to query formats and rates */
2372 .open = stac92xx_playback_pcm_open,
2373 .prepare = stac92xx_playback_pcm_prepare,
2374 .cleanup = stac92xx_playback_pcm_cleanup
2378 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2382 .nid = 0x06, /* NID to query formats and rates */
2384 .open = stac92xx_playback_pcm_open,
2385 .prepare = stac92xx_playback_pcm_prepare,
2386 .cleanup = stac92xx_playback_pcm_cleanup
2390 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2393 /* NID + .substreams is set in stac92xx_build_pcms */
2395 .prepare = stac92xx_capture_pcm_prepare,
2396 .cleanup = stac92xx_capture_pcm_cleanup
2400 static int stac92xx_build_pcms(struct hda_codec *codec)
2402 struct sigmatel_spec *spec = codec->spec;
2403 struct hda_pcm *info = spec->pcm_rec;
2405 codec->num_pcms = 1;
2406 codec->pcm_info = info;
2408 info->name = "STAC92xx Analog";
2409 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2410 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2411 spec->multiout.dac_nids[0];
2412 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2413 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2414 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2416 if (spec->alt_switch) {
2419 info->name = "STAC92xx Analog Alt";
2420 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2423 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2426 info->name = "STAC92xx Digital";
2427 info->pcm_type = spec->autocfg.dig_out_type[0];
2428 if (spec->multiout.dig_out_nid) {
2429 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2430 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2432 if (spec->dig_in_nid) {
2433 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2434 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2441 static unsigned int stac92xx_get_default_vref(struct hda_codec *codec,
2444 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2445 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2446 if (pincap & AC_PINCAP_VREF_100)
2447 return AC_PINCTL_VREF_100;
2448 if (pincap & AC_PINCAP_VREF_80)
2449 return AC_PINCTL_VREF_80;
2450 if (pincap & AC_PINCAP_VREF_50)
2451 return AC_PINCTL_VREF_50;
2452 if (pincap & AC_PINCAP_VREF_GRD)
2453 return AC_PINCTL_VREF_GRD;
2457 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2460 snd_hda_codec_write_cache(codec, nid, 0,
2461 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2464 #define stac92xx_hp_switch_info snd_ctl_boolean_mono_info
2466 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2467 struct snd_ctl_elem_value *ucontrol)
2469 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2470 struct sigmatel_spec *spec = codec->spec;
2472 ucontrol->value.integer.value[0] = !!spec->hp_switch;
2476 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid);
2478 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2479 struct snd_ctl_elem_value *ucontrol)
2481 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2482 struct sigmatel_spec *spec = codec->spec;
2483 int nid = kcontrol->private_value;
2485 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2487 /* check to be sure that the ports are upto date with
2490 stac_issue_unsol_event(codec, nid);
2495 static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol,
2496 struct snd_ctl_elem_info *uinfo)
2499 static char *texts[] = {
2500 "Mic In", "Line In", "Line Out"
2503 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2504 struct sigmatel_spec *spec = codec->spec;
2505 hda_nid_t nid = kcontrol->private_value;
2507 if (nid == spec->mic_switch || nid == spec->line_switch)
2512 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2513 uinfo->value.enumerated.items = i;
2515 if (uinfo->value.enumerated.item >= i)
2516 uinfo->value.enumerated.item = i-1;
2517 strcpy(uinfo->value.enumerated.name,
2518 texts[uinfo->value.enumerated.item]);
2523 static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol,
2524 struct snd_ctl_elem_value *ucontrol)
2526 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2527 hda_nid_t nid = kcontrol->private_value;
2528 unsigned int vref = stac92xx_vref_get(codec, nid);
2530 if (vref == stac92xx_get_default_vref(codec, nid))
2531 ucontrol->value.enumerated.item[0] = 0;
2532 else if (vref == AC_PINCTL_VREF_GRD)
2533 ucontrol->value.enumerated.item[0] = 1;
2534 else if (vref == AC_PINCTL_VREF_HIZ)
2535 ucontrol->value.enumerated.item[0] = 2;
2540 static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol,
2541 struct snd_ctl_elem_value *ucontrol)
2543 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2544 unsigned int new_vref = 0;
2546 hda_nid_t nid = kcontrol->private_value;
2548 if (ucontrol->value.enumerated.item[0] == 0)
2549 new_vref = stac92xx_get_default_vref(codec, nid);
2550 else if (ucontrol->value.enumerated.item[0] == 1)
2551 new_vref = AC_PINCTL_VREF_GRD;
2552 else if (ucontrol->value.enumerated.item[0] == 2)
2553 new_vref = AC_PINCTL_VREF_HIZ;
2557 if (new_vref != stac92xx_vref_get(codec, nid)) {
2558 error = stac92xx_vref_set(codec, nid, new_vref);
2565 static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol,
2566 struct snd_ctl_elem_info *uinfo)
2568 static char *texts[2];
2569 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2570 struct sigmatel_spec *spec = codec->spec;
2572 if (kcontrol->private_value == spec->line_switch)
2573 texts[0] = "Line In";
2575 texts[0] = "Mic In";
2576 texts[1] = "Line Out";
2577 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2578 uinfo->value.enumerated.items = 2;
2581 if (uinfo->value.enumerated.item >= 2)
2582 uinfo->value.enumerated.item = 1;
2583 strcpy(uinfo->value.enumerated.name,
2584 texts[uinfo->value.enumerated.item]);
2589 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2591 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2592 struct sigmatel_spec *spec = codec->spec;
2593 hda_nid_t nid = kcontrol->private_value;
2594 int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2596 ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx];
2600 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2602 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2603 struct sigmatel_spec *spec = codec->spec;
2604 hda_nid_t nid = kcontrol->private_value;
2605 int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2606 unsigned short val = !!ucontrol->value.enumerated.item[0];
2608 spec->io_switch[io_idx] = val;
2611 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2613 unsigned int pinctl = AC_PINCTL_IN_EN;
2614 if (io_idx) /* set VREF for mic */
2615 pinctl |= stac92xx_get_default_vref(codec, nid);
2616 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2619 /* check the auto-mute again: we need to mute/unmute the speaker
2620 * appropriately according to the pin direction
2622 if (spec->hp_detect)
2623 stac_issue_unsol_event(codec, nid);
2628 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2630 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2631 struct snd_ctl_elem_value *ucontrol)
2633 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2634 struct sigmatel_spec *spec = codec->spec;
2636 ucontrol->value.integer.value[0] = spec->clfe_swap;
2640 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2641 struct snd_ctl_elem_value *ucontrol)
2643 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2644 struct sigmatel_spec *spec = codec->spec;
2645 hda_nid_t nid = kcontrol->private_value & 0xff;
2646 unsigned int val = !!ucontrol->value.integer.value[0];
2648 if (spec->clfe_swap == val)
2651 spec->clfe_swap = val;
2653 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2654 spec->clfe_swap ? 0x4 : 0x0);
2659 #define STAC_CODEC_HP_SWITCH(xname) \
2660 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2663 .info = stac92xx_hp_switch_info, \
2664 .get = stac92xx_hp_switch_get, \
2665 .put = stac92xx_hp_switch_put, \
2668 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2669 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2672 .info = stac92xx_io_switch_info, \
2673 .get = stac92xx_io_switch_get, \
2674 .put = stac92xx_io_switch_put, \
2675 .private_value = xpval, \
2678 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2679 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2682 .info = stac92xx_clfe_switch_info, \
2683 .get = stac92xx_clfe_switch_get, \
2684 .put = stac92xx_clfe_switch_put, \
2685 .private_value = xpval, \
2689 STAC_CTL_WIDGET_VOL,
2690 STAC_CTL_WIDGET_MUTE,
2691 STAC_CTL_WIDGET_MUTE_BEEP,
2692 STAC_CTL_WIDGET_MONO_MUX,
2693 STAC_CTL_WIDGET_HP_SWITCH,
2694 STAC_CTL_WIDGET_IO_SWITCH,
2695 STAC_CTL_WIDGET_CLFE_SWITCH,
2696 STAC_CTL_WIDGET_DC_BIAS
2699 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2700 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2701 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2702 HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0),
2704 STAC_CODEC_HP_SWITCH(NULL),
2705 STAC_CODEC_IO_SWITCH(NULL, 0),
2706 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2707 DC_BIAS(NULL, 0, 0),
2710 /* add dynamic controls */
2711 static struct snd_kcontrol_new *
2712 stac_control_new(struct sigmatel_spec *spec,
2713 struct snd_kcontrol_new *ktemp,
2715 unsigned int subdev)
2717 struct snd_kcontrol_new *knew;
2719 snd_array_init(&spec->kctls, sizeof(*knew), 32);
2720 knew = snd_array_new(&spec->kctls);
2724 knew->name = kstrdup(name, GFP_KERNEL);
2727 memset(knew, 0, sizeof(*knew));
2728 spec->kctls.alloced--;
2731 knew->subdevice = subdev;
2735 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2736 struct snd_kcontrol_new *ktemp,
2737 int idx, const char *name,
2740 struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name,
2741 HDA_SUBDEV_AMP_FLAG);
2745 knew->private_value = val;
2749 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2750 int type, int idx, const char *name,
2753 return stac92xx_add_control_temp(spec,
2754 &stac92xx_control_templates[type],
2759 /* add dynamic controls */
2760 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2761 const char *name, unsigned long val)
2763 return stac92xx_add_control_idx(spec, type, 0, name, val);
2766 static struct snd_kcontrol_new stac_input_src_temp = {
2767 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2768 .name = "Input Source",
2769 .info = stac92xx_mux_enum_info,
2770 .get = stac92xx_mux_enum_get,
2771 .put = stac92xx_mux_enum_put,
2774 static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
2775 hda_nid_t nid, int idx)
2777 int def_conf = snd_hda_codec_get_pincfg(codec, nid);
2779 struct sigmatel_spec *spec = codec->spec;
2782 if (!((get_defcfg_connect(def_conf)) & AC_JACK_PORT_FIXED)) {
2783 if (stac92xx_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
2784 && nid == spec->line_switch)
2785 control = STAC_CTL_WIDGET_IO_SWITCH;
2786 else if (snd_hda_query_pin_caps(codec, nid)
2787 & (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT))
2788 control = STAC_CTL_WIDGET_DC_BIAS;
2789 else if (nid == spec->mic_switch)
2790 control = STAC_CTL_WIDGET_IO_SWITCH;
2794 strcpy(name, auto_pin_cfg_labels[idx]);
2795 return stac92xx_add_control(codec->spec, control,
2796 strcat(name, " Jack Mode"), nid);
2802 static int stac92xx_add_input_source(struct sigmatel_spec *spec)
2804 struct snd_kcontrol_new *knew;
2805 struct hda_input_mux *imux = &spec->private_imux;
2808 return 0; /* no need for input source */
2809 if (!spec->num_adcs || imux->num_items <= 1)
2810 return 0; /* no need for input source control */
2811 knew = stac_control_new(spec, &stac_input_src_temp,
2812 stac_input_src_temp.name, 0);
2815 knew->count = spec->num_adcs;
2819 /* check whether the line-input can be used as line-out */
2820 static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2822 struct sigmatel_spec *spec = codec->spec;
2823 struct auto_pin_cfg *cfg = &spec->autocfg;
2825 unsigned int pincap;
2828 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2830 for (i = 0; i < cfg->num_inputs; i++) {
2831 if (cfg->inputs[i].type == AUTO_PIN_LINE) {
2832 nid = cfg->inputs[i].pin;
2833 pincap = snd_hda_query_pin_caps(codec, nid);
2834 if (pincap & AC_PINCAP_OUT)
2841 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid);
2843 /* check whether the mic-input can be used as line-out */
2844 static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac)
2846 struct sigmatel_spec *spec = codec->spec;
2847 struct auto_pin_cfg *cfg = &spec->autocfg;
2848 unsigned int def_conf, pincap;
2852 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2854 mic_type = AUTO_PIN_MIC;
2856 for (i = 0; i < cfg->num_inputs; i++) {
2857 hda_nid_t nid = cfg->inputs[i].pin;
2858 if (cfg->inputs[i].type != mic_type)
2860 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2861 /* some laptops have an internal analog microphone
2862 * which can't be used as a output */
2863 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2864 pincap = snd_hda_query_pin_caps(codec, nid);
2865 if (pincap & AC_PINCAP_OUT) {
2866 *dac = get_unassigned_dac(codec, nid);
2872 if (mic_type == AUTO_PIN_MIC) {
2873 mic_type = AUTO_PIN_FRONT_MIC;
2879 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2883 for (i = 0; i < spec->multiout.num_dacs; i++) {
2884 if (spec->multiout.dac_nids[i] == nid)
2891 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2894 if (is_in_dac_nids(spec, nid))
2896 for (i = 0; i < spec->autocfg.hp_outs; i++)
2897 if (spec->hp_dacs[i] == nid)
2899 for (i = 0; i < spec->autocfg.speaker_outs; i++)
2900 if (spec->speaker_dacs[i] == nid)
2905 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2907 struct sigmatel_spec *spec = codec->spec;
2909 hda_nid_t conn[HDA_MAX_CONNECTIONS];
2910 unsigned int wcaps, wtype;
2912 conn_len = snd_hda_get_connections(codec, nid, conn,
2913 HDA_MAX_CONNECTIONS);
2914 /* 92HD88: trace back up the link of nids to find the DAC */
2915 while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0]))
2916 != AC_WID_AUD_OUT)) {
2918 conn_len = snd_hda_get_connections(codec, nid, conn,
2919 HDA_MAX_CONNECTIONS);
2921 for (j = 0; j < conn_len; j++) {
2922 wcaps = get_wcaps(codec, conn[j]);
2923 wtype = get_wcaps_type(wcaps);
2924 /* we check only analog outputs */
2925 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2927 /* if this route has a free DAC, assign it */
2928 if (!check_all_dac_nids(spec, conn[j])) {
2930 /* select this DAC in the pin's input mux */
2931 snd_hda_codec_write_cache(codec, nid, 0,
2932 AC_VERB_SET_CONNECT_SEL, j);
2937 /* if all DACs are already assigned, connect to the primary DAC */
2939 for (j = 0; j < conn_len; j++) {
2940 if (conn[j] == spec->multiout.dac_nids[0]) {
2941 snd_hda_codec_write_cache(codec, nid, 0,
2942 AC_VERB_SET_CONNECT_SEL, j);
2950 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2951 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2954 * Fill in the dac_nids table from the parsed pin configuration
2955 * This function only works when every pin in line_out_pins[]
2956 * contains atleast one DAC in its connection list. Some 92xx
2957 * codecs are not connected directly to a DAC, such as the 9200
2958 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2960 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2962 struct sigmatel_spec *spec = codec->spec;
2963 struct auto_pin_cfg *cfg = &spec->autocfg;
2967 for (i = 0; i < cfg->line_outs; i++) {
2968 nid = cfg->line_out_pins[i];
2969 dac = get_unassigned_dac(codec, nid);
2971 if (spec->multiout.num_dacs > 0) {
2972 /* we have already working output pins,
2973 * so let's drop the broken ones again
2975 cfg->line_outs = spec->multiout.num_dacs;
2978 /* error out, no available DAC found */
2980 "%s: No available DAC for pin 0x%x\n",
2984 add_spec_dacs(spec, dac);
2987 for (i = 0; i < cfg->hp_outs; i++) {
2988 nid = cfg->hp_pins[i];
2989 dac = get_unassigned_dac(codec, nid);
2991 if (!spec->multiout.hp_nid)
2992 spec->multiout.hp_nid = dac;
2994 add_spec_extra_dacs(spec, dac);
2996 spec->hp_dacs[i] = dac;
2999 for (i = 0; i < cfg->speaker_outs; i++) {
3000 nid = cfg->speaker_pins[i];
3001 dac = get_unassigned_dac(codec, nid);
3003 add_spec_extra_dacs(spec, dac);
3004 spec->speaker_dacs[i] = dac;
3007 /* add line-in as output */
3008 nid = check_line_out_switch(codec);
3010 dac = get_unassigned_dac(codec, nid);
3012 snd_printdd("STAC: Add line-in 0x%x as output %d\n",
3013 nid, cfg->line_outs);
3014 cfg->line_out_pins[cfg->line_outs] = nid;
3016 spec->line_switch = nid;
3017 add_spec_dacs(spec, dac);
3020 /* add mic as output */
3021 nid = check_mic_out_switch(codec, &dac);
3023 snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
3024 nid, cfg->line_outs);
3025 cfg->line_out_pins[cfg->line_outs] = nid;
3027 spec->mic_switch = nid;
3028 add_spec_dacs(spec, dac);
3031 snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3032 spec->multiout.num_dacs,
3033 spec->multiout.dac_nids[0],
3034 spec->multiout.dac_nids[1],
3035 spec->multiout.dac_nids[2],
3036 spec->multiout.dac_nids[3],
3037 spec->multiout.dac_nids[4]);
3042 /* create volume control/switch for the given prefx type */
3043 static int create_controls_idx(struct hda_codec *codec, const char *pfx,
3044 int idx, hda_nid_t nid, int chs)
3046 struct sigmatel_spec *spec = codec->spec;
3050 if (!spec->check_volume_offset) {
3051 unsigned int caps, step, nums, db_scale;
3052 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3053 step = (caps & AC_AMPCAP_STEP_SIZE) >>
3054 AC_AMPCAP_STEP_SIZE_SHIFT;
3055 step = (step + 1) * 25; /* in .01dB unit */
3056 nums = (caps & AC_AMPCAP_NUM_STEPS) >>
3057 AC_AMPCAP_NUM_STEPS_SHIFT;
3058 db_scale = nums * step;
3059 /* if dB scale is over -64dB, and finer enough,
3060 * let's reduce it to half
3062 if (db_scale > 6400 && nums >= 0x1f)
3063 spec->volume_offset = nums / 2;
3064 spec->check_volume_offset = 1;
3067 sprintf(name, "%s Playback Volume", pfx);
3068 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
3069 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3070 spec->volume_offset));
3073 sprintf(name, "%s Playback Switch", pfx);
3074 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
3075 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3081 #define create_controls(codec, pfx, nid, chs) \
3082 create_controls_idx(codec, pfx, 0, nid, chs)
3084 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3086 if (spec->multiout.num_dacs > 4) {
3087 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3090 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
3091 spec->multiout.num_dacs++;
3096 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3099 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3100 if (!spec->multiout.extra_out_nid[i]) {
3101 spec->multiout.extra_out_nid[i] = nid;
3105 printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3109 /* Create output controls
3110 * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
3112 static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
3113 const hda_nid_t *pins,
3114 const hda_nid_t *dac_nids,
3117 struct sigmatel_spec *spec = codec->spec;
3118 static const char *chname[4] = {
3119 "Front", "Surround", NULL /*CLFE*/, "Side"
3123 unsigned int wid_caps;
3125 for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
3126 if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3127 wid_caps = get_wcaps(codec, pins[i]);
3128 if (wid_caps & AC_WCAP_UNSOL_CAP)
3129 spec->hp_detect = 1;
3134 if (type != AUTO_PIN_HP_OUT && i == 2) {
3136 err = create_controls(codec, "Center", nid, 1);
3139 err = create_controls(codec, "LFE", nid, 2);
3143 wid_caps = get_wcaps(codec, nid);
3145 if (wid_caps & AC_WCAP_LR_SWAP) {
3146 err = stac92xx_add_control(spec,
3147 STAC_CTL_WIDGET_CLFE_SWITCH,
3148 "Swap Center/LFE Playback Switch", nid);
3158 case AUTO_PIN_HP_OUT:
3162 case AUTO_PIN_SPEAKER_OUT:
3171 err = create_controls_idx(codec, name, idx, nid, 3);
3179 static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol,
3180 unsigned long sw, int idx)
3183 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx,
3184 "Capture Volume", vol);
3187 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_MUTE, idx,
3188 "Capture Switch", sw);
3194 /* add playback controls from the parsed DAC table */
3195 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3196 const struct auto_pin_cfg *cfg)
3198 struct sigmatel_spec *spec = codec->spec;
3203 err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
3204 spec->multiout.dac_nids,
3205 cfg->line_out_type);
3209 if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3210 err = stac92xx_add_control(spec,
3211 STAC_CTL_WIDGET_HP_SWITCH,
3212 "Headphone as Line Out Switch",
3213 cfg->hp_pins[cfg->hp_outs - 1]);
3218 for (idx = 0; idx < cfg->num_inputs; idx++) {
3219 if (cfg->inputs[idx].type > AUTO_PIN_FRONT_LINE)
3221 nid = cfg->inputs[idx].pin;
3222 err = stac92xx_add_jack_mode_control(codec, nid, idx);
3230 /* add playback controls for Speaker and HP outputs */
3231 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3232 struct auto_pin_cfg *cfg)
3234 struct sigmatel_spec *spec = codec->spec;
3237 err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
3238 spec->hp_dacs, AUTO_PIN_HP_OUT);
3242 err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
3243 spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
3250 /* labels for mono mux outputs */
3251 static const char *stac92xx_mono_labels[4] = {
3252 "DAC0", "DAC1", "Mixer", "DAC2"
3255 /* create mono mux for mono out on capable codecs */
3256 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3258 struct sigmatel_spec *spec = codec->spec;
3259 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3261 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3263 num_cons = snd_hda_get_connections(codec,
3266 HDA_MAX_NUM_INPUTS);
3267 if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3270 for (i = 0; i < num_cons; i++) {
3271 mono_mux->items[mono_mux->num_items].label =
3272 stac92xx_mono_labels[i];
3273 mono_mux->items[mono_mux->num_items].index = i;
3274 mono_mux->num_items++;
3277 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3278 "Mono Mux", spec->mono_nid);
3281 /* create PC beep volume controls */
3282 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3285 struct sigmatel_spec *spec = codec->spec;
3286 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3287 int err, type = STAC_CTL_WIDGET_MUTE_BEEP;
3289 if (spec->anabeep_nid == nid)
3290 type = STAC_CTL_WIDGET_MUTE;
3292 /* check for mute support for the the amp */
3293 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3294 err = stac92xx_add_control(spec, type,
3295 "Beep Playback Switch",
3296 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3301 /* check to see if there is volume support for the amp */
3302 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3303 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3304 "Beep Playback Volume",
3305 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3312 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3313 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3315 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3316 struct snd_ctl_elem_value *ucontrol)
3318 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3319 ucontrol->value.integer.value[0] = codec->beep->enabled;
3323 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3324 struct snd_ctl_elem_value *ucontrol)
3326 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3327 return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
3330 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3331 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3332 .info = stac92xx_dig_beep_switch_info,
3333 .get = stac92xx_dig_beep_switch_get,
3334 .put = stac92xx_dig_beep_switch_put,
3337 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3339 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3340 0, "Beep Playback Switch", 0);
3344 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3346 struct sigmatel_spec *spec = codec->spec;
3349 for (i = 0; i < spec->num_muxes; i++) {
3354 nid = spec->mux_nids[i];
3355 wcaps = get_wcaps(codec, nid);
3356 if (!(wcaps & AC_WCAP_OUT_AMP))
3359 /* check whether already the same control was created as
3360 * normal Capture Volume.
3362 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3363 for (j = 0; j < spec->num_caps; j++) {
3364 if (spec->capvols[j] == val)
3367 if (j < spec->num_caps)
3370 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i,
3371 "Mux Capture Volume", val);
3378 static const char *stac92xx_spdif_labels[3] = {
3379 "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3382 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3384 struct sigmatel_spec *spec = codec->spec;
3385 struct hda_input_mux *spdif_mux = &spec->private_smux;
3386 const char **labels = spec->spdif_labels;
3388 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3390 num_cons = snd_hda_get_connections(codec,
3393 HDA_MAX_NUM_INPUTS);
3398 labels = stac92xx_spdif_labels;
3400 for (i = 0; i < num_cons; i++) {
3401 spdif_mux->items[spdif_mux->num_items].label = labels[i];
3402 spdif_mux->items[spdif_mux->num_items].index = i;
3403 spdif_mux->num_items++;
3409 /* labels for dmic mux inputs */
3410 static const char *stac92xx_dmic_labels[5] = {
3411 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3412 "Digital Mic 3", "Digital Mic 4"
3415 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
3418 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3421 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3422 for (i = 0; i < nums; i++)
3428 /* create a volume assigned to the given pin (only if supported) */
3429 /* return 1 if the volume control is created */
3430 static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
3431 const char *label, int idx, int direction)
3433 unsigned int caps, nums;
3437 if (direction == HDA_OUTPUT)
3438 caps = AC_WCAP_OUT_AMP;
3440 caps = AC_WCAP_IN_AMP;
3441 if (!(get_wcaps(codec, nid) & caps))
3443 caps = query_amp_caps(codec, nid, direction);
3444 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
3447 snprintf(name, sizeof(name), "%s Capture Volume", label);
3448 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, name,
3449 HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction));
3455 /* create playback/capture controls for input pins on dmic capable codecs */
3456 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3457 const struct auto_pin_cfg *cfg)
3459 struct sigmatel_spec *spec = codec->spec;
3460 struct hda_input_mux *imux = &spec->private_imux;
3461 struct hda_input_mux *dimux = &spec->private_dimux;
3462 int err, i, active_mics;
3463 unsigned int def_conf;
3465 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
3466 dimux->items[dimux->num_items].index = 0;
3470 for (i = 0; i < spec->num_dmics; i++) {
3471 /* check the validity: sometimes it's a dead vendor-spec node */
3472 if (get_wcaps_type(get_wcaps(codec, spec->dmic_nids[i]))
3475 def_conf = snd_hda_codec_get_pincfg(codec, spec->dmic_nids[i]);
3476 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)
3480 for (i = 0; i < spec->num_dmics; i++) {
3485 nid = spec->dmic_nids[i];
3486 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
3488 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3489 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3492 index = get_connection_index(codec, spec->dmux_nids[0], nid);
3496 if (active_mics == 1)
3497 label = "Digital Mic";
3499 label = stac92xx_dmic_labels[dimux->num_items];
3501 err = create_elem_capture_vol(codec, nid, label, 0, HDA_INPUT);
3505 err = create_elem_capture_vol(codec, nid, label, 0,
3511 dimux->items[dimux->num_items].label = label;
3512 dimux->items[dimux->num_items].index = index;
3514 if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1) {
3515 imux->items[imux->num_items].label = label;
3516 imux->items[imux->num_items].index = index;
3524 static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid,
3525 hda_nid_t *fixed, hda_nid_t *ext)
3531 cfg = snd_hda_codec_get_pincfg(codec, nid);
3532 switch (get_defcfg_connect(cfg)) {
3533 case AC_JACK_PORT_FIXED:
3535 return 1; /* already occupied */
3538 case AC_JACK_PORT_COMPLEX:
3540 return 1; /* already occupied */
3547 static int set_mic_route(struct hda_codec *codec,
3548 struct sigmatel_mic_route *mic,
3551 struct sigmatel_spec *spec = codec->spec;
3552 struct auto_pin_cfg *cfg = &spec->autocfg;
3556 for (i = 0; i < cfg->num_inputs; i++) {
3557 if (pin == cfg->inputs[i].pin)
3560 if (i < cfg->num_inputs && cfg->inputs[i].type <= AUTO_PIN_FRONT_MIC) {
3562 i = get_connection_index(codec, spec->mux_nids[0], pin);
3567 if (spec->dmux_nids)
3568 mic->dmux_idx = get_connection_index(codec,
3571 } else if (spec->dmux_nids) {
3573 i = get_connection_index(codec, spec->dmux_nids[0], pin);
3579 mic->mux_idx = get_connection_index(codec,
3581 spec->dmux_nids[0]);
3586 /* return non-zero if the device is for automatic mic switch */
3587 static int stac_check_auto_mic(struct hda_codec *codec)
3589 struct sigmatel_spec *spec = codec->spec;
3590 struct auto_pin_cfg *cfg = &spec->autocfg;
3591 hda_nid_t fixed, ext;
3594 for (i = 0; i < cfg->num_inputs; i++) {
3595 if (cfg->inputs[i].type >= AUTO_PIN_LINE)
3596 return 0; /* must be exclusively mics */
3599 for (i = 0; i < cfg->num_inputs; i++)
3600 if (check_mic_pin(codec, cfg->inputs[i].pin, &fixed, &ext))
3602 for (i = 0; i < spec->num_dmics; i++)
3603 if (check_mic_pin(codec, spec->dmic_nids[i], &fixed, &ext))
3607 if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
3608 return 0; /* no unsol support */
3609 if (set_mic_route(codec, &spec->ext_mic, ext) ||
3610 set_mic_route(codec, &spec->int_mic, fixed))
3611 return 0; /* something is wrong */
3615 /* create playback/capture controls for input pins */
3616 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3618 struct sigmatel_spec *spec = codec->spec;
3619 struct hda_input_mux *imux = &spec->private_imux;
3620 int i, j, type_idx = 0;
3622 for (i = 0; i < cfg->num_inputs; i++) {
3623 hda_nid_t nid = cfg->inputs[i].pin;
3627 for (j = 0; j < spec->num_muxes; j++) {
3628 index = get_connection_index(codec, spec->mux_nids[j],
3636 if (i > 0 && cfg->inputs[i].type == cfg->inputs[i - 1].type)
3640 err = create_elem_capture_vol(codec, nid,
3641 auto_pin_cfg_labels[i], type_idx,
3646 imux->items[imux->num_items].label =
3647 snd_hda_get_input_pin_label(cfg, i);
3648 imux->items[imux->num_items].index = index;
3651 spec->num_analog_muxes = imux->num_items;
3653 if (imux->num_items) {
3655 * Set the current input for the muxes.
3656 * The STAC9221 has two input muxes with identical source
3657 * NID lists. Hopefully this won't get confused.
3659 for (i = 0; i < spec->num_muxes; i++) {
3660 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3661 AC_VERB_SET_CONNECT_SEL,
3662 imux->items[0].index);
3669 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3671 struct sigmatel_spec *spec = codec->spec;
3674 for (i = 0; i < spec->autocfg.line_outs; i++) {
3675 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3676 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3680 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3682 struct sigmatel_spec *spec = codec->spec;
3685 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3687 pin = spec->autocfg.hp_pins[i];
3688 if (pin) /* connect to front */
3689 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3691 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3693 pin = spec->autocfg.speaker_pins[i];
3694 if (pin) /* connect to front */
3695 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3699 static int is_dual_headphones(struct hda_codec *codec)
3701 struct sigmatel_spec *spec = codec->spec;
3704 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT ||
3705 spec->autocfg.hp_outs <= 1)
3708 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3709 hda_nid_t nid = spec->autocfg.hp_pins[i];
3710 unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid);
3711 if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE)
3715 return (valid_hps > 1);
3719 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3721 struct sigmatel_spec *spec = codec->spec;
3725 if ((err = snd_hda_parse_pin_def_config(codec,
3727 spec->dmic_nids)) < 0)
3729 if (! spec->autocfg.line_outs)
3730 return 0; /* can't find valid pin config */
3732 /* If we have no real line-out pin and multiple hp-outs, HPs should
3733 * be set up as multi-channel outputs.
3735 if (is_dual_headphones(codec)) {
3736 /* Copy hp_outs to line_outs, backup line_outs in
3737 * speaker_outs so that the following routines can handle
3738 * HP pins as primary outputs.
3740 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3741 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3742 sizeof(spec->autocfg.line_out_pins));
3743 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3744 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3745 sizeof(spec->autocfg.hp_pins));
3746 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3747 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3748 spec->autocfg.hp_outs = 0;
3751 if (spec->autocfg.mono_out_pin) {
3752 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3753 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3754 u32 caps = query_amp_caps(codec,
3755 spec->autocfg.mono_out_pin, dir);
3756 hda_nid_t conn_list[1];
3758 /* get the mixer node and then the mono mux if it exists */
3759 if (snd_hda_get_connections(codec,
3760 spec->autocfg.mono_out_pin, conn_list, 1) &&
3761 snd_hda_get_connections(codec, conn_list[0],
3762 conn_list, 1) > 0) {
3764 int wcaps = get_wcaps(codec, conn_list[0]);
3765 int wid_type = get_wcaps_type(wcaps);
3766 /* LR swap check, some stac925x have a mux that
3767 * changes the DACs output path instead of the
3770 if (wid_type == AC_WID_AUD_SEL &&
3771 !(wcaps & AC_WCAP_LR_SWAP))
3772 spec->mono_nid = conn_list[0];
3775 hda_nid_t nid = spec->autocfg.mono_out_pin;
3777 /* most mono outs have a least a mute/unmute switch */
3778 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3779 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3780 "Mono Playback Switch",
3781 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3784 /* check for volume support for the amp */
3785 if ((caps & AC_AMPCAP_NUM_STEPS)
3786 >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3787 err = stac92xx_add_control(spec,
3788 STAC_CTL_WIDGET_VOL,
3789 "Mono Playback Volume",
3790 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3796 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3800 if (!spec->multiout.num_dacs) {
3801 err = stac92xx_auto_fill_dac_nids(codec);
3804 err = stac92xx_auto_create_multi_out_ctls(codec,
3810 /* setup analog beep controls */
3811 if (spec->anabeep_nid > 0) {
3812 err = stac92xx_auto_create_beep_ctls(codec,
3818 /* setup digital beep controls and input device */
3819 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3820 if (spec->digbeep_nid > 0) {
3821 hda_nid_t nid = spec->digbeep_nid;
3824 err = stac92xx_auto_create_beep_ctls(codec, nid);
3827 err = snd_hda_attach_beep_device(codec, nid);
3831 /* IDT/STAC codecs have linear beep tone parameter */
3832 codec->beep->linear_tone = spec->linear_tone_beep;
3833 /* if no beep switch is available, make its own one */
3834 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3835 if (!(caps & AC_AMPCAP_MUTE)) {
3836 err = stac92xx_beep_switch_ctl(codec);
3844 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3848 /* All output parsing done, now restore the swapped hp pins */
3850 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3851 sizeof(spec->autocfg.hp_pins));
3852 spec->autocfg.hp_outs = spec->autocfg.line_outs;
3853 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3854 spec->autocfg.line_outs = 0;
3857 if (stac_check_auto_mic(codec)) {
3859 /* only one capture for auto-mic */
3862 spec->num_muxes = 1;
3865 for (i = 0; i < spec->num_caps; i++) {
3866 err = stac92xx_add_capvol_ctls(codec, spec->capvols[i],
3867 spec->capsws[i], i);
3872 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3876 if (spec->mono_nid > 0) {
3877 err = stac92xx_auto_create_mono_output_ctls(codec);
3881 if (spec->num_dmics > 0 && !spec->dinput_mux)
3882 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3883 &spec->autocfg)) < 0)
3885 if (spec->num_muxes > 0) {
3886 err = stac92xx_auto_create_mux_input_ctls(codec);
3890 if (spec->num_smuxes > 0) {
3891 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3896 err = stac92xx_add_input_source(spec);
3900 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3901 if (spec->multiout.max_channels > 2)
3902 spec->surr_switch = 1;
3904 if (spec->autocfg.dig_outs)
3905 spec->multiout.dig_out_nid = dig_out;
3906 if (dig_in && spec->autocfg.dig_in_pin)
3907 spec->dig_in_nid = dig_in;
3909 if (spec->kctls.list)
3910 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3912 spec->input_mux = &spec->private_imux;
3913 if (!spec->dinput_mux)
3914 spec->dinput_mux = &spec->private_dimux;
3915 spec->sinput_mux = &spec->private_smux;
3916 spec->mono_mux = &spec->private_mono_mux;
3920 /* add playback controls for HP output */
3921 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3922 struct auto_pin_cfg *cfg)
3924 struct sigmatel_spec *spec = codec->spec;
3925 hda_nid_t pin = cfg->hp_pins[0];
3926 unsigned int wid_caps;
3931 wid_caps = get_wcaps(codec, pin);
3932 if (wid_caps & AC_WCAP_UNSOL_CAP)
3933 spec->hp_detect = 1;
3938 /* add playback controls for LFE output */
3939 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3940 struct auto_pin_cfg *cfg)
3942 struct sigmatel_spec *spec = codec->spec;
3944 hda_nid_t lfe_pin = 0x0;
3948 * search speaker outs and line outs for a mono speaker pin
3949 * with an amp. If one is found, add LFE controls
3952 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3953 hda_nid_t pin = spec->autocfg.speaker_pins[i];
3954 unsigned int wcaps = get_wcaps(codec, pin);
3955 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3956 if (wcaps == AC_WCAP_OUT_AMP)
3957 /* found a mono speaker with an amp, must be lfe */
3961 /* if speaker_outs is 0, then speakers may be in line_outs */
3962 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3963 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3964 hda_nid_t pin = spec->autocfg.line_out_pins[i];
3965 unsigned int defcfg;
3966 defcfg = snd_hda_codec_get_pincfg(codec, pin);
3967 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3968 unsigned int wcaps = get_wcaps(codec, pin);
3969 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3970 if (wcaps == AC_WCAP_OUT_AMP)
3971 /* found a mono speaker with an amp,
3979 err = create_controls(codec, "LFE", lfe_pin, 1);
3987 static int stac9200_parse_auto_config(struct hda_codec *codec)
3989 struct sigmatel_spec *spec = codec->spec;
3992 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3995 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3998 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
4001 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
4004 if (spec->num_muxes > 0) {
4005 err = stac92xx_auto_create_mux_input_ctls(codec);
4010 err = stac92xx_add_input_source(spec);
4014 if (spec->autocfg.dig_outs)
4015 spec->multiout.dig_out_nid = 0x05;
4016 if (spec->autocfg.dig_in_pin)
4017 spec->dig_in_nid = 0x04;
4019 if (spec->kctls.list)
4020 spec->mixers[spec->num_mixers++] = spec->kctls.list;
4022 spec->input_mux = &spec->private_imux;
4023 spec->dinput_mux = &spec->private_dimux;
4029 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
4030 * funky external mute control using GPIO pins.
4033 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
4034 unsigned int dir_mask, unsigned int data)
4036 unsigned int gpiostate, gpiomask, gpiodir;
4038 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4039 AC_VERB_GET_GPIO_DATA, 0);
4040 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
4042 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4043 AC_VERB_GET_GPIO_MASK, 0);
4046 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4047 AC_VERB_GET_GPIO_DIRECTION, 0);
4048 gpiodir |= dir_mask;
4050 /* Configure GPIOx as CMOS */
4051 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
4053 snd_hda_codec_write(codec, codec->afg, 0,
4054 AC_VERB_SET_GPIO_MASK, gpiomask);
4055 snd_hda_codec_read(codec, codec->afg, 0,
4056 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
4060 snd_hda_codec_read(codec, codec->afg, 0,
4061 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
4064 #ifdef CONFIG_SND_HDA_INPUT_JACK
4065 static void stac92xx_free_jack_priv(struct snd_jack *jack)
4067 struct sigmatel_jack *jacks = jack->private_data;
4073 static int stac92xx_add_jack(struct hda_codec *codec,
4074 hda_nid_t nid, int type)
4076 #ifdef CONFIG_SND_HDA_INPUT_JACK
4077 struct sigmatel_spec *spec = codec->spec;
4078 struct sigmatel_jack *jack;
4079 int def_conf = snd_hda_codec_get_pincfg(codec, nid);
4080 int connectivity = get_defcfg_connect(def_conf);
4084 if (connectivity && connectivity != AC_JACK_PORT_FIXED)
4087 snd_array_init(&spec->jacks, sizeof(*jack), 32);
4088 jack = snd_array_new(&spec->jacks);
4094 snprintf(name, sizeof(name), "%s at %s %s Jack",
4095 snd_hda_get_jack_type(def_conf),
4096 snd_hda_get_jack_connectivity(def_conf),
4097 snd_hda_get_jack_location(def_conf));
4099 err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
4104 jack->jack->private_data = jack;
4105 jack->jack->private_free = stac92xx_free_jack_priv;
4110 static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
4111 unsigned char type, int data)
4113 struct sigmatel_event *event;
4115 snd_array_init(&spec->events, sizeof(*event), 32);
4116 event = snd_array_new(&spec->events);
4121 event->tag = spec->events.used;
4127 static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
4130 struct sigmatel_spec *spec = codec->spec;
4131 struct sigmatel_event *event = spec->events.list;
4134 for (i = 0; i < spec->events.used; i++, event++) {
4135 if (event->nid == nid)
4141 static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
4144 struct sigmatel_spec *spec = codec->spec;
4145 struct sigmatel_event *event = spec->events.list;
4148 for (i = 0; i < spec->events.used; i++, event++) {
4149 if (event->tag == tag)
4155 /* check if given nid is a valid pin and no other events are assigned
4156 * to it. If OK, assign the event, set the unsol flag, and returns 1.
4157 * Otherwise, returns zero.
4159 static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
4162 struct sigmatel_event *event;
4165 if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
4167 event = stac_get_event(codec, nid);
4169 if (event->type != type)
4173 tag = stac_add_event(codec->spec, nid, type, 0);
4177 snd_hda_codec_write_cache(codec, nid, 0,
4178 AC_VERB_SET_UNSOLICITED_ENABLE,
4183 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
4186 for (i = 0; i < cfg->hp_outs; i++)
4187 if (cfg->hp_pins[i] == nid)
4188 return 1; /* nid is a HP-Out */
4190 return 0; /* nid is not a HP-Out */
4193 static void stac92xx_power_down(struct hda_codec *codec)
4195 struct sigmatel_spec *spec = codec->spec;
4197 /* power down inactive DACs */
4199 for (dac = spec->dac_list; *dac; dac++)
4200 if (!check_all_dac_nids(spec, *dac))
4201 snd_hda_codec_write(codec, *dac, 0,
4202 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4205 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4208 static inline int get_int_hint(struct hda_codec *codec, const char *key,
4212 p = snd_hda_get_hint(codec, key);
4215 if (!strict_strtoul(p, 0, &val)) {
4223 /* override some hints from the hwdep entry */
4224 static void stac_store_hints(struct hda_codec *codec)
4226 struct sigmatel_spec *spec = codec->spec;
4229 val = snd_hda_get_bool_hint(codec, "hp_detect");
4231 spec->hp_detect = val;
4232 if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) {
4233 spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
4236 if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir))
4237 spec->gpio_mask &= spec->gpio_mask;
4238 if (get_int_hint(codec, "gpio_data", &spec->gpio_data))
4239 spec->gpio_dir &= spec->gpio_mask;
4240 if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask))
4241 spec->eapd_mask &= spec->gpio_mask;
4242 if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute))
4243 spec->gpio_mute &= spec->gpio_mask;
4244 val = snd_hda_get_bool_hint(codec, "eapd_switch");
4246 spec->eapd_switch = val;
4247 get_int_hint(codec, "gpio_led_polarity", &spec->gpio_led_polarity);
4248 if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) {
4249 spec->gpio_mask |= spec->gpio_led;
4250 spec->gpio_dir |= spec->gpio_led;
4251 if (spec->gpio_led_polarity)
4252 spec->gpio_data |= spec->gpio_led;
4256 static int stac92xx_init(struct hda_codec *codec)
4258 struct sigmatel_spec *spec = codec->spec;
4259 struct auto_pin_cfg *cfg = &spec->autocfg;
4263 snd_hda_sequence_write(codec, spec->init);
4265 /* power down adcs initially */
4266 if (spec->powerdown_adcs)
4267 for (i = 0; i < spec->num_adcs; i++)
4268 snd_hda_codec_write(codec,
4269 spec->adc_nids[i], 0,
4270 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4272 /* override some hints */
4273 stac_store_hints(codec);
4276 gpio = spec->gpio_data;
4277 /* turn on EAPD statically when spec->eapd_switch isn't set.
4278 * otherwise, unsol event will turn it on/off dynamically
4280 if (!spec->eapd_switch)
4281 gpio |= spec->eapd_mask;
4282 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
4285 if (spec->hp_detect) {
4286 /* Enable unsolicited responses on the HP widget */
4287 for (i = 0; i < cfg->hp_outs; i++) {
4288 hda_nid_t nid = cfg->hp_pins[i];
4289 enable_pin_detect(codec, nid, STAC_HP_EVENT);
4291 if (cfg->line_out_type == AUTO_PIN_LINE_OUT &&
4292 cfg->speaker_outs > 0) {
4293 /* enable pin-detect for line-outs as well */
4294 for (i = 0; i < cfg->line_outs; i++) {
4295 hda_nid_t nid = cfg->line_out_pins[i];
4296 enable_pin_detect(codec, nid, STAC_LO_EVENT);
4300 /* force to enable the first line-out; the others are set up
4303 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
4305 /* fake event to set up pins */
4306 if (cfg->hp_pins[0])
4307 stac_issue_unsol_event(codec, cfg->hp_pins[0]);
4308 else if (cfg->line_out_pins[0])
4309 stac_issue_unsol_event(codec, cfg->line_out_pins[0]);
4311 stac92xx_auto_init_multi_out(codec);
4312 stac92xx_auto_init_hp_out(codec);
4313 for (i = 0; i < cfg->hp_outs; i++)
4314 stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
4316 if (spec->auto_mic) {
4317 /* initialize connection to analog input */
4318 if (spec->dmux_nids)
4319 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4320 AC_VERB_SET_CONNECT_SEL, 0);
4321 if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT))
4322 stac_issue_unsol_event(codec, spec->ext_mic.pin);
4324 for (i = 0; i < cfg->num_inputs; i++) {
4325 hda_nid_t nid = cfg->inputs[i].pin;
4326 int type = cfg->inputs[i].type;
4327 unsigned int pinctl, conf;
4328 if (type == AUTO_PIN_MIC || type == AUTO_PIN_FRONT_MIC) {
4329 /* for mic pins, force to initialize */
4330 pinctl = stac92xx_get_default_vref(codec, nid);
4331 pinctl |= AC_PINCTL_IN_EN;
4332 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4334 pinctl = snd_hda_codec_read(codec, nid, 0,
4335 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4336 /* if PINCTL already set then skip */
4337 /* Also, if both INPUT and OUTPUT are set,
4338 * it must be a BIOS bug; need to override, too
4340 if (!(pinctl & AC_PINCTL_IN_EN) ||
4341 (pinctl & AC_PINCTL_OUT_EN)) {
4342 pinctl &= ~AC_PINCTL_OUT_EN;
4343 pinctl |= AC_PINCTL_IN_EN;
4344 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4347 conf = snd_hda_codec_get_pincfg(codec, nid);
4348 if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
4349 if (enable_pin_detect(codec, nid, STAC_INSERT_EVENT))
4350 stac_issue_unsol_event(codec, nid);
4353 for (i = 0; i < spec->num_dmics; i++)
4354 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4356 if (cfg->dig_out_pins[0])
4357 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0],
4359 if (cfg->dig_in_pin)
4360 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4362 for (i = 0; i < spec->num_pwrs; i++) {
4363 hda_nid_t nid = spec->pwr_nids[i];
4364 int pinctl, def_conf;
4366 /* power on when no jack detection is available */
4367 if (!spec->hp_detect) {
4368 stac_toggle_power_map(codec, nid, 1);
4372 if (is_nid_hp_pin(cfg, nid))
4373 continue; /* already has an unsol event */
4375 pinctl = snd_hda_codec_read(codec, nid, 0,
4376 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4377 /* outputs are only ports capable of power management
4378 * any attempts on powering down a input port cause the
4379 * referenced VREF to act quirky.
4381 if (pinctl & AC_PINCTL_IN_EN) {
4382 stac_toggle_power_map(codec, nid, 1);
4385 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4386 def_conf = get_defcfg_connect(def_conf);
4387 /* skip any ports that don't have jacks since presence
4388 * detection is useless */
4389 if (def_conf != AC_JACK_PORT_COMPLEX) {
4390 if (def_conf != AC_JACK_PORT_NONE)
4391 stac_toggle_power_map(codec, nid, 1);
4394 if (enable_pin_detect(codec, nid, STAC_PWR_EVENT))
4395 stac_issue_unsol_event(codec, nid);
4398 #ifdef CONFIG_SND_HDA_POWER_SAVE
4400 if (spec->gpio_led && codec->patch_ops.check_power_status)
4401 codec->patch_ops.check_power_status(codec, 0x01);
4404 stac92xx_power_down(codec);
4408 static void stac92xx_free_jacks(struct hda_codec *codec)
4410 #ifdef CONFIG_SND_HDA_INPUT_JACK
4411 /* free jack instances manually when clearing/reconfiguring */
4412 struct sigmatel_spec *spec = codec->spec;
4413 if (!codec->bus->shutdown && spec->jacks.list) {
4414 struct sigmatel_jack *jacks = spec->jacks.list;
4416 for (i = 0; i < spec->jacks.used; i++, jacks++) {
4418 snd_device_free(codec->bus->card, jacks->jack);
4421 snd_array_free(&spec->jacks);
4425 static void stac92xx_free_kctls(struct hda_codec *codec)
4427 struct sigmatel_spec *spec = codec->spec;
4429 if (spec->kctls.list) {
4430 struct snd_kcontrol_new *kctl = spec->kctls.list;
4432 for (i = 0; i < spec->kctls.used; i++)
4433 kfree(kctl[i].name);
4435 snd_array_free(&spec->kctls);
4438 static void stac92xx_shutup(struct hda_codec *codec)
4440 struct sigmatel_spec *spec = codec->spec;
4442 snd_hda_shutup_pins(codec);
4444 if (spec->eapd_mask)
4445 stac_gpio_set(codec, spec->gpio_mask,
4446 spec->gpio_dir, spec->gpio_data &
4450 static void stac92xx_free(struct hda_codec *codec)
4452 struct sigmatel_spec *spec = codec->spec;
4457 stac92xx_shutup(codec);
4458 stac92xx_free_jacks(codec);
4459 snd_array_free(&spec->events);
4462 snd_hda_detach_beep_device(codec);
4465 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4468 unsigned int old_ctl, pin_ctl;
4470 pin_ctl = snd_hda_codec_read(codec, nid,
4471 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4473 if (pin_ctl & AC_PINCTL_IN_EN) {
4475 * we need to check the current set-up direction of
4476 * shared input pins since they can be switched via
4477 * "xxx as Output" mixer switch
4479 struct sigmatel_spec *spec = codec->spec;
4480 if (nid == spec->line_switch || nid == spec->mic_switch)
4485 /* if setting pin direction bits, clear the current
4486 direction bits first */
4487 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4488 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4491 if (old_ctl != pin_ctl)
4492 snd_hda_codec_write_cache(codec, nid, 0,
4493 AC_VERB_SET_PIN_WIDGET_CONTROL,
4497 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4500 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4501 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4503 snd_hda_codec_write_cache(codec, nid, 0,
4504 AC_VERB_SET_PIN_WIDGET_CONTROL,
4508 static inline int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4512 return snd_hda_jack_detect(codec, nid);
4515 static void stac92xx_line_out_detect(struct hda_codec *codec,
4518 struct sigmatel_spec *spec = codec->spec;
4519 struct auto_pin_cfg *cfg = &spec->autocfg;
4522 for (i = 0; i < cfg->line_outs; i++) {
4525 presence = get_pin_presence(codec, cfg->line_out_pins[i]);
4527 unsigned int pinctl;
4528 pinctl = snd_hda_codec_read(codec,
4529 cfg->line_out_pins[i], 0,
4530 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4531 if (pinctl & AC_PINCTL_IN_EN)
4532 presence = 0; /* mic- or line-input */
4537 /* disable speakers */
4538 for (i = 0; i < cfg->speaker_outs; i++)
4539 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4541 if (spec->eapd_mask && spec->eapd_switch)
4542 stac_gpio_set(codec, spec->gpio_mask,
4543 spec->gpio_dir, spec->gpio_data &
4546 /* enable speakers */
4547 for (i = 0; i < cfg->speaker_outs; i++)
4548 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4550 if (spec->eapd_mask && spec->eapd_switch)
4551 stac_gpio_set(codec, spec->gpio_mask,
4552 spec->gpio_dir, spec->gpio_data |
4557 /* return non-zero if the hp-pin of the given array index isn't
4558 * a jack-detection target
4560 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4562 struct auto_pin_cfg *cfg = &spec->autocfg;
4564 /* ignore sensing of shared line and mic jacks */
4565 if (cfg->hp_pins[i] == spec->line_switch)
4567 if (cfg->hp_pins[i] == spec->mic_switch)
4569 /* ignore if the pin is set as line-out */
4570 if (cfg->hp_pins[i] == spec->hp_switch)
4575 static void stac92xx_hp_detect(struct hda_codec *codec)
4577 struct sigmatel_spec *spec = codec->spec;
4578 struct auto_pin_cfg *cfg = &spec->autocfg;
4582 if (spec->gpio_mute)
4583 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4584 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4586 for (i = 0; i < cfg->hp_outs; i++) {
4589 if (no_hp_sensing(spec, i))
4591 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4593 unsigned int pinctl;
4594 pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4595 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4596 if (pinctl & AC_PINCTL_IN_EN)
4597 presence = 0; /* mic- or line-input */
4602 /* disable lineouts */
4603 if (spec->hp_switch)
4604 stac92xx_reset_pinctl(codec, spec->hp_switch,
4606 for (i = 0; i < cfg->line_outs; i++)
4607 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4610 /* enable lineouts */
4611 if (spec->hp_switch)
4612 stac92xx_set_pinctl(codec, spec->hp_switch,
4614 for (i = 0; i < cfg->line_outs; i++)
4615 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4618 stac92xx_line_out_detect(codec, presence);
4619 /* toggle hp outs */
4620 for (i = 0; i < cfg->hp_outs; i++) {
4621 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4622 if (no_hp_sensing(spec, i))
4625 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4627 /* Resetting the pinctl like below may lead to (a sort of) regressions
4628 * on some devices since they use the HP pin actually for line/speaker
4629 * outs although the default pin config shows a different pin (that is
4630 * wrong and useless).
4632 * So, it's basically a problem of default pin configs, likely a BIOS issue.
4633 * But, disabling the code below just works around it, and I'm too tired of
4634 * bug reports with such devices...
4637 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4642 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4645 struct sigmatel_spec *spec = codec->spec;
4646 unsigned int idx, val;
4648 for (idx = 0; idx < spec->num_pwrs; idx++) {
4649 if (spec->pwr_nids[idx] == nid)
4652 if (idx >= spec->num_pwrs)
4655 /* several codecs have two power down bits */
4656 if (spec->pwr_mapping)
4657 idx = spec->pwr_mapping[idx];
4661 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
4667 /* power down unused output ports */
4668 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4671 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4673 stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4676 static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
4678 struct sigmatel_spec *spec = codec->spec;
4679 struct sigmatel_jack *jacks = spec->jacks.list;
4683 for (i = 0; i < spec->jacks.used; i++) {
4684 if (jacks->nid == nid) {
4685 unsigned int pin_ctl =
4686 snd_hda_codec_read(codec, nid,
4687 0, AC_VERB_GET_PIN_WIDGET_CONTROL,
4689 int type = jacks->type;
4690 if (type == (SND_JACK_LINEOUT
4691 | SND_JACK_HEADPHONE))
4692 type = (pin_ctl & AC_PINCTL_HP_EN)
4693 ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
4694 snd_jack_report(jacks->jack,
4695 get_pin_presence(codec, nid)
4703 /* get the pin connection (fixed, none, etc) */
4704 static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
4706 struct sigmatel_spec *spec = codec->spec;
4709 cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]);
4710 return get_defcfg_connect(cfg);
4713 static int stac92xx_connected_ports(struct hda_codec *codec,
4714 hda_nid_t *nids, int num_nids)
4716 struct sigmatel_spec *spec = codec->spec;
4718 unsigned int def_conf;
4720 for (num = 0; num < num_nids; num++) {
4721 for (idx = 0; idx < spec->num_pins; idx++)
4722 if (spec->pin_nids[idx] == nids[num])
4724 if (idx >= spec->num_pins)
4726 def_conf = stac_get_defcfg_connect(codec, idx);
4727 if (def_conf == AC_JACK_PORT_NONE)
4733 static void stac92xx_mic_detect(struct hda_codec *codec)
4735 struct sigmatel_spec *spec = codec->spec;
4736 struct sigmatel_mic_route *mic;
4738 if (get_pin_presence(codec, spec->ext_mic.pin))
4739 mic = &spec->ext_mic;
4741 mic = &spec->int_mic;
4742 if (mic->dmux_idx >= 0)
4743 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4744 AC_VERB_SET_CONNECT_SEL,
4746 if (mic->mux_idx >= 0)
4747 snd_hda_codec_write_cache(codec, spec->mux_nids[0], 0,
4748 AC_VERB_SET_CONNECT_SEL,
4752 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid)
4754 struct sigmatel_event *event = stac_get_event(codec, nid);
4757 codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
4760 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4762 struct sigmatel_spec *spec = codec->spec;
4763 struct sigmatel_event *event;
4766 tag = (res >> 26) & 0x7f;
4767 event = stac_get_event_from_tag(codec, tag);
4771 switch (event->type) {
4774 stac92xx_hp_detect(codec);
4776 case STAC_MIC_EVENT:
4777 stac92xx_mic_detect(codec);
4781 switch (event->type) {
4784 case STAC_MIC_EVENT:
4785 case STAC_INSERT_EVENT:
4786 case STAC_PWR_EVENT:
4787 if (spec->num_pwrs > 0)
4788 stac92xx_pin_sense(codec, event->nid);
4789 stac92xx_report_jack(codec, event->nid);
4791 switch (codec->subsystem_id) {
4793 if (event->nid == 0xb) {
4794 int pin = AC_PINCTL_IN_EN;
4796 if (get_pin_presence(codec, 0xa)
4797 && get_pin_presence(codec, 0xb))
4798 pin |= AC_PINCTL_VREF_80;
4799 if (!get_pin_presence(codec, 0xb))
4800 pin |= AC_PINCTL_VREF_80;
4802 /* toggle VREF state based on mic + hp pin
4805 stac92xx_auto_set_pinctl(codec, 0x0a, pin);
4809 case STAC_VREF_EVENT:
4810 data = snd_hda_codec_read(codec, codec->afg, 0,
4811 AC_VERB_GET_GPIO_DATA, 0);
4812 /* toggle VREF state based on GPIOx status */
4813 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4814 !!(data & (1 << event->data)));
4819 static int hp_blike_system(u32 subsystem_id);
4821 static void set_hp_led_gpio(struct hda_codec *codec)
4823 struct sigmatel_spec *spec = codec->spec;
4829 gpio = snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP);
4830 gpio &= AC_GPIO_IO_COUNT;
4832 spec->gpio_led = 0x08; /* GPIO 3 */
4834 spec->gpio_led = 0x01; /* GPIO 0 */
4838 * This method searches for the mute LED GPIO configuration
4839 * provided as OEM string in SMBIOS. The format of that string
4840 * is HP_Mute_LED_P_G or HP_Mute_LED_P
4841 * where P can be 0 or 1 and defines mute LED GPIO control state (low/high)
4842 * that corresponds to the NOT muted state of the master volume
4843 * and G is the index of the GPIO to use as the mute LED control (0..9)
4844 * If _G portion is missing it is assigned based on the codec ID
4846 * So, HP B-series like systems may have HP_Mute_LED_0 (current models)
4847 * or HP_Mute_LED_0_3 (future models) OEM SMBIOS strings
4850 * The dv-series laptops don't seem to have the HP_Mute_LED* strings in
4851 * SMBIOS - at least the ones I have seen do not have them - which include
4852 * my own system (HP Pavilion dv6-1110ax) and my cousin's
4853 * HP Pavilion dv9500t CTO.
4854 * Need more information on whether it is true across the entire series.
4857 static int find_mute_led_gpio(struct hda_codec *codec, int default_polarity)
4859 struct sigmatel_spec *spec = codec->spec;
4860 const struct dmi_device *dev = NULL;
4862 if ((codec->subsystem_id >> 16) == PCI_VENDOR_ID_HP) {
4863 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING,
4865 if (sscanf(dev->name, "HP_Mute_LED_%d_%d",
4866 &spec->gpio_led_polarity,
4867 &spec->gpio_led) == 2) {
4868 spec->gpio_led = 1 << spec->gpio_led;
4871 if (sscanf(dev->name, "HP_Mute_LED_%d",
4872 &spec->gpio_led_polarity) == 1) {
4873 set_hp_led_gpio(codec);
4879 * Fallback case - if we don't find the DMI strings,
4880 * we statically set the GPIO - if not a B-series system.
4882 if (!hp_blike_system(codec->subsystem_id)) {
4883 set_hp_led_gpio(codec);
4884 spec->gpio_led_polarity = default_polarity;
4891 static int hp_blike_system(u32 subsystem_id)
4893 switch (subsystem_id) {
4920 #ifdef CONFIG_PROC_FS
4921 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4922 struct hda_codec *codec, hda_nid_t nid)
4924 if (nid == codec->afg)
4925 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4926 snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
4929 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4930 struct hda_codec *codec,
4933 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4934 snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
4937 /* stac92hd71bxx, stac92hd73xx */
4938 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4939 struct hda_codec *codec, hda_nid_t nid)
4941 stac92hd_proc_hook(buffer, codec, nid);
4942 if (nid == codec->afg)
4943 analog_loop_proc_hook(buffer, codec, 0xfa0);
4946 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4947 struct hda_codec *codec, hda_nid_t nid)
4949 if (nid == codec->afg)
4950 analog_loop_proc_hook(buffer, codec, 0xfe0);
4953 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4954 struct hda_codec *codec, hda_nid_t nid)
4956 if (nid == codec->afg)
4957 analog_loop_proc_hook(buffer, codec, 0xfeb);
4960 #define stac92hd_proc_hook NULL
4961 #define stac92hd7x_proc_hook NULL
4962 #define stac9205_proc_hook NULL
4963 #define stac927x_proc_hook NULL
4966 #ifdef SND_HDA_NEEDS_RESUME
4967 static int stac92xx_resume(struct hda_codec *codec)
4969 struct sigmatel_spec *spec = codec->spec;
4971 stac92xx_init(codec);
4972 snd_hda_codec_resume_amp(codec);
4973 snd_hda_codec_resume_cache(codec);
4974 /* fake event to set up pins again to override cached values */
4975 if (spec->hp_detect) {
4976 if (spec->autocfg.hp_pins[0])
4977 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0]);
4978 else if (spec->autocfg.line_out_pins[0])
4979 stac_issue_unsol_event(codec,
4980 spec->autocfg.line_out_pins[0]);
4982 #ifdef CONFIG_SND_HDA_POWER_SAVE
4984 if (spec->gpio_led && codec->patch_ops.check_power_status)
4985 codec->patch_ops.check_power_status(codec, 0x01);
4991 * using power check for controlling mute led of HP notebooks
4992 * check for mute state only on Speakers (nid = 0x10)
4994 * For this feature CONFIG_SND_HDA_POWER_SAVE is needed, otherwise
4995 * the LED is NOT working properly !
4997 * Changed name to reflect that it now works for any designated
4998 * model, not just HP HDX.
5001 #ifdef CONFIG_SND_HDA_POWER_SAVE
5002 static int stac92xx_hp_check_power_status(struct hda_codec *codec,
5005 struct sigmatel_spec *spec = codec->spec;
5008 for (i = 0; i < spec->multiout.num_dacs; i++) {
5009 nid = spec->multiout.dac_nids[i];
5010 if (!(snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
5012 muted = 0; /* something heard */
5017 spec->gpio_data &= ~spec->gpio_led; /* orange */
5019 spec->gpio_data |= spec->gpio_led; /* white */
5021 if (!spec->gpio_led_polarity) {
5022 /* LED state is inverted on these systems */
5023 spec->gpio_data ^= spec->gpio_led;
5026 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
5031 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
5033 stac92xx_shutup(codec);
5038 static struct hda_codec_ops stac92xx_patch_ops = {
5039 .build_controls = stac92xx_build_controls,
5040 .build_pcms = stac92xx_build_pcms,
5041 .init = stac92xx_init,
5042 .free = stac92xx_free,
5043 .unsol_event = stac92xx_unsol_event,
5044 #ifdef SND_HDA_NEEDS_RESUME
5045 .suspend = stac92xx_suspend,
5046 .resume = stac92xx_resume,
5048 .reboot_notify = stac92xx_shutup,
5051 static int patch_stac9200(struct hda_codec *codec)
5053 struct sigmatel_spec *spec;
5056 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5060 codec->no_trigger_sense = 1;
5062 spec->linear_tone_beep = 1;
5063 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
5064 spec->pin_nids = stac9200_pin_nids;
5065 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
5068 if (spec->board_config < 0)
5069 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5072 stac92xx_set_config_regs(codec,
5073 stac9200_brd_tbl[spec->board_config]);
5075 spec->multiout.max_channels = 2;
5076 spec->multiout.num_dacs = 1;
5077 spec->multiout.dac_nids = stac9200_dac_nids;
5078 spec->adc_nids = stac9200_adc_nids;
5079 spec->mux_nids = stac9200_mux_nids;
5080 spec->num_muxes = 1;
5081 spec->num_dmics = 0;
5085 if (spec->board_config == STAC_9200_M4 ||
5086 spec->board_config == STAC_9200_M4_2 ||
5087 spec->board_config == STAC_9200_OQO)
5088 spec->init = stac9200_eapd_init;
5090 spec->init = stac9200_core_init;
5091 spec->mixer = stac9200_mixer;
5093 if (spec->board_config == STAC_9200_PANASONIC) {
5094 spec->gpio_mask = spec->gpio_dir = 0x09;
5095 spec->gpio_data = 0x00;
5098 err = stac9200_parse_auto_config(codec);
5100 stac92xx_free(codec);
5104 /* CF-74 has no headphone detection, and the driver should *NOT*
5105 * do detection and HP/speaker toggle because the hardware does it.
5107 if (spec->board_config == STAC_9200_PANASONIC)
5108 spec->hp_detect = 0;
5110 codec->patch_ops = stac92xx_patch_ops;
5115 static int patch_stac925x(struct hda_codec *codec)
5117 struct sigmatel_spec *spec;
5120 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5124 codec->no_trigger_sense = 1;
5126 spec->linear_tone_beep = 1;
5127 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
5128 spec->pin_nids = stac925x_pin_nids;
5130 /* Check first for codec ID */
5131 spec->board_config = snd_hda_check_board_codec_sid_config(codec,
5134 stac925x_codec_id_cfg_tbl);
5136 /* Now checks for PCI ID, if codec ID is not found */
5137 if (spec->board_config < 0)
5138 spec->board_config = snd_hda_check_board_config(codec,
5143 if (spec->board_config < 0)
5144 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5147 stac92xx_set_config_regs(codec,
5148 stac925x_brd_tbl[spec->board_config]);
5150 spec->multiout.max_channels = 2;
5151 spec->multiout.num_dacs = 1;
5152 spec->multiout.dac_nids = stac925x_dac_nids;
5153 spec->adc_nids = stac925x_adc_nids;
5154 spec->mux_nids = stac925x_mux_nids;
5155 spec->num_muxes = 1;
5158 switch (codec->vendor_id) {
5159 case 0x83847632: /* STAC9202 */
5160 case 0x83847633: /* STAC9202D */
5161 case 0x83847636: /* STAC9251 */
5162 case 0x83847637: /* STAC9251D */
5163 spec->num_dmics = STAC925X_NUM_DMICS;
5164 spec->dmic_nids = stac925x_dmic_nids;
5165 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
5166 spec->dmux_nids = stac925x_dmux_nids;
5169 spec->num_dmics = 0;
5173 spec->init = stac925x_core_init;
5174 spec->mixer = stac925x_mixer;
5176 spec->capvols = stac925x_capvols;
5177 spec->capsws = stac925x_capsws;
5179 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
5181 if (spec->board_config < 0) {
5182 printk(KERN_WARNING "hda_codec: No auto-config is "
5183 "available, default to model=ref\n");
5184 spec->board_config = STAC_925x_REF;
5190 stac92xx_free(codec);
5194 codec->patch_ops = stac92xx_patch_ops;
5199 static int patch_stac92hd73xx(struct hda_codec *codec)
5201 struct sigmatel_spec *spec;
5202 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
5206 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5210 codec->no_trigger_sense = 1;
5212 spec->linear_tone_beep = 0;
5213 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
5214 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
5215 spec->pin_nids = stac92hd73xx_pin_nids;
5216 spec->board_config = snd_hda_check_board_config(codec,
5217 STAC_92HD73XX_MODELS,
5218 stac92hd73xx_models,
5219 stac92hd73xx_cfg_tbl);
5220 /* check codec subsystem id if not found */
5221 if (spec->board_config < 0)
5222 spec->board_config =
5223 snd_hda_check_board_codec_sid_config(codec,
5224 STAC_92HD73XX_MODELS, stac92hd73xx_models,
5225 stac92hd73xx_codec_id_cfg_tbl);
5227 if (spec->board_config < 0)
5228 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5231 stac92xx_set_config_regs(codec,
5232 stac92hd73xx_brd_tbl[spec->board_config]);
5234 num_dacs = snd_hda_get_connections(codec, 0x0a,
5235 conn, STAC92HD73_DAC_COUNT + 2) - 1;
5237 if (num_dacs < 3 || num_dacs > 5) {
5238 printk(KERN_WARNING "hda_codec: Could not determine "
5239 "number of channels defaulting to DAC count\n");
5240 num_dacs = STAC92HD73_DAC_COUNT;
5242 spec->init = stac92hd73xx_core_init;
5244 case 0x3: /* 6 Channel */
5245 spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
5247 case 0x4: /* 8 Channel */
5248 spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
5250 case 0x5: /* 10 Channel */
5251 spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
5254 spec->multiout.dac_nids = spec->dac_nids;
5256 spec->aloopback_mask = 0x01;
5257 spec->aloopback_shift = 8;
5259 spec->digbeep_nid = 0x1c;
5260 spec->mux_nids = stac92hd73xx_mux_nids;
5261 spec->adc_nids = stac92hd73xx_adc_nids;
5262 spec->dmic_nids = stac92hd73xx_dmic_nids;
5263 spec->dmux_nids = stac92hd73xx_dmux_nids;
5264 spec->smux_nids = stac92hd73xx_smux_nids;
5266 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
5267 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
5268 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
5270 spec->num_caps = STAC92HD73XX_NUM_CAPS;
5271 spec->capvols = stac92hd73xx_capvols;
5272 spec->capsws = stac92hd73xx_capsws;
5274 switch (spec->board_config) {
5276 spec->init = dell_eq_core_init;
5278 case STAC_DELL_M6_AMIC:
5279 case STAC_DELL_M6_DMIC:
5280 case STAC_DELL_M6_BOTH:
5281 spec->num_smuxes = 0;
5282 spec->eapd_switch = 0;
5284 switch (spec->board_config) {
5285 case STAC_DELL_M6_AMIC: /* Analog Mics */
5286 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5287 spec->num_dmics = 0;
5289 case STAC_DELL_M6_DMIC: /* Digital Mics */
5290 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5291 spec->num_dmics = 1;
5293 case STAC_DELL_M6_BOTH: /* Both */
5294 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5295 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5296 spec->num_dmics = 1;
5300 case STAC_ALIENWARE_M17X:
5301 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
5302 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
5303 spec->eapd_switch = 0;
5306 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
5307 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
5308 spec->eapd_switch = 1;
5311 if (spec->board_config != STAC_92HD73XX_REF) {
5312 /* GPIO0 High = Enable EAPD */
5313 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5314 spec->gpio_data = 0x01;
5317 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
5318 spec->pwr_nids = stac92hd73xx_pwr_nids;
5320 err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
5323 if (spec->board_config < 0) {
5324 printk(KERN_WARNING "hda_codec: No auto-config is "
5325 "available, default to model=ref\n");
5326 spec->board_config = STAC_92HD73XX_REF;
5333 stac92xx_free(codec);
5337 if (spec->board_config == STAC_92HD73XX_NO_JD)
5338 spec->hp_detect = 0;
5340 codec->patch_ops = stac92xx_patch_ops;
5342 codec->proc_widget_hook = stac92hd7x_proc_hook;
5347 static int patch_stac92hd83xxx(struct hda_codec *codec)
5349 struct sigmatel_spec *spec;
5350 hda_nid_t conn[STAC92HD83_DAC_COUNT + 1];
5354 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5358 codec->no_trigger_sense = 1;
5360 spec->linear_tone_beep = 1;
5361 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
5362 spec->digbeep_nid = 0x21;
5363 spec->dmic_nids = stac92hd83xxx_dmic_nids;
5364 spec->dmux_nids = stac92hd83xxx_mux_nids;
5365 spec->mux_nids = stac92hd83xxx_mux_nids;
5366 spec->num_muxes = ARRAY_SIZE(stac92hd83xxx_mux_nids);
5367 spec->adc_nids = stac92hd83xxx_adc_nids;
5368 spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
5369 spec->pwr_nids = stac92hd83xxx_pwr_nids;
5370 spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
5371 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
5372 spec->multiout.dac_nids = spec->dac_nids;
5374 spec->init = stac92hd83xxx_core_init;
5375 spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
5376 spec->pin_nids = stac92hd83xxx_pin_nids;
5377 spec->num_caps = STAC92HD83XXX_NUM_CAPS;
5378 spec->capvols = stac92hd83xxx_capvols;
5379 spec->capsws = stac92hd83xxx_capsws;
5381 spec->board_config = snd_hda_check_board_config(codec,
5382 STAC_92HD83XXX_MODELS,
5383 stac92hd83xxx_models,
5384 stac92hd83xxx_cfg_tbl);
5386 if (spec->board_config < 0)
5387 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5390 stac92xx_set_config_regs(codec,
5391 stac92hd83xxx_brd_tbl[spec->board_config]);
5393 switch (codec->vendor_id) {
5400 spec->num_pins = ARRAY_SIZE(stac92hd88xxx_pin_nids);
5401 spec->pin_nids = stac92hd88xxx_pin_nids;
5403 spec->digbeep_nid = 0;
5411 if (spec->board_config == STAC_92HD83XXX_PWR_REF)
5414 spec->num_dmics = stac92xx_connected_ports(codec,
5415 stac92hd83xxx_dmic_nids,
5416 STAC92HD83XXX_NUM_DMICS);
5420 codec->patch_ops = stac92xx_patch_ops;
5422 if (find_mute_led_gpio(codec, 0))
5423 snd_printd("mute LED gpio %d polarity %d\n",
5425 spec->gpio_led_polarity);
5427 #ifdef CONFIG_SND_HDA_POWER_SAVE
5428 if (spec->gpio_led) {
5429 spec->gpio_mask |= spec->gpio_led;
5430 spec->gpio_dir |= spec->gpio_led;
5431 spec->gpio_data |= spec->gpio_led;
5432 /* register check_power_status callback. */
5433 codec->patch_ops.check_power_status =
5434 stac92xx_hp_check_power_status;
5438 err = stac92xx_parse_auto_config(codec, 0x1d, 0);
5440 if (spec->board_config < 0) {
5441 printk(KERN_WARNING "hda_codec: No auto-config is "
5442 "available, default to model=ref\n");
5443 spec->board_config = STAC_92HD83XXX_REF;
5450 stac92xx_free(codec);
5454 /* docking output support */
5455 num_dacs = snd_hda_get_connections(codec, 0xF,
5456 conn, STAC92HD83_DAC_COUNT + 1) - 1;
5457 /* skip non-DAC connections */
5458 while (num_dacs >= 0 &&
5459 (get_wcaps_type(get_wcaps(codec, conn[num_dacs]))
5462 /* set port E and F to select the last DAC */
5463 if (num_dacs >= 0) {
5464 snd_hda_codec_write_cache(codec, 0xE, 0,
5465 AC_VERB_SET_CONNECT_SEL, num_dacs);
5466 snd_hda_codec_write_cache(codec, 0xF, 0,
5467 AC_VERB_SET_CONNECT_SEL, num_dacs);
5470 codec->proc_widget_hook = stac92hd_proc_hook;
5475 static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
5478 struct sigmatel_spec *spec = codec->spec;
5481 for (idx = 0; idx < spec->num_pins; idx++)
5482 if (spec->pin_nids[idx] == dig0pin)
5484 if ((idx + 2) >= spec->num_pins)
5488 if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE)
5491 /* dig0pin + dig2pin case */
5492 if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE)
5494 if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE)
5500 /* HP dv7 bass switch - GPIO5 */
5501 #define stac_hp_bass_gpio_info snd_ctl_boolean_mono_info
5502 static int stac_hp_bass_gpio_get(struct snd_kcontrol *kcontrol,
5503 struct snd_ctl_elem_value *ucontrol)
5505 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5506 struct sigmatel_spec *spec = codec->spec;
5507 ucontrol->value.integer.value[0] = !!(spec->gpio_data & 0x20);
5511 static int stac_hp_bass_gpio_put(struct snd_kcontrol *kcontrol,
5512 struct snd_ctl_elem_value *ucontrol)
5514 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5515 struct sigmatel_spec *spec = codec->spec;
5516 unsigned int gpio_data;
5518 gpio_data = (spec->gpio_data & ~0x20) |
5519 (ucontrol->value.integer.value[0] ? 0x20 : 0);
5520 if (gpio_data == spec->gpio_data)
5522 spec->gpio_data = gpio_data;
5523 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
5527 static struct snd_kcontrol_new stac_hp_bass_sw_ctrl = {
5528 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5529 .info = stac_hp_bass_gpio_info,
5530 .get = stac_hp_bass_gpio_get,
5531 .put = stac_hp_bass_gpio_put,
5534 static int stac_add_hp_bass_switch(struct hda_codec *codec)
5536 struct sigmatel_spec *spec = codec->spec;
5538 if (!stac_control_new(spec, &stac_hp_bass_sw_ctrl,
5539 "Bass Speaker Playback Switch", 0))
5542 spec->gpio_mask |= 0x20;
5543 spec->gpio_dir |= 0x20;
5544 spec->gpio_data |= 0x20;
5548 static int patch_stac92hd71bxx(struct hda_codec *codec)
5550 struct sigmatel_spec *spec;
5551 struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
5552 unsigned int pin_cfg;
5555 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5559 codec->no_trigger_sense = 1;
5561 spec->linear_tone_beep = 0;
5562 codec->patch_ops = stac92xx_patch_ops;
5563 spec->num_pins = STAC92HD71BXX_NUM_PINS;
5564 switch (codec->vendor_id) {
5567 spec->pin_nids = stac92hd71bxx_pin_nids_4port;
5571 /* On 92HD75Bx 0x27 isn't a pin nid */
5575 spec->pin_nids = stac92hd71bxx_pin_nids_6port;
5577 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
5578 spec->board_config = snd_hda_check_board_config(codec,
5579 STAC_92HD71BXX_MODELS,
5580 stac92hd71bxx_models,
5581 stac92hd71bxx_cfg_tbl);
5583 if (spec->board_config < 0)
5584 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5587 stac92xx_set_config_regs(codec,
5588 stac92hd71bxx_brd_tbl[spec->board_config]);
5590 if (spec->board_config != STAC_92HD71BXX_REF) {
5592 spec->gpio_mask = 0x01;
5593 spec->gpio_dir = 0x01;
5594 spec->gpio_data = 0x01;
5597 spec->dmic_nids = stac92hd71bxx_dmic_nids;
5598 spec->dmux_nids = stac92hd71bxx_dmux_nids;
5600 spec->num_caps = STAC92HD71BXX_NUM_CAPS;
5601 spec->capvols = stac92hd71bxx_capvols;
5602 spec->capsws = stac92hd71bxx_capsws;
5604 switch (codec->vendor_id) {
5605 case 0x111d76b6: /* 4 Port without Analog Mixer */
5609 case 0x111d76b4: /* 6 Port without Analog Mixer */
5611 spec->init = stac92hd71bxx_core_init;
5612 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5613 spec->num_dmics = stac92xx_connected_ports(codec,
5614 stac92hd71bxx_dmic_nids,
5615 STAC92HD71BXX_NUM_DMICS);
5617 case 0x111d7608: /* 5 Port with Analog Mixer */
5618 switch (spec->board_config) {
5620 /* Enable VREF power saving on GPIO1 detect */
5621 err = stac_add_event(spec, codec->afg,
5622 STAC_VREF_EVENT, 0x02);
5625 snd_hda_codec_write_cache(codec, codec->afg, 0,
5626 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
5627 snd_hda_codec_write_cache(codec, codec->afg, 0,
5628 AC_VERB_SET_UNSOLICITED_ENABLE,
5630 spec->gpio_mask |= 0x02;
5633 if ((codec->revision_id & 0xf) == 0 ||
5634 (codec->revision_id & 0xf) == 1)
5635 spec->stream_delay = 40; /* 40 milliseconds */
5637 /* no output amps */
5640 spec->init = stac92hd71bxx_core_init;
5642 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
5643 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
5644 stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS - 1] = 0;
5645 spec->num_dmics = stac92xx_connected_ports(codec,
5646 stac92hd71bxx_dmic_nids,
5647 STAC92HD71BXX_NUM_DMICS - 1);
5649 case 0x111d7603: /* 6 Port with Analog Mixer */
5650 if ((codec->revision_id & 0xf) == 1)
5651 spec->stream_delay = 40; /* 40 milliseconds */
5653 /* no output amps */
5657 spec->init = stac92hd71bxx_core_init;
5658 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5659 spec->num_dmics = stac92xx_connected_ports(codec,
5660 stac92hd71bxx_dmic_nids,
5661 STAC92HD71BXX_NUM_DMICS);
5665 if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
5666 snd_hda_sequence_write_cache(codec, unmute_init);
5668 /* Some HP machines seem to have unstable codec communications
5669 * especially with ATI fglrx driver. For recovering from the
5670 * CORB/RIRB stall, allow the BUS reset and keep always sync
5672 if (spec->board_config == STAC_HP_DV5) {
5673 codec->bus->sync_write = 1;
5674 codec->bus->allow_bus_reset = 1;
5677 spec->aloopback_ctl = stac92hd71bxx_loopback;
5678 spec->aloopback_mask = 0x50;
5679 spec->aloopback_shift = 0;
5681 spec->powerdown_adcs = 1;
5682 spec->digbeep_nid = 0x26;
5683 spec->mux_nids = stac92hd71bxx_mux_nids;
5684 spec->adc_nids = stac92hd71bxx_adc_nids;
5685 spec->smux_nids = stac92hd71bxx_smux_nids;
5686 spec->pwr_nids = stac92hd71bxx_pwr_nids;
5688 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
5689 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
5690 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5691 spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
5693 snd_printdd("Found board config: %d\n", spec->board_config);
5695 switch (spec->board_config) {
5697 /* enable internal microphone */
5698 snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
5699 stac92xx_auto_set_pinctl(codec, 0x0e,
5700 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
5702 case STAC_DELL_M4_2:
5703 spec->num_dmics = 0;
5704 spec->num_smuxes = 0;
5705 spec->num_dmuxes = 0;
5707 case STAC_DELL_M4_1:
5708 case STAC_DELL_M4_3:
5709 spec->num_dmics = 1;
5710 spec->num_smuxes = 0;
5711 spec->num_dmuxes = 1;
5713 case STAC_HP_DV4_1222NR:
5714 spec->num_dmics = 1;
5715 /* I don't know if it needs 1 or 2 smuxes - will wait for
5716 * bug reports to fix if needed
5718 spec->num_smuxes = 1;
5719 spec->num_dmuxes = 1;
5722 spec->gpio_led = 0x01;
5725 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
5726 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
5727 /* HP dv6 gives the headphone pin as a line-out. Thus we
5728 * need to set hp_detect flag here to force to enable HP
5731 spec->hp_detect = 1;
5734 spec->num_dmics = 1;
5735 spec->num_dmuxes = 1;
5736 spec->num_smuxes = 1;
5737 spec->gpio_led = 0x08;
5741 if (hp_blike_system(codec->subsystem_id)) {
5742 pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f);
5743 if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT ||
5744 get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER ||
5745 get_defcfg_device(pin_cfg) == AC_JACK_HP_OUT) {
5746 /* It was changed in the BIOS to just satisfy MS DTM.
5747 * Lets turn it back into slaved HP
5749 pin_cfg = (pin_cfg & (~AC_DEFCFG_DEVICE))
5750 | (AC_JACK_HP_OUT <<
5751 AC_DEFCFG_DEVICE_SHIFT);
5752 pin_cfg = (pin_cfg & (~(AC_DEFCFG_DEF_ASSOC
5753 | AC_DEFCFG_SEQUENCE)))
5755 snd_hda_codec_set_pincfg(codec, 0x0f, pin_cfg);
5759 if (find_mute_led_gpio(codec, 1))
5760 snd_printd("mute LED gpio %d polarity %d\n",
5762 spec->gpio_led_polarity);
5764 #ifdef CONFIG_SND_HDA_POWER_SAVE
5765 if (spec->gpio_led) {
5766 spec->gpio_mask |= spec->gpio_led;
5767 spec->gpio_dir |= spec->gpio_led;
5768 spec->gpio_data |= spec->gpio_led;
5769 /* register check_power_status callback. */
5770 codec->patch_ops.check_power_status =
5771 stac92xx_hp_check_power_status;
5775 spec->multiout.dac_nids = spec->dac_nids;
5777 err = stac92xx_parse_auto_config(codec, 0x21, 0);
5779 if (spec->board_config < 0) {
5780 printk(KERN_WARNING "hda_codec: No auto-config is "
5781 "available, default to model=ref\n");
5782 spec->board_config = STAC_92HD71BXX_REF;
5789 stac92xx_free(codec);
5793 /* enable bass on HP dv7 */
5794 if (spec->board_config == STAC_HP_DV4 ||
5795 spec->board_config == STAC_HP_DV5) {
5797 cap = snd_hda_param_read(codec, 0x1, AC_PAR_GPIO_CAP);
5798 cap &= AC_GPIO_IO_COUNT;
5800 stac_add_hp_bass_switch(codec);
5803 codec->proc_widget_hook = stac92hd7x_proc_hook;
5808 static int patch_stac922x(struct hda_codec *codec)
5810 struct sigmatel_spec *spec;
5813 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5817 codec->no_trigger_sense = 1;
5819 spec->linear_tone_beep = 1;
5820 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
5821 spec->pin_nids = stac922x_pin_nids;
5822 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
5825 if (spec->board_config == STAC_INTEL_MAC_AUTO) {
5826 spec->gpio_mask = spec->gpio_dir = 0x03;
5827 spec->gpio_data = 0x03;
5828 /* Intel Macs have all same PCI SSID, so we need to check
5829 * codec SSID to distinguish the exact models
5831 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
5832 switch (codec->subsystem_id) {
5835 spec->board_config = STAC_INTEL_MAC_V1;
5839 spec->board_config = STAC_INTEL_MAC_V2;
5847 spec->board_config = STAC_INTEL_MAC_V3;
5851 spec->board_config = STAC_INTEL_MAC_V4;
5855 spec->board_config = STAC_INTEL_MAC_V5;
5858 spec->board_config = STAC_INTEL_MAC_V3;
5864 if (spec->board_config < 0)
5865 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5868 stac92xx_set_config_regs(codec,
5869 stac922x_brd_tbl[spec->board_config]);
5871 spec->adc_nids = stac922x_adc_nids;
5872 spec->mux_nids = stac922x_mux_nids;
5873 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
5874 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
5875 spec->num_dmics = 0;
5878 spec->init = stac922x_core_init;
5880 spec->num_caps = STAC922X_NUM_CAPS;
5881 spec->capvols = stac922x_capvols;
5882 spec->capsws = stac922x_capsws;
5884 spec->multiout.dac_nids = spec->dac_nids;
5886 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
5888 if (spec->board_config < 0) {
5889 printk(KERN_WARNING "hda_codec: No auto-config is "
5890 "available, default to model=ref\n");
5891 spec->board_config = STAC_D945_REF;
5897 stac92xx_free(codec);
5901 codec->patch_ops = stac92xx_patch_ops;
5903 /* Fix Mux capture level; max to 2 */
5904 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
5905 (0 << AC_AMPCAP_OFFSET_SHIFT) |
5906 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5907 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5908 (0 << AC_AMPCAP_MUTE_SHIFT));
5913 static int patch_stac927x(struct hda_codec *codec)
5915 struct sigmatel_spec *spec;
5918 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5922 codec->no_trigger_sense = 1;
5924 spec->linear_tone_beep = 1;
5925 codec->slave_dig_outs = stac927x_slave_dig_outs;
5926 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
5927 spec->pin_nids = stac927x_pin_nids;
5928 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
5932 if (spec->board_config < 0)
5933 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5936 stac92xx_set_config_regs(codec,
5937 stac927x_brd_tbl[spec->board_config]);
5939 spec->digbeep_nid = 0x23;
5940 spec->adc_nids = stac927x_adc_nids;
5941 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
5942 spec->mux_nids = stac927x_mux_nids;
5943 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
5944 spec->smux_nids = stac927x_smux_nids;
5945 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
5946 spec->spdif_labels = stac927x_spdif_labels;
5947 spec->dac_list = stac927x_dac_nids;
5948 spec->multiout.dac_nids = spec->dac_nids;
5950 if (spec->board_config != STAC_D965_REF) {
5951 /* GPIO0 High = Enable EAPD */
5952 spec->eapd_mask = spec->gpio_mask = 0x01;
5953 spec->gpio_dir = spec->gpio_data = 0x01;
5956 switch (spec->board_config) {
5959 /* GPIO0 High = Enable EAPD */
5960 spec->num_dmics = 0;
5961 spec->init = d965_core_init;
5963 case STAC_DELL_BIOS:
5964 switch (codec->subsystem_id) {
5967 /* correct the device field to SPDIF out */
5968 snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
5971 /* configure the analog microphone on some laptops */
5972 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
5973 /* correct the front output jack as a hp out */
5974 snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f);
5975 /* correct the front input jack as a mic */
5976 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
5979 if (codec->subsystem_id != 0x1028022f) {
5980 /* GPIO2 High = Enable EAPD */
5981 spec->eapd_mask = spec->gpio_mask = 0x04;
5982 spec->gpio_dir = spec->gpio_data = 0x04;
5984 spec->dmic_nids = stac927x_dmic_nids;
5985 spec->num_dmics = STAC927X_NUM_DMICS;
5987 spec->init = dell_3st_core_init;
5988 spec->dmux_nids = stac927x_dmux_nids;
5989 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
5991 case STAC_927X_VOLKNOB:
5992 spec->num_dmics = 0;
5993 spec->init = stac927x_volknob_core_init;
5996 spec->num_dmics = 0;
5997 spec->init = stac927x_core_init;
6001 spec->num_caps = STAC927X_NUM_CAPS;
6002 spec->capvols = stac927x_capvols;
6003 spec->capsws = stac927x_capsws;
6006 spec->aloopback_ctl = stac927x_loopback;
6007 spec->aloopback_mask = 0x40;
6008 spec->aloopback_shift = 0;
6009 spec->eapd_switch = 1;
6011 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
6013 if (spec->board_config < 0) {
6014 printk(KERN_WARNING "hda_codec: No auto-config is "
6015 "available, default to model=ref\n");
6016 spec->board_config = STAC_D965_REF;
6022 stac92xx_free(codec);
6026 codec->patch_ops = stac92xx_patch_ops;
6028 codec->proc_widget_hook = stac927x_proc_hook;
6032 * The STAC927x seem to require fairly long delays for certain
6033 * command sequences. With too short delays (even if the answer
6034 * is set to RIRB properly), it results in the silence output
6035 * on some hardwares like Dell.
6037 * The below flag enables the longer delay (see get_response
6040 codec->bus->needs_damn_long_delay = 1;
6042 /* no jack detecion for ref-no-jd model */
6043 if (spec->board_config == STAC_D965_REF_NO_JD)
6044 spec->hp_detect = 0;
6049 static int patch_stac9205(struct hda_codec *codec)
6051 struct sigmatel_spec *spec;
6054 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6058 codec->no_trigger_sense = 1;
6060 spec->linear_tone_beep = 1;
6061 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
6062 spec->pin_nids = stac9205_pin_nids;
6063 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
6067 if (spec->board_config < 0)
6068 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6071 stac92xx_set_config_regs(codec,
6072 stac9205_brd_tbl[spec->board_config]);
6074 spec->digbeep_nid = 0x23;
6075 spec->adc_nids = stac9205_adc_nids;
6076 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
6077 spec->mux_nids = stac9205_mux_nids;
6078 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
6079 spec->smux_nids = stac9205_smux_nids;
6080 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
6081 spec->dmic_nids = stac9205_dmic_nids;
6082 spec->num_dmics = STAC9205_NUM_DMICS;
6083 spec->dmux_nids = stac9205_dmux_nids;
6084 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
6087 spec->init = stac9205_core_init;
6088 spec->aloopback_ctl = stac9205_loopback;
6090 spec->num_caps = STAC9205_NUM_CAPS;
6091 spec->capvols = stac9205_capvols;
6092 spec->capsws = stac9205_capsws;
6094 spec->aloopback_mask = 0x40;
6095 spec->aloopback_shift = 0;
6096 /* Turn on/off EAPD per HP plugging */
6097 if (spec->board_config != STAC_9205_EAPD)
6098 spec->eapd_switch = 1;
6099 spec->multiout.dac_nids = spec->dac_nids;
6101 switch (spec->board_config){
6102 case STAC_9205_DELL_M43:
6103 /* Enable SPDIF in/out */
6104 snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030);
6105 snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030);
6107 /* Enable unsol response for GPIO4/Dock HP connection */
6108 err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
6111 snd_hda_codec_write_cache(codec, codec->afg, 0,
6112 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
6113 snd_hda_codec_write_cache(codec, codec->afg, 0,
6114 AC_VERB_SET_UNSOLICITED_ENABLE,
6117 spec->gpio_dir = 0x0b;
6118 spec->eapd_mask = 0x01;
6119 spec->gpio_mask = 0x1b;
6120 spec->gpio_mute = 0x10;
6121 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
6124 spec->gpio_data = 0x01;
6127 /* SPDIF-In enabled */
6130 /* GPIO0 High = EAPD */
6131 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
6132 spec->gpio_data = 0x01;
6136 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
6138 if (spec->board_config < 0) {
6139 printk(KERN_WARNING "hda_codec: No auto-config is "
6140 "available, default to model=ref\n");
6141 spec->board_config = STAC_9205_REF;
6147 stac92xx_free(codec);
6151 codec->patch_ops = stac92xx_patch_ops;
6153 codec->proc_widget_hook = stac9205_proc_hook;
6162 static struct hda_verb stac9872_core_init[] = {
6163 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
6164 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
6168 static hda_nid_t stac9872_pin_nids[] = {
6169 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
6173 static hda_nid_t stac9872_adc_nids[] = {
6177 static hda_nid_t stac9872_mux_nids[] = {
6181 static unsigned long stac9872_capvols[] = {
6182 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
6184 #define stac9872_capsws stac9872_capvols
6186 static unsigned int stac9872_vaio_pin_configs[9] = {
6187 0x03211020, 0x411111f0, 0x411111f0, 0x03a15030,
6188 0x411111f0, 0x90170110, 0x411111f0, 0x411111f0,
6192 static const char *stac9872_models[STAC_9872_MODELS] = {
6193 [STAC_9872_AUTO] = "auto",
6194 [STAC_9872_VAIO] = "vaio",
6197 static unsigned int *stac9872_brd_tbl[STAC_9872_MODELS] = {
6198 [STAC_9872_VAIO] = stac9872_vaio_pin_configs,
6201 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
6202 SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0,
6203 "Sony VAIO F/S", STAC_9872_VAIO),
6207 static int patch_stac9872(struct hda_codec *codec)
6209 struct sigmatel_spec *spec;
6212 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6215 codec->no_trigger_sense = 1;
6217 spec->linear_tone_beep = 1;
6218 spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
6219 spec->pin_nids = stac9872_pin_nids;
6221 spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
6224 if (spec->board_config < 0)
6225 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6228 stac92xx_set_config_regs(codec,
6229 stac9872_brd_tbl[spec->board_config]);
6231 spec->multiout.dac_nids = spec->dac_nids;
6232 spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
6233 spec->adc_nids = stac9872_adc_nids;
6234 spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
6235 spec->mux_nids = stac9872_mux_nids;
6236 spec->init = stac9872_core_init;
6238 spec->capvols = stac9872_capvols;
6239 spec->capsws = stac9872_capsws;
6241 err = stac92xx_parse_auto_config(codec, 0x10, 0x12);
6243 stac92xx_free(codec);
6246 spec->input_mux = &spec->private_imux;
6247 codec->patch_ops = stac92xx_patch_ops;
6255 static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
6256 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
6257 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
6258 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
6259 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
6260 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
6261 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
6262 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
6263 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
6264 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
6265 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
6266 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
6267 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
6268 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
6269 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
6270 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
6271 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
6272 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
6273 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
6274 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
6275 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
6276 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
6277 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
6278 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
6279 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
6280 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
6281 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
6282 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
6283 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
6284 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
6285 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
6286 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
6287 /* The following does not take into account .id=0x83847661 when subsys =
6288 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
6289 * currently not fully supported.
6291 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
6292 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
6293 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
6294 { .id = 0x83847698, .name = "STAC9205", .patch = patch_stac9205 },
6295 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
6296 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
6297 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
6298 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
6299 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
6300 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
6301 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
6302 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
6303 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
6304 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
6305 { .id = 0x111d76d4, .name = "92HD83C1C5", .patch = patch_stac92hd83xxx},
6306 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
6307 { .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx},
6308 { .id = 0x111d76d1, .name = "92HD87B1/3", .patch = patch_stac92hd83xxx},
6309 { .id = 0x111d76d9, .name = "92HD87B2/4", .patch = patch_stac92hd83xxx},
6310 { .id = 0x111d7666, .name = "92HD88B3", .patch = patch_stac92hd83xxx},
6311 { .id = 0x111d7667, .name = "92HD88B1", .patch = patch_stac92hd83xxx},
6312 { .id = 0x111d7668, .name = "92HD88B2", .patch = patch_stac92hd83xxx},
6313 { .id = 0x111d7669, .name = "92HD88B4", .patch = patch_stac92hd83xxx},
6314 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
6315 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
6316 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
6317 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
6318 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
6319 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
6320 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
6321 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
6322 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
6323 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
6324 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
6325 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
6326 { .id = 0x111d76c0, .name = "92HD89C3", .patch = patch_stac92hd73xx },
6327 { .id = 0x111d76c1, .name = "92HD89C2", .patch = patch_stac92hd73xx },
6328 { .id = 0x111d76c2, .name = "92HD89C1", .patch = patch_stac92hd73xx },
6329 { .id = 0x111d76c3, .name = "92HD89B3", .patch = patch_stac92hd73xx },
6330 { .id = 0x111d76c4, .name = "92HD89B2", .patch = patch_stac92hd73xx },
6331 { .id = 0x111d76c5, .name = "92HD89B1", .patch = patch_stac92hd73xx },
6332 { .id = 0x111d76c6, .name = "92HD89E3", .patch = patch_stac92hd73xx },
6333 { .id = 0x111d76c7, .name = "92HD89E2", .patch = patch_stac92hd73xx },
6334 { .id = 0x111d76c8, .name = "92HD89E1", .patch = patch_stac92hd73xx },
6335 { .id = 0x111d76c9, .name = "92HD89D3", .patch = patch_stac92hd73xx },
6336 { .id = 0x111d76ca, .name = "92HD89D2", .patch = patch_stac92hd73xx },
6337 { .id = 0x111d76cb, .name = "92HD89D1", .patch = patch_stac92hd73xx },
6338 { .id = 0x111d76cc, .name = "92HD89F3", .patch = patch_stac92hd73xx },
6339 { .id = 0x111d76cd, .name = "92HD89F2", .patch = patch_stac92hd73xx },
6340 { .id = 0x111d76ce, .name = "92HD89F1", .patch = patch_stac92hd73xx },
6341 { .id = 0x111d76e0, .name = "92HD91BXX", .patch = patch_stac92hd83xxx},
6342 { .id = 0x111d76e7, .name = "92HD90BXX", .patch = patch_stac92hd83xxx},
6346 MODULE_ALIAS("snd-hda-codec-id:8384*");
6347 MODULE_ALIAS("snd-hda-codec-id:111d*");
6349 MODULE_LICENSE("GPL");
6350 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
6352 static struct hda_codec_preset_list sigmatel_list = {
6353 .preset = snd_hda_preset_sigmatel,
6354 .owner = THIS_MODULE,
6357 static int __init patch_sigmatel_init(void)
6359 return snd_hda_add_codec_preset(&sigmatel_list);
6362 static void __exit patch_sigmatel_exit(void)
6364 snd_hda_delete_codec_preset(&sigmatel_list);
6367 module_init(patch_sigmatel_init)
6368 module_exit(patch_sigmatel_exit)