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;
266 struct sigmatel_mic_route dock_mic;
268 const char **spdif_labels;
270 hda_nid_t dig_in_nid;
272 hda_nid_t anabeep_nid;
273 hda_nid_t digbeep_nid;
277 unsigned int num_pins;
279 /* codec specific stuff */
280 struct hda_verb *init;
281 struct snd_kcontrol_new *mixer;
284 struct hda_input_mux *dinput_mux;
285 unsigned int cur_dmux[2];
286 struct hda_input_mux *input_mux;
287 unsigned int cur_mux[3];
288 struct hda_input_mux *sinput_mux;
289 unsigned int cur_smux[2];
290 unsigned int cur_amux;
292 unsigned int powerdown_adcs;
295 unsigned int io_switch[2];
296 unsigned int clfe_swap;
297 hda_nid_t line_switch; /* shared line-in for input and output */
298 hda_nid_t mic_switch; /* shared mic-in for input and output */
299 hda_nid_t hp_switch; /* NID of HP as line-out */
300 unsigned int aloopback;
302 struct hda_pcm pcm_rec[2]; /* PCM information */
304 /* dynamic controls and input_mux */
305 struct auto_pin_cfg autocfg;
306 struct snd_array kctls;
307 struct hda_input_mux private_dimux;
308 struct hda_input_mux private_imux;
309 struct hda_input_mux private_smux;
310 struct hda_input_mux private_mono_mux;
313 static hda_nid_t stac9200_adc_nids[1] = {
317 static hda_nid_t stac9200_mux_nids[1] = {
321 static hda_nid_t stac9200_dac_nids[1] = {
325 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
326 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
330 static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
334 static hda_nid_t stac92hd73xx_adc_nids[2] = {
338 #define STAC92HD73XX_NUM_DMICS 2
339 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
343 #define STAC92HD73_DAC_COUNT 5
345 static hda_nid_t stac92hd73xx_mux_nids[2] = {
349 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
353 static hda_nid_t stac92hd73xx_smux_nids[2] = {
357 #define STAC92HD73XX_NUM_CAPS 2
358 static unsigned long stac92hd73xx_capvols[] = {
359 HDA_COMPOSE_AMP_VAL(0x20, 3, 0, HDA_OUTPUT),
360 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
362 #define stac92hd73xx_capsws stac92hd73xx_capvols
364 #define STAC92HD83_DAC_COUNT 3
366 static hda_nid_t stac92hd83xxx_mux_nids[2] = {
370 static hda_nid_t stac92hd83xxx_adc_nids[2] = {
374 static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
378 static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
382 static unsigned int stac92hd83xxx_pwr_mapping[4] = {
383 0x03, 0x0c, 0x20, 0x40,
386 #define STAC92HD83XXX_NUM_DMICS 2
387 static hda_nid_t stac92hd83xxx_dmic_nids[STAC92HD83XXX_NUM_DMICS + 1] = {
391 #define STAC92HD83XXX_NUM_CAPS 2
392 static unsigned long stac92hd83xxx_capvols[] = {
393 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
394 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_OUTPUT),
396 #define stac92hd83xxx_capsws stac92hd83xxx_capvols
398 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
402 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
406 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
410 static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
414 static hda_nid_t stac92hd71bxx_smux_nids[2] = {
418 #define STAC92HD71BXX_NUM_DMICS 2
419 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
423 static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
427 #define STAC92HD71BXX_NUM_CAPS 2
428 static unsigned long stac92hd71bxx_capvols[] = {
429 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
430 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
432 #define stac92hd71bxx_capsws stac92hd71bxx_capvols
434 static hda_nid_t stac925x_adc_nids[1] = {
438 static hda_nid_t stac925x_mux_nids[1] = {
442 static hda_nid_t stac925x_dac_nids[1] = {
446 #define STAC925X_NUM_DMICS 1
447 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
451 static hda_nid_t stac925x_dmux_nids[1] = {
455 static unsigned long stac925x_capvols[] = {
456 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
458 static unsigned long stac925x_capsws[] = {
459 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
462 static hda_nid_t stac922x_adc_nids[2] = {
466 static hda_nid_t stac922x_mux_nids[2] = {
470 #define STAC922X_NUM_CAPS 2
471 static unsigned long stac922x_capvols[] = {
472 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_INPUT),
473 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
475 #define stac922x_capsws stac922x_capvols
477 static hda_nid_t stac927x_slave_dig_outs[2] = {
481 static hda_nid_t stac927x_adc_nids[3] = {
485 static hda_nid_t stac927x_mux_nids[3] = {
489 static hda_nid_t stac927x_smux_nids[1] = {
493 static hda_nid_t stac927x_dac_nids[6] = {
494 0x02, 0x03, 0x04, 0x05, 0x06, 0
497 static hda_nid_t stac927x_dmux_nids[1] = {
501 #define STAC927X_NUM_DMICS 2
502 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
506 #define STAC927X_NUM_CAPS 3
507 static unsigned long stac927x_capvols[] = {
508 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
509 HDA_COMPOSE_AMP_VAL(0x19, 3, 0, HDA_INPUT),
510 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_INPUT),
512 static unsigned long stac927x_capsws[] = {
513 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
514 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
515 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
518 static const char *stac927x_spdif_labels[5] = {
519 "Digital Playback", "ADAT", "Analog Mux 1",
520 "Analog Mux 2", "Analog Mux 3"
523 static hda_nid_t stac9205_adc_nids[2] = {
527 static hda_nid_t stac9205_mux_nids[2] = {
531 static hda_nid_t stac9205_dmux_nids[1] = {
535 static hda_nid_t stac9205_smux_nids[1] = {
539 #define STAC9205_NUM_DMICS 2
540 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
544 #define STAC9205_NUM_CAPS 2
545 static unsigned long stac9205_capvols[] = {
546 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_INPUT),
547 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_INPUT),
549 static unsigned long stac9205_capsws[] = {
550 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
551 HDA_COMPOSE_AMP_VAL(0x1e, 3, 0, HDA_OUTPUT),
554 static hda_nid_t stac9200_pin_nids[8] = {
555 0x08, 0x09, 0x0d, 0x0e,
556 0x0f, 0x10, 0x11, 0x12,
559 static hda_nid_t stac925x_pin_nids[8] = {
560 0x07, 0x08, 0x0a, 0x0b,
561 0x0c, 0x0d, 0x10, 0x11,
564 static hda_nid_t stac922x_pin_nids[10] = {
565 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
566 0x0f, 0x10, 0x11, 0x15, 0x1b,
569 static hda_nid_t stac92hd73xx_pin_nids[13] = {
570 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
571 0x0f, 0x10, 0x11, 0x12, 0x13,
575 static hda_nid_t stac92hd83xxx_pin_nids[10] = {
576 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
577 0x0f, 0x10, 0x11, 0x1f, 0x20,
580 static hda_nid_t stac92hd88xxx_pin_nids[10] = {
581 0x0a, 0x0b, 0x0c, 0x0d,
582 0x0f, 0x11, 0x1f, 0x20,
585 #define STAC92HD71BXX_NUM_PINS 13
586 static hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
587 0x0a, 0x0b, 0x0c, 0x0d, 0x00,
588 0x00, 0x14, 0x18, 0x19, 0x1e,
591 static hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
592 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
593 0x0f, 0x14, 0x18, 0x19, 0x1e,
597 static hda_nid_t stac927x_pin_nids[14] = {
598 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
599 0x0f, 0x10, 0x11, 0x12, 0x13,
600 0x14, 0x21, 0x22, 0x23,
603 static hda_nid_t stac9205_pin_nids[12] = {
604 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
605 0x0f, 0x14, 0x16, 0x17, 0x18,
609 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
610 struct snd_ctl_elem_info *uinfo)
612 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
613 struct sigmatel_spec *spec = codec->spec;
614 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
617 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
618 struct snd_ctl_elem_value *ucontrol)
620 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
621 struct sigmatel_spec *spec = codec->spec;
622 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
624 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
628 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
629 struct snd_ctl_elem_value *ucontrol)
631 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
632 struct sigmatel_spec *spec = codec->spec;
633 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
635 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
636 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
639 static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
640 struct snd_ctl_elem_info *uinfo)
642 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
643 struct sigmatel_spec *spec = codec->spec;
644 return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
647 static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
648 struct snd_ctl_elem_value *ucontrol)
650 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
651 struct sigmatel_spec *spec = codec->spec;
652 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
654 ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
658 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
659 struct snd_ctl_elem_value *ucontrol)
661 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
662 struct sigmatel_spec *spec = codec->spec;
663 struct hda_input_mux *smux = &spec->private_smux;
664 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
668 err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
669 spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
673 if (spec->spdif_mute) {
675 nid = spec->multiout.dig_out_nid;
677 nid = codec->slave_dig_outs[smux_idx - 1];
678 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
682 /* un/mute SPDIF out */
683 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
689 static unsigned int stac92xx_vref_set(struct hda_codec *codec,
690 hda_nid_t nid, unsigned int new_vref)
694 pincfg = snd_hda_codec_read(codec, nid, 0,
695 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
698 pincfg &= ~(AC_PINCTL_VREFEN | AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
701 if (new_vref == AC_PINCTL_VREF_HIZ)
702 pincfg |= AC_PINCTL_OUT_EN;
704 pincfg |= AC_PINCTL_IN_EN;
706 error = snd_hda_codec_write_cache(codec, nid, 0,
707 AC_VERB_SET_PIN_WIDGET_CONTROL, pincfg);
714 static unsigned int stac92xx_vref_get(struct hda_codec *codec, hda_nid_t nid)
717 vref = snd_hda_codec_read(codec, nid, 0,
718 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
719 vref &= AC_PINCTL_VREFEN;
723 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
725 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
726 struct sigmatel_spec *spec = codec->spec;
727 return snd_hda_input_mux_info(spec->input_mux, uinfo);
730 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
732 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
733 struct sigmatel_spec *spec = codec->spec;
734 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
736 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
740 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
742 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
743 struct sigmatel_spec *spec = codec->spec;
744 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
745 const struct hda_input_mux *imux = spec->input_mux;
746 unsigned int idx, prev_idx;
748 idx = ucontrol->value.enumerated.item[0];
749 if (idx >= imux->num_items)
750 idx = imux->num_items - 1;
751 prev_idx = spec->cur_mux[adc_idx];
754 if (idx < spec->num_analog_muxes) {
755 snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0,
756 AC_VERB_SET_CONNECT_SEL,
757 imux->items[idx].index);
758 if (prev_idx >= spec->num_analog_muxes) {
759 imux = spec->dinput_mux;
761 snd_hda_codec_write_cache(codec,
762 spec->dmux_nids[adc_idx], 0,
763 AC_VERB_SET_CONNECT_SEL,
764 imux->items[0].index);
767 imux = spec->dinput_mux;
768 snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0,
769 AC_VERB_SET_CONNECT_SEL,
770 imux->items[idx - 1].index);
772 spec->cur_mux[adc_idx] = idx;
776 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
777 struct snd_ctl_elem_info *uinfo)
779 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
780 struct sigmatel_spec *spec = codec->spec;
781 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
784 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
785 struct snd_ctl_elem_value *ucontrol)
787 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
788 struct sigmatel_spec *spec = codec->spec;
790 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
794 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
795 struct snd_ctl_elem_value *ucontrol)
797 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
798 struct sigmatel_spec *spec = codec->spec;
800 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
801 spec->mono_nid, &spec->cur_mmux);
804 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
806 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
807 struct snd_ctl_elem_value *ucontrol)
809 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
810 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
811 struct sigmatel_spec *spec = codec->spec;
813 ucontrol->value.integer.value[0] = !!(spec->aloopback &
814 (spec->aloopback_mask << idx));
818 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
819 struct snd_ctl_elem_value *ucontrol)
821 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
822 struct sigmatel_spec *spec = codec->spec;
823 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
824 unsigned int dac_mode;
825 unsigned int val, idx_val;
827 idx_val = spec->aloopback_mask << idx;
828 if (ucontrol->value.integer.value[0])
829 val = spec->aloopback | idx_val;
831 val = spec->aloopback & ~idx_val;
832 if (spec->aloopback == val)
835 spec->aloopback = val;
837 /* Only return the bits defined by the shift value of the
838 * first two bytes of the mask
840 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
841 kcontrol->private_value & 0xFFFF, 0x0);
842 dac_mode >>= spec->aloopback_shift;
844 if (spec->aloopback & idx_val) {
845 snd_hda_power_up(codec);
848 snd_hda_power_down(codec);
849 dac_mode &= ~idx_val;
852 snd_hda_codec_write_cache(codec, codec->afg, 0,
853 kcontrol->private_value >> 16, dac_mode);
858 static struct hda_verb stac9200_core_init[] = {
859 /* set dac0mux for dac converter */
860 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
864 static struct hda_verb stac9200_eapd_init[] = {
865 /* set dac0mux for dac converter */
866 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
867 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
871 static struct hda_verb dell_eq_core_init[] = {
872 /* set master volume to max value without distortion
873 * and direct control */
874 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
878 static struct hda_verb stac92hd73xx_core_init[] = {
879 /* set master volume and direct control */
880 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
884 static struct hda_verb stac92hd83xxx_core_init[] = {
885 /* power state controls amps */
886 { 0x01, AC_VERB_SET_EAPD, 1 << 2},
890 static struct hda_verb stac92hd71bxx_core_init[] = {
891 /* set master volume and direct control */
892 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
896 static struct hda_verb stac92hd71bxx_unmute_core_init[] = {
897 /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
898 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
899 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
900 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
904 static struct hda_verb stac925x_core_init[] = {
905 /* set dac0mux for dac converter */
906 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
907 /* mute the master volume */
908 { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
912 static struct hda_verb stac922x_core_init[] = {
913 /* set master volume and direct control */
914 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
918 static struct hda_verb d965_core_init[] = {
919 /* set master volume and direct control */
920 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
921 /* unmute node 0x1b */
922 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
923 /* select node 0x03 as DAC */
924 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
928 static struct hda_verb dell_3st_core_init[] = {
929 /* don't set delta bit */
930 {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
931 /* unmute node 0x1b */
932 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
933 /* select node 0x03 as DAC */
934 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
938 static struct hda_verb stac927x_core_init[] = {
939 /* set master volume and direct control */
940 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
941 /* enable analog pc beep path */
942 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
946 static struct hda_verb stac927x_volknob_core_init[] = {
947 /* don't set delta bit */
948 {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
949 /* enable analog pc beep path */
950 {0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
954 static struct hda_verb stac9205_core_init[] = {
955 /* set master volume and direct control */
956 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
957 /* enable analog pc beep path */
958 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
962 #define STAC_MONO_MUX \
964 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
965 .name = "Mono Mux", \
967 .info = stac92xx_mono_mux_enum_info, \
968 .get = stac92xx_mono_mux_enum_get, \
969 .put = stac92xx_mono_mux_enum_put, \
972 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
974 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
975 .name = "Analog Loopback", \
977 .info = stac92xx_aloopback_info, \
978 .get = stac92xx_aloopback_get, \
979 .put = stac92xx_aloopback_put, \
980 .private_value = verb_read | (verb_write << 16), \
983 #define DC_BIAS(xname, idx, nid) \
985 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
988 .info = stac92xx_dc_bias_info, \
989 .get = stac92xx_dc_bias_get, \
990 .put = stac92xx_dc_bias_put, \
991 .private_value = nid, \
994 static struct snd_kcontrol_new stac9200_mixer[] = {
995 HDA_CODEC_VOLUME_MIN_MUTE("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
996 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
997 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
998 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
1002 static struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
1003 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
1007 static struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = {
1008 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1012 static struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
1013 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1018 static struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
1019 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
1022 static struct snd_kcontrol_new stac925x_mixer[] = {
1023 HDA_CODEC_VOLUME_MIN_MUTE("Master Playback Volume", 0xe, 0, HDA_OUTPUT),
1024 HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
1028 static struct snd_kcontrol_new stac9205_loopback[] = {
1029 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1033 static struct snd_kcontrol_new stac927x_loopback[] = {
1034 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1038 static struct snd_kcontrol_new stac_dmux_mixer = {
1039 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1040 .name = "Digital Input Source",
1041 /* count set later */
1042 .info = stac92xx_dmux_enum_info,
1043 .get = stac92xx_dmux_enum_get,
1044 .put = stac92xx_dmux_enum_put,
1047 static struct snd_kcontrol_new stac_smux_mixer = {
1048 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1049 .name = "IEC958 Playback Source",
1050 /* count set later */
1051 .info = stac92xx_smux_enum_info,
1052 .get = stac92xx_smux_enum_get,
1053 .put = stac92xx_smux_enum_put,
1056 static const char *slave_vols[] = {
1057 "Front Playback Volume",
1058 "Surround Playback Volume",
1059 "Center Playback Volume",
1060 "LFE Playback Volume",
1061 "Side Playback Volume",
1062 "Headphone Playback Volume",
1063 "Speaker Playback Volume",
1067 static const char *slave_sws[] = {
1068 "Front Playback Switch",
1069 "Surround Playback Switch",
1070 "Center Playback Switch",
1071 "LFE Playback Switch",
1072 "Side Playback Switch",
1073 "Headphone Playback Switch",
1074 "Speaker Playback Switch",
1075 "IEC958 Playback Switch",
1079 static void stac92xx_free_kctls(struct hda_codec *codec);
1080 static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
1082 static int stac92xx_build_controls(struct hda_codec *codec)
1084 struct sigmatel_spec *spec = codec->spec;
1085 struct auto_pin_cfg *cfg = &spec->autocfg;
1091 err = snd_hda_add_new_ctls(codec, spec->mixer);
1096 for (i = 0; i < spec->num_mixers; i++) {
1097 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1101 if (!spec->auto_mic && spec->num_dmuxes > 0 &&
1102 snd_hda_get_bool_hint(codec, "separate_dmux") == 1) {
1103 stac_dmux_mixer.count = spec->num_dmuxes;
1104 err = snd_hda_ctl_add(codec, 0,
1105 snd_ctl_new1(&stac_dmux_mixer, codec));
1109 if (spec->num_smuxes > 0) {
1110 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1111 struct hda_input_mux *smux = &spec->private_smux;
1112 /* check for mute support on SPDIF out */
1113 if (wcaps & AC_WCAP_OUT_AMP) {
1114 snd_hda_add_imux_item(smux, "Off", 0, NULL);
1115 spec->spdif_mute = 1;
1117 stac_smux_mixer.count = spec->num_smuxes;
1118 err = snd_hda_ctl_add(codec, 0,
1119 snd_ctl_new1(&stac_smux_mixer, codec));
1124 if (spec->multiout.dig_out_nid) {
1125 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1128 err = snd_hda_create_spdif_share_sw(codec,
1132 spec->multiout.share_spdif = 1;
1134 if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1135 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1140 /* if we have no master control, let's create it */
1141 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1142 unsigned int vmaster_tlv[4];
1143 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1144 HDA_OUTPUT, vmaster_tlv);
1145 /* correct volume offset */
1146 vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
1147 /* minimum value is actually mute */
1148 vmaster_tlv[3] |= 0x1000;
1149 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1150 vmaster_tlv, slave_vols);
1154 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1155 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1161 if (spec->aloopback_ctl &&
1162 snd_hda_get_bool_hint(codec, "loopback") == 1) {
1163 err = snd_hda_add_new_ctls(codec, spec->aloopback_ctl);
1168 stac92xx_free_kctls(codec); /* no longer needed */
1170 /* create jack input elements */
1171 if (spec->hp_detect) {
1172 for (i = 0; i < cfg->hp_outs; i++) {
1173 int type = SND_JACK_HEADPHONE;
1174 nid = cfg->hp_pins[i];
1175 /* jack detection */
1176 if (cfg->hp_outs == i)
1177 type |= SND_JACK_LINEOUT;
1178 err = stac92xx_add_jack(codec, nid, type);
1183 for (i = 0; i < cfg->line_outs; i++) {
1184 err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
1189 for (i = 0; i < cfg->num_inputs; i++) {
1190 nid = cfg->inputs[i].pin;
1191 err = stac92xx_add_jack(codec, nid, SND_JACK_MICROPHONE);
1199 static unsigned int ref9200_pin_configs[8] = {
1200 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1201 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1204 static unsigned int gateway9200_m4_pin_configs[8] = {
1205 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1206 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1208 static unsigned int gateway9200_m4_2_pin_configs[8] = {
1209 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1210 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1214 STAC 9200 pin configs for
1219 static unsigned int dell9200_d21_pin_configs[8] = {
1220 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
1221 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1225 STAC 9200 pin configs for
1229 static unsigned int dell9200_d22_pin_configs[8] = {
1230 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1231 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1235 STAC 9200 pin configs for
1236 102801C4 (Dell Dimension E310)
1243 static unsigned int dell9200_d23_pin_configs[8] = {
1244 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1245 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
1250 STAC 9200-32 pin configs for
1251 102801B5 (Dell Inspiron 630m)
1252 102801D8 (Dell Inspiron 640m)
1254 static unsigned int dell9200_m21_pin_configs[8] = {
1255 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1256 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1260 STAC 9200-32 pin configs for
1261 102801C2 (Dell Latitude D620)
1263 102801CC (Dell Latitude D820)
1267 static unsigned int dell9200_m22_pin_configs[8] = {
1268 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1269 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1273 STAC 9200-32 pin configs for
1274 102801CE (Dell XPS M1710)
1275 102801CF (Dell Precision M90)
1277 static unsigned int dell9200_m23_pin_configs[8] = {
1278 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1279 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1283 STAC 9200-32 pin configs for
1286 102801CB (Dell Latitude 120L)
1289 static unsigned int dell9200_m24_pin_configs[8] = {
1290 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1291 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1295 STAC 9200-32 pin configs for
1296 102801BD (Dell Inspiron E1505n)
1300 static unsigned int dell9200_m25_pin_configs[8] = {
1301 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1302 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1306 STAC 9200-32 pin configs for
1307 102801F5 (Dell Inspiron 1501)
1310 static unsigned int dell9200_m26_pin_configs[8] = {
1311 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1312 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1317 102801CD (Dell Inspiron E1705/9400)
1319 static unsigned int dell9200_m27_pin_configs[8] = {
1320 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1321 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1324 static unsigned int oqo9200_pin_configs[8] = {
1325 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1326 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1330 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1331 [STAC_REF] = ref9200_pin_configs,
1332 [STAC_9200_OQO] = oqo9200_pin_configs,
1333 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1334 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1335 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1336 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1337 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1338 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1339 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1340 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1341 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1342 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1343 [STAC_9200_M4] = gateway9200_m4_pin_configs,
1344 [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1345 [STAC_9200_PANASONIC] = ref9200_pin_configs,
1348 static const char *stac9200_models[STAC_9200_MODELS] = {
1349 [STAC_AUTO] = "auto",
1351 [STAC_9200_OQO] = "oqo",
1352 [STAC_9200_DELL_D21] = "dell-d21",
1353 [STAC_9200_DELL_D22] = "dell-d22",
1354 [STAC_9200_DELL_D23] = "dell-d23",
1355 [STAC_9200_DELL_M21] = "dell-m21",
1356 [STAC_9200_DELL_M22] = "dell-m22",
1357 [STAC_9200_DELL_M23] = "dell-m23",
1358 [STAC_9200_DELL_M24] = "dell-m24",
1359 [STAC_9200_DELL_M25] = "dell-m25",
1360 [STAC_9200_DELL_M26] = "dell-m26",
1361 [STAC_9200_DELL_M27] = "dell-m27",
1362 [STAC_9200_M4] = "gateway-m4",
1363 [STAC_9200_M4_2] = "gateway-m4-2",
1364 [STAC_9200_PANASONIC] = "panasonic",
1367 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1368 /* SigmaTel reference board */
1369 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1370 "DFI LanParty", STAC_REF),
1371 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1372 "DFI LanParty", STAC_REF),
1373 /* Dell laptops have BIOS problem */
1374 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1375 "unknown Dell", STAC_9200_DELL_D21),
1376 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1377 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1378 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1379 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1380 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1381 "unknown Dell", STAC_9200_DELL_D22),
1382 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1383 "unknown Dell", STAC_9200_DELL_D22),
1384 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1385 "Dell Latitude D620", STAC_9200_DELL_M22),
1386 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1387 "unknown Dell", STAC_9200_DELL_D23),
1388 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1389 "unknown Dell", STAC_9200_DELL_D23),
1390 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1391 "unknown Dell", STAC_9200_DELL_M22),
1392 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1393 "unknown Dell", STAC_9200_DELL_M24),
1394 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1395 "unknown Dell", STAC_9200_DELL_M24),
1396 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1397 "Dell Latitude 120L", STAC_9200_DELL_M24),
1398 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1399 "Dell Latitude D820", STAC_9200_DELL_M22),
1400 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1401 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1402 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1403 "Dell XPS M1710", STAC_9200_DELL_M23),
1404 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1405 "Dell Precision M90", STAC_9200_DELL_M23),
1406 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1407 "unknown Dell", STAC_9200_DELL_M22),
1408 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1409 "unknown Dell", STAC_9200_DELL_M22),
1410 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1411 "unknown Dell", STAC_9200_DELL_M22),
1412 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1413 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1414 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1415 "unknown Dell", STAC_9200_DELL_D23),
1416 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1417 "unknown Dell", STAC_9200_DELL_D23),
1418 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1419 "unknown Dell", STAC_9200_DELL_D21),
1420 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1421 "unknown Dell", STAC_9200_DELL_D23),
1422 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1423 "unknown Dell", STAC_9200_DELL_D21),
1424 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1425 "unknown Dell", STAC_9200_DELL_M25),
1426 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1427 "unknown Dell", STAC_9200_DELL_M25),
1428 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1429 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1430 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1431 "unknown Dell", STAC_9200_DELL_M26),
1433 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1434 /* Gateway machines needs EAPD to be set on resume */
1435 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1436 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1437 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1439 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1443 static unsigned int ref925x_pin_configs[8] = {
1444 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1445 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1448 static unsigned int stac925xM1_pin_configs[8] = {
1449 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1450 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1453 static unsigned int stac925xM1_2_pin_configs[8] = {
1454 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1455 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1458 static unsigned int stac925xM2_pin_configs[8] = {
1459 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1460 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1463 static unsigned int stac925xM2_2_pin_configs[8] = {
1464 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1465 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1468 static unsigned int stac925xM3_pin_configs[8] = {
1469 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1470 0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1473 static unsigned int stac925xM5_pin_configs[8] = {
1474 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1475 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1478 static unsigned int stac925xM6_pin_configs[8] = {
1479 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1480 0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1483 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1484 [STAC_REF] = ref925x_pin_configs,
1485 [STAC_M1] = stac925xM1_pin_configs,
1486 [STAC_M1_2] = stac925xM1_2_pin_configs,
1487 [STAC_M2] = stac925xM2_pin_configs,
1488 [STAC_M2_2] = stac925xM2_2_pin_configs,
1489 [STAC_M3] = stac925xM3_pin_configs,
1490 [STAC_M5] = stac925xM5_pin_configs,
1491 [STAC_M6] = stac925xM6_pin_configs,
1494 static const char *stac925x_models[STAC_925x_MODELS] = {
1495 [STAC_925x_AUTO] = "auto",
1498 [STAC_M1_2] = "m1-2",
1500 [STAC_M2_2] = "m2-2",
1506 static struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1507 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1508 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1509 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1510 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1511 SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1512 /* Not sure about the brand name for those */
1513 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1514 SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1515 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1516 SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1520 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1521 /* SigmaTel reference board */
1522 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1523 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
1524 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1526 /* Default table for unknown ID */
1527 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1532 static unsigned int ref92hd73xx_pin_configs[13] = {
1533 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1534 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1535 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1539 static unsigned int dell_m6_pin_configs[13] = {
1540 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1541 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1542 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1546 static unsigned int alienware_m17x_pin_configs[13] = {
1547 0x0321101f, 0x0321101f, 0x03a11020, 0x03014020,
1548 0x90170110, 0x4f0000f0, 0x4f0000f0, 0x4f0000f0,
1549 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1553 static unsigned int intel_dg45id_pin_configs[13] = {
1554 0x02214230, 0x02A19240, 0x01013214, 0x01014210,
1555 0x01A19250, 0x01011212, 0x01016211
1558 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1559 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1560 [STAC_DELL_M6_AMIC] = dell_m6_pin_configs,
1561 [STAC_DELL_M6_DMIC] = dell_m6_pin_configs,
1562 [STAC_DELL_M6_BOTH] = dell_m6_pin_configs,
1563 [STAC_DELL_EQ] = dell_m6_pin_configs,
1564 [STAC_ALIENWARE_M17X] = alienware_m17x_pin_configs,
1565 [STAC_92HD73XX_INTEL] = intel_dg45id_pin_configs,
1568 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1569 [STAC_92HD73XX_AUTO] = "auto",
1570 [STAC_92HD73XX_NO_JD] = "no-jd",
1571 [STAC_92HD73XX_REF] = "ref",
1572 [STAC_92HD73XX_INTEL] = "intel",
1573 [STAC_DELL_M6_AMIC] = "dell-m6-amic",
1574 [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1575 [STAC_DELL_M6_BOTH] = "dell-m6",
1576 [STAC_DELL_EQ] = "dell-eq",
1577 [STAC_ALIENWARE_M17X] = "alienware",
1580 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1581 /* SigmaTel reference board */
1582 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1583 "DFI LanParty", STAC_92HD73XX_REF),
1584 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1585 "DFI LanParty", STAC_92HD73XX_REF),
1586 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
1587 "Intel DG45ID", STAC_92HD73XX_INTEL),
1588 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
1589 "Intel DG45FC", STAC_92HD73XX_INTEL),
1590 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1591 "Dell Studio 1535", STAC_DELL_M6_DMIC),
1592 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1593 "unknown Dell", STAC_DELL_M6_DMIC),
1594 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1595 "unknown Dell", STAC_DELL_M6_BOTH),
1596 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1597 "unknown Dell", STAC_DELL_M6_BOTH),
1598 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1599 "unknown Dell", STAC_DELL_M6_AMIC),
1600 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1601 "unknown Dell", STAC_DELL_M6_AMIC),
1602 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1603 "unknown Dell", STAC_DELL_M6_DMIC),
1604 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1605 "unknown Dell", STAC_DELL_M6_DMIC),
1606 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1607 "Dell Studio 1537", STAC_DELL_M6_DMIC),
1608 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1609 "Dell Studio 17", STAC_DELL_M6_DMIC),
1610 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
1611 "Dell Studio 1555", STAC_DELL_M6_DMIC),
1612 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd,
1613 "Dell Studio 1557", STAC_DELL_M6_DMIC),
1614 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe,
1615 "Dell Studio XPS 1645", STAC_DELL_M6_BOTH),
1616 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413,
1617 "Dell Studio 1558", STAC_DELL_M6_BOTH),
1621 static struct snd_pci_quirk stac92hd73xx_codec_id_cfg_tbl[] = {
1622 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1,
1623 "Alienware M17x", STAC_ALIENWARE_M17X),
1627 static unsigned int ref92hd83xxx_pin_configs[10] = {
1628 0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1629 0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1630 0x01451160, 0x98560170,
1633 static unsigned int dell_s14_pin_configs[10] = {
1634 0x0221403f, 0x0221101f, 0x02a19020, 0x90170110,
1635 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a60160,
1636 0x40f000f0, 0x40f000f0,
1639 static unsigned int hp_dv7_4000_pin_configs[10] = {
1640 0x03a12050, 0x0321201f, 0x40f000f0, 0x90170110,
1641 0x40f000f0, 0x40f000f0, 0x90170110, 0xd5a30140,
1642 0x40f000f0, 0x40f000f0,
1645 static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1646 [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1647 [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
1648 [STAC_DELL_S14] = dell_s14_pin_configs,
1649 [STAC_HP_DV7_4000] = hp_dv7_4000_pin_configs,
1652 static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1653 [STAC_92HD83XXX_AUTO] = "auto",
1654 [STAC_92HD83XXX_REF] = "ref",
1655 [STAC_92HD83XXX_PWR_REF] = "mic-ref",
1656 [STAC_DELL_S14] = "dell-s14",
1657 [STAC_92HD83XXX_HP] = "hp",
1658 [STAC_HP_DV7_4000] = "hp-dv7-4000",
1661 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1662 /* SigmaTel reference board */
1663 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1664 "DFI LanParty", STAC_92HD83XXX_REF),
1665 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1666 "DFI LanParty", STAC_92HD83XXX_REF),
1667 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
1668 "unknown Dell", STAC_DELL_S14),
1669 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x3600,
1670 "HP", STAC_92HD83XXX_HP),
1674 static unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1675 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1676 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1677 0x90a000f0, 0x01452050, 0x01452050, 0x00000000,
1681 static unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1682 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1683 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1684 0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000,
1688 static unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1689 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1690 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1691 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1695 static unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1696 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1697 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1698 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1702 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1703 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1704 [STAC_DELL_M4_1] = dell_m4_1_pin_configs,
1705 [STAC_DELL_M4_2] = dell_m4_2_pin_configs,
1706 [STAC_DELL_M4_3] = dell_m4_3_pin_configs,
1707 [STAC_HP_M4] = NULL,
1708 [STAC_HP_DV4] = NULL,
1709 [STAC_HP_DV5] = NULL,
1710 [STAC_HP_HDX] = NULL,
1711 [STAC_HP_DV4_1222NR] = NULL,
1714 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1715 [STAC_92HD71BXX_AUTO] = "auto",
1716 [STAC_92HD71BXX_REF] = "ref",
1717 [STAC_DELL_M4_1] = "dell-m4-1",
1718 [STAC_DELL_M4_2] = "dell-m4-2",
1719 [STAC_DELL_M4_3] = "dell-m4-3",
1720 [STAC_HP_M4] = "hp-m4",
1721 [STAC_HP_DV4] = "hp-dv4",
1722 [STAC_HP_DV5] = "hp-dv5",
1723 [STAC_HP_HDX] = "hp-hdx",
1724 [STAC_HP_DV4_1222NR] = "hp-dv4-1222nr",
1727 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1728 /* SigmaTel reference board */
1729 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1730 "DFI LanParty", STAC_92HD71BXX_REF),
1731 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1732 "DFI LanParty", STAC_92HD71BXX_REF),
1733 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb,
1734 "HP dv4-1222nr", STAC_HP_DV4_1222NR),
1735 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720,
1737 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
1739 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
1740 "HP dv4-7", STAC_HP_DV4),
1741 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
1742 "HP dv4-7", STAC_HP_DV5),
1743 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
1744 "HP HDX", STAC_HP_HDX), /* HDX18 */
1745 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1746 "HP mini 1000", STAC_HP_M4),
1747 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
1748 "HP HDX", STAC_HP_HDX), /* HDX16 */
1749 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
1750 "HP dv6", STAC_HP_DV5),
1751 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061,
1752 "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */
1753 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
1755 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1756 "unknown Dell", STAC_DELL_M4_1),
1757 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1758 "unknown Dell", STAC_DELL_M4_1),
1759 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1760 "unknown Dell", STAC_DELL_M4_1),
1761 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1762 "unknown Dell", STAC_DELL_M4_1),
1763 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1764 "unknown Dell", STAC_DELL_M4_1),
1765 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1766 "unknown Dell", STAC_DELL_M4_1),
1767 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1768 "unknown Dell", STAC_DELL_M4_1),
1769 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1770 "unknown Dell", STAC_DELL_M4_2),
1771 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1772 "unknown Dell", STAC_DELL_M4_2),
1773 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1774 "unknown Dell", STAC_DELL_M4_2),
1775 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1776 "unknown Dell", STAC_DELL_M4_2),
1777 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1778 "unknown Dell", STAC_DELL_M4_3),
1782 static unsigned int ref922x_pin_configs[10] = {
1783 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1784 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1785 0x40000100, 0x40000100,
1789 STAC 922X pin configs for
1796 static unsigned int dell_922x_d81_pin_configs[10] = {
1797 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1798 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1799 0x01813122, 0x400001f2,
1803 STAC 922X pin configs for
1807 static unsigned int dell_922x_d82_pin_configs[10] = {
1808 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1809 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1810 0x01813122, 0x400001f1,
1814 STAC 922X pin configs for
1817 static unsigned int dell_922x_m81_pin_configs[10] = {
1818 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1819 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1820 0x40C003f1, 0x405003f0,
1824 STAC 9221 A1 pin configs for
1825 102801D7 (Dell XPS M1210)
1827 static unsigned int dell_922x_m82_pin_configs[10] = {
1828 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1829 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1830 0x508003f3, 0x405003f4,
1833 static unsigned int d945gtp3_pin_configs[10] = {
1834 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1835 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1836 0x02a19120, 0x40000100,
1839 static unsigned int d945gtp5_pin_configs[10] = {
1840 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1841 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1842 0x02a19320, 0x40000100,
1845 static unsigned int intel_mac_v1_pin_configs[10] = {
1846 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1847 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1848 0x400000fc, 0x400000fb,
1851 static unsigned int intel_mac_v2_pin_configs[10] = {
1852 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1853 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1854 0x400000fc, 0x400000fb,
1857 static unsigned int intel_mac_v3_pin_configs[10] = {
1858 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1859 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1860 0x400000fc, 0x400000fb,
1863 static unsigned int intel_mac_v4_pin_configs[10] = {
1864 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1865 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1866 0x400000fc, 0x400000fb,
1869 static unsigned int intel_mac_v5_pin_configs[10] = {
1870 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1871 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1872 0x400000fc, 0x400000fb,
1875 static unsigned int ecs202_pin_configs[10] = {
1876 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1877 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1878 0x9037012e, 0x40e000f2,
1881 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1882 [STAC_D945_REF] = ref922x_pin_configs,
1883 [STAC_D945GTP3] = d945gtp3_pin_configs,
1884 [STAC_D945GTP5] = d945gtp5_pin_configs,
1885 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1886 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1887 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1888 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1889 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1890 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1891 /* for backward compatibility */
1892 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1893 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1894 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1895 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1896 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1897 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1898 [STAC_ECS_202] = ecs202_pin_configs,
1899 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1900 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1901 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1902 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1905 static const char *stac922x_models[STAC_922X_MODELS] = {
1906 [STAC_922X_AUTO] = "auto",
1907 [STAC_D945_REF] = "ref",
1908 [STAC_D945GTP5] = "5stack",
1909 [STAC_D945GTP3] = "3stack",
1910 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1911 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1912 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1913 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1914 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1915 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1916 /* for backward compatibility */
1917 [STAC_MACMINI] = "macmini",
1918 [STAC_MACBOOK] = "macbook",
1919 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1920 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1921 [STAC_IMAC_INTEL] = "imac-intel",
1922 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1923 [STAC_ECS_202] = "ecs202",
1924 [STAC_922X_DELL_D81] = "dell-d81",
1925 [STAC_922X_DELL_D82] = "dell-d82",
1926 [STAC_922X_DELL_M81] = "dell-m81",
1927 [STAC_922X_DELL_M82] = "dell-m82",
1930 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1931 /* SigmaTel reference board */
1932 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1933 "DFI LanParty", STAC_D945_REF),
1934 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1935 "DFI LanParty", STAC_D945_REF),
1936 /* Intel 945G based systems */
1937 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1938 "Intel D945G", STAC_D945GTP3),
1939 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1940 "Intel D945G", STAC_D945GTP3),
1941 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1942 "Intel D945G", STAC_D945GTP3),
1943 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1944 "Intel D945G", STAC_D945GTP3),
1945 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1946 "Intel D945G", STAC_D945GTP3),
1947 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1948 "Intel D945G", STAC_D945GTP3),
1949 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1950 "Intel D945G", STAC_D945GTP3),
1951 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1952 "Intel D945G", STAC_D945GTP3),
1953 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1954 "Intel D945G", STAC_D945GTP3),
1955 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1956 "Intel D945G", STAC_D945GTP3),
1957 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1958 "Intel D945G", STAC_D945GTP3),
1959 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1960 "Intel D945G", STAC_D945GTP3),
1961 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1962 "Intel D945G", STAC_D945GTP3),
1963 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1964 "Intel D945G", STAC_D945GTP3),
1965 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1966 "Intel D945G", STAC_D945GTP3),
1967 /* Intel D945G 5-stack systems */
1968 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1969 "Intel D945G", STAC_D945GTP5),
1970 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1971 "Intel D945G", STAC_D945GTP5),
1972 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1973 "Intel D945G", STAC_D945GTP5),
1974 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1975 "Intel D945G", STAC_D945GTP5),
1976 /* Intel 945P based systems */
1977 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1978 "Intel D945P", STAC_D945GTP3),
1979 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1980 "Intel D945P", STAC_D945GTP3),
1981 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1982 "Intel D945P", STAC_D945GTP3),
1983 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1984 "Intel D945P", STAC_D945GTP3),
1985 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1986 "Intel D945P", STAC_D945GTP3),
1987 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1988 "Intel D945P", STAC_D945GTP5),
1990 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
1991 "Intel D945", STAC_D945_REF),
1993 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
1994 SND_PCI_QUIRK(0x8384, 0x7680,
1995 "Mac", STAC_INTEL_MAC_AUTO),
1997 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1998 "unknown Dell", STAC_922X_DELL_D81),
1999 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
2000 "unknown Dell", STAC_922X_DELL_D81),
2001 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
2002 "unknown Dell", STAC_922X_DELL_D81),
2003 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
2004 "unknown Dell", STAC_922X_DELL_D82),
2005 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
2006 "unknown Dell", STAC_922X_DELL_M81),
2007 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
2008 "unknown Dell", STAC_922X_DELL_D82),
2009 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
2010 "unknown Dell", STAC_922X_DELL_D81),
2011 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
2012 "unknown Dell", STAC_922X_DELL_D81),
2013 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
2014 "Dell XPS M1210", STAC_922X_DELL_M82),
2015 /* ECS/PC Chips boards */
2016 SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
2017 "ECS/PC chips", STAC_ECS_202),
2021 static unsigned int ref927x_pin_configs[14] = {
2022 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2023 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
2024 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2025 0x01c42190, 0x40000100,
2028 static unsigned int d965_3st_pin_configs[14] = {
2029 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2030 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2031 0x40000100, 0x40000100, 0x40000100, 0x40000100,
2032 0x40000100, 0x40000100
2035 static unsigned int d965_5st_pin_configs[14] = {
2036 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2037 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2038 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2039 0x40000100, 0x40000100
2042 static unsigned int d965_5st_no_fp_pin_configs[14] = {
2043 0x40000100, 0x40000100, 0x0181304e, 0x01014010,
2044 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2045 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2046 0x40000100, 0x40000100
2049 static unsigned int dell_3st_pin_configs[14] = {
2050 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2051 0x01111212, 0x01116211, 0x01813050, 0x01112214,
2052 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2053 0x40c003fc, 0x40000100
2056 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2057 [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2058 [STAC_D965_REF] = ref927x_pin_configs,
2059 [STAC_D965_3ST] = d965_3st_pin_configs,
2060 [STAC_D965_5ST] = d965_5st_pin_configs,
2061 [STAC_D965_5ST_NO_FP] = d965_5st_no_fp_pin_configs,
2062 [STAC_DELL_3ST] = dell_3st_pin_configs,
2063 [STAC_DELL_BIOS] = NULL,
2064 [STAC_927X_VOLKNOB] = NULL,
2067 static const char *stac927x_models[STAC_927X_MODELS] = {
2068 [STAC_927X_AUTO] = "auto",
2069 [STAC_D965_REF_NO_JD] = "ref-no-jd",
2070 [STAC_D965_REF] = "ref",
2071 [STAC_D965_3ST] = "3stack",
2072 [STAC_D965_5ST] = "5stack",
2073 [STAC_D965_5ST_NO_FP] = "5stack-no-fp",
2074 [STAC_DELL_3ST] = "dell-3stack",
2075 [STAC_DELL_BIOS] = "dell-bios",
2076 [STAC_927X_VOLKNOB] = "volknob",
2079 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2080 /* SigmaTel reference board */
2081 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2082 "DFI LanParty", STAC_D965_REF),
2083 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2084 "DFI LanParty", STAC_D965_REF),
2085 /* Intel 946 based systems */
2086 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2087 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2088 /* 965 based 3 stack systems */
2089 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
2090 "Intel D965", STAC_D965_3ST),
2091 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
2092 "Intel D965", STAC_D965_3ST),
2093 /* Dell 3 stack systems */
2094 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2095 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
2096 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
2097 /* Dell 3 stack systems with verb table in BIOS */
2098 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2099 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_BIOS),
2100 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
2101 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
2102 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
2103 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
2104 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
2105 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
2106 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2107 /* 965 based 5 stack systems */
2108 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
2109 "Intel D965", STAC_D965_5ST),
2110 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
2111 "Intel D965", STAC_D965_5ST),
2112 /* volume-knob fixes */
2113 SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB),
2117 static unsigned int ref9205_pin_configs[12] = {
2118 0x40000100, 0x40000100, 0x01016011, 0x01014010,
2119 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2120 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2124 STAC 9205 pin configs for
2131 10280228 (Dell Vostro 1500)
2132 10280229 (Dell Vostro 1700)
2134 static unsigned int dell_9205_m42_pin_configs[12] = {
2135 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2136 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2137 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2141 STAC 9205 pin configs for
2145 102801FF (Dell Precision M4300)
2150 static unsigned int dell_9205_m43_pin_configs[12] = {
2151 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2152 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2153 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2156 static unsigned int dell_9205_m44_pin_configs[12] = {
2157 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2158 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2159 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2162 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2163 [STAC_9205_REF] = ref9205_pin_configs,
2164 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2165 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2166 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2167 [STAC_9205_EAPD] = NULL,
2170 static const char *stac9205_models[STAC_9205_MODELS] = {
2171 [STAC_9205_AUTO] = "auto",
2172 [STAC_9205_REF] = "ref",
2173 [STAC_9205_DELL_M42] = "dell-m42",
2174 [STAC_9205_DELL_M43] = "dell-m43",
2175 [STAC_9205_DELL_M44] = "dell-m44",
2176 [STAC_9205_EAPD] = "eapd",
2179 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
2180 /* SigmaTel reference board */
2181 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2182 "DFI LanParty", STAC_9205_REF),
2183 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
2184 "SigmaTel", STAC_9205_REF),
2185 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2186 "DFI LanParty", STAC_9205_REF),
2188 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2189 "unknown Dell", STAC_9205_DELL_M42),
2190 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2191 "unknown Dell", STAC_9205_DELL_M42),
2192 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2193 "Dell Precision", STAC_9205_DELL_M43),
2194 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2195 "Dell Precision", STAC_9205_DELL_M43),
2196 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2197 "Dell Precision", STAC_9205_DELL_M43),
2198 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2199 "unknown Dell", STAC_9205_DELL_M42),
2200 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2201 "unknown Dell", STAC_9205_DELL_M42),
2202 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2203 "Dell Precision", STAC_9205_DELL_M43),
2204 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2205 "Dell Precision M4300", STAC_9205_DELL_M43),
2206 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2207 "unknown Dell", STAC_9205_DELL_M42),
2208 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2209 "Dell Precision", STAC_9205_DELL_M43),
2210 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2211 "Dell Precision", STAC_9205_DELL_M43),
2212 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2213 "Dell Precision", STAC_9205_DELL_M43),
2214 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2215 "Dell Inspiron", STAC_9205_DELL_M44),
2216 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2217 "Dell Vostro 1500", STAC_9205_DELL_M42),
2218 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229,
2219 "Dell Vostro 1700", STAC_9205_DELL_M42),
2221 SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
2222 SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
2226 static void stac92xx_set_config_regs(struct hda_codec *codec,
2227 unsigned int *pincfgs)
2230 struct sigmatel_spec *spec = codec->spec;
2235 for (i = 0; i < spec->num_pins; i++)
2236 if (spec->pin_nids[i] && pincfgs[i])
2237 snd_hda_codec_set_pincfg(codec, spec->pin_nids[i],
2242 * Analog playback callbacks
2244 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2245 struct hda_codec *codec,
2246 struct snd_pcm_substream *substream)
2248 struct sigmatel_spec *spec = codec->spec;
2249 if (spec->stream_delay)
2250 msleep(spec->stream_delay);
2251 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2255 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2256 struct hda_codec *codec,
2257 unsigned int stream_tag,
2258 unsigned int format,
2259 struct snd_pcm_substream *substream)
2261 struct sigmatel_spec *spec = codec->spec;
2262 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2265 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2266 struct hda_codec *codec,
2267 struct snd_pcm_substream *substream)
2269 struct sigmatel_spec *spec = codec->spec;
2270 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2274 * Digital playback callbacks
2276 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2277 struct hda_codec *codec,
2278 struct snd_pcm_substream *substream)
2280 struct sigmatel_spec *spec = codec->spec;
2281 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2284 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2285 struct hda_codec *codec,
2286 struct snd_pcm_substream *substream)
2288 struct sigmatel_spec *spec = codec->spec;
2289 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2292 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2293 struct hda_codec *codec,
2294 unsigned int stream_tag,
2295 unsigned int format,
2296 struct snd_pcm_substream *substream)
2298 struct sigmatel_spec *spec = codec->spec;
2299 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2300 stream_tag, format, substream);
2303 static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2304 struct hda_codec *codec,
2305 struct snd_pcm_substream *substream)
2307 struct sigmatel_spec *spec = codec->spec;
2308 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2313 * Analog capture callbacks
2315 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2316 struct hda_codec *codec,
2317 unsigned int stream_tag,
2318 unsigned int format,
2319 struct snd_pcm_substream *substream)
2321 struct sigmatel_spec *spec = codec->spec;
2322 hda_nid_t nid = spec->adc_nids[substream->number];
2324 if (spec->powerdown_adcs) {
2326 snd_hda_codec_write(codec, nid, 0,
2327 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2329 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2333 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2334 struct hda_codec *codec,
2335 struct snd_pcm_substream *substream)
2337 struct sigmatel_spec *spec = codec->spec;
2338 hda_nid_t nid = spec->adc_nids[substream->number];
2340 snd_hda_codec_cleanup_stream(codec, nid);
2341 if (spec->powerdown_adcs)
2342 snd_hda_codec_write(codec, nid, 0,
2343 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2347 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2351 /* NID is set in stac92xx_build_pcms */
2353 .open = stac92xx_dig_playback_pcm_open,
2354 .close = stac92xx_dig_playback_pcm_close,
2355 .prepare = stac92xx_dig_playback_pcm_prepare,
2356 .cleanup = stac92xx_dig_playback_pcm_cleanup
2360 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2364 /* NID is set in stac92xx_build_pcms */
2367 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2371 .nid = 0x02, /* NID to query formats and rates */
2373 .open = stac92xx_playback_pcm_open,
2374 .prepare = stac92xx_playback_pcm_prepare,
2375 .cleanup = stac92xx_playback_pcm_cleanup
2379 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2383 .nid = 0x06, /* NID to query formats and rates */
2385 .open = stac92xx_playback_pcm_open,
2386 .prepare = stac92xx_playback_pcm_prepare,
2387 .cleanup = stac92xx_playback_pcm_cleanup
2391 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2394 /* NID + .substreams is set in stac92xx_build_pcms */
2396 .prepare = stac92xx_capture_pcm_prepare,
2397 .cleanup = stac92xx_capture_pcm_cleanup
2401 static int stac92xx_build_pcms(struct hda_codec *codec)
2403 struct sigmatel_spec *spec = codec->spec;
2404 struct hda_pcm *info = spec->pcm_rec;
2406 codec->num_pcms = 1;
2407 codec->pcm_info = info;
2409 info->name = "STAC92xx Analog";
2410 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2411 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2412 spec->multiout.dac_nids[0];
2413 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2414 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2415 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2417 if (spec->alt_switch) {
2420 info->name = "STAC92xx Analog Alt";
2421 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2424 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2427 info->name = "STAC92xx Digital";
2428 info->pcm_type = spec->autocfg.dig_out_type[0];
2429 if (spec->multiout.dig_out_nid) {
2430 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2431 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2433 if (spec->dig_in_nid) {
2434 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2435 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2442 static unsigned int stac92xx_get_default_vref(struct hda_codec *codec,
2445 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2446 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2447 if (pincap & AC_PINCAP_VREF_100)
2448 return AC_PINCTL_VREF_100;
2449 if (pincap & AC_PINCAP_VREF_80)
2450 return AC_PINCTL_VREF_80;
2451 if (pincap & AC_PINCAP_VREF_50)
2452 return AC_PINCTL_VREF_50;
2453 if (pincap & AC_PINCAP_VREF_GRD)
2454 return AC_PINCTL_VREF_GRD;
2458 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2461 snd_hda_codec_write_cache(codec, nid, 0,
2462 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2465 #define stac92xx_hp_switch_info snd_ctl_boolean_mono_info
2467 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2468 struct snd_ctl_elem_value *ucontrol)
2470 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2471 struct sigmatel_spec *spec = codec->spec;
2473 ucontrol->value.integer.value[0] = !!spec->hp_switch;
2477 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid);
2479 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2480 struct snd_ctl_elem_value *ucontrol)
2482 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2483 struct sigmatel_spec *spec = codec->spec;
2484 int nid = kcontrol->private_value;
2486 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2488 /* check to be sure that the ports are upto date with
2491 stac_issue_unsol_event(codec, nid);
2496 static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol,
2497 struct snd_ctl_elem_info *uinfo)
2500 static char *texts[] = {
2501 "Mic In", "Line In", "Line Out"
2504 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2505 struct sigmatel_spec *spec = codec->spec;
2506 hda_nid_t nid = kcontrol->private_value;
2508 if (nid == spec->mic_switch || nid == spec->line_switch)
2513 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2514 uinfo->value.enumerated.items = i;
2516 if (uinfo->value.enumerated.item >= i)
2517 uinfo->value.enumerated.item = i-1;
2518 strcpy(uinfo->value.enumerated.name,
2519 texts[uinfo->value.enumerated.item]);
2524 static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol,
2525 struct snd_ctl_elem_value *ucontrol)
2527 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2528 hda_nid_t nid = kcontrol->private_value;
2529 unsigned int vref = stac92xx_vref_get(codec, nid);
2531 if (vref == stac92xx_get_default_vref(codec, nid))
2532 ucontrol->value.enumerated.item[0] = 0;
2533 else if (vref == AC_PINCTL_VREF_GRD)
2534 ucontrol->value.enumerated.item[0] = 1;
2535 else if (vref == AC_PINCTL_VREF_HIZ)
2536 ucontrol->value.enumerated.item[0] = 2;
2541 static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol,
2542 struct snd_ctl_elem_value *ucontrol)
2544 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2545 unsigned int new_vref = 0;
2547 hda_nid_t nid = kcontrol->private_value;
2549 if (ucontrol->value.enumerated.item[0] == 0)
2550 new_vref = stac92xx_get_default_vref(codec, nid);
2551 else if (ucontrol->value.enumerated.item[0] == 1)
2552 new_vref = AC_PINCTL_VREF_GRD;
2553 else if (ucontrol->value.enumerated.item[0] == 2)
2554 new_vref = AC_PINCTL_VREF_HIZ;
2558 if (new_vref != stac92xx_vref_get(codec, nid)) {
2559 error = stac92xx_vref_set(codec, nid, new_vref);
2566 static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol,
2567 struct snd_ctl_elem_info *uinfo)
2569 static char *texts[2];
2570 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2571 struct sigmatel_spec *spec = codec->spec;
2573 if (kcontrol->private_value == spec->line_switch)
2574 texts[0] = "Line In";
2576 texts[0] = "Mic In";
2577 texts[1] = "Line Out";
2578 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2579 uinfo->value.enumerated.items = 2;
2582 if (uinfo->value.enumerated.item >= 2)
2583 uinfo->value.enumerated.item = 1;
2584 strcpy(uinfo->value.enumerated.name,
2585 texts[uinfo->value.enumerated.item]);
2590 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2592 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2593 struct sigmatel_spec *spec = codec->spec;
2594 hda_nid_t nid = kcontrol->private_value;
2595 int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2597 ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx];
2601 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2603 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2604 struct sigmatel_spec *spec = codec->spec;
2605 hda_nid_t nid = kcontrol->private_value;
2606 int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2607 unsigned short val = !!ucontrol->value.enumerated.item[0];
2609 spec->io_switch[io_idx] = val;
2612 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2614 unsigned int pinctl = AC_PINCTL_IN_EN;
2615 if (io_idx) /* set VREF for mic */
2616 pinctl |= stac92xx_get_default_vref(codec, nid);
2617 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2620 /* check the auto-mute again: we need to mute/unmute the speaker
2621 * appropriately according to the pin direction
2623 if (spec->hp_detect)
2624 stac_issue_unsol_event(codec, nid);
2629 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2631 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2632 struct snd_ctl_elem_value *ucontrol)
2634 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2635 struct sigmatel_spec *spec = codec->spec;
2637 ucontrol->value.integer.value[0] = spec->clfe_swap;
2641 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2642 struct snd_ctl_elem_value *ucontrol)
2644 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2645 struct sigmatel_spec *spec = codec->spec;
2646 hda_nid_t nid = kcontrol->private_value & 0xff;
2647 unsigned int val = !!ucontrol->value.integer.value[0];
2649 if (spec->clfe_swap == val)
2652 spec->clfe_swap = val;
2654 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2655 spec->clfe_swap ? 0x4 : 0x0);
2660 #define STAC_CODEC_HP_SWITCH(xname) \
2661 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2664 .info = stac92xx_hp_switch_info, \
2665 .get = stac92xx_hp_switch_get, \
2666 .put = stac92xx_hp_switch_put, \
2669 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2670 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2673 .info = stac92xx_io_switch_info, \
2674 .get = stac92xx_io_switch_get, \
2675 .put = stac92xx_io_switch_put, \
2676 .private_value = xpval, \
2679 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2680 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2683 .info = stac92xx_clfe_switch_info, \
2684 .get = stac92xx_clfe_switch_get, \
2685 .put = stac92xx_clfe_switch_put, \
2686 .private_value = xpval, \
2690 STAC_CTL_WIDGET_VOL,
2691 STAC_CTL_WIDGET_MUTE,
2692 STAC_CTL_WIDGET_MUTE_BEEP,
2693 STAC_CTL_WIDGET_MONO_MUX,
2694 STAC_CTL_WIDGET_HP_SWITCH,
2695 STAC_CTL_WIDGET_IO_SWITCH,
2696 STAC_CTL_WIDGET_CLFE_SWITCH,
2697 STAC_CTL_WIDGET_DC_BIAS
2700 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2701 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2702 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2703 HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0),
2705 STAC_CODEC_HP_SWITCH(NULL),
2706 STAC_CODEC_IO_SWITCH(NULL, 0),
2707 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2708 DC_BIAS(NULL, 0, 0),
2711 /* add dynamic controls */
2712 static struct snd_kcontrol_new *
2713 stac_control_new(struct sigmatel_spec *spec,
2714 struct snd_kcontrol_new *ktemp,
2716 unsigned int subdev)
2718 struct snd_kcontrol_new *knew;
2720 snd_array_init(&spec->kctls, sizeof(*knew), 32);
2721 knew = snd_array_new(&spec->kctls);
2725 knew->name = kstrdup(name, GFP_KERNEL);
2728 memset(knew, 0, sizeof(*knew));
2729 spec->kctls.alloced--;
2732 knew->subdevice = subdev;
2736 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2737 struct snd_kcontrol_new *ktemp,
2738 int idx, const char *name,
2741 struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name,
2742 HDA_SUBDEV_AMP_FLAG);
2746 knew->private_value = val;
2750 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2751 int type, int idx, const char *name,
2754 return stac92xx_add_control_temp(spec,
2755 &stac92xx_control_templates[type],
2760 /* add dynamic controls */
2761 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2762 const char *name, unsigned long val)
2764 return stac92xx_add_control_idx(spec, type, 0, name, val);
2767 static struct snd_kcontrol_new stac_input_src_temp = {
2768 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2769 .name = "Input Source",
2770 .info = stac92xx_mux_enum_info,
2771 .get = stac92xx_mux_enum_get,
2772 .put = stac92xx_mux_enum_put,
2775 static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
2776 hda_nid_t nid, int idx)
2778 int def_conf = snd_hda_codec_get_pincfg(codec, nid);
2780 struct sigmatel_spec *spec = codec->spec;
2783 if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
2784 if (stac92xx_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
2785 && nid == spec->line_switch)
2786 control = STAC_CTL_WIDGET_IO_SWITCH;
2787 else if (snd_hda_query_pin_caps(codec, nid)
2788 & (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT))
2789 control = STAC_CTL_WIDGET_DC_BIAS;
2790 else if (nid == spec->mic_switch)
2791 control = STAC_CTL_WIDGET_IO_SWITCH;
2795 strcpy(name, hda_get_input_pin_label(codec, nid, 1));
2796 return stac92xx_add_control(codec->spec, control,
2797 strcat(name, " Jack Mode"), nid);
2803 static int stac92xx_add_input_source(struct sigmatel_spec *spec)
2805 struct snd_kcontrol_new *knew;
2806 struct hda_input_mux *imux = &spec->private_imux;
2809 return 0; /* no need for input source */
2810 if (!spec->num_adcs || imux->num_items <= 1)
2811 return 0; /* no need for input source control */
2812 knew = stac_control_new(spec, &stac_input_src_temp,
2813 stac_input_src_temp.name, 0);
2816 knew->count = spec->num_adcs;
2820 /* check whether the line-input can be used as line-out */
2821 static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2823 struct sigmatel_spec *spec = codec->spec;
2824 struct auto_pin_cfg *cfg = &spec->autocfg;
2826 unsigned int pincap;
2829 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2831 for (i = 0; i < cfg->num_inputs; i++) {
2832 if (cfg->inputs[i].type == AUTO_PIN_LINE_IN) {
2833 nid = cfg->inputs[i].pin;
2834 pincap = snd_hda_query_pin_caps(codec, nid);
2835 if (pincap & AC_PINCAP_OUT)
2842 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid);
2844 /* check whether the mic-input can be used as line-out */
2845 static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac)
2847 struct sigmatel_spec *spec = codec->spec;
2848 struct auto_pin_cfg *cfg = &spec->autocfg;
2849 unsigned int def_conf, pincap;
2853 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2855 for (i = 0; i < cfg->num_inputs; i++) {
2856 hda_nid_t nid = cfg->inputs[i].pin;
2857 if (cfg->inputs[i].type != AUTO_PIN_MIC)
2859 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2860 /* some laptops have an internal analog microphone
2861 * which can't be used as a output */
2862 if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
2863 pincap = snd_hda_query_pin_caps(codec, nid);
2864 if (pincap & AC_PINCAP_OUT) {
2865 *dac = get_unassigned_dac(codec, nid);
2874 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2878 for (i = 0; i < spec->multiout.num_dacs; i++) {
2879 if (spec->multiout.dac_nids[i] == nid)
2886 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2889 if (is_in_dac_nids(spec, nid))
2891 for (i = 0; i < spec->autocfg.hp_outs; i++)
2892 if (spec->hp_dacs[i] == nid)
2894 for (i = 0; i < spec->autocfg.speaker_outs; i++)
2895 if (spec->speaker_dacs[i] == nid)
2900 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2902 struct sigmatel_spec *spec = codec->spec;
2904 hda_nid_t conn[HDA_MAX_CONNECTIONS];
2905 unsigned int wcaps, wtype;
2907 conn_len = snd_hda_get_connections(codec, nid, conn,
2908 HDA_MAX_CONNECTIONS);
2909 /* 92HD88: trace back up the link of nids to find the DAC */
2910 while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0]))
2911 != AC_WID_AUD_OUT)) {
2913 conn_len = snd_hda_get_connections(codec, nid, conn,
2914 HDA_MAX_CONNECTIONS);
2916 for (j = 0; j < conn_len; j++) {
2917 wcaps = get_wcaps(codec, conn[j]);
2918 wtype = get_wcaps_type(wcaps);
2919 /* we check only analog outputs */
2920 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2922 /* if this route has a free DAC, assign it */
2923 if (!check_all_dac_nids(spec, conn[j])) {
2925 /* select this DAC in the pin's input mux */
2926 snd_hda_codec_write_cache(codec, nid, 0,
2927 AC_VERB_SET_CONNECT_SEL, j);
2932 /* if all DACs are already assigned, connect to the primary DAC */
2934 for (j = 0; j < conn_len; j++) {
2935 if (conn[j] == spec->multiout.dac_nids[0]) {
2936 snd_hda_codec_write_cache(codec, nid, 0,
2937 AC_VERB_SET_CONNECT_SEL, j);
2945 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2946 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2949 * Fill in the dac_nids table from the parsed pin configuration
2950 * This function only works when every pin in line_out_pins[]
2951 * contains atleast one DAC in its connection list. Some 92xx
2952 * codecs are not connected directly to a DAC, such as the 9200
2953 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2955 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2957 struct sigmatel_spec *spec = codec->spec;
2958 struct auto_pin_cfg *cfg = &spec->autocfg;
2962 for (i = 0; i < cfg->line_outs; i++) {
2963 nid = cfg->line_out_pins[i];
2964 dac = get_unassigned_dac(codec, nid);
2966 if (spec->multiout.num_dacs > 0) {
2967 /* we have already working output pins,
2968 * so let's drop the broken ones again
2970 cfg->line_outs = spec->multiout.num_dacs;
2973 /* error out, no available DAC found */
2975 "%s: No available DAC for pin 0x%x\n",
2979 add_spec_dacs(spec, dac);
2982 for (i = 0; i < cfg->hp_outs; i++) {
2983 nid = cfg->hp_pins[i];
2984 dac = get_unassigned_dac(codec, nid);
2986 if (!spec->multiout.hp_nid)
2987 spec->multiout.hp_nid = dac;
2989 add_spec_extra_dacs(spec, dac);
2991 spec->hp_dacs[i] = dac;
2994 for (i = 0; i < cfg->speaker_outs; i++) {
2995 nid = cfg->speaker_pins[i];
2996 dac = get_unassigned_dac(codec, nid);
2998 add_spec_extra_dacs(spec, dac);
2999 spec->speaker_dacs[i] = dac;
3002 /* add line-in as output */
3003 nid = check_line_out_switch(codec);
3005 dac = get_unassigned_dac(codec, nid);
3007 snd_printdd("STAC: Add line-in 0x%x as output %d\n",
3008 nid, cfg->line_outs);
3009 cfg->line_out_pins[cfg->line_outs] = nid;
3011 spec->line_switch = nid;
3012 add_spec_dacs(spec, dac);
3015 /* add mic as output */
3016 nid = check_mic_out_switch(codec, &dac);
3018 snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
3019 nid, cfg->line_outs);
3020 cfg->line_out_pins[cfg->line_outs] = nid;
3022 spec->mic_switch = nid;
3023 add_spec_dacs(spec, dac);
3026 snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3027 spec->multiout.num_dacs,
3028 spec->multiout.dac_nids[0],
3029 spec->multiout.dac_nids[1],
3030 spec->multiout.dac_nids[2],
3031 spec->multiout.dac_nids[3],
3032 spec->multiout.dac_nids[4]);
3037 /* create volume control/switch for the given prefx type */
3038 static int create_controls_idx(struct hda_codec *codec, const char *pfx,
3039 int idx, hda_nid_t nid, int chs)
3041 struct sigmatel_spec *spec = codec->spec;
3045 if (!spec->check_volume_offset) {
3046 unsigned int caps, step, nums, db_scale;
3047 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3048 step = (caps & AC_AMPCAP_STEP_SIZE) >>
3049 AC_AMPCAP_STEP_SIZE_SHIFT;
3050 step = (step + 1) * 25; /* in .01dB unit */
3051 nums = (caps & AC_AMPCAP_NUM_STEPS) >>
3052 AC_AMPCAP_NUM_STEPS_SHIFT;
3053 db_scale = nums * step;
3054 /* if dB scale is over -64dB, and finer enough,
3055 * let's reduce it to half
3057 if (db_scale > 6400 && nums >= 0x1f)
3058 spec->volume_offset = nums / 2;
3059 spec->check_volume_offset = 1;
3062 sprintf(name, "%s Playback Volume", pfx);
3063 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
3064 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3065 spec->volume_offset));
3068 sprintf(name, "%s Playback Switch", pfx);
3069 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
3070 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3076 #define create_controls(codec, pfx, nid, chs) \
3077 create_controls_idx(codec, pfx, 0, nid, chs)
3079 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3081 if (spec->multiout.num_dacs > 4) {
3082 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3085 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
3086 spec->multiout.num_dacs++;
3091 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3094 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3095 if (!spec->multiout.extra_out_nid[i]) {
3096 spec->multiout.extra_out_nid[i] = nid;
3100 printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3104 /* Create output controls
3105 * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
3107 static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
3108 const hda_nid_t *pins,
3109 const hda_nid_t *dac_nids,
3112 struct sigmatel_spec *spec = codec->spec;
3113 static const char *chname[4] = {
3114 "Front", "Surround", NULL /*CLFE*/, "Side"
3118 unsigned int wid_caps;
3120 for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
3121 if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3122 wid_caps = get_wcaps(codec, pins[i]);
3123 if (wid_caps & AC_WCAP_UNSOL_CAP)
3124 spec->hp_detect = 1;
3129 if (type != AUTO_PIN_HP_OUT && i == 2) {
3131 err = create_controls(codec, "Center", nid, 1);
3134 err = create_controls(codec, "LFE", nid, 2);
3138 wid_caps = get_wcaps(codec, nid);
3140 if (wid_caps & AC_WCAP_LR_SWAP) {
3141 err = stac92xx_add_control(spec,
3142 STAC_CTL_WIDGET_CLFE_SWITCH,
3143 "Swap Center/LFE Playback Switch", nid);
3153 case AUTO_PIN_HP_OUT:
3157 case AUTO_PIN_SPEAKER_OUT:
3166 err = create_controls_idx(codec, name, idx, nid, 3);
3174 static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol,
3175 unsigned long sw, int idx)
3178 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx,
3179 "Capture Volume", vol);
3182 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_MUTE, idx,
3183 "Capture Switch", sw);
3189 /* add playback controls from the parsed DAC table */
3190 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3191 const struct auto_pin_cfg *cfg)
3193 struct sigmatel_spec *spec = codec->spec;
3198 err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
3199 spec->multiout.dac_nids,
3200 cfg->line_out_type);
3204 if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3205 err = stac92xx_add_control(spec,
3206 STAC_CTL_WIDGET_HP_SWITCH,
3207 "Headphone as Line Out Switch",
3208 cfg->hp_pins[cfg->hp_outs - 1]);
3213 for (idx = 0; idx < cfg->num_inputs; idx++) {
3214 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3216 nid = cfg->inputs[idx].pin;
3217 err = stac92xx_add_jack_mode_control(codec, nid, idx);
3225 /* add playback controls for Speaker and HP outputs */
3226 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3227 struct auto_pin_cfg *cfg)
3229 struct sigmatel_spec *spec = codec->spec;
3232 err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
3233 spec->hp_dacs, AUTO_PIN_HP_OUT);
3237 err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
3238 spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
3245 /* labels for mono mux outputs */
3246 static const char *stac92xx_mono_labels[4] = {
3247 "DAC0", "DAC1", "Mixer", "DAC2"
3250 /* create mono mux for mono out on capable codecs */
3251 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3253 struct sigmatel_spec *spec = codec->spec;
3254 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3256 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3258 num_cons = snd_hda_get_connections(codec,
3261 HDA_MAX_NUM_INPUTS);
3262 if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3265 for (i = 0; i < num_cons; i++)
3266 snd_hda_add_imux_item(mono_mux, stac92xx_mono_labels[i], i,
3269 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3270 "Mono Mux", spec->mono_nid);
3273 /* create PC beep volume controls */
3274 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3277 struct sigmatel_spec *spec = codec->spec;
3278 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3279 int err, type = STAC_CTL_WIDGET_MUTE_BEEP;
3281 if (spec->anabeep_nid == nid)
3282 type = STAC_CTL_WIDGET_MUTE;
3284 /* check for mute support for the the amp */
3285 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3286 err = stac92xx_add_control(spec, type,
3287 "Beep Playback Switch",
3288 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3293 /* check to see if there is volume support for the amp */
3294 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3295 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3296 "Beep Playback Volume",
3297 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3304 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3305 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3307 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3308 struct snd_ctl_elem_value *ucontrol)
3310 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3311 ucontrol->value.integer.value[0] = codec->beep->enabled;
3315 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3316 struct snd_ctl_elem_value *ucontrol)
3318 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3319 return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
3322 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3323 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3324 .info = stac92xx_dig_beep_switch_info,
3325 .get = stac92xx_dig_beep_switch_get,
3326 .put = stac92xx_dig_beep_switch_put,
3329 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3331 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3332 0, "Beep Playback Switch", 0);
3336 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3338 struct sigmatel_spec *spec = codec->spec;
3341 for (i = 0; i < spec->num_muxes; i++) {
3346 nid = spec->mux_nids[i];
3347 wcaps = get_wcaps(codec, nid);
3348 if (!(wcaps & AC_WCAP_OUT_AMP))
3351 /* check whether already the same control was created as
3352 * normal Capture Volume.
3354 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3355 for (j = 0; j < spec->num_caps; j++) {
3356 if (spec->capvols[j] == val)
3359 if (j < spec->num_caps)
3362 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i,
3363 "Mux Capture Volume", val);
3370 static const char *stac92xx_spdif_labels[3] = {
3371 "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3374 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3376 struct sigmatel_spec *spec = codec->spec;
3377 struct hda_input_mux *spdif_mux = &spec->private_smux;
3378 const char **labels = spec->spdif_labels;
3380 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3382 num_cons = snd_hda_get_connections(codec,
3385 HDA_MAX_NUM_INPUTS);
3390 labels = stac92xx_spdif_labels;
3392 for (i = 0; i < num_cons; i++)
3393 snd_hda_add_imux_item(spdif_mux, labels[i], i, NULL);
3398 /* labels for dmic mux inputs */
3399 static const char *stac92xx_dmic_labels[5] = {
3400 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3401 "Digital Mic 3", "Digital Mic 4"
3404 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
3407 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3410 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3411 for (i = 0; i < nums; i++)
3417 /* create a volume assigned to the given pin (only if supported) */
3418 /* return 1 if the volume control is created */
3419 static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
3420 const char *label, int idx, int direction)
3422 unsigned int caps, nums;
3426 if (direction == HDA_OUTPUT)
3427 caps = AC_WCAP_OUT_AMP;
3429 caps = AC_WCAP_IN_AMP;
3430 if (!(get_wcaps(codec, nid) & caps))
3432 caps = query_amp_caps(codec, nid, direction);
3433 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
3436 snprintf(name, sizeof(name), "%s Capture Volume", label);
3437 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, name,
3438 HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction));
3444 /* create playback/capture controls for input pins on dmic capable codecs */
3445 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3446 const struct auto_pin_cfg *cfg)
3448 struct sigmatel_spec *spec = codec->spec;
3449 struct hda_input_mux *imux = &spec->private_imux;
3450 struct hda_input_mux *dimux = &spec->private_dimux;
3452 unsigned int def_conf;
3454 snd_hda_add_imux_item(dimux, stac92xx_dmic_labels[0], 0, NULL);
3456 for (i = 0; i < spec->num_dmics; i++) {
3458 int index, type_idx;
3461 nid = spec->dmic_nids[i];
3462 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
3464 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3465 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3468 index = get_connection_index(codec, spec->dmux_nids[0], nid);
3472 label = hda_get_input_pin_label(codec, nid, 1);
3473 snd_hda_add_imux_item(dimux, label, index, &type_idx);
3475 err = create_elem_capture_vol(codec, nid, label, type_idx,
3480 err = create_elem_capture_vol(codec, nid, label,
3481 type_idx, HDA_OUTPUT);
3486 if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1) {
3487 snd_hda_add_imux_item(imux, label, index, NULL);
3488 spec->num_analog_muxes++;
3495 static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid,
3496 hda_nid_t *fixed, hda_nid_t *ext, hda_nid_t *dock)
3502 cfg = snd_hda_codec_get_pincfg(codec, nid);
3503 switch (snd_hda_get_input_pin_attr(cfg)) {
3504 case INPUT_PIN_ATTR_INT:
3506 return 1; /* already occupied */
3509 case INPUT_PIN_ATTR_UNUSED:
3511 case INPUT_PIN_ATTR_DOCK:
3513 return 1; /* already occupied */
3518 return 1; /* already occupied */
3525 static int set_mic_route(struct hda_codec *codec,
3526 struct sigmatel_mic_route *mic,
3529 struct sigmatel_spec *spec = codec->spec;
3530 struct auto_pin_cfg *cfg = &spec->autocfg;
3536 for (i = 0; i < cfg->num_inputs; i++) {
3537 if (pin == cfg->inputs[i].pin)
3540 if (i < cfg->num_inputs && cfg->inputs[i].type == AUTO_PIN_MIC) {
3542 i = get_connection_index(codec, spec->mux_nids[0], pin);
3547 if (spec->dmux_nids)
3548 mic->dmux_idx = get_connection_index(codec,
3551 } else if (spec->dmux_nids) {
3553 i = get_connection_index(codec, spec->dmux_nids[0], pin);
3559 mic->mux_idx = get_connection_index(codec,
3561 spec->dmux_nids[0]);
3566 /* return non-zero if the device is for automatic mic switch */
3567 static int stac_check_auto_mic(struct hda_codec *codec)
3569 struct sigmatel_spec *spec = codec->spec;
3570 struct auto_pin_cfg *cfg = &spec->autocfg;
3571 hda_nid_t fixed, ext, dock;
3574 for (i = 0; i < cfg->num_inputs; i++) {
3575 if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN)
3576 return 0; /* must be exclusively mics */
3578 fixed = ext = dock = 0;
3579 for (i = 0; i < cfg->num_inputs; i++)
3580 if (check_mic_pin(codec, cfg->inputs[i].pin,
3581 &fixed, &ext, &dock))
3583 for (i = 0; i < spec->num_dmics; i++)
3584 if (check_mic_pin(codec, spec->dmic_nids[i],
3585 &fixed, &ext, &dock))
3587 if (!fixed && !ext && !dock)
3588 return 0; /* no input to switch */
3589 if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
3590 return 0; /* no unsol support */
3591 if (set_mic_route(codec, &spec->ext_mic, ext) ||
3592 set_mic_route(codec, &spec->int_mic, fixed) ||
3593 set_mic_route(codec, &spec->dock_mic, dock))
3594 return 0; /* something is wrong */
3598 /* create playback/capture controls for input pins */
3599 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3601 struct sigmatel_spec *spec = codec->spec;
3602 struct hda_input_mux *imux = &spec->private_imux;
3606 for (i = 0; i < cfg->num_inputs; i++) {
3607 hda_nid_t nid = cfg->inputs[i].pin;
3608 int index, err, type_idx;
3611 for (j = 0; j < spec->num_muxes; j++) {
3612 index = get_connection_index(codec, spec->mux_nids[j],
3620 label = hda_get_autocfg_input_label(codec, cfg, i);
3621 snd_hda_add_imux_item(imux, label, index, &type_idx);
3623 err = create_elem_capture_vol(codec, nid,
3629 spec->num_analog_muxes = imux->num_items;
3631 if (imux->num_items) {
3633 * Set the current input for the muxes.
3634 * The STAC9221 has two input muxes with identical source
3635 * NID lists. Hopefully this won't get confused.
3637 for (i = 0; i < spec->num_muxes; i++) {
3638 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3639 AC_VERB_SET_CONNECT_SEL,
3640 imux->items[0].index);
3647 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3649 struct sigmatel_spec *spec = codec->spec;
3652 for (i = 0; i < spec->autocfg.line_outs; i++) {
3653 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3654 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3658 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3660 struct sigmatel_spec *spec = codec->spec;
3663 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3665 pin = spec->autocfg.hp_pins[i];
3666 if (pin) /* connect to front */
3667 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3669 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3671 pin = spec->autocfg.speaker_pins[i];
3672 if (pin) /* connect to front */
3673 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3677 static int is_dual_headphones(struct hda_codec *codec)
3679 struct sigmatel_spec *spec = codec->spec;
3682 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT ||
3683 spec->autocfg.hp_outs <= 1)
3686 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3687 hda_nid_t nid = spec->autocfg.hp_pins[i];
3688 unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid);
3689 if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE)
3693 return (valid_hps > 1);
3697 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3699 struct sigmatel_spec *spec = codec->spec;
3703 if ((err = snd_hda_parse_pin_def_config(codec,
3705 spec->dmic_nids)) < 0)
3707 if (! spec->autocfg.line_outs)
3708 return 0; /* can't find valid pin config */
3710 /* If we have no real line-out pin and multiple hp-outs, HPs should
3711 * be set up as multi-channel outputs.
3713 if (is_dual_headphones(codec)) {
3714 /* Copy hp_outs to line_outs, backup line_outs in
3715 * speaker_outs so that the following routines can handle
3716 * HP pins as primary outputs.
3718 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3719 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3720 sizeof(spec->autocfg.line_out_pins));
3721 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3722 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3723 sizeof(spec->autocfg.hp_pins));
3724 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3725 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3726 spec->autocfg.hp_outs = 0;
3729 if (spec->autocfg.mono_out_pin) {
3730 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3731 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3732 u32 caps = query_amp_caps(codec,
3733 spec->autocfg.mono_out_pin, dir);
3734 hda_nid_t conn_list[1];
3736 /* get the mixer node and then the mono mux if it exists */
3737 if (snd_hda_get_connections(codec,
3738 spec->autocfg.mono_out_pin, conn_list, 1) &&
3739 snd_hda_get_connections(codec, conn_list[0],
3740 conn_list, 1) > 0) {
3742 int wcaps = get_wcaps(codec, conn_list[0]);
3743 int wid_type = get_wcaps_type(wcaps);
3744 /* LR swap check, some stac925x have a mux that
3745 * changes the DACs output path instead of the
3748 if (wid_type == AC_WID_AUD_SEL &&
3749 !(wcaps & AC_WCAP_LR_SWAP))
3750 spec->mono_nid = conn_list[0];
3753 hda_nid_t nid = spec->autocfg.mono_out_pin;
3755 /* most mono outs have a least a mute/unmute switch */
3756 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3757 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3758 "Mono Playback Switch",
3759 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3762 /* check for volume support for the amp */
3763 if ((caps & AC_AMPCAP_NUM_STEPS)
3764 >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3765 err = stac92xx_add_control(spec,
3766 STAC_CTL_WIDGET_VOL,
3767 "Mono Playback Volume",
3768 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3774 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3778 if (!spec->multiout.num_dacs) {
3779 err = stac92xx_auto_fill_dac_nids(codec);
3782 err = stac92xx_auto_create_multi_out_ctls(codec,
3788 /* setup analog beep controls */
3789 if (spec->anabeep_nid > 0) {
3790 err = stac92xx_auto_create_beep_ctls(codec,
3796 /* setup digital beep controls and input device */
3797 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3798 if (spec->digbeep_nid > 0) {
3799 hda_nid_t nid = spec->digbeep_nid;
3802 err = stac92xx_auto_create_beep_ctls(codec, nid);
3805 err = snd_hda_attach_beep_device(codec, nid);
3809 /* IDT/STAC codecs have linear beep tone parameter */
3810 codec->beep->linear_tone = spec->linear_tone_beep;
3811 /* if no beep switch is available, make its own one */
3812 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3813 if (!(caps & AC_AMPCAP_MUTE)) {
3814 err = stac92xx_beep_switch_ctl(codec);
3822 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3826 /* All output parsing done, now restore the swapped hp pins */
3828 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3829 sizeof(spec->autocfg.hp_pins));
3830 spec->autocfg.hp_outs = spec->autocfg.line_outs;
3831 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3832 spec->autocfg.line_outs = 0;
3835 if (stac_check_auto_mic(codec)) {
3837 /* only one capture for auto-mic */
3840 spec->num_muxes = 1;
3843 for (i = 0; i < spec->num_caps; i++) {
3844 err = stac92xx_add_capvol_ctls(codec, spec->capvols[i],
3845 spec->capsws[i], i);
3850 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3854 if (spec->mono_nid > 0) {
3855 err = stac92xx_auto_create_mono_output_ctls(codec);
3859 if (spec->num_dmics > 0 && !spec->dinput_mux)
3860 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3861 &spec->autocfg)) < 0)
3863 if (spec->num_muxes > 0) {
3864 err = stac92xx_auto_create_mux_input_ctls(codec);
3868 if (spec->num_smuxes > 0) {
3869 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3874 err = stac92xx_add_input_source(spec);
3878 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3879 if (spec->multiout.max_channels > 2)
3880 spec->surr_switch = 1;
3882 if (spec->autocfg.dig_outs)
3883 spec->multiout.dig_out_nid = dig_out;
3884 if (dig_in && spec->autocfg.dig_in_pin)
3885 spec->dig_in_nid = dig_in;
3887 if (spec->kctls.list)
3888 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3890 spec->input_mux = &spec->private_imux;
3891 if (!spec->dinput_mux)
3892 spec->dinput_mux = &spec->private_dimux;
3893 spec->sinput_mux = &spec->private_smux;
3894 spec->mono_mux = &spec->private_mono_mux;
3898 /* add playback controls for HP output */
3899 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3900 struct auto_pin_cfg *cfg)
3902 struct sigmatel_spec *spec = codec->spec;
3903 hda_nid_t pin = cfg->hp_pins[0];
3904 unsigned int wid_caps;
3909 wid_caps = get_wcaps(codec, pin);
3910 if (wid_caps & AC_WCAP_UNSOL_CAP)
3911 spec->hp_detect = 1;
3916 /* add playback controls for LFE output */
3917 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3918 struct auto_pin_cfg *cfg)
3920 struct sigmatel_spec *spec = codec->spec;
3922 hda_nid_t lfe_pin = 0x0;
3926 * search speaker outs and line outs for a mono speaker pin
3927 * with an amp. If one is found, add LFE controls
3930 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3931 hda_nid_t pin = spec->autocfg.speaker_pins[i];
3932 unsigned int wcaps = get_wcaps(codec, pin);
3933 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3934 if (wcaps == AC_WCAP_OUT_AMP)
3935 /* found a mono speaker with an amp, must be lfe */
3939 /* if speaker_outs is 0, then speakers may be in line_outs */
3940 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3941 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3942 hda_nid_t pin = spec->autocfg.line_out_pins[i];
3943 unsigned int defcfg;
3944 defcfg = snd_hda_codec_get_pincfg(codec, pin);
3945 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3946 unsigned int wcaps = get_wcaps(codec, pin);
3947 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3948 if (wcaps == AC_WCAP_OUT_AMP)
3949 /* found a mono speaker with an amp,
3957 err = create_controls(codec, "LFE", lfe_pin, 1);
3965 static int stac9200_parse_auto_config(struct hda_codec *codec)
3967 struct sigmatel_spec *spec = codec->spec;
3970 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3973 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3976 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
3979 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
3982 if (spec->num_muxes > 0) {
3983 err = stac92xx_auto_create_mux_input_ctls(codec);
3988 err = stac92xx_add_input_source(spec);
3992 if (spec->autocfg.dig_outs)
3993 spec->multiout.dig_out_nid = 0x05;
3994 if (spec->autocfg.dig_in_pin)
3995 spec->dig_in_nid = 0x04;
3997 if (spec->kctls.list)
3998 spec->mixers[spec->num_mixers++] = spec->kctls.list;
4000 spec->input_mux = &spec->private_imux;
4001 spec->dinput_mux = &spec->private_dimux;
4007 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
4008 * funky external mute control using GPIO pins.
4011 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
4012 unsigned int dir_mask, unsigned int data)
4014 unsigned int gpiostate, gpiomask, gpiodir;
4016 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4017 AC_VERB_GET_GPIO_DATA, 0);
4018 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
4020 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4021 AC_VERB_GET_GPIO_MASK, 0);
4024 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4025 AC_VERB_GET_GPIO_DIRECTION, 0);
4026 gpiodir |= dir_mask;
4028 /* Configure GPIOx as CMOS */
4029 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
4031 snd_hda_codec_write(codec, codec->afg, 0,
4032 AC_VERB_SET_GPIO_MASK, gpiomask);
4033 snd_hda_codec_read(codec, codec->afg, 0,
4034 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
4038 snd_hda_codec_read(codec, codec->afg, 0,
4039 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
4042 #ifdef CONFIG_SND_HDA_INPUT_JACK
4043 static void stac92xx_free_jack_priv(struct snd_jack *jack)
4045 struct sigmatel_jack *jacks = jack->private_data;
4051 static int stac92xx_add_jack(struct hda_codec *codec,
4052 hda_nid_t nid, int type)
4054 #ifdef CONFIG_SND_HDA_INPUT_JACK
4055 struct sigmatel_spec *spec = codec->spec;
4056 struct sigmatel_jack *jack;
4057 int def_conf = snd_hda_codec_get_pincfg(codec, nid);
4058 int connectivity = get_defcfg_connect(def_conf);
4062 if (connectivity && connectivity != AC_JACK_PORT_FIXED)
4065 snd_array_init(&spec->jacks, sizeof(*jack), 32);
4066 jack = snd_array_new(&spec->jacks);
4072 snprintf(name, sizeof(name), "%s at %s %s Jack",
4073 snd_hda_get_jack_type(def_conf),
4074 snd_hda_get_jack_connectivity(def_conf),
4075 snd_hda_get_jack_location(def_conf));
4077 err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
4082 jack->jack->private_data = jack;
4083 jack->jack->private_free = stac92xx_free_jack_priv;
4088 static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
4089 unsigned char type, int data)
4091 struct sigmatel_event *event;
4093 snd_array_init(&spec->events, sizeof(*event), 32);
4094 event = snd_array_new(&spec->events);
4099 event->tag = spec->events.used;
4105 static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
4108 struct sigmatel_spec *spec = codec->spec;
4109 struct sigmatel_event *event = spec->events.list;
4112 for (i = 0; i < spec->events.used; i++, event++) {
4113 if (event->nid == nid)
4119 static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
4122 struct sigmatel_spec *spec = codec->spec;
4123 struct sigmatel_event *event = spec->events.list;
4126 for (i = 0; i < spec->events.used; i++, event++) {
4127 if (event->tag == tag)
4133 /* check if given nid is a valid pin and no other events are assigned
4134 * to it. If OK, assign the event, set the unsol flag, and returns 1.
4135 * Otherwise, returns zero.
4137 static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
4140 struct sigmatel_event *event;
4143 if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
4145 event = stac_get_event(codec, nid);
4147 if (event->type != type)
4151 tag = stac_add_event(codec->spec, nid, type, 0);
4155 snd_hda_codec_write_cache(codec, nid, 0,
4156 AC_VERB_SET_UNSOLICITED_ENABLE,
4161 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
4164 for (i = 0; i < cfg->hp_outs; i++)
4165 if (cfg->hp_pins[i] == nid)
4166 return 1; /* nid is a HP-Out */
4168 return 0; /* nid is not a HP-Out */
4171 static void stac92xx_power_down(struct hda_codec *codec)
4173 struct sigmatel_spec *spec = codec->spec;
4175 /* power down inactive DACs */
4177 for (dac = spec->dac_list; *dac; dac++)
4178 if (!check_all_dac_nids(spec, *dac))
4179 snd_hda_codec_write(codec, *dac, 0,
4180 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4183 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4186 static inline int get_int_hint(struct hda_codec *codec, const char *key,
4190 p = snd_hda_get_hint(codec, key);
4193 if (!strict_strtoul(p, 0, &val)) {
4201 /* override some hints from the hwdep entry */
4202 static void stac_store_hints(struct hda_codec *codec)
4204 struct sigmatel_spec *spec = codec->spec;
4207 val = snd_hda_get_bool_hint(codec, "hp_detect");
4209 spec->hp_detect = val;
4210 if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) {
4211 spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
4214 if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir))
4215 spec->gpio_mask &= spec->gpio_mask;
4216 if (get_int_hint(codec, "gpio_data", &spec->gpio_data))
4217 spec->gpio_dir &= spec->gpio_mask;
4218 if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask))
4219 spec->eapd_mask &= spec->gpio_mask;
4220 if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute))
4221 spec->gpio_mute &= spec->gpio_mask;
4222 val = snd_hda_get_bool_hint(codec, "eapd_switch");
4224 spec->eapd_switch = val;
4225 get_int_hint(codec, "gpio_led_polarity", &spec->gpio_led_polarity);
4226 if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) {
4227 spec->gpio_mask |= spec->gpio_led;
4228 spec->gpio_dir |= spec->gpio_led;
4229 if (spec->gpio_led_polarity)
4230 spec->gpio_data |= spec->gpio_led;
4234 static int stac92xx_init(struct hda_codec *codec)
4236 struct sigmatel_spec *spec = codec->spec;
4237 struct auto_pin_cfg *cfg = &spec->autocfg;
4241 snd_hda_sequence_write(codec, spec->init);
4243 /* power down adcs initially */
4244 if (spec->powerdown_adcs)
4245 for (i = 0; i < spec->num_adcs; i++)
4246 snd_hda_codec_write(codec,
4247 spec->adc_nids[i], 0,
4248 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4250 /* override some hints */
4251 stac_store_hints(codec);
4254 gpio = spec->gpio_data;
4255 /* turn on EAPD statically when spec->eapd_switch isn't set.
4256 * otherwise, unsol event will turn it on/off dynamically
4258 if (!spec->eapd_switch)
4259 gpio |= spec->eapd_mask;
4260 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
4263 if (spec->hp_detect) {
4264 /* Enable unsolicited responses on the HP widget */
4265 for (i = 0; i < cfg->hp_outs; i++) {
4266 hda_nid_t nid = cfg->hp_pins[i];
4267 enable_pin_detect(codec, nid, STAC_HP_EVENT);
4269 if (cfg->line_out_type == AUTO_PIN_LINE_OUT &&
4270 cfg->speaker_outs > 0) {
4271 /* enable pin-detect for line-outs as well */
4272 for (i = 0; i < cfg->line_outs; i++) {
4273 hda_nid_t nid = cfg->line_out_pins[i];
4274 enable_pin_detect(codec, nid, STAC_LO_EVENT);
4278 /* force to enable the first line-out; the others are set up
4281 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
4283 /* fake event to set up pins */
4284 if (cfg->hp_pins[0])
4285 stac_issue_unsol_event(codec, cfg->hp_pins[0]);
4286 else if (cfg->line_out_pins[0])
4287 stac_issue_unsol_event(codec, cfg->line_out_pins[0]);
4289 stac92xx_auto_init_multi_out(codec);
4290 stac92xx_auto_init_hp_out(codec);
4291 for (i = 0; i < cfg->hp_outs; i++)
4292 stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
4294 if (spec->auto_mic) {
4295 /* initialize connection to analog input */
4296 if (spec->dmux_nids)
4297 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4298 AC_VERB_SET_CONNECT_SEL, 0);
4299 if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT))
4300 stac_issue_unsol_event(codec, spec->ext_mic.pin);
4301 if (enable_pin_detect(codec, spec->dock_mic.pin,
4303 stac_issue_unsol_event(codec, spec->dock_mic.pin);
4305 for (i = 0; i < cfg->num_inputs; i++) {
4306 hda_nid_t nid = cfg->inputs[i].pin;
4307 int type = cfg->inputs[i].type;
4308 unsigned int pinctl, conf;
4309 if (type == AUTO_PIN_MIC) {
4310 /* for mic pins, force to initialize */
4311 pinctl = stac92xx_get_default_vref(codec, nid);
4312 pinctl |= AC_PINCTL_IN_EN;
4313 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4315 pinctl = snd_hda_codec_read(codec, nid, 0,
4316 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4317 /* if PINCTL already set then skip */
4318 /* Also, if both INPUT and OUTPUT are set,
4319 * it must be a BIOS bug; need to override, too
4321 if (!(pinctl & AC_PINCTL_IN_EN) ||
4322 (pinctl & AC_PINCTL_OUT_EN)) {
4323 pinctl &= ~AC_PINCTL_OUT_EN;
4324 pinctl |= AC_PINCTL_IN_EN;
4325 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4328 conf = snd_hda_codec_get_pincfg(codec, nid);
4329 if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
4330 if (enable_pin_detect(codec, nid, STAC_INSERT_EVENT))
4331 stac_issue_unsol_event(codec, nid);
4334 for (i = 0; i < spec->num_dmics; i++)
4335 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4337 if (cfg->dig_out_pins[0])
4338 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0],
4340 if (cfg->dig_in_pin)
4341 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4343 for (i = 0; i < spec->num_pwrs; i++) {
4344 hda_nid_t nid = spec->pwr_nids[i];
4345 int pinctl, def_conf;
4347 /* power on when no jack detection is available */
4348 if (!spec->hp_detect) {
4349 stac_toggle_power_map(codec, nid, 1);
4353 if (is_nid_hp_pin(cfg, nid))
4354 continue; /* already has an unsol event */
4356 pinctl = snd_hda_codec_read(codec, nid, 0,
4357 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4358 /* outputs are only ports capable of power management
4359 * any attempts on powering down a input port cause the
4360 * referenced VREF to act quirky.
4362 if (pinctl & AC_PINCTL_IN_EN) {
4363 stac_toggle_power_map(codec, nid, 1);
4366 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4367 def_conf = get_defcfg_connect(def_conf);
4368 /* skip any ports that don't have jacks since presence
4369 * detection is useless */
4370 if (def_conf != AC_JACK_PORT_COMPLEX) {
4371 if (def_conf != AC_JACK_PORT_NONE)
4372 stac_toggle_power_map(codec, nid, 1);
4375 if (enable_pin_detect(codec, nid, STAC_PWR_EVENT))
4376 stac_issue_unsol_event(codec, nid);
4381 hda_call_check_power_status(codec, 0x01);
4383 stac92xx_power_down(codec);
4387 static void stac92xx_free_jacks(struct hda_codec *codec)
4389 #ifdef CONFIG_SND_HDA_INPUT_JACK
4390 /* free jack instances manually when clearing/reconfiguring */
4391 struct sigmatel_spec *spec = codec->spec;
4392 if (!codec->bus->shutdown && spec->jacks.list) {
4393 struct sigmatel_jack *jacks = spec->jacks.list;
4395 for (i = 0; i < spec->jacks.used; i++, jacks++) {
4397 snd_device_free(codec->bus->card, jacks->jack);
4400 snd_array_free(&spec->jacks);
4404 static void stac92xx_free_kctls(struct hda_codec *codec)
4406 struct sigmatel_spec *spec = codec->spec;
4408 if (spec->kctls.list) {
4409 struct snd_kcontrol_new *kctl = spec->kctls.list;
4411 for (i = 0; i < spec->kctls.used; i++)
4412 kfree(kctl[i].name);
4414 snd_array_free(&spec->kctls);
4417 static void stac92xx_shutup(struct hda_codec *codec)
4419 struct sigmatel_spec *spec = codec->spec;
4421 snd_hda_shutup_pins(codec);
4423 if (spec->eapd_mask)
4424 stac_gpio_set(codec, spec->gpio_mask,
4425 spec->gpio_dir, spec->gpio_data &
4429 static void stac92xx_free(struct hda_codec *codec)
4431 struct sigmatel_spec *spec = codec->spec;
4436 stac92xx_shutup(codec);
4437 stac92xx_free_jacks(codec);
4438 snd_array_free(&spec->events);
4441 snd_hda_detach_beep_device(codec);
4444 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4447 unsigned int old_ctl, pin_ctl;
4449 pin_ctl = snd_hda_codec_read(codec, nid,
4450 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4452 if (pin_ctl & AC_PINCTL_IN_EN) {
4454 * we need to check the current set-up direction of
4455 * shared input pins since they can be switched via
4456 * "xxx as Output" mixer switch
4458 struct sigmatel_spec *spec = codec->spec;
4459 if (nid == spec->line_switch || nid == spec->mic_switch)
4464 /* if setting pin direction bits, clear the current
4465 direction bits first */
4466 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4467 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4470 if (old_ctl != pin_ctl)
4471 snd_hda_codec_write_cache(codec, nid, 0,
4472 AC_VERB_SET_PIN_WIDGET_CONTROL,
4476 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4479 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4480 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4482 snd_hda_codec_write_cache(codec, nid, 0,
4483 AC_VERB_SET_PIN_WIDGET_CONTROL,
4487 static inline int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4491 return snd_hda_jack_detect(codec, nid);
4494 static void stac92xx_line_out_detect(struct hda_codec *codec,
4497 struct sigmatel_spec *spec = codec->spec;
4498 struct auto_pin_cfg *cfg = &spec->autocfg;
4501 for (i = 0; i < cfg->line_outs; i++) {
4504 presence = get_pin_presence(codec, cfg->line_out_pins[i]);
4506 unsigned int pinctl;
4507 pinctl = snd_hda_codec_read(codec,
4508 cfg->line_out_pins[i], 0,
4509 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4510 if (pinctl & AC_PINCTL_IN_EN)
4511 presence = 0; /* mic- or line-input */
4516 /* disable speakers */
4517 for (i = 0; i < cfg->speaker_outs; i++)
4518 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4520 if (spec->eapd_mask && spec->eapd_switch)
4521 stac_gpio_set(codec, spec->gpio_mask,
4522 spec->gpio_dir, spec->gpio_data &
4525 /* enable speakers */
4526 for (i = 0; i < cfg->speaker_outs; i++)
4527 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4529 if (spec->eapd_mask && spec->eapd_switch)
4530 stac_gpio_set(codec, spec->gpio_mask,
4531 spec->gpio_dir, spec->gpio_data |
4536 /* return non-zero if the hp-pin of the given array index isn't
4537 * a jack-detection target
4539 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4541 struct auto_pin_cfg *cfg = &spec->autocfg;
4543 /* ignore sensing of shared line and mic jacks */
4544 if (cfg->hp_pins[i] == spec->line_switch)
4546 if (cfg->hp_pins[i] == spec->mic_switch)
4548 /* ignore if the pin is set as line-out */
4549 if (cfg->hp_pins[i] == spec->hp_switch)
4554 static void stac92xx_hp_detect(struct hda_codec *codec)
4556 struct sigmatel_spec *spec = codec->spec;
4557 struct auto_pin_cfg *cfg = &spec->autocfg;
4561 if (spec->gpio_mute)
4562 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4563 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4565 for (i = 0; i < cfg->hp_outs; i++) {
4568 if (no_hp_sensing(spec, i))
4570 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4572 unsigned int pinctl;
4573 pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4574 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4575 if (pinctl & AC_PINCTL_IN_EN)
4576 presence = 0; /* mic- or line-input */
4581 /* disable lineouts */
4582 if (spec->hp_switch)
4583 stac92xx_reset_pinctl(codec, spec->hp_switch,
4585 for (i = 0; i < cfg->line_outs; i++)
4586 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4589 /* enable lineouts */
4590 if (spec->hp_switch)
4591 stac92xx_set_pinctl(codec, spec->hp_switch,
4593 for (i = 0; i < cfg->line_outs; i++)
4594 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4597 stac92xx_line_out_detect(codec, presence);
4598 /* toggle hp outs */
4599 for (i = 0; i < cfg->hp_outs; i++) {
4600 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4601 if (no_hp_sensing(spec, i))
4604 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4606 /* Resetting the pinctl like below may lead to (a sort of) regressions
4607 * on some devices since they use the HP pin actually for line/speaker
4608 * outs although the default pin config shows a different pin (that is
4609 * wrong and useless).
4611 * So, it's basically a problem of default pin configs, likely a BIOS issue.
4612 * But, disabling the code below just works around it, and I'm too tired of
4613 * bug reports with such devices...
4616 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4621 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4624 struct sigmatel_spec *spec = codec->spec;
4625 unsigned int idx, val;
4627 for (idx = 0; idx < spec->num_pwrs; idx++) {
4628 if (spec->pwr_nids[idx] == nid)
4631 if (idx >= spec->num_pwrs)
4634 /* several codecs have two power down bits */
4635 if (spec->pwr_mapping)
4636 idx = spec->pwr_mapping[idx];
4640 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
4646 /* power down unused output ports */
4647 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4650 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4652 stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4655 static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
4657 struct sigmatel_spec *spec = codec->spec;
4658 struct sigmatel_jack *jacks = spec->jacks.list;
4662 for (i = 0; i < spec->jacks.used; i++) {
4663 if (jacks->nid == nid) {
4664 unsigned int pin_ctl =
4665 snd_hda_codec_read(codec, nid,
4666 0, AC_VERB_GET_PIN_WIDGET_CONTROL,
4668 int type = jacks->type;
4669 if (type == (SND_JACK_LINEOUT
4670 | SND_JACK_HEADPHONE))
4671 type = (pin_ctl & AC_PINCTL_HP_EN)
4672 ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
4673 snd_jack_report(jacks->jack,
4674 get_pin_presence(codec, nid)
4682 /* get the pin connection (fixed, none, etc) */
4683 static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
4685 struct sigmatel_spec *spec = codec->spec;
4688 cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]);
4689 return get_defcfg_connect(cfg);
4692 static int stac92xx_connected_ports(struct hda_codec *codec,
4693 hda_nid_t *nids, int num_nids)
4695 struct sigmatel_spec *spec = codec->spec;
4697 unsigned int def_conf;
4699 for (num = 0; num < num_nids; num++) {
4700 for (idx = 0; idx < spec->num_pins; idx++)
4701 if (spec->pin_nids[idx] == nids[num])
4703 if (idx >= spec->num_pins)
4705 def_conf = stac_get_defcfg_connect(codec, idx);
4706 if (def_conf == AC_JACK_PORT_NONE)
4712 static void stac92xx_mic_detect(struct hda_codec *codec)
4714 struct sigmatel_spec *spec = codec->spec;
4715 struct sigmatel_mic_route *mic;
4717 if (get_pin_presence(codec, spec->ext_mic.pin))
4718 mic = &spec->ext_mic;
4719 else if (get_pin_presence(codec, spec->dock_mic.pin))
4720 mic = &spec->dock_mic;
4722 mic = &spec->int_mic;
4723 if (mic->dmux_idx >= 0)
4724 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4725 AC_VERB_SET_CONNECT_SEL,
4727 if (mic->mux_idx >= 0)
4728 snd_hda_codec_write_cache(codec, spec->mux_nids[0], 0,
4729 AC_VERB_SET_CONNECT_SEL,
4733 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid)
4735 struct sigmatel_event *event = stac_get_event(codec, nid);
4738 codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
4741 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4743 struct sigmatel_spec *spec = codec->spec;
4744 struct sigmatel_event *event;
4747 tag = (res >> 26) & 0x7f;
4748 event = stac_get_event_from_tag(codec, tag);
4752 switch (event->type) {
4755 stac92xx_hp_detect(codec);
4757 case STAC_MIC_EVENT:
4758 stac92xx_mic_detect(codec);
4762 switch (event->type) {
4765 case STAC_MIC_EVENT:
4766 case STAC_INSERT_EVENT:
4767 case STAC_PWR_EVENT:
4768 if (spec->num_pwrs > 0)
4769 stac92xx_pin_sense(codec, event->nid);
4770 stac92xx_report_jack(codec, event->nid);
4772 switch (codec->subsystem_id) {
4774 if (event->nid == 0xb) {
4775 int pin = AC_PINCTL_IN_EN;
4777 if (get_pin_presence(codec, 0xa)
4778 && get_pin_presence(codec, 0xb))
4779 pin |= AC_PINCTL_VREF_80;
4780 if (!get_pin_presence(codec, 0xb))
4781 pin |= AC_PINCTL_VREF_80;
4783 /* toggle VREF state based on mic + hp pin
4786 stac92xx_auto_set_pinctl(codec, 0x0a, pin);
4790 case STAC_VREF_EVENT:
4791 data = snd_hda_codec_read(codec, codec->afg, 0,
4792 AC_VERB_GET_GPIO_DATA, 0);
4793 /* toggle VREF state based on GPIOx status */
4794 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4795 !!(data & (1 << event->data)));
4800 static int hp_blike_system(u32 subsystem_id);
4802 static void set_hp_led_gpio(struct hda_codec *codec)
4804 struct sigmatel_spec *spec = codec->spec;
4810 gpio = snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP);
4811 gpio &= AC_GPIO_IO_COUNT;
4813 spec->gpio_led = 0x08; /* GPIO 3 */
4815 spec->gpio_led = 0x01; /* GPIO 0 */
4819 * This method searches for the mute LED GPIO configuration
4820 * provided as OEM string in SMBIOS. The format of that string
4821 * is HP_Mute_LED_P_G or HP_Mute_LED_P
4822 * where P can be 0 or 1 and defines mute LED GPIO control state (low/high)
4823 * that corresponds to the NOT muted state of the master volume
4824 * and G is the index of the GPIO to use as the mute LED control (0..9)
4825 * If _G portion is missing it is assigned based on the codec ID
4827 * So, HP B-series like systems may have HP_Mute_LED_0 (current models)
4828 * or HP_Mute_LED_0_3 (future models) OEM SMBIOS strings
4831 * The dv-series laptops don't seem to have the HP_Mute_LED* strings in
4832 * SMBIOS - at least the ones I have seen do not have them - which include
4833 * my own system (HP Pavilion dv6-1110ax) and my cousin's
4834 * HP Pavilion dv9500t CTO.
4835 * Need more information on whether it is true across the entire series.
4838 static int find_mute_led_gpio(struct hda_codec *codec, int default_polarity)
4840 struct sigmatel_spec *spec = codec->spec;
4841 const struct dmi_device *dev = NULL;
4843 if ((codec->subsystem_id >> 16) == PCI_VENDOR_ID_HP) {
4844 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING,
4846 if (sscanf(dev->name, "HP_Mute_LED_%d_%d",
4847 &spec->gpio_led_polarity,
4848 &spec->gpio_led) == 2) {
4849 spec->gpio_led = 1 << spec->gpio_led;
4852 if (sscanf(dev->name, "HP_Mute_LED_%d",
4853 &spec->gpio_led_polarity) == 1) {
4854 set_hp_led_gpio(codec);
4860 * Fallback case - if we don't find the DMI strings,
4861 * we statically set the GPIO - if not a B-series system.
4863 if (!hp_blike_system(codec->subsystem_id)) {
4864 set_hp_led_gpio(codec);
4865 spec->gpio_led_polarity = default_polarity;
4872 static int hp_blike_system(u32 subsystem_id)
4874 switch (subsystem_id) {
4901 #ifdef CONFIG_PROC_FS
4902 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4903 struct hda_codec *codec, hda_nid_t nid)
4905 if (nid == codec->afg)
4906 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4907 snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
4910 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4911 struct hda_codec *codec,
4914 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4915 snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
4918 /* stac92hd71bxx, stac92hd73xx */
4919 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4920 struct hda_codec *codec, hda_nid_t nid)
4922 stac92hd_proc_hook(buffer, codec, nid);
4923 if (nid == codec->afg)
4924 analog_loop_proc_hook(buffer, codec, 0xfa0);
4927 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4928 struct hda_codec *codec, hda_nid_t nid)
4930 if (nid == codec->afg)
4931 analog_loop_proc_hook(buffer, codec, 0xfe0);
4934 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4935 struct hda_codec *codec, hda_nid_t nid)
4937 if (nid == codec->afg)
4938 analog_loop_proc_hook(buffer, codec, 0xfeb);
4941 #define stac92hd_proc_hook NULL
4942 #define stac92hd7x_proc_hook NULL
4943 #define stac9205_proc_hook NULL
4944 #define stac927x_proc_hook NULL
4947 #ifdef SND_HDA_NEEDS_RESUME
4948 static int stac92xx_resume(struct hda_codec *codec)
4950 struct sigmatel_spec *spec = codec->spec;
4952 stac92xx_init(codec);
4953 snd_hda_codec_resume_amp(codec);
4954 snd_hda_codec_resume_cache(codec);
4955 /* fake event to set up pins again to override cached values */
4956 if (spec->hp_detect) {
4957 if (spec->autocfg.hp_pins[0])
4958 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0]);
4959 else if (spec->autocfg.line_out_pins[0])
4960 stac_issue_unsol_event(codec,
4961 spec->autocfg.line_out_pins[0]);
4965 hda_call_check_power_status(codec, 0x01);
4970 * using power check for controlling mute led of HP notebooks
4971 * check for mute state only on Speakers (nid = 0x10)
4973 * For this feature CONFIG_SND_HDA_POWER_SAVE is needed, otherwise
4974 * the LED is NOT working properly !
4976 * Changed name to reflect that it now works for any designated
4977 * model, not just HP HDX.
4980 #ifdef CONFIG_SND_HDA_POWER_SAVE
4981 static int stac92xx_hp_check_power_status(struct hda_codec *codec,
4984 struct sigmatel_spec *spec = codec->spec;
4987 for (i = 0; i < spec->multiout.num_dacs; i++) {
4988 nid = spec->multiout.dac_nids[i];
4989 if (!(snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
4991 muted = 0; /* something heard */
4996 spec->gpio_data &= ~spec->gpio_led; /* orange */
4998 spec->gpio_data |= spec->gpio_led; /* white */
5000 if (!spec->gpio_led_polarity) {
5001 /* LED state is inverted on these systems */
5002 spec->gpio_data ^= spec->gpio_led;
5005 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
5010 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
5012 stac92xx_shutup(codec);
5017 static struct hda_codec_ops stac92xx_patch_ops = {
5018 .build_controls = stac92xx_build_controls,
5019 .build_pcms = stac92xx_build_pcms,
5020 .init = stac92xx_init,
5021 .free = stac92xx_free,
5022 .unsol_event = stac92xx_unsol_event,
5023 #ifdef SND_HDA_NEEDS_RESUME
5024 .suspend = stac92xx_suspend,
5025 .resume = stac92xx_resume,
5027 .reboot_notify = stac92xx_shutup,
5030 static int patch_stac9200(struct hda_codec *codec)
5032 struct sigmatel_spec *spec;
5035 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5039 codec->no_trigger_sense = 1;
5041 spec->linear_tone_beep = 1;
5042 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
5043 spec->pin_nids = stac9200_pin_nids;
5044 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
5047 if (spec->board_config < 0)
5048 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5051 stac92xx_set_config_regs(codec,
5052 stac9200_brd_tbl[spec->board_config]);
5054 spec->multiout.max_channels = 2;
5055 spec->multiout.num_dacs = 1;
5056 spec->multiout.dac_nids = stac9200_dac_nids;
5057 spec->adc_nids = stac9200_adc_nids;
5058 spec->mux_nids = stac9200_mux_nids;
5059 spec->num_muxes = 1;
5060 spec->num_dmics = 0;
5064 if (spec->board_config == STAC_9200_M4 ||
5065 spec->board_config == STAC_9200_M4_2 ||
5066 spec->board_config == STAC_9200_OQO)
5067 spec->init = stac9200_eapd_init;
5069 spec->init = stac9200_core_init;
5070 spec->mixer = stac9200_mixer;
5072 if (spec->board_config == STAC_9200_PANASONIC) {
5073 spec->gpio_mask = spec->gpio_dir = 0x09;
5074 spec->gpio_data = 0x00;
5077 err = stac9200_parse_auto_config(codec);
5079 stac92xx_free(codec);
5083 /* CF-74 has no headphone detection, and the driver should *NOT*
5084 * do detection and HP/speaker toggle because the hardware does it.
5086 if (spec->board_config == STAC_9200_PANASONIC)
5087 spec->hp_detect = 0;
5089 codec->patch_ops = stac92xx_patch_ops;
5094 static int patch_stac925x(struct hda_codec *codec)
5096 struct sigmatel_spec *spec;
5099 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5103 codec->no_trigger_sense = 1;
5105 spec->linear_tone_beep = 1;
5106 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
5107 spec->pin_nids = stac925x_pin_nids;
5109 /* Check first for codec ID */
5110 spec->board_config = snd_hda_check_board_codec_sid_config(codec,
5113 stac925x_codec_id_cfg_tbl);
5115 /* Now checks for PCI ID, if codec ID is not found */
5116 if (spec->board_config < 0)
5117 spec->board_config = snd_hda_check_board_config(codec,
5122 if (spec->board_config < 0)
5123 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5126 stac92xx_set_config_regs(codec,
5127 stac925x_brd_tbl[spec->board_config]);
5129 spec->multiout.max_channels = 2;
5130 spec->multiout.num_dacs = 1;
5131 spec->multiout.dac_nids = stac925x_dac_nids;
5132 spec->adc_nids = stac925x_adc_nids;
5133 spec->mux_nids = stac925x_mux_nids;
5134 spec->num_muxes = 1;
5137 switch (codec->vendor_id) {
5138 case 0x83847632: /* STAC9202 */
5139 case 0x83847633: /* STAC9202D */
5140 case 0x83847636: /* STAC9251 */
5141 case 0x83847637: /* STAC9251D */
5142 spec->num_dmics = STAC925X_NUM_DMICS;
5143 spec->dmic_nids = stac925x_dmic_nids;
5144 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
5145 spec->dmux_nids = stac925x_dmux_nids;
5148 spec->num_dmics = 0;
5152 spec->init = stac925x_core_init;
5153 spec->mixer = stac925x_mixer;
5155 spec->capvols = stac925x_capvols;
5156 spec->capsws = stac925x_capsws;
5158 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
5160 if (spec->board_config < 0) {
5161 printk(KERN_WARNING "hda_codec: No auto-config is "
5162 "available, default to model=ref\n");
5163 spec->board_config = STAC_925x_REF;
5169 stac92xx_free(codec);
5173 codec->patch_ops = stac92xx_patch_ops;
5178 static int patch_stac92hd73xx(struct hda_codec *codec)
5180 struct sigmatel_spec *spec;
5181 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
5185 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5189 codec->no_trigger_sense = 1;
5191 spec->linear_tone_beep = 0;
5192 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
5193 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
5194 spec->pin_nids = stac92hd73xx_pin_nids;
5195 spec->board_config = snd_hda_check_board_config(codec,
5196 STAC_92HD73XX_MODELS,
5197 stac92hd73xx_models,
5198 stac92hd73xx_cfg_tbl);
5199 /* check codec subsystem id if not found */
5200 if (spec->board_config < 0)
5201 spec->board_config =
5202 snd_hda_check_board_codec_sid_config(codec,
5203 STAC_92HD73XX_MODELS, stac92hd73xx_models,
5204 stac92hd73xx_codec_id_cfg_tbl);
5206 if (spec->board_config < 0)
5207 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5210 stac92xx_set_config_regs(codec,
5211 stac92hd73xx_brd_tbl[spec->board_config]);
5213 num_dacs = snd_hda_get_connections(codec, 0x0a,
5214 conn, STAC92HD73_DAC_COUNT + 2) - 1;
5216 if (num_dacs < 3 || num_dacs > 5) {
5217 printk(KERN_WARNING "hda_codec: Could not determine "
5218 "number of channels defaulting to DAC count\n");
5219 num_dacs = STAC92HD73_DAC_COUNT;
5221 spec->init = stac92hd73xx_core_init;
5223 case 0x3: /* 6 Channel */
5224 spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
5226 case 0x4: /* 8 Channel */
5227 spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
5229 case 0x5: /* 10 Channel */
5230 spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
5233 spec->multiout.dac_nids = spec->dac_nids;
5235 spec->aloopback_mask = 0x01;
5236 spec->aloopback_shift = 8;
5238 spec->digbeep_nid = 0x1c;
5239 spec->mux_nids = stac92hd73xx_mux_nids;
5240 spec->adc_nids = stac92hd73xx_adc_nids;
5241 spec->dmic_nids = stac92hd73xx_dmic_nids;
5242 spec->dmux_nids = stac92hd73xx_dmux_nids;
5243 spec->smux_nids = stac92hd73xx_smux_nids;
5245 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
5246 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
5247 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
5249 spec->num_caps = STAC92HD73XX_NUM_CAPS;
5250 spec->capvols = stac92hd73xx_capvols;
5251 spec->capsws = stac92hd73xx_capsws;
5253 switch (spec->board_config) {
5255 spec->init = dell_eq_core_init;
5257 case STAC_DELL_M6_AMIC:
5258 case STAC_DELL_M6_DMIC:
5259 case STAC_DELL_M6_BOTH:
5260 spec->num_smuxes = 0;
5261 spec->eapd_switch = 0;
5263 switch (spec->board_config) {
5264 case STAC_DELL_M6_AMIC: /* Analog Mics */
5265 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5266 spec->num_dmics = 0;
5268 case STAC_DELL_M6_DMIC: /* Digital Mics */
5269 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5270 spec->num_dmics = 1;
5272 case STAC_DELL_M6_BOTH: /* Both */
5273 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5274 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5275 spec->num_dmics = 1;
5279 case STAC_ALIENWARE_M17X:
5280 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
5281 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
5282 spec->eapd_switch = 0;
5285 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
5286 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
5287 spec->eapd_switch = 1;
5290 if (spec->board_config != STAC_92HD73XX_REF) {
5291 /* GPIO0 High = Enable EAPD */
5292 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5293 spec->gpio_data = 0x01;
5296 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
5297 spec->pwr_nids = stac92hd73xx_pwr_nids;
5299 err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
5302 if (spec->board_config < 0) {
5303 printk(KERN_WARNING "hda_codec: No auto-config is "
5304 "available, default to model=ref\n");
5305 spec->board_config = STAC_92HD73XX_REF;
5312 stac92xx_free(codec);
5316 if (spec->board_config == STAC_92HD73XX_NO_JD)
5317 spec->hp_detect = 0;
5319 codec->patch_ops = stac92xx_patch_ops;
5321 codec->proc_widget_hook = stac92hd7x_proc_hook;
5326 static int patch_stac92hd83xxx(struct hda_codec *codec)
5328 struct sigmatel_spec *spec;
5329 hda_nid_t conn[STAC92HD83_DAC_COUNT + 1];
5333 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5337 /* reset pin power-down; Windows may leave these bits after reboot */
5338 snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7EC, 0);
5339 snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7ED, 0);
5340 codec->no_trigger_sense = 1;
5342 spec->linear_tone_beep = 1;
5343 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
5344 spec->digbeep_nid = 0x21;
5345 spec->dmic_nids = stac92hd83xxx_dmic_nids;
5346 spec->dmux_nids = stac92hd83xxx_mux_nids;
5347 spec->mux_nids = stac92hd83xxx_mux_nids;
5348 spec->num_muxes = ARRAY_SIZE(stac92hd83xxx_mux_nids);
5349 spec->adc_nids = stac92hd83xxx_adc_nids;
5350 spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
5351 spec->pwr_nids = stac92hd83xxx_pwr_nids;
5352 spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
5353 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
5354 spec->multiout.dac_nids = spec->dac_nids;
5356 spec->init = stac92hd83xxx_core_init;
5357 spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
5358 spec->pin_nids = stac92hd83xxx_pin_nids;
5359 spec->num_caps = STAC92HD83XXX_NUM_CAPS;
5360 spec->capvols = stac92hd83xxx_capvols;
5361 spec->capsws = stac92hd83xxx_capsws;
5363 spec->board_config = snd_hda_check_board_config(codec,
5364 STAC_92HD83XXX_MODELS,
5365 stac92hd83xxx_models,
5366 stac92hd83xxx_cfg_tbl);
5368 if (spec->board_config < 0)
5369 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5372 stac92xx_set_config_regs(codec,
5373 stac92hd83xxx_brd_tbl[spec->board_config]);
5375 switch (codec->vendor_id) {
5382 spec->num_pins = ARRAY_SIZE(stac92hd88xxx_pin_nids);
5383 spec->pin_nids = stac92hd88xxx_pin_nids;
5385 spec->digbeep_nid = 0;
5393 if (spec->board_config == STAC_92HD83XXX_PWR_REF)
5396 spec->num_dmics = stac92xx_connected_ports(codec,
5397 stac92hd83xxx_dmic_nids,
5398 STAC92HD83XXX_NUM_DMICS);
5402 codec->patch_ops = stac92xx_patch_ops;
5404 if (find_mute_led_gpio(codec, 0))
5405 snd_printd("mute LED gpio %d polarity %d\n",
5407 spec->gpio_led_polarity);
5409 #ifdef CONFIG_SND_HDA_POWER_SAVE
5410 if (spec->gpio_led) {
5411 spec->gpio_mask |= spec->gpio_led;
5412 spec->gpio_dir |= spec->gpio_led;
5413 spec->gpio_data |= spec->gpio_led;
5414 /* register check_power_status callback. */
5415 codec->patch_ops.check_power_status =
5416 stac92xx_hp_check_power_status;
5420 err = stac92xx_parse_auto_config(codec, 0x1d, 0);
5422 if (spec->board_config < 0) {
5423 printk(KERN_WARNING "hda_codec: No auto-config is "
5424 "available, default to model=ref\n");
5425 spec->board_config = STAC_92HD83XXX_REF;
5432 stac92xx_free(codec);
5436 /* docking output support */
5437 num_dacs = snd_hda_get_connections(codec, 0xF,
5438 conn, STAC92HD83_DAC_COUNT + 1) - 1;
5439 /* skip non-DAC connections */
5440 while (num_dacs >= 0 &&
5441 (get_wcaps_type(get_wcaps(codec, conn[num_dacs]))
5444 /* set port E and F to select the last DAC */
5445 if (num_dacs >= 0) {
5446 snd_hda_codec_write_cache(codec, 0xE, 0,
5447 AC_VERB_SET_CONNECT_SEL, num_dacs);
5448 snd_hda_codec_write_cache(codec, 0xF, 0,
5449 AC_VERB_SET_CONNECT_SEL, num_dacs);
5452 codec->proc_widget_hook = stac92hd_proc_hook;
5457 static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
5460 struct sigmatel_spec *spec = codec->spec;
5463 for (idx = 0; idx < spec->num_pins; idx++)
5464 if (spec->pin_nids[idx] == dig0pin)
5466 if ((idx + 2) >= spec->num_pins)
5470 if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE)
5473 /* dig0pin + dig2pin case */
5474 if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE)
5476 if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE)
5482 /* HP dv7 bass switch - GPIO5 */
5483 #define stac_hp_bass_gpio_info snd_ctl_boolean_mono_info
5484 static int stac_hp_bass_gpio_get(struct snd_kcontrol *kcontrol,
5485 struct snd_ctl_elem_value *ucontrol)
5487 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5488 struct sigmatel_spec *spec = codec->spec;
5489 ucontrol->value.integer.value[0] = !!(spec->gpio_data & 0x20);
5493 static int stac_hp_bass_gpio_put(struct snd_kcontrol *kcontrol,
5494 struct snd_ctl_elem_value *ucontrol)
5496 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5497 struct sigmatel_spec *spec = codec->spec;
5498 unsigned int gpio_data;
5500 gpio_data = (spec->gpio_data & ~0x20) |
5501 (ucontrol->value.integer.value[0] ? 0x20 : 0);
5502 if (gpio_data == spec->gpio_data)
5504 spec->gpio_data = gpio_data;
5505 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
5509 static struct snd_kcontrol_new stac_hp_bass_sw_ctrl = {
5510 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5511 .info = stac_hp_bass_gpio_info,
5512 .get = stac_hp_bass_gpio_get,
5513 .put = stac_hp_bass_gpio_put,
5516 static int stac_add_hp_bass_switch(struct hda_codec *codec)
5518 struct sigmatel_spec *spec = codec->spec;
5520 if (!stac_control_new(spec, &stac_hp_bass_sw_ctrl,
5521 "Bass Speaker Playback Switch", 0))
5524 spec->gpio_mask |= 0x20;
5525 spec->gpio_dir |= 0x20;
5526 spec->gpio_data |= 0x20;
5530 static int patch_stac92hd71bxx(struct hda_codec *codec)
5532 struct sigmatel_spec *spec;
5533 struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
5534 unsigned int pin_cfg;
5537 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5541 codec->no_trigger_sense = 1;
5543 spec->linear_tone_beep = 0;
5544 codec->patch_ops = stac92xx_patch_ops;
5545 spec->num_pins = STAC92HD71BXX_NUM_PINS;
5546 switch (codec->vendor_id) {
5549 spec->pin_nids = stac92hd71bxx_pin_nids_4port;
5553 /* On 92HD75Bx 0x27 isn't a pin nid */
5557 spec->pin_nids = stac92hd71bxx_pin_nids_6port;
5559 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
5560 spec->board_config = snd_hda_check_board_config(codec,
5561 STAC_92HD71BXX_MODELS,
5562 stac92hd71bxx_models,
5563 stac92hd71bxx_cfg_tbl);
5565 if (spec->board_config < 0)
5566 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5569 stac92xx_set_config_regs(codec,
5570 stac92hd71bxx_brd_tbl[spec->board_config]);
5572 if (spec->board_config != STAC_92HD71BXX_REF) {
5574 spec->gpio_mask = 0x01;
5575 spec->gpio_dir = 0x01;
5576 spec->gpio_data = 0x01;
5579 spec->dmic_nids = stac92hd71bxx_dmic_nids;
5580 spec->dmux_nids = stac92hd71bxx_dmux_nids;
5582 spec->num_caps = STAC92HD71BXX_NUM_CAPS;
5583 spec->capvols = stac92hd71bxx_capvols;
5584 spec->capsws = stac92hd71bxx_capsws;
5586 switch (codec->vendor_id) {
5587 case 0x111d76b6: /* 4 Port without Analog Mixer */
5591 case 0x111d76b4: /* 6 Port without Analog Mixer */
5593 spec->init = stac92hd71bxx_core_init;
5594 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5595 spec->num_dmics = stac92xx_connected_ports(codec,
5596 stac92hd71bxx_dmic_nids,
5597 STAC92HD71BXX_NUM_DMICS);
5599 case 0x111d7608: /* 5 Port with Analog Mixer */
5600 switch (spec->board_config) {
5602 /* Enable VREF power saving on GPIO1 detect */
5603 err = stac_add_event(spec, codec->afg,
5604 STAC_VREF_EVENT, 0x02);
5607 snd_hda_codec_write_cache(codec, codec->afg, 0,
5608 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
5609 snd_hda_codec_write_cache(codec, codec->afg, 0,
5610 AC_VERB_SET_UNSOLICITED_ENABLE,
5612 spec->gpio_mask |= 0x02;
5615 if ((codec->revision_id & 0xf) == 0 ||
5616 (codec->revision_id & 0xf) == 1)
5617 spec->stream_delay = 40; /* 40 milliseconds */
5619 /* no output amps */
5622 spec->init = stac92hd71bxx_core_init;
5624 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
5625 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
5626 stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS - 1] = 0;
5627 spec->num_dmics = stac92xx_connected_ports(codec,
5628 stac92hd71bxx_dmic_nids,
5629 STAC92HD71BXX_NUM_DMICS - 1);
5631 case 0x111d7603: /* 6 Port with Analog Mixer */
5632 if ((codec->revision_id & 0xf) == 1)
5633 spec->stream_delay = 40; /* 40 milliseconds */
5635 /* no output amps */
5639 spec->init = stac92hd71bxx_core_init;
5640 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5641 spec->num_dmics = stac92xx_connected_ports(codec,
5642 stac92hd71bxx_dmic_nids,
5643 STAC92HD71BXX_NUM_DMICS);
5647 if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
5648 snd_hda_sequence_write_cache(codec, unmute_init);
5650 /* Some HP machines seem to have unstable codec communications
5651 * especially with ATI fglrx driver. For recovering from the
5652 * CORB/RIRB stall, allow the BUS reset and keep always sync
5654 if (spec->board_config == STAC_HP_DV5) {
5655 codec->bus->sync_write = 1;
5656 codec->bus->allow_bus_reset = 1;
5659 spec->aloopback_ctl = stac92hd71bxx_loopback;
5660 spec->aloopback_mask = 0x50;
5661 spec->aloopback_shift = 0;
5663 spec->powerdown_adcs = 1;
5664 spec->digbeep_nid = 0x26;
5665 spec->mux_nids = stac92hd71bxx_mux_nids;
5666 spec->adc_nids = stac92hd71bxx_adc_nids;
5667 spec->smux_nids = stac92hd71bxx_smux_nids;
5668 spec->pwr_nids = stac92hd71bxx_pwr_nids;
5670 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
5671 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
5672 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5673 spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
5675 snd_printdd("Found board config: %d\n", spec->board_config);
5677 switch (spec->board_config) {
5679 /* enable internal microphone */
5680 snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
5681 stac92xx_auto_set_pinctl(codec, 0x0e,
5682 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
5684 case STAC_DELL_M4_2:
5685 spec->num_dmics = 0;
5686 spec->num_smuxes = 0;
5687 spec->num_dmuxes = 0;
5689 case STAC_DELL_M4_1:
5690 case STAC_DELL_M4_3:
5691 spec->num_dmics = 1;
5692 spec->num_smuxes = 0;
5693 spec->num_dmuxes = 1;
5695 case STAC_HP_DV4_1222NR:
5696 spec->num_dmics = 1;
5697 /* I don't know if it needs 1 or 2 smuxes - will wait for
5698 * bug reports to fix if needed
5700 spec->num_smuxes = 1;
5701 spec->num_dmuxes = 1;
5704 spec->gpio_led = 0x01;
5707 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
5708 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
5709 /* HP dv6 gives the headphone pin as a line-out. Thus we
5710 * need to set hp_detect flag here to force to enable HP
5713 spec->hp_detect = 1;
5716 spec->num_dmics = 1;
5717 spec->num_dmuxes = 1;
5718 spec->num_smuxes = 1;
5719 spec->gpio_led = 0x08;
5723 if (hp_blike_system(codec->subsystem_id)) {
5724 pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f);
5725 if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT ||
5726 get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER ||
5727 get_defcfg_device(pin_cfg) == AC_JACK_HP_OUT) {
5728 /* It was changed in the BIOS to just satisfy MS DTM.
5729 * Lets turn it back into slaved HP
5731 pin_cfg = (pin_cfg & (~AC_DEFCFG_DEVICE))
5732 | (AC_JACK_HP_OUT <<
5733 AC_DEFCFG_DEVICE_SHIFT);
5734 pin_cfg = (pin_cfg & (~(AC_DEFCFG_DEF_ASSOC
5735 | AC_DEFCFG_SEQUENCE)))
5737 snd_hda_codec_set_pincfg(codec, 0x0f, pin_cfg);
5741 if (find_mute_led_gpio(codec, 1))
5742 snd_printd("mute LED gpio %d polarity %d\n",
5744 spec->gpio_led_polarity);
5746 #ifdef CONFIG_SND_HDA_POWER_SAVE
5747 if (spec->gpio_led) {
5748 spec->gpio_mask |= spec->gpio_led;
5749 spec->gpio_dir |= spec->gpio_led;
5750 spec->gpio_data |= spec->gpio_led;
5751 /* register check_power_status callback. */
5752 codec->patch_ops.check_power_status =
5753 stac92xx_hp_check_power_status;
5757 spec->multiout.dac_nids = spec->dac_nids;
5759 err = stac92xx_parse_auto_config(codec, 0x21, 0);
5761 if (spec->board_config < 0) {
5762 printk(KERN_WARNING "hda_codec: No auto-config is "
5763 "available, default to model=ref\n");
5764 spec->board_config = STAC_92HD71BXX_REF;
5771 stac92xx_free(codec);
5775 /* enable bass on HP dv7 */
5776 if (spec->board_config == STAC_HP_DV4 ||
5777 spec->board_config == STAC_HP_DV5) {
5779 cap = snd_hda_param_read(codec, 0x1, AC_PAR_GPIO_CAP);
5780 cap &= AC_GPIO_IO_COUNT;
5782 stac_add_hp_bass_switch(codec);
5785 codec->proc_widget_hook = stac92hd7x_proc_hook;
5790 static int patch_stac922x(struct hda_codec *codec)
5792 struct sigmatel_spec *spec;
5795 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5799 codec->no_trigger_sense = 1;
5801 spec->linear_tone_beep = 1;
5802 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
5803 spec->pin_nids = stac922x_pin_nids;
5804 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
5807 if (spec->board_config == STAC_INTEL_MAC_AUTO) {
5808 spec->gpio_mask = spec->gpio_dir = 0x03;
5809 spec->gpio_data = 0x03;
5810 /* Intel Macs have all same PCI SSID, so we need to check
5811 * codec SSID to distinguish the exact models
5813 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
5814 switch (codec->subsystem_id) {
5817 spec->board_config = STAC_INTEL_MAC_V1;
5821 spec->board_config = STAC_INTEL_MAC_V2;
5829 spec->board_config = STAC_INTEL_MAC_V3;
5833 spec->board_config = STAC_INTEL_MAC_V4;
5837 spec->board_config = STAC_INTEL_MAC_V5;
5840 spec->board_config = STAC_INTEL_MAC_V3;
5846 if (spec->board_config < 0)
5847 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5850 stac92xx_set_config_regs(codec,
5851 stac922x_brd_tbl[spec->board_config]);
5853 spec->adc_nids = stac922x_adc_nids;
5854 spec->mux_nids = stac922x_mux_nids;
5855 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
5856 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
5857 spec->num_dmics = 0;
5860 spec->init = stac922x_core_init;
5862 spec->num_caps = STAC922X_NUM_CAPS;
5863 spec->capvols = stac922x_capvols;
5864 spec->capsws = stac922x_capsws;
5866 spec->multiout.dac_nids = spec->dac_nids;
5868 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
5870 if (spec->board_config < 0) {
5871 printk(KERN_WARNING "hda_codec: No auto-config is "
5872 "available, default to model=ref\n");
5873 spec->board_config = STAC_D945_REF;
5879 stac92xx_free(codec);
5883 codec->patch_ops = stac92xx_patch_ops;
5885 /* Fix Mux capture level; max to 2 */
5886 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
5887 (0 << AC_AMPCAP_OFFSET_SHIFT) |
5888 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5889 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5890 (0 << AC_AMPCAP_MUTE_SHIFT));
5895 static int patch_stac927x(struct hda_codec *codec)
5897 struct sigmatel_spec *spec;
5900 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5904 codec->no_trigger_sense = 1;
5906 spec->linear_tone_beep = 1;
5907 codec->slave_dig_outs = stac927x_slave_dig_outs;
5908 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
5909 spec->pin_nids = stac927x_pin_nids;
5910 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
5914 if (spec->board_config < 0)
5915 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5918 stac92xx_set_config_regs(codec,
5919 stac927x_brd_tbl[spec->board_config]);
5921 spec->digbeep_nid = 0x23;
5922 spec->adc_nids = stac927x_adc_nids;
5923 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
5924 spec->mux_nids = stac927x_mux_nids;
5925 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
5926 spec->smux_nids = stac927x_smux_nids;
5927 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
5928 spec->spdif_labels = stac927x_spdif_labels;
5929 spec->dac_list = stac927x_dac_nids;
5930 spec->multiout.dac_nids = spec->dac_nids;
5932 if (spec->board_config != STAC_D965_REF) {
5933 /* GPIO0 High = Enable EAPD */
5934 spec->eapd_mask = spec->gpio_mask = 0x01;
5935 spec->gpio_dir = spec->gpio_data = 0x01;
5938 switch (spec->board_config) {
5941 /* GPIO0 High = Enable EAPD */
5942 spec->num_dmics = 0;
5943 spec->init = d965_core_init;
5945 case STAC_DELL_BIOS:
5946 switch (codec->subsystem_id) {
5949 /* correct the device field to SPDIF out */
5950 snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
5953 /* configure the analog microphone on some laptops */
5954 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
5955 /* correct the front output jack as a hp out */
5956 snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f);
5957 /* correct the front input jack as a mic */
5958 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
5961 if (codec->subsystem_id != 0x1028022f) {
5962 /* GPIO2 High = Enable EAPD */
5963 spec->eapd_mask = spec->gpio_mask = 0x04;
5964 spec->gpio_dir = spec->gpio_data = 0x04;
5966 spec->dmic_nids = stac927x_dmic_nids;
5967 spec->num_dmics = STAC927X_NUM_DMICS;
5969 spec->init = dell_3st_core_init;
5970 spec->dmux_nids = stac927x_dmux_nids;
5971 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
5973 case STAC_927X_VOLKNOB:
5974 spec->num_dmics = 0;
5975 spec->init = stac927x_volknob_core_init;
5978 spec->num_dmics = 0;
5979 spec->init = stac927x_core_init;
5983 spec->num_caps = STAC927X_NUM_CAPS;
5984 spec->capvols = stac927x_capvols;
5985 spec->capsws = stac927x_capsws;
5988 spec->aloopback_ctl = stac927x_loopback;
5989 spec->aloopback_mask = 0x40;
5990 spec->aloopback_shift = 0;
5991 spec->eapd_switch = 1;
5993 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
5995 if (spec->board_config < 0) {
5996 printk(KERN_WARNING "hda_codec: No auto-config is "
5997 "available, default to model=ref\n");
5998 spec->board_config = STAC_D965_REF;
6004 stac92xx_free(codec);
6008 codec->patch_ops = stac92xx_patch_ops;
6010 codec->proc_widget_hook = stac927x_proc_hook;
6014 * The STAC927x seem to require fairly long delays for certain
6015 * command sequences. With too short delays (even if the answer
6016 * is set to RIRB properly), it results in the silence output
6017 * on some hardwares like Dell.
6019 * The below flag enables the longer delay (see get_response
6022 codec->bus->needs_damn_long_delay = 1;
6024 /* no jack detecion for ref-no-jd model */
6025 if (spec->board_config == STAC_D965_REF_NO_JD)
6026 spec->hp_detect = 0;
6031 static int patch_stac9205(struct hda_codec *codec)
6033 struct sigmatel_spec *spec;
6036 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6040 codec->no_trigger_sense = 1;
6042 spec->linear_tone_beep = 1;
6043 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
6044 spec->pin_nids = stac9205_pin_nids;
6045 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
6049 if (spec->board_config < 0)
6050 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6053 stac92xx_set_config_regs(codec,
6054 stac9205_brd_tbl[spec->board_config]);
6056 spec->digbeep_nid = 0x23;
6057 spec->adc_nids = stac9205_adc_nids;
6058 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
6059 spec->mux_nids = stac9205_mux_nids;
6060 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
6061 spec->smux_nids = stac9205_smux_nids;
6062 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
6063 spec->dmic_nids = stac9205_dmic_nids;
6064 spec->num_dmics = STAC9205_NUM_DMICS;
6065 spec->dmux_nids = stac9205_dmux_nids;
6066 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
6069 spec->init = stac9205_core_init;
6070 spec->aloopback_ctl = stac9205_loopback;
6072 spec->num_caps = STAC9205_NUM_CAPS;
6073 spec->capvols = stac9205_capvols;
6074 spec->capsws = stac9205_capsws;
6076 spec->aloopback_mask = 0x40;
6077 spec->aloopback_shift = 0;
6078 /* Turn on/off EAPD per HP plugging */
6079 if (spec->board_config != STAC_9205_EAPD)
6080 spec->eapd_switch = 1;
6081 spec->multiout.dac_nids = spec->dac_nids;
6083 switch (spec->board_config){
6084 case STAC_9205_DELL_M43:
6085 /* Enable SPDIF in/out */
6086 snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030);
6087 snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030);
6089 /* Enable unsol response for GPIO4/Dock HP connection */
6090 err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
6093 snd_hda_codec_write_cache(codec, codec->afg, 0,
6094 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
6095 snd_hda_codec_write_cache(codec, codec->afg, 0,
6096 AC_VERB_SET_UNSOLICITED_ENABLE,
6099 spec->gpio_dir = 0x0b;
6100 spec->eapd_mask = 0x01;
6101 spec->gpio_mask = 0x1b;
6102 spec->gpio_mute = 0x10;
6103 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
6106 spec->gpio_data = 0x01;
6109 /* SPDIF-In enabled */
6112 /* GPIO0 High = EAPD */
6113 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
6114 spec->gpio_data = 0x01;
6118 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
6120 if (spec->board_config < 0) {
6121 printk(KERN_WARNING "hda_codec: No auto-config is "
6122 "available, default to model=ref\n");
6123 spec->board_config = STAC_9205_REF;
6129 stac92xx_free(codec);
6133 codec->patch_ops = stac92xx_patch_ops;
6135 codec->proc_widget_hook = stac9205_proc_hook;
6144 static struct hda_verb stac9872_core_init[] = {
6145 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
6146 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
6150 static hda_nid_t stac9872_pin_nids[] = {
6151 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
6155 static hda_nid_t stac9872_adc_nids[] = {
6159 static hda_nid_t stac9872_mux_nids[] = {
6163 static unsigned long stac9872_capvols[] = {
6164 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
6166 #define stac9872_capsws stac9872_capvols
6168 static unsigned int stac9872_vaio_pin_configs[9] = {
6169 0x03211020, 0x411111f0, 0x411111f0, 0x03a15030,
6170 0x411111f0, 0x90170110, 0x411111f0, 0x411111f0,
6174 static const char *stac9872_models[STAC_9872_MODELS] = {
6175 [STAC_9872_AUTO] = "auto",
6176 [STAC_9872_VAIO] = "vaio",
6179 static unsigned int *stac9872_brd_tbl[STAC_9872_MODELS] = {
6180 [STAC_9872_VAIO] = stac9872_vaio_pin_configs,
6183 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
6184 SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0,
6185 "Sony VAIO F/S", STAC_9872_VAIO),
6189 static int patch_stac9872(struct hda_codec *codec)
6191 struct sigmatel_spec *spec;
6194 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6197 codec->no_trigger_sense = 1;
6199 spec->linear_tone_beep = 1;
6200 spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
6201 spec->pin_nids = stac9872_pin_nids;
6203 spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
6206 if (spec->board_config < 0)
6207 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6210 stac92xx_set_config_regs(codec,
6211 stac9872_brd_tbl[spec->board_config]);
6213 spec->multiout.dac_nids = spec->dac_nids;
6214 spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
6215 spec->adc_nids = stac9872_adc_nids;
6216 spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
6217 spec->mux_nids = stac9872_mux_nids;
6218 spec->init = stac9872_core_init;
6220 spec->capvols = stac9872_capvols;
6221 spec->capsws = stac9872_capsws;
6223 err = stac92xx_parse_auto_config(codec, 0x10, 0x12);
6225 stac92xx_free(codec);
6228 spec->input_mux = &spec->private_imux;
6229 codec->patch_ops = stac92xx_patch_ops;
6237 static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
6238 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
6239 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
6240 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
6241 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
6242 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
6243 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
6244 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
6245 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
6246 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
6247 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
6248 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
6249 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
6250 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
6251 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
6252 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
6253 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
6254 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
6255 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
6256 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
6257 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
6258 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
6259 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
6260 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
6261 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
6262 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
6263 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
6264 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
6265 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
6266 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
6267 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
6268 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
6269 /* The following does not take into account .id=0x83847661 when subsys =
6270 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
6271 * currently not fully supported.
6273 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
6274 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
6275 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
6276 { .id = 0x83847698, .name = "STAC9205", .patch = patch_stac9205 },
6277 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
6278 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
6279 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
6280 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
6281 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
6282 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
6283 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
6284 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
6285 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
6286 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
6287 { .id = 0x111d76d4, .name = "92HD83C1C5", .patch = patch_stac92hd83xxx},
6288 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
6289 { .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx},
6290 { .id = 0x111d76d1, .name = "92HD87B1/3", .patch = patch_stac92hd83xxx},
6291 { .id = 0x111d76d9, .name = "92HD87B2/4", .patch = patch_stac92hd83xxx},
6292 { .id = 0x111d7666, .name = "92HD88B3", .patch = patch_stac92hd83xxx},
6293 { .id = 0x111d7667, .name = "92HD88B1", .patch = patch_stac92hd83xxx},
6294 { .id = 0x111d7668, .name = "92HD88B2", .patch = patch_stac92hd83xxx},
6295 { .id = 0x111d7669, .name = "92HD88B4", .patch = patch_stac92hd83xxx},
6296 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
6297 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
6298 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
6299 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
6300 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
6301 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
6302 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
6303 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
6304 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
6305 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
6306 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
6307 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
6308 { .id = 0x111d76c0, .name = "92HD89C3", .patch = patch_stac92hd73xx },
6309 { .id = 0x111d76c1, .name = "92HD89C2", .patch = patch_stac92hd73xx },
6310 { .id = 0x111d76c2, .name = "92HD89C1", .patch = patch_stac92hd73xx },
6311 { .id = 0x111d76c3, .name = "92HD89B3", .patch = patch_stac92hd73xx },
6312 { .id = 0x111d76c4, .name = "92HD89B2", .patch = patch_stac92hd73xx },
6313 { .id = 0x111d76c5, .name = "92HD89B1", .patch = patch_stac92hd73xx },
6314 { .id = 0x111d76c6, .name = "92HD89E3", .patch = patch_stac92hd73xx },
6315 { .id = 0x111d76c7, .name = "92HD89E2", .patch = patch_stac92hd73xx },
6316 { .id = 0x111d76c8, .name = "92HD89E1", .patch = patch_stac92hd73xx },
6317 { .id = 0x111d76c9, .name = "92HD89D3", .patch = patch_stac92hd73xx },
6318 { .id = 0x111d76ca, .name = "92HD89D2", .patch = patch_stac92hd73xx },
6319 { .id = 0x111d76cb, .name = "92HD89D1", .patch = patch_stac92hd73xx },
6320 { .id = 0x111d76cc, .name = "92HD89F3", .patch = patch_stac92hd73xx },
6321 { .id = 0x111d76cd, .name = "92HD89F2", .patch = patch_stac92hd73xx },
6322 { .id = 0x111d76ce, .name = "92HD89F1", .patch = patch_stac92hd73xx },
6323 { .id = 0x111d76e0, .name = "92HD91BXX", .patch = patch_stac92hd83xxx},
6324 { .id = 0x111d76e7, .name = "92HD90BXX", .patch = patch_stac92hd83xxx},
6328 MODULE_ALIAS("snd-hda-codec-id:8384*");
6329 MODULE_ALIAS("snd-hda-codec-id:111d*");
6331 MODULE_LICENSE("GPL");
6332 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
6334 static struct hda_codec_preset_list sigmatel_list = {
6335 .preset = snd_hda_preset_sigmatel,
6336 .owner = THIS_MODULE,
6339 static int __init patch_sigmatel_init(void)
6341 return snd_hda_add_codec_preset(&sigmatel_list);
6344 static void __exit patch_sigmatel_exit(void)
6346 snd_hda_delete_codec_preset(&sigmatel_list);
6349 module_init(patch_sigmatel_init)
6350 module_exit(patch_sigmatel_exit)