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 <sound/core.h>
32 #include <sound/asoundef.h>
33 #include "hda_codec.h"
34 #include "hda_local.h"
35 #include "hda_patch.h"
38 #define NUM_CONTROL_ALLOC 32
40 #define STAC_VREF_EVENT 0x00
41 #define STAC_INSERT_EVENT 0x10
42 #define STAC_PWR_EVENT 0x20
43 #define STAC_HP_EVENT 0x30
109 STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
110 * is given, one of the above models will be
111 * chosen according to the subsystem id. */
112 /* for backward compatibility */
136 struct sigmatel_spec {
137 struct snd_kcontrol_new *mixers[4];
138 unsigned int num_mixers;
141 unsigned int eapd_switch: 1;
142 unsigned int surr_switch: 1;
143 unsigned int line_switch: 1;
144 unsigned int mic_switch: 1;
145 unsigned int alt_switch: 1;
146 unsigned int hp_detect: 1;
147 unsigned int spdif_mute: 1;
150 unsigned int eapd_mask;
151 unsigned int gpio_mask;
152 unsigned int gpio_dir;
153 unsigned int gpio_data;
154 unsigned int gpio_mute;
157 unsigned int stream_delay;
159 /* analog loopback */
160 unsigned char aloopback_mask;
161 unsigned char aloopback_shift;
163 /* power management */
164 unsigned int num_pwrs;
165 unsigned int *pwr_mapping;
170 struct hda_input_mux *mono_mux;
171 struct hda_input_mux *amp_mux;
172 unsigned int cur_mmux;
173 struct hda_multi_out multiout;
174 hda_nid_t dac_nids[5];
178 unsigned int num_adcs;
180 unsigned int num_muxes;
181 hda_nid_t *dmic_nids;
182 unsigned int num_dmics;
183 hda_nid_t *dmux_nids;
184 unsigned int num_dmuxes;
185 hda_nid_t *smux_nids;
186 unsigned int num_smuxes;
187 const char **spdif_labels;
189 hda_nid_t dig_in_nid;
191 hda_nid_t anabeep_nid;
192 hda_nid_t digbeep_nid;
196 unsigned int num_pins;
197 unsigned int *pin_configs;
198 unsigned int *bios_pin_configs;
200 /* codec specific stuff */
201 struct hda_verb *init;
202 struct snd_kcontrol_new *mixer;
205 struct hda_input_mux *dinput_mux;
206 unsigned int cur_dmux[2];
207 struct hda_input_mux *input_mux;
208 unsigned int cur_mux[3];
209 struct hda_input_mux *sinput_mux;
210 unsigned int cur_smux[2];
211 unsigned int cur_amux;
213 unsigned int num_amps;
214 unsigned int powerdown_adcs;
217 unsigned int io_switch[2];
218 unsigned int clfe_swap;
219 unsigned int hp_switch; /* NID of HP as line-out */
220 unsigned int aloopback;
222 struct hda_pcm pcm_rec[2]; /* PCM information */
224 /* dynamic controls and input_mux */
225 struct auto_pin_cfg autocfg;
226 unsigned int num_kctl_alloc, num_kctl_used;
227 struct snd_kcontrol_new *kctl_alloc;
228 struct hda_input_mux private_dimux;
229 struct hda_input_mux private_imux;
230 struct hda_input_mux private_smux;
231 struct hda_input_mux private_amp_mux;
232 struct hda_input_mux private_mono_mux;
235 static hda_nid_t stac9200_adc_nids[1] = {
239 static hda_nid_t stac9200_mux_nids[1] = {
243 static hda_nid_t stac9200_dac_nids[1] = {
247 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
248 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
252 static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
256 static hda_nid_t stac92hd73xx_adc_nids[2] = {
260 #define DELL_M6_AMP 2
261 static hda_nid_t stac92hd73xx_amp_nids[3] = {
265 #define STAC92HD73XX_NUM_DMICS 2
266 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
270 #define STAC92HD73_DAC_COUNT 5
271 static hda_nid_t stac92hd73xx_dac_nids[STAC92HD73_DAC_COUNT] = {
272 0x15, 0x16, 0x17, 0x18, 0x19,
275 static hda_nid_t stac92hd73xx_mux_nids[4] = {
276 0x28, 0x29, 0x2a, 0x2b,
279 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
283 static hda_nid_t stac92hd73xx_smux_nids[2] = {
287 #define STAC92HD83XXX_NUM_DMICS 2
288 static hda_nid_t stac92hd83xxx_dmic_nids[STAC92HD83XXX_NUM_DMICS + 1] = {
292 #define STAC92HD81_DAC_COUNT 2
293 #define STAC92HD83_DAC_COUNT 3
294 static hda_nid_t stac92hd83xxx_dac_nids[STAC92HD73_DAC_COUNT] = {
298 static hda_nid_t stac92hd83xxx_dmux_nids[2] = {
302 static hda_nid_t stac92hd83xxx_adc_nids[2] = {
306 static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
310 static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
314 static unsigned int stac92hd83xxx_pwr_mapping[4] = {
315 0x03, 0x0c, 0x10, 0x40,
318 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
322 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
326 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
330 static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
334 static hda_nid_t stac92hd71bxx_smux_nids[2] = {
338 static hda_nid_t stac92hd71bxx_dac_nids[1] = {
342 #define STAC92HD71BXX_NUM_DMICS 2
343 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
347 static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
351 static hda_nid_t stac925x_adc_nids[1] = {
355 static hda_nid_t stac925x_mux_nids[1] = {
359 static hda_nid_t stac925x_dac_nids[1] = {
363 #define STAC925X_NUM_DMICS 1
364 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
368 static hda_nid_t stac925x_dmux_nids[1] = {
372 static hda_nid_t stac922x_adc_nids[2] = {
376 static hda_nid_t stac922x_mux_nids[2] = {
380 static hda_nid_t stac927x_adc_nids[3] = {
384 static hda_nid_t stac927x_mux_nids[3] = {
388 static hda_nid_t stac927x_smux_nids[1] = {
392 static hda_nid_t stac927x_dac_nids[6] = {
393 0x02, 0x03, 0x04, 0x05, 0x06, 0
396 static hda_nid_t stac927x_dmux_nids[1] = {
400 #define STAC927X_NUM_DMICS 2
401 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
405 static const char *stac927x_spdif_labels[5] = {
406 "Digital Playback", "ADAT", "Analog Mux 1",
407 "Analog Mux 2", "Analog Mux 3"
410 static hda_nid_t stac9205_adc_nids[2] = {
414 static hda_nid_t stac9205_mux_nids[2] = {
418 static hda_nid_t stac9205_dmux_nids[1] = {
422 static hda_nid_t stac9205_smux_nids[1] = {
426 #define STAC9205_NUM_DMICS 2
427 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
431 static hda_nid_t stac9200_pin_nids[8] = {
432 0x08, 0x09, 0x0d, 0x0e,
433 0x0f, 0x10, 0x11, 0x12,
436 static hda_nid_t stac925x_pin_nids[8] = {
437 0x07, 0x08, 0x0a, 0x0b,
438 0x0c, 0x0d, 0x10, 0x11,
441 static hda_nid_t stac922x_pin_nids[10] = {
442 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
443 0x0f, 0x10, 0x11, 0x15, 0x1b,
446 static hda_nid_t stac92hd73xx_pin_nids[13] = {
447 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
448 0x0f, 0x10, 0x11, 0x12, 0x13,
452 static hda_nid_t stac92hd83xxx_pin_nids[14] = {
453 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
454 0x0f, 0x10, 0x11, 0x12, 0x13,
455 0x1d, 0x1e, 0x1f, 0x20
457 static hda_nid_t stac92hd71bxx_pin_nids[11] = {
458 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
459 0x0f, 0x14, 0x18, 0x19, 0x1e,
463 static hda_nid_t stac927x_pin_nids[14] = {
464 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
465 0x0f, 0x10, 0x11, 0x12, 0x13,
466 0x14, 0x21, 0x22, 0x23,
469 static hda_nid_t stac9205_pin_nids[12] = {
470 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
471 0x0f, 0x14, 0x16, 0x17, 0x18,
475 #define stac92xx_amp_volume_info snd_hda_mixer_amp_volume_info
477 static int stac92xx_amp_volume_get(struct snd_kcontrol *kcontrol,
478 struct snd_ctl_elem_value *ucontrol)
480 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
481 struct sigmatel_spec *spec = codec->spec;
482 hda_nid_t nid = spec->amp_nids[spec->cur_amux];
484 kcontrol->private_value ^= get_amp_nid(kcontrol);
485 kcontrol->private_value |= nid;
487 return snd_hda_mixer_amp_volume_get(kcontrol, ucontrol);
490 static int stac92xx_amp_volume_put(struct snd_kcontrol *kcontrol,
491 struct snd_ctl_elem_value *ucontrol)
493 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
494 struct sigmatel_spec *spec = codec->spec;
495 hda_nid_t nid = spec->amp_nids[spec->cur_amux];
497 kcontrol->private_value ^= get_amp_nid(kcontrol);
498 kcontrol->private_value |= nid;
500 return snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
503 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
504 struct snd_ctl_elem_info *uinfo)
506 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
507 struct sigmatel_spec *spec = codec->spec;
508 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
511 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
512 struct snd_ctl_elem_value *ucontrol)
514 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
515 struct sigmatel_spec *spec = codec->spec;
516 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
518 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
522 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
523 struct snd_ctl_elem_value *ucontrol)
525 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
526 struct sigmatel_spec *spec = codec->spec;
527 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
529 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
530 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
533 static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
534 struct snd_ctl_elem_info *uinfo)
536 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
537 struct sigmatel_spec *spec = codec->spec;
538 return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
541 static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
542 struct snd_ctl_elem_value *ucontrol)
544 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
545 struct sigmatel_spec *spec = codec->spec;
546 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
548 ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
552 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
553 struct snd_ctl_elem_value *ucontrol)
555 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
556 struct sigmatel_spec *spec = codec->spec;
557 struct hda_input_mux *smux = &spec->private_smux;
558 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
562 err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
563 spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
567 if (spec->spdif_mute) {
569 nid = spec->multiout.dig_out_nid;
571 nid = codec->slave_dig_outs[smux_idx - 1];
572 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
575 val = AMP_OUT_UNMUTE;
576 /* un/mute SPDIF out */
577 snd_hda_codec_write_cache(codec, nid, 0,
578 AC_VERB_SET_AMP_GAIN_MUTE, val);
583 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
585 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
586 struct sigmatel_spec *spec = codec->spec;
587 return snd_hda_input_mux_info(spec->input_mux, uinfo);
590 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
592 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
593 struct sigmatel_spec *spec = codec->spec;
594 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
596 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
600 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
602 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
603 struct sigmatel_spec *spec = codec->spec;
604 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
606 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
607 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
610 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
611 struct snd_ctl_elem_info *uinfo)
613 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
614 struct sigmatel_spec *spec = codec->spec;
615 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
618 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
619 struct snd_ctl_elem_value *ucontrol)
621 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
622 struct sigmatel_spec *spec = codec->spec;
624 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
628 static int stac92xx_mono_mux_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;
634 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
635 spec->mono_nid, &spec->cur_mmux);
638 static int stac92xx_amp_mux_enum_info(struct snd_kcontrol *kcontrol,
639 struct snd_ctl_elem_info *uinfo)
641 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
642 struct sigmatel_spec *spec = codec->spec;
643 return snd_hda_input_mux_info(spec->amp_mux, uinfo);
646 static int stac92xx_amp_mux_enum_get(struct snd_kcontrol *kcontrol,
647 struct snd_ctl_elem_value *ucontrol)
649 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
650 struct sigmatel_spec *spec = codec->spec;
652 ucontrol->value.enumerated.item[0] = spec->cur_amux;
656 static int stac92xx_amp_mux_enum_put(struct snd_kcontrol *kcontrol,
657 struct snd_ctl_elem_value *ucontrol)
659 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
660 struct sigmatel_spec *spec = codec->spec;
661 struct snd_kcontrol *ctl =
662 snd_hda_find_mixer_ctl(codec, "Amp Capture Volume");
666 snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE |
667 SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
669 return snd_hda_input_mux_put(codec, spec->amp_mux, ucontrol,
673 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
675 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
676 struct snd_ctl_elem_value *ucontrol)
678 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
679 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
680 struct sigmatel_spec *spec = codec->spec;
682 ucontrol->value.integer.value[0] = !!(spec->aloopback &
683 (spec->aloopback_mask << idx));
687 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
688 struct snd_ctl_elem_value *ucontrol)
690 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
691 struct sigmatel_spec *spec = codec->spec;
692 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
693 unsigned int dac_mode;
694 unsigned int val, idx_val;
696 idx_val = spec->aloopback_mask << idx;
697 if (ucontrol->value.integer.value[0])
698 val = spec->aloopback | idx_val;
700 val = spec->aloopback & ~idx_val;
701 if (spec->aloopback == val)
704 spec->aloopback = val;
706 /* Only return the bits defined by the shift value of the
707 * first two bytes of the mask
709 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
710 kcontrol->private_value & 0xFFFF, 0x0);
711 dac_mode >>= spec->aloopback_shift;
713 if (spec->aloopback & idx_val) {
714 snd_hda_power_up(codec);
717 snd_hda_power_down(codec);
718 dac_mode &= ~idx_val;
721 snd_hda_codec_write_cache(codec, codec->afg, 0,
722 kcontrol->private_value >> 16, dac_mode);
727 static struct hda_verb stac9200_core_init[] = {
728 /* set dac0mux for dac converter */
729 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
733 static struct hda_verb stac9200_eapd_init[] = {
734 /* set dac0mux for dac converter */
735 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
736 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
740 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
741 /* set master volume and direct control */
742 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
743 /* setup audio connections */
744 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
745 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
746 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
747 /* setup adcs to point to mixer */
748 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
749 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
750 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
751 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
752 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
753 /* setup import muxs */
754 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
755 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
756 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
757 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
761 static struct hda_verb dell_eq_core_init[] = {
762 /* set master volume to max value without distortion
763 * and direct control */
764 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
765 /* setup audio connections */
766 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
767 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x02},
768 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x01},
769 /* setup adcs to point to mixer */
770 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
771 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
772 /* setup import muxs */
773 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
774 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
775 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
776 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
780 static struct hda_verb dell_m6_core_init[] = {
781 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
782 /* setup audio connections */
783 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
784 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
785 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x02},
786 /* setup adcs to point to mixer */
787 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
788 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
789 /* setup import muxs */
790 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
791 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
792 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
793 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
797 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
798 /* set master volume and direct control */
799 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
800 /* setup audio connections */
801 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
802 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
803 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
804 /* connect hp ports to dac3 */
805 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x03},
806 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x03},
807 /* setup adcs to point to mixer */
808 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
809 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
810 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
811 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
812 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
813 /* setup import muxs */
814 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
815 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
816 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
817 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
821 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
822 /* set master volume and direct control */
823 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
824 /* setup audio connections */
825 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
826 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01 },
827 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02 },
828 /* dac3 is connected to import3 mux */
829 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
830 /* connect hp ports to dac4 */
831 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x04},
832 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x04},
833 /* setup adcs to point to mixer */
834 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
835 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
836 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
837 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
838 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
839 /* setup import muxs */
840 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
841 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
842 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
843 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
847 static struct hda_verb stac92hd83xxx_core_init[] = {
848 /* start of config #1 */
849 { 0xe, AC_VERB_SET_CONNECT_SEL, 0x3},
851 /* start of config #2 */
852 { 0xa, AC_VERB_SET_CONNECT_SEL, 0x0},
853 { 0xb, AC_VERB_SET_CONNECT_SEL, 0x0},
854 { 0xd, AC_VERB_SET_CONNECT_SEL, 0x1},
856 /* power state controls amps */
857 { 0x01, AC_VERB_SET_EAPD, 1 << 2},
860 static struct hda_verb stac92hd71bxx_core_init[] = {
861 /* set master volume and direct control */
862 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
863 /* connect headphone jack to dac1 */
864 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
865 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
866 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
867 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
868 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
871 #define HD_DISABLE_PORTF 2
872 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
873 /* start of config #1 */
875 /* connect port 0f to audio mixer */
876 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
877 /* unmute right and left channels for node 0x0f */
878 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
879 /* start of config #2 */
881 /* set master volume and direct control */
882 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
883 /* connect headphone jack to dac1 */
884 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
885 /* unmute right and left channels for nodes 0x0a, 0xd */
886 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
887 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
891 static struct hda_verb stac925x_core_init[] = {
892 /* set dac0mux for dac converter */
893 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
897 static struct hda_verb stac922x_core_init[] = {
898 /* set master volume and direct control */
899 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
903 static struct hda_verb d965_core_init[] = {
904 /* set master volume and direct control */
905 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
906 /* unmute node 0x1b */
907 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
908 /* select node 0x03 as DAC */
909 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
913 static struct hda_verb stac927x_core_init[] = {
914 /* set master volume and direct control */
915 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
916 /* enable analog pc beep path */
917 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
921 static struct hda_verb stac9205_core_init[] = {
922 /* set master volume and direct control */
923 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
924 /* enable analog pc beep path */
925 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
929 #define STAC_MONO_MUX \
931 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
932 .name = "Mono Mux", \
934 .info = stac92xx_mono_mux_enum_info, \
935 .get = stac92xx_mono_mux_enum_get, \
936 .put = stac92xx_mono_mux_enum_put, \
939 #define STAC_AMP_MUX \
941 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
942 .name = "Amp Selector Capture Switch", \
944 .info = stac92xx_amp_mux_enum_info, \
945 .get = stac92xx_amp_mux_enum_get, \
946 .put = stac92xx_amp_mux_enum_put, \
949 #define STAC_AMP_VOL(xname, nid, chs, idx, dir) \
951 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
954 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
955 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
956 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
957 .info = stac92xx_amp_volume_info, \
958 .get = stac92xx_amp_volume_get, \
959 .put = stac92xx_amp_volume_put, \
960 .tlv = { .c = snd_hda_mixer_amp_tlv }, \
961 .private_value = HDA_COMPOSE_AMP_VAL(nid, chs, idx, dir) \
964 #define STAC_INPUT_SOURCE(cnt) \
966 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
967 .name = "Input Source", \
969 .info = stac92xx_mux_enum_info, \
970 .get = stac92xx_mux_enum_get, \
971 .put = stac92xx_mux_enum_put, \
974 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
976 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
977 .name = "Analog Loopback", \
979 .info = stac92xx_aloopback_info, \
980 .get = stac92xx_aloopback_get, \
981 .put = stac92xx_aloopback_put, \
982 .private_value = verb_read | (verb_write << 16), \
985 static struct snd_kcontrol_new stac9200_mixer[] = {
986 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
987 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
988 STAC_INPUT_SOURCE(1),
989 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
990 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
994 #define DELL_M6_MIXER 6
995 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
996 /* start of config #1 */
997 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
998 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1000 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1001 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1003 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1004 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1006 /* start of config #2 */
1007 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1008 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1010 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1011 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1013 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
1015 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1016 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1018 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1019 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1024 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
1025 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1027 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1028 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1030 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1031 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1033 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1034 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1036 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1037 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1039 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1040 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1042 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1043 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1045 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1046 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1050 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
1051 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1053 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1054 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1056 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1057 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1059 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1060 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1062 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1063 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1065 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1066 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1068 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1069 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1071 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1072 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1077 static struct snd_kcontrol_new stac92hd83xxx_mixer[] = {
1078 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_OUTPUT),
1079 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_OUTPUT),
1081 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_OUTPUT),
1082 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_OUTPUT),
1084 HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x1b, 0, HDA_INPUT),
1085 HDA_CODEC_MUTE("DAC0 Capture Switch", 0x1b, 0, HDA_INPUT),
1087 HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x1b, 0x1, HDA_INPUT),
1088 HDA_CODEC_MUTE("DAC1 Capture Switch", 0x1b, 0x1, HDA_INPUT),
1090 HDA_CODEC_VOLUME("Front Mic Capture Volume", 0x1b, 0x2, HDA_INPUT),
1091 HDA_CODEC_MUTE("Front Mic Capture Switch", 0x1b, 0x2, HDA_INPUT),
1093 HDA_CODEC_VOLUME("Line In Capture Volume", 0x1b, 0x3, HDA_INPUT),
1094 HDA_CODEC_MUTE("Line In Capture Switch", 0x1b, 0x3, HDA_INPUT),
1097 HDA_CODEC_VOLUME("Mic Capture Volume", 0x1b, 0x4, HDA_INPUT),
1098 HDA_CODEC_MUTE("Mic Capture Switch", 0x1b 0x4, HDA_INPUT),
1103 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
1104 STAC_INPUT_SOURCE(2),
1105 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
1107 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1108 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1110 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1111 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1112 /* analog pc-beep replaced with digital beep support */
1114 HDA_CODEC_VOLUME("PC Beep Volume", 0x17, 0x2, HDA_INPUT),
1115 HDA_CODEC_MUTE("PC Beep Switch", 0x17, 0x2, HDA_INPUT),
1118 HDA_CODEC_MUTE("Import0 Mux Capture Switch", 0x17, 0x0, HDA_INPUT),
1119 HDA_CODEC_VOLUME("Import0 Mux Capture Volume", 0x17, 0x0, HDA_INPUT),
1121 HDA_CODEC_MUTE("Import1 Mux Capture Switch", 0x17, 0x1, HDA_INPUT),
1122 HDA_CODEC_VOLUME("Import1 Mux Capture Volume", 0x17, 0x1, HDA_INPUT),
1124 HDA_CODEC_MUTE("DAC0 Capture Switch", 0x17, 0x3, HDA_INPUT),
1125 HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x17, 0x3, HDA_INPUT),
1127 HDA_CODEC_MUTE("DAC1 Capture Switch", 0x17, 0x4, HDA_INPUT),
1128 HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x17, 0x4, HDA_INPUT),
1132 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
1133 STAC_INPUT_SOURCE(2),
1134 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
1136 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1137 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1139 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1140 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1144 static struct snd_kcontrol_new stac925x_mixer[] = {
1145 STAC_INPUT_SOURCE(1),
1146 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
1147 HDA_CODEC_MUTE("Capture Switch", 0x14, 0, HDA_OUTPUT),
1151 static struct snd_kcontrol_new stac9205_mixer[] = {
1152 STAC_INPUT_SOURCE(2),
1153 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1155 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
1156 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
1158 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
1159 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
1163 /* This needs to be generated dynamically based on sequence */
1164 static struct snd_kcontrol_new stac922x_mixer[] = {
1165 STAC_INPUT_SOURCE(2),
1166 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
1167 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
1169 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
1170 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
1175 static struct snd_kcontrol_new stac927x_mixer[] = {
1176 STAC_INPUT_SOURCE(3),
1177 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1179 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
1180 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
1182 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
1183 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
1185 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
1186 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
1190 static struct snd_kcontrol_new stac_dmux_mixer = {
1191 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1192 .name = "Digital Input Source",
1193 /* count set later */
1194 .info = stac92xx_dmux_enum_info,
1195 .get = stac92xx_dmux_enum_get,
1196 .put = stac92xx_dmux_enum_put,
1199 static struct snd_kcontrol_new stac_smux_mixer = {
1200 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1201 .name = "IEC958 Playback Source",
1202 /* count set later */
1203 .info = stac92xx_smux_enum_info,
1204 .get = stac92xx_smux_enum_get,
1205 .put = stac92xx_smux_enum_put,
1208 static const char *slave_vols[] = {
1209 "Front Playback Volume",
1210 "Surround Playback Volume",
1211 "Center Playback Volume",
1212 "LFE Playback Volume",
1213 "Side Playback Volume",
1214 "Headphone Playback Volume",
1215 "Headphone Playback Volume",
1216 "Speaker Playback Volume",
1217 "External Speaker Playback Volume",
1218 "Speaker2 Playback Volume",
1222 static const char *slave_sws[] = {
1223 "Front Playback Switch",
1224 "Surround Playback Switch",
1225 "Center Playback Switch",
1226 "LFE Playback Switch",
1227 "Side Playback Switch",
1228 "Headphone Playback Switch",
1229 "Headphone Playback Switch",
1230 "Speaker Playback Switch",
1231 "External Speaker Playback Switch",
1232 "Speaker2 Playback Switch",
1233 "IEC958 Playback Switch",
1237 static int stac92xx_build_controls(struct hda_codec *codec)
1239 struct sigmatel_spec *spec = codec->spec;
1243 err = snd_hda_add_new_ctls(codec, spec->mixer);
1247 for (i = 0; i < spec->num_mixers; i++) {
1248 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1252 if (spec->num_dmuxes > 0) {
1253 stac_dmux_mixer.count = spec->num_dmuxes;
1254 err = snd_ctl_add(codec->bus->card,
1255 snd_ctl_new1(&stac_dmux_mixer, codec));
1259 if (spec->num_smuxes > 0) {
1260 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1261 struct hda_input_mux *smux = &spec->private_smux;
1262 /* check for mute support on SPDIF out */
1263 if (wcaps & AC_WCAP_OUT_AMP) {
1264 smux->items[smux->num_items].label = "Off";
1265 smux->items[smux->num_items].index = 0;
1267 spec->spdif_mute = 1;
1269 stac_smux_mixer.count = spec->num_smuxes;
1270 err = snd_ctl_add(codec->bus->card,
1271 snd_ctl_new1(&stac_smux_mixer, codec));
1276 if (spec->multiout.dig_out_nid) {
1277 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1280 err = snd_hda_create_spdif_share_sw(codec,
1284 spec->multiout.share_spdif = 1;
1286 if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1287 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1292 /* if we have no master control, let's create it */
1293 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1294 unsigned int vmaster_tlv[4];
1295 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1296 HDA_OUTPUT, vmaster_tlv);
1297 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1298 vmaster_tlv, slave_vols);
1302 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1303 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1312 static unsigned int ref9200_pin_configs[8] = {
1313 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1314 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1318 STAC 9200 pin configs for
1323 static unsigned int dell9200_d21_pin_configs[8] = {
1324 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
1325 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1329 STAC 9200 pin configs for
1333 static unsigned int dell9200_d22_pin_configs[8] = {
1334 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1335 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1339 STAC 9200 pin configs for
1340 102801C4 (Dell Dimension E310)
1347 static unsigned int dell9200_d23_pin_configs[8] = {
1348 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1349 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
1354 STAC 9200-32 pin configs for
1355 102801B5 (Dell Inspiron 630m)
1356 102801D8 (Dell Inspiron 640m)
1358 static unsigned int dell9200_m21_pin_configs[8] = {
1359 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1360 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1364 STAC 9200-32 pin configs for
1365 102801C2 (Dell Latitude D620)
1367 102801CC (Dell Latitude D820)
1371 static unsigned int dell9200_m22_pin_configs[8] = {
1372 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1373 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1377 STAC 9200-32 pin configs for
1378 102801CE (Dell XPS M1710)
1379 102801CF (Dell Precision M90)
1381 static unsigned int dell9200_m23_pin_configs[8] = {
1382 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1383 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1387 STAC 9200-32 pin configs for
1390 102801CB (Dell Latitude 120L)
1393 static unsigned int dell9200_m24_pin_configs[8] = {
1394 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1395 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1399 STAC 9200-32 pin configs for
1400 102801BD (Dell Inspiron E1505n)
1404 static unsigned int dell9200_m25_pin_configs[8] = {
1405 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1406 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1410 STAC 9200-32 pin configs for
1411 102801F5 (Dell Inspiron 1501)
1414 static unsigned int dell9200_m26_pin_configs[8] = {
1415 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1416 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1421 102801CD (Dell Inspiron E1705/9400)
1423 static unsigned int dell9200_m27_pin_configs[8] = {
1424 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1425 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1428 static unsigned int oqo9200_pin_configs[8] = {
1429 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1430 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1434 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1435 [STAC_REF] = ref9200_pin_configs,
1436 [STAC_9200_OQO] = oqo9200_pin_configs,
1437 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1438 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1439 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1440 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1441 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1442 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1443 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1444 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1445 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1446 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1447 [STAC_9200_PANASONIC] = ref9200_pin_configs,
1450 static const char *stac9200_models[STAC_9200_MODELS] = {
1452 [STAC_9200_OQO] = "oqo",
1453 [STAC_9200_DELL_D21] = "dell-d21",
1454 [STAC_9200_DELL_D22] = "dell-d22",
1455 [STAC_9200_DELL_D23] = "dell-d23",
1456 [STAC_9200_DELL_M21] = "dell-m21",
1457 [STAC_9200_DELL_M22] = "dell-m22",
1458 [STAC_9200_DELL_M23] = "dell-m23",
1459 [STAC_9200_DELL_M24] = "dell-m24",
1460 [STAC_9200_DELL_M25] = "dell-m25",
1461 [STAC_9200_DELL_M26] = "dell-m26",
1462 [STAC_9200_DELL_M27] = "dell-m27",
1463 [STAC_9200_GATEWAY] = "gateway",
1464 [STAC_9200_PANASONIC] = "panasonic",
1467 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1468 /* SigmaTel reference board */
1469 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1470 "DFI LanParty", STAC_REF),
1471 /* Dell laptops have BIOS problem */
1472 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1473 "unknown Dell", STAC_9200_DELL_D21),
1474 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1475 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1476 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1477 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1478 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1479 "unknown Dell", STAC_9200_DELL_D22),
1480 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1481 "unknown Dell", STAC_9200_DELL_D22),
1482 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1483 "Dell Latitude D620", STAC_9200_DELL_M22),
1484 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1485 "unknown Dell", STAC_9200_DELL_D23),
1486 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1487 "unknown Dell", STAC_9200_DELL_D23),
1488 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1489 "unknown Dell", STAC_9200_DELL_M22),
1490 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1491 "unknown Dell", STAC_9200_DELL_M24),
1492 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1493 "unknown Dell", STAC_9200_DELL_M24),
1494 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1495 "Dell Latitude 120L", STAC_9200_DELL_M24),
1496 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1497 "Dell Latitude D820", STAC_9200_DELL_M22),
1498 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1499 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1500 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1501 "Dell XPS M1710", STAC_9200_DELL_M23),
1502 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1503 "Dell Precision M90", STAC_9200_DELL_M23),
1504 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1505 "unknown Dell", STAC_9200_DELL_M22),
1506 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1507 "unknown Dell", STAC_9200_DELL_M22),
1508 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1509 "unknown Dell", STAC_9200_DELL_M22),
1510 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1511 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1512 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1513 "unknown Dell", STAC_9200_DELL_D23),
1514 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1515 "unknown Dell", STAC_9200_DELL_D23),
1516 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1517 "unknown Dell", STAC_9200_DELL_D21),
1518 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1519 "unknown Dell", STAC_9200_DELL_D23),
1520 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1521 "unknown Dell", STAC_9200_DELL_D21),
1522 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1523 "unknown Dell", STAC_9200_DELL_M25),
1524 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1525 "unknown Dell", STAC_9200_DELL_M25),
1526 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1527 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1528 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1529 "unknown Dell", STAC_9200_DELL_M26),
1531 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1532 /* Gateway machines needs EAPD to be set on resume */
1533 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
1534 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
1536 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
1539 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1543 static unsigned int ref925x_pin_configs[8] = {
1544 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1545 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1548 static unsigned int stac925x_MA6_pin_configs[8] = {
1549 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1550 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
1553 static unsigned int stac925x_PA6_pin_configs[8] = {
1554 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1555 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
1558 static unsigned int stac925xM2_2_pin_configs[8] = {
1559 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
1560 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
1563 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1564 [STAC_REF] = ref925x_pin_configs,
1565 [STAC_M2_2] = stac925xM2_2_pin_configs,
1566 [STAC_MA6] = stac925x_MA6_pin_configs,
1567 [STAC_PA6] = stac925x_PA6_pin_configs,
1570 static const char *stac925x_models[STAC_925x_MODELS] = {
1572 [STAC_M2_2] = "m2-2",
1577 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1578 /* SigmaTel reference board */
1579 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1580 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1581 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
1582 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
1583 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
1584 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
1585 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
1589 static unsigned int ref92hd73xx_pin_configs[13] = {
1590 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1591 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1592 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1596 static unsigned int dell_m6_pin_configs[13] = {
1597 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1598 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1599 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1603 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1604 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1605 [STAC_DELL_M6] = dell_m6_pin_configs,
1606 [STAC_DELL_EQ] = dell_m6_pin_configs,
1609 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1610 [STAC_92HD73XX_REF] = "ref",
1611 [STAC_DELL_M6] = "dell-m6",
1612 [STAC_DELL_EQ] = "dell-eq",
1615 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1616 /* SigmaTel reference board */
1617 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1618 "DFI LanParty", STAC_92HD73XX_REF),
1619 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1620 "unknown Dell", STAC_DELL_M6),
1621 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1622 "unknown Dell", STAC_DELL_M6),
1623 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1624 "unknown Dell", STAC_DELL_M6),
1625 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1626 "unknown Dell", STAC_DELL_M6),
1627 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1628 "unknown Dell", STAC_DELL_M6),
1629 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1630 "unknown Dell", STAC_DELL_M6),
1631 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1632 "unknown Dell", STAC_DELL_M6),
1636 static unsigned int ref92hd83xxx_pin_configs[14] = {
1637 0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1638 0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1639 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x40f000f0,
1640 0x01451160, 0x98560170,
1643 static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1644 [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1647 static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1648 [STAC_92HD83XXX_REF] = "ref",
1651 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1652 /* SigmaTel reference board */
1653 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1654 "DFI LanParty", STAC_92HD71BXX_REF),
1657 static unsigned int ref92hd71bxx_pin_configs[11] = {
1658 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1659 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1660 0x90a000f0, 0x01452050, 0x01452050,
1663 static unsigned int dell_m4_1_pin_configs[11] = {
1664 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1665 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1666 0x40f000f0, 0x4f0000f0, 0x4f0000f0,
1669 static unsigned int dell_m4_2_pin_configs[11] = {
1670 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1671 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1672 0x40f000f0, 0x044413b0, 0x044413b0,
1675 static unsigned int dell_m4_3_pin_configs[11] = {
1676 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1677 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1678 0x40f000f0, 0x044413b0, 0x044413b0,
1681 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1682 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1683 [STAC_DELL_M4_1] = dell_m4_1_pin_configs,
1684 [STAC_DELL_M4_2] = dell_m4_2_pin_configs,
1685 [STAC_DELL_M4_3] = dell_m4_3_pin_configs,
1686 [STAC_HP_M4] = NULL,
1689 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1690 [STAC_92HD71BXX_REF] = "ref",
1691 [STAC_DELL_M4_1] = "dell-m4-1",
1692 [STAC_DELL_M4_2] = "dell-m4-2",
1693 [STAC_DELL_M4_3] = "dell-m4-3",
1694 [STAC_HP_M4] = "hp-m4",
1697 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1698 /* SigmaTel reference board */
1699 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1700 "DFI LanParty", STAC_92HD71BXX_REF),
1701 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f2,
1702 "HP dv5", STAC_HP_M4),
1703 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f4,
1704 "HP dv7", STAC_HP_M4),
1705 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1706 "unknown HP", STAC_HP_M4),
1707 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1708 "unknown Dell", STAC_DELL_M4_1),
1709 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1710 "unknown Dell", STAC_DELL_M4_1),
1711 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1712 "unknown Dell", STAC_DELL_M4_1),
1713 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1714 "unknown Dell", STAC_DELL_M4_1),
1715 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1716 "unknown Dell", STAC_DELL_M4_1),
1717 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1718 "unknown Dell", STAC_DELL_M4_1),
1719 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1720 "unknown Dell", STAC_DELL_M4_1),
1721 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1722 "unknown Dell", STAC_DELL_M4_2),
1723 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1724 "unknown Dell", STAC_DELL_M4_2),
1725 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1726 "unknown Dell", STAC_DELL_M4_2),
1727 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1728 "unknown Dell", STAC_DELL_M4_2),
1729 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1730 "unknown Dell", STAC_DELL_M4_3),
1734 static unsigned int ref922x_pin_configs[10] = {
1735 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1736 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1737 0x40000100, 0x40000100,
1741 STAC 922X pin configs for
1748 static unsigned int dell_922x_d81_pin_configs[10] = {
1749 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1750 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1751 0x01813122, 0x400001f2,
1755 STAC 922X pin configs for
1759 static unsigned int dell_922x_d82_pin_configs[10] = {
1760 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1761 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1762 0x01813122, 0x400001f1,
1766 STAC 922X pin configs for
1769 static unsigned int dell_922x_m81_pin_configs[10] = {
1770 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1771 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1772 0x40C003f1, 0x405003f0,
1776 STAC 9221 A1 pin configs for
1777 102801D7 (Dell XPS M1210)
1779 static unsigned int dell_922x_m82_pin_configs[10] = {
1780 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1781 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1782 0x508003f3, 0x405003f4,
1785 static unsigned int d945gtp3_pin_configs[10] = {
1786 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1787 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1788 0x02a19120, 0x40000100,
1791 static unsigned int d945gtp5_pin_configs[10] = {
1792 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1793 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1794 0x02a19320, 0x40000100,
1797 static unsigned int intel_mac_v1_pin_configs[10] = {
1798 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1799 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1800 0x400000fc, 0x400000fb,
1803 static unsigned int intel_mac_v2_pin_configs[10] = {
1804 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1805 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1806 0x400000fc, 0x400000fb,
1809 static unsigned int intel_mac_v3_pin_configs[10] = {
1810 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1811 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1812 0x400000fc, 0x400000fb,
1815 static unsigned int intel_mac_v4_pin_configs[10] = {
1816 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1817 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1818 0x400000fc, 0x400000fb,
1821 static unsigned int intel_mac_v5_pin_configs[10] = {
1822 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1823 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1824 0x400000fc, 0x400000fb,
1827 static unsigned int ecs202_pin_configs[10] = {
1828 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1829 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1830 0x9037012e, 0x40e000f2,
1833 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1834 [STAC_D945_REF] = ref922x_pin_configs,
1835 [STAC_D945GTP3] = d945gtp3_pin_configs,
1836 [STAC_D945GTP5] = d945gtp5_pin_configs,
1837 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1838 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1839 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1840 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1841 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1842 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1843 /* for backward compatibility */
1844 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1845 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1846 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1847 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1848 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1849 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1850 [STAC_ECS_202] = ecs202_pin_configs,
1851 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1852 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1853 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1854 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1857 static const char *stac922x_models[STAC_922X_MODELS] = {
1858 [STAC_D945_REF] = "ref",
1859 [STAC_D945GTP5] = "5stack",
1860 [STAC_D945GTP3] = "3stack",
1861 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1862 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1863 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1864 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1865 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1866 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1867 /* for backward compatibility */
1868 [STAC_MACMINI] = "macmini",
1869 [STAC_MACBOOK] = "macbook",
1870 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1871 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1872 [STAC_IMAC_INTEL] = "imac-intel",
1873 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1874 [STAC_ECS_202] = "ecs202",
1875 [STAC_922X_DELL_D81] = "dell-d81",
1876 [STAC_922X_DELL_D82] = "dell-d82",
1877 [STAC_922X_DELL_M81] = "dell-m81",
1878 [STAC_922X_DELL_M82] = "dell-m82",
1881 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1882 /* SigmaTel reference board */
1883 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1884 "DFI LanParty", STAC_D945_REF),
1885 /* Intel 945G based systems */
1886 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1887 "Intel D945G", STAC_D945GTP3),
1888 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1889 "Intel D945G", STAC_D945GTP3),
1890 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1891 "Intel D945G", STAC_D945GTP3),
1892 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1893 "Intel D945G", STAC_D945GTP3),
1894 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1895 "Intel D945G", STAC_D945GTP3),
1896 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1897 "Intel D945G", STAC_D945GTP3),
1898 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1899 "Intel D945G", STAC_D945GTP3),
1900 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1901 "Intel D945G", STAC_D945GTP3),
1902 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1903 "Intel D945G", STAC_D945GTP3),
1904 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1905 "Intel D945G", STAC_D945GTP3),
1906 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1907 "Intel D945G", STAC_D945GTP3),
1908 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1909 "Intel D945G", STAC_D945GTP3),
1910 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1911 "Intel D945G", STAC_D945GTP3),
1912 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1913 "Intel D945G", STAC_D945GTP3),
1914 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1915 "Intel D945G", STAC_D945GTP3),
1916 /* Intel D945G 5-stack systems */
1917 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1918 "Intel D945G", STAC_D945GTP5),
1919 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1920 "Intel D945G", STAC_D945GTP5),
1921 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1922 "Intel D945G", STAC_D945GTP5),
1923 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1924 "Intel D945G", STAC_D945GTP5),
1925 /* Intel 945P based systems */
1926 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1927 "Intel D945P", STAC_D945GTP3),
1928 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1929 "Intel D945P", STAC_D945GTP3),
1930 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1931 "Intel D945P", STAC_D945GTP3),
1932 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1933 "Intel D945P", STAC_D945GTP3),
1934 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1935 "Intel D945P", STAC_D945GTP3),
1936 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1937 "Intel D945P", STAC_D945GTP5),
1939 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
1940 SND_PCI_QUIRK(0x8384, 0x7680,
1941 "Mac", STAC_INTEL_MAC_AUTO),
1943 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1944 "unknown Dell", STAC_922X_DELL_D81),
1945 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1946 "unknown Dell", STAC_922X_DELL_D81),
1947 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1948 "unknown Dell", STAC_922X_DELL_D81),
1949 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1950 "unknown Dell", STAC_922X_DELL_D82),
1951 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1952 "unknown Dell", STAC_922X_DELL_M81),
1953 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1954 "unknown Dell", STAC_922X_DELL_D82),
1955 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1956 "unknown Dell", STAC_922X_DELL_D81),
1957 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1958 "unknown Dell", STAC_922X_DELL_D81),
1959 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1960 "Dell XPS M1210", STAC_922X_DELL_M82),
1961 /* ECS/PC Chips boards */
1962 SND_PCI_QUIRK(0x1019, 0x2144,
1963 "ECS/PC chips", STAC_ECS_202),
1964 SND_PCI_QUIRK(0x1019, 0x2608,
1965 "ECS/PC chips", STAC_ECS_202),
1966 SND_PCI_QUIRK(0x1019, 0x2633,
1967 "ECS/PC chips P17G/1333", STAC_ECS_202),
1968 SND_PCI_QUIRK(0x1019, 0x2811,
1969 "ECS/PC chips", STAC_ECS_202),
1970 SND_PCI_QUIRK(0x1019, 0x2812,
1971 "ECS/PC chips", STAC_ECS_202),
1972 SND_PCI_QUIRK(0x1019, 0x2813,
1973 "ECS/PC chips", STAC_ECS_202),
1974 SND_PCI_QUIRK(0x1019, 0x2814,
1975 "ECS/PC chips", STAC_ECS_202),
1976 SND_PCI_QUIRK(0x1019, 0x2815,
1977 "ECS/PC chips", STAC_ECS_202),
1978 SND_PCI_QUIRK(0x1019, 0x2816,
1979 "ECS/PC chips", STAC_ECS_202),
1980 SND_PCI_QUIRK(0x1019, 0x2817,
1981 "ECS/PC chips", STAC_ECS_202),
1982 SND_PCI_QUIRK(0x1019, 0x2818,
1983 "ECS/PC chips", STAC_ECS_202),
1984 SND_PCI_QUIRK(0x1019, 0x2819,
1985 "ECS/PC chips", STAC_ECS_202),
1986 SND_PCI_QUIRK(0x1019, 0x2820,
1987 "ECS/PC chips", STAC_ECS_202),
1991 static unsigned int ref927x_pin_configs[14] = {
1992 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1993 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1994 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1995 0x01c42190, 0x40000100,
1998 static unsigned int d965_3st_pin_configs[14] = {
1999 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2000 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2001 0x40000100, 0x40000100, 0x40000100, 0x40000100,
2002 0x40000100, 0x40000100
2005 static unsigned int d965_5st_pin_configs[14] = {
2006 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2007 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2008 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2009 0x40000100, 0x40000100
2012 static unsigned int dell_3st_pin_configs[14] = {
2013 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2014 0x01111212, 0x01116211, 0x01813050, 0x01112214,
2015 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2016 0x40c003fc, 0x40000100
2019 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2020 [STAC_D965_REF] = ref927x_pin_configs,
2021 [STAC_D965_3ST] = d965_3st_pin_configs,
2022 [STAC_D965_5ST] = d965_5st_pin_configs,
2023 [STAC_DELL_3ST] = dell_3st_pin_configs,
2024 [STAC_DELL_BIOS] = NULL,
2027 static const char *stac927x_models[STAC_927X_MODELS] = {
2028 [STAC_D965_REF] = "ref",
2029 [STAC_D965_3ST] = "3stack",
2030 [STAC_D965_5ST] = "5stack",
2031 [STAC_DELL_3ST] = "dell-3stack",
2032 [STAC_DELL_BIOS] = "dell-bios",
2035 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2036 /* SigmaTel reference board */
2037 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2038 "DFI LanParty", STAC_D965_REF),
2039 /* Intel 946 based systems */
2040 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2041 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2042 /* 965 based 3 stack systems */
2043 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
2044 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
2045 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
2046 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
2047 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
2048 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
2049 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
2050 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
2051 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
2052 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
2053 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
2054 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
2055 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
2056 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
2057 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
2058 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
2059 /* Dell 3 stack systems */
2060 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
2061 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2062 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
2063 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
2064 /* Dell 3 stack systems with verb table in BIOS */
2065 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2066 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
2067 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
2068 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_3ST),
2069 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
2070 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
2071 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
2072 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2073 /* 965 based 5 stack systems */
2074 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
2075 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
2076 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
2077 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
2078 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
2079 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
2080 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
2081 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
2082 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
2086 static unsigned int ref9205_pin_configs[12] = {
2087 0x40000100, 0x40000100, 0x01016011, 0x01014010,
2088 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2089 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2093 STAC 9205 pin configs for
2100 10280228 (Dell Vostro 1500)
2102 static unsigned int dell_9205_m42_pin_configs[12] = {
2103 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2104 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2105 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2109 STAC 9205 pin configs for
2113 102801FF (Dell Precision M4300)
2118 static unsigned int dell_9205_m43_pin_configs[12] = {
2119 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2120 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2121 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2124 static unsigned int dell_9205_m44_pin_configs[12] = {
2125 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2126 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2127 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2130 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2131 [STAC_9205_REF] = ref9205_pin_configs,
2132 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2133 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2134 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2137 static const char *stac9205_models[STAC_9205_MODELS] = {
2138 [STAC_9205_REF] = "ref",
2139 [STAC_9205_DELL_M42] = "dell-m42",
2140 [STAC_9205_DELL_M43] = "dell-m43",
2141 [STAC_9205_DELL_M44] = "dell-m44",
2144 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
2145 /* SigmaTel reference board */
2146 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2147 "DFI LanParty", STAC_9205_REF),
2148 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2149 "unknown Dell", STAC_9205_DELL_M42),
2150 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2151 "unknown Dell", STAC_9205_DELL_M42),
2152 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2153 "Dell Precision", STAC_9205_DELL_M43),
2154 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2155 "Dell Precision", STAC_9205_DELL_M43),
2156 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2157 "Dell Precision", STAC_9205_DELL_M43),
2158 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2159 "unknown Dell", STAC_9205_DELL_M42),
2160 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2161 "unknown Dell", STAC_9205_DELL_M42),
2162 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2163 "Dell Precision", STAC_9205_DELL_M43),
2164 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2165 "Dell Precision M4300", STAC_9205_DELL_M43),
2166 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2167 "unknown Dell", STAC_9205_DELL_M42),
2168 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2169 "Dell Precision", STAC_9205_DELL_M43),
2170 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2171 "Dell Precision", STAC_9205_DELL_M43),
2172 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2173 "Dell Precision", STAC_9205_DELL_M43),
2174 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2175 "Dell Inspiron", STAC_9205_DELL_M44),
2176 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2177 "Dell Vostro 1500", STAC_9205_DELL_M42),
2181 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
2184 struct sigmatel_spec *spec = codec->spec;
2186 if (! spec->bios_pin_configs) {
2187 spec->bios_pin_configs = kcalloc(spec->num_pins,
2188 sizeof(*spec->bios_pin_configs), GFP_KERNEL);
2189 if (! spec->bios_pin_configs)
2193 for (i = 0; i < spec->num_pins; i++) {
2194 hda_nid_t nid = spec->pin_nids[i];
2195 unsigned int pin_cfg;
2197 pin_cfg = snd_hda_codec_read(codec, nid, 0,
2198 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
2199 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
2201 spec->bios_pin_configs[i] = pin_cfg;
2207 static void stac92xx_set_config_reg(struct hda_codec *codec,
2208 hda_nid_t pin_nid, unsigned int pin_config)
2211 snd_hda_codec_write(codec, pin_nid, 0,
2212 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
2213 pin_config & 0x000000ff);
2214 snd_hda_codec_write(codec, pin_nid, 0,
2215 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
2216 (pin_config & 0x0000ff00) >> 8);
2217 snd_hda_codec_write(codec, pin_nid, 0,
2218 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
2219 (pin_config & 0x00ff0000) >> 16);
2220 snd_hda_codec_write(codec, pin_nid, 0,
2221 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
2223 i = snd_hda_codec_read(codec, pin_nid, 0,
2224 AC_VERB_GET_CONFIG_DEFAULT,
2226 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
2230 static void stac92xx_set_config_regs(struct hda_codec *codec)
2233 struct sigmatel_spec *spec = codec->spec;
2235 if (!spec->pin_configs)
2238 for (i = 0; i < spec->num_pins; i++)
2239 stac92xx_set_config_reg(codec, spec->pin_nids[i],
2240 spec->pin_configs[i]);
2244 * Analog playback callbacks
2246 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2247 struct hda_codec *codec,
2248 struct snd_pcm_substream *substream)
2250 struct sigmatel_spec *spec = codec->spec;
2251 if (spec->stream_delay)
2252 msleep(spec->stream_delay);
2253 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2257 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2258 struct hda_codec *codec,
2259 unsigned int stream_tag,
2260 unsigned int format,
2261 struct snd_pcm_substream *substream)
2263 struct sigmatel_spec *spec = codec->spec;
2264 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2267 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2268 struct hda_codec *codec,
2269 struct snd_pcm_substream *substream)
2271 struct sigmatel_spec *spec = codec->spec;
2272 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2276 * Digital playback callbacks
2278 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2279 struct hda_codec *codec,
2280 struct snd_pcm_substream *substream)
2282 struct sigmatel_spec *spec = codec->spec;
2283 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2286 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2287 struct hda_codec *codec,
2288 struct snd_pcm_substream *substream)
2290 struct sigmatel_spec *spec = codec->spec;
2291 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2294 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2295 struct hda_codec *codec,
2296 unsigned int stream_tag,
2297 unsigned int format,
2298 struct snd_pcm_substream *substream)
2300 struct sigmatel_spec *spec = codec->spec;
2301 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2302 stream_tag, format, substream);
2307 * Analog capture callbacks
2309 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2310 struct hda_codec *codec,
2311 unsigned int stream_tag,
2312 unsigned int format,
2313 struct snd_pcm_substream *substream)
2315 struct sigmatel_spec *spec = codec->spec;
2316 hda_nid_t nid = spec->adc_nids[substream->number];
2318 if (spec->powerdown_adcs) {
2320 snd_hda_codec_write_cache(codec, nid, 0,
2321 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2323 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2327 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2328 struct hda_codec *codec,
2329 struct snd_pcm_substream *substream)
2331 struct sigmatel_spec *spec = codec->spec;
2332 hda_nid_t nid = spec->adc_nids[substream->number];
2334 snd_hda_codec_cleanup_stream(codec, nid);
2335 if (spec->powerdown_adcs)
2336 snd_hda_codec_write_cache(codec, nid, 0,
2337 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2341 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2345 /* NID is set in stac92xx_build_pcms */
2347 .open = stac92xx_dig_playback_pcm_open,
2348 .close = stac92xx_dig_playback_pcm_close,
2349 .prepare = stac92xx_dig_playback_pcm_prepare
2353 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2357 /* NID is set in stac92xx_build_pcms */
2360 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2364 .nid = 0x02, /* NID to query formats and rates */
2366 .open = stac92xx_playback_pcm_open,
2367 .prepare = stac92xx_playback_pcm_prepare,
2368 .cleanup = stac92xx_playback_pcm_cleanup
2372 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2376 .nid = 0x06, /* NID to query formats and rates */
2378 .open = stac92xx_playback_pcm_open,
2379 .prepare = stac92xx_playback_pcm_prepare,
2380 .cleanup = stac92xx_playback_pcm_cleanup
2384 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2387 /* NID + .substreams is set in stac92xx_build_pcms */
2389 .prepare = stac92xx_capture_pcm_prepare,
2390 .cleanup = stac92xx_capture_pcm_cleanup
2394 static int stac92xx_build_pcms(struct hda_codec *codec)
2396 struct sigmatel_spec *spec = codec->spec;
2397 struct hda_pcm *info = spec->pcm_rec;
2399 codec->num_pcms = 1;
2400 codec->pcm_info = info;
2402 info->name = "STAC92xx Analog";
2403 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2404 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2405 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2406 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2408 if (spec->alt_switch) {
2411 info->name = "STAC92xx Analog Alt";
2412 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2415 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2418 info->name = "STAC92xx Digital";
2419 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2420 if (spec->multiout.dig_out_nid) {
2421 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2422 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2424 if (spec->dig_in_nid) {
2425 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2426 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2433 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
2435 unsigned int pincap = snd_hda_param_read(codec, nid,
2437 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2438 if (pincap & AC_PINCAP_VREF_100)
2439 return AC_PINCTL_VREF_100;
2440 if (pincap & AC_PINCAP_VREF_80)
2441 return AC_PINCTL_VREF_80;
2442 if (pincap & AC_PINCAP_VREF_50)
2443 return AC_PINCTL_VREF_50;
2444 if (pincap & AC_PINCAP_VREF_GRD)
2445 return AC_PINCTL_VREF_GRD;
2449 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2452 snd_hda_codec_write_cache(codec, nid, 0,
2453 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2456 #define stac92xx_hp_switch_info snd_ctl_boolean_mono_info
2458 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2459 struct snd_ctl_elem_value *ucontrol)
2461 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2462 struct sigmatel_spec *spec = codec->spec;
2464 ucontrol->value.integer.value[0] = !!spec->hp_switch;
2468 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2469 struct snd_ctl_elem_value *ucontrol)
2471 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2472 struct sigmatel_spec *spec = codec->spec;
2473 int nid = kcontrol->private_value;
2475 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2477 /* check to be sure that the ports are upto date with
2480 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2485 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
2487 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2489 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2490 struct sigmatel_spec *spec = codec->spec;
2491 int io_idx = kcontrol-> private_value & 0xff;
2493 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
2497 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2499 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2500 struct sigmatel_spec *spec = codec->spec;
2501 hda_nid_t nid = kcontrol->private_value >> 8;
2502 int io_idx = kcontrol-> private_value & 0xff;
2503 unsigned short val = !!ucontrol->value.integer.value[0];
2505 spec->io_switch[io_idx] = val;
2508 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2510 unsigned int pinctl = AC_PINCTL_IN_EN;
2511 if (io_idx) /* set VREF for mic */
2512 pinctl |= stac92xx_get_vref(codec, nid);
2513 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2516 /* check the auto-mute again: we need to mute/unmute the speaker
2517 * appropriately according to the pin direction
2519 if (spec->hp_detect)
2520 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2525 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2527 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2528 struct snd_ctl_elem_value *ucontrol)
2530 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2531 struct sigmatel_spec *spec = codec->spec;
2533 ucontrol->value.integer.value[0] = spec->clfe_swap;
2537 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2538 struct snd_ctl_elem_value *ucontrol)
2540 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2541 struct sigmatel_spec *spec = codec->spec;
2542 hda_nid_t nid = kcontrol->private_value & 0xff;
2543 unsigned int val = !!ucontrol->value.integer.value[0];
2545 if (spec->clfe_swap == val)
2548 spec->clfe_swap = val;
2550 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2551 spec->clfe_swap ? 0x4 : 0x0);
2556 #define STAC_CODEC_HP_SWITCH(xname) \
2557 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2560 .info = stac92xx_hp_switch_info, \
2561 .get = stac92xx_hp_switch_get, \
2562 .put = stac92xx_hp_switch_put, \
2565 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2566 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2569 .info = stac92xx_io_switch_info, \
2570 .get = stac92xx_io_switch_get, \
2571 .put = stac92xx_io_switch_put, \
2572 .private_value = xpval, \
2575 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2576 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2579 .info = stac92xx_clfe_switch_info, \
2580 .get = stac92xx_clfe_switch_get, \
2581 .put = stac92xx_clfe_switch_put, \
2582 .private_value = xpval, \
2586 STAC_CTL_WIDGET_VOL,
2587 STAC_CTL_WIDGET_MUTE,
2588 STAC_CTL_WIDGET_MONO_MUX,
2589 STAC_CTL_WIDGET_AMP_MUX,
2590 STAC_CTL_WIDGET_AMP_VOL,
2591 STAC_CTL_WIDGET_HP_SWITCH,
2592 STAC_CTL_WIDGET_IO_SWITCH,
2593 STAC_CTL_WIDGET_CLFE_SWITCH
2596 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2597 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2598 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2601 STAC_AMP_VOL(NULL, 0, 0, 0, 0),
2602 STAC_CODEC_HP_SWITCH(NULL),
2603 STAC_CODEC_IO_SWITCH(NULL, 0),
2604 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2607 /* add dynamic controls */
2608 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2609 struct snd_kcontrol_new *ktemp,
2610 int idx, const char *name,
2613 struct snd_kcontrol_new *knew;
2615 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
2616 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
2618 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
2621 if (spec->kctl_alloc) {
2622 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
2623 kfree(spec->kctl_alloc);
2625 spec->kctl_alloc = knew;
2626 spec->num_kctl_alloc = num;
2629 knew = &spec->kctl_alloc[spec->num_kctl_used];
2632 knew->name = kstrdup(name, GFP_KERNEL);
2635 knew->private_value = val;
2636 spec->num_kctl_used++;
2640 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2641 int type, int idx, const char *name,
2644 return stac92xx_add_control_temp(spec,
2645 &stac92xx_control_templates[type],
2650 /* add dynamic controls */
2651 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2652 const char *name, unsigned long val)
2654 return stac92xx_add_control_idx(spec, type, 0, name, val);
2657 /* flag inputs as additional dynamic lineouts */
2658 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
2660 struct sigmatel_spec *spec = codec->spec;
2661 unsigned int wcaps, wtype;
2662 int i, num_dacs = 0;
2664 /* use the wcaps cache to count all DACs available for line-outs */
2665 for (i = 0; i < codec->num_nodes; i++) {
2666 wcaps = codec->wcaps[i];
2667 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2669 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
2673 snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
2675 switch (cfg->line_outs) {
2677 /* add line-in as side */
2678 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
2679 cfg->line_out_pins[cfg->line_outs] =
2680 cfg->input_pins[AUTO_PIN_LINE];
2681 spec->line_switch = 1;
2686 /* add line-in as clfe and mic as side */
2687 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
2688 cfg->line_out_pins[cfg->line_outs] =
2689 cfg->input_pins[AUTO_PIN_LINE];
2690 spec->line_switch = 1;
2693 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
2694 cfg->line_out_pins[cfg->line_outs] =
2695 cfg->input_pins[AUTO_PIN_MIC];
2696 spec->mic_switch = 1;
2701 /* add line-in as surr and mic as clfe */
2702 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
2703 cfg->line_out_pins[cfg->line_outs] =
2704 cfg->input_pins[AUTO_PIN_LINE];
2705 spec->line_switch = 1;
2708 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
2709 cfg->line_out_pins[cfg->line_outs] =
2710 cfg->input_pins[AUTO_PIN_MIC];
2711 spec->mic_switch = 1;
2721 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2725 for (i = 0; i < spec->multiout.num_dacs; i++) {
2726 if (spec->multiout.dac_nids[i] == nid)
2734 * Fill in the dac_nids table from the parsed pin configuration
2735 * This function only works when every pin in line_out_pins[]
2736 * contains atleast one DAC in its connection list. Some 92xx
2737 * codecs are not connected directly to a DAC, such as the 9200
2738 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2740 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
2741 struct auto_pin_cfg *cfg)
2743 struct sigmatel_spec *spec = codec->spec;
2744 int i, j, conn_len = 0;
2745 hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
2746 unsigned int wcaps, wtype;
2748 for (i = 0; i < cfg->line_outs; i++) {
2749 nid = cfg->line_out_pins[i];
2750 conn_len = snd_hda_get_connections(codec, nid, conn,
2751 HDA_MAX_CONNECTIONS);
2752 for (j = 0; j < conn_len; j++) {
2753 wcaps = snd_hda_param_read(codec, conn[j],
2754 AC_PAR_AUDIO_WIDGET_CAP);
2755 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2756 if (wtype != AC_WID_AUD_OUT ||
2757 (wcaps & AC_WCAP_DIGITAL))
2759 /* conn[j] is a DAC routed to this line-out */
2760 if (!is_in_dac_nids(spec, conn[j]))
2764 if (j == conn_len) {
2765 if (spec->multiout.num_dacs > 0) {
2766 /* we have already working output pins,
2767 * so let's drop the broken ones again
2769 cfg->line_outs = spec->multiout.num_dacs;
2772 /* error out, no available DAC found */
2774 "%s: No available DAC for pin 0x%x\n",
2779 spec->multiout.dac_nids[i] = conn[j];
2780 spec->multiout.num_dacs++;
2782 /* select this DAC in the pin's input mux */
2783 snd_hda_codec_write_cache(codec, nid, 0,
2784 AC_VERB_SET_CONNECT_SEL, j);
2789 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2790 spec->multiout.num_dacs,
2791 spec->multiout.dac_nids[0],
2792 spec->multiout.dac_nids[1],
2793 spec->multiout.dac_nids[2],
2794 spec->multiout.dac_nids[3],
2795 spec->multiout.dac_nids[4]);
2799 /* create volume control/switch for the given prefx type */
2800 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
2805 sprintf(name, "%s Playback Volume", pfx);
2806 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
2807 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2810 sprintf(name, "%s Playback Switch", pfx);
2811 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
2812 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2818 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
2820 if (!spec->multiout.hp_nid)
2821 spec->multiout.hp_nid = nid;
2822 else if (spec->multiout.num_dacs > 4) {
2823 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
2826 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
2827 spec->multiout.num_dacs++;
2832 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2834 if (is_in_dac_nids(spec, nid))
2836 if (spec->multiout.hp_nid == nid)
2841 /* add playback controls from the parsed DAC table */
2842 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
2843 const struct auto_pin_cfg *cfg)
2845 static const char *chname[4] = {
2846 "Front", "Surround", NULL /*CLFE*/, "Side"
2851 struct sigmatel_spec *spec = codec->spec;
2852 unsigned int wid_caps, pincap;
2855 for (i = 0; i < cfg->line_outs && i < spec->multiout.num_dacs; i++) {
2856 if (!spec->multiout.dac_nids[i])
2859 nid = spec->multiout.dac_nids[i];
2863 err = create_controls(spec, "Center", nid, 1);
2866 err = create_controls(spec, "LFE", nid, 2);
2870 wid_caps = get_wcaps(codec, nid);
2872 if (wid_caps & AC_WCAP_LR_SWAP) {
2873 err = stac92xx_add_control(spec,
2874 STAC_CTL_WIDGET_CLFE_SWITCH,
2875 "Swap Center/LFE Playback Switch", nid);
2882 err = create_controls(spec, chname[i], nid, 3);
2888 if ((spec->multiout.num_dacs - cfg->line_outs) > 0 &&
2889 cfg->hp_outs && !spec->multiout.hp_nid)
2890 spec->multiout.hp_nid = nid;
2892 if (cfg->hp_outs > 1) {
2893 err = stac92xx_add_control(spec,
2894 STAC_CTL_WIDGET_HP_SWITCH,
2895 "Headphone as Line Out Switch",
2896 cfg->hp_pins[cfg->hp_outs - 1]);
2901 if (spec->line_switch) {
2902 nid = cfg->input_pins[AUTO_PIN_LINE];
2903 pincap = snd_hda_param_read(codec, nid,
2905 if (pincap & AC_PINCAP_OUT) {
2906 err = stac92xx_add_control(spec,
2907 STAC_CTL_WIDGET_IO_SWITCH,
2908 "Line In as Output Switch", nid << 8);
2914 if (spec->mic_switch) {
2915 unsigned int def_conf;
2916 unsigned int mic_pin = AUTO_PIN_MIC;
2918 nid = cfg->input_pins[mic_pin];
2919 def_conf = snd_hda_codec_read(codec, nid, 0,
2920 AC_VERB_GET_CONFIG_DEFAULT, 0);
2921 /* some laptops have an internal analog microphone
2922 * which can't be used as a output */
2923 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2924 pincap = snd_hda_param_read(codec, nid,
2926 if (pincap & AC_PINCAP_OUT) {
2927 err = stac92xx_add_control(spec,
2928 STAC_CTL_WIDGET_IO_SWITCH,
2929 "Mic as Output Switch", (nid << 8) | 1);
2930 nid = snd_hda_codec_read(codec, nid, 0,
2931 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2932 if (!check_in_dac_nids(spec, nid))
2933 add_spec_dacs(spec, nid);
2937 } else if (mic_pin == AUTO_PIN_MIC) {
2938 mic_pin = AUTO_PIN_FRONT_MIC;
2946 /* add playback controls for Speaker and HP outputs */
2947 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
2948 struct auto_pin_cfg *cfg)
2950 struct sigmatel_spec *spec = codec->spec;
2952 int i, old_num_dacs, err;
2954 old_num_dacs = spec->multiout.num_dacs;
2955 for (i = 0; i < cfg->hp_outs; i++) {
2956 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
2957 if (wid_caps & AC_WCAP_UNSOL_CAP)
2958 spec->hp_detect = 1;
2959 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
2960 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2961 if (check_in_dac_nids(spec, nid))
2965 add_spec_dacs(spec, nid);
2967 for (i = 0; i < cfg->speaker_outs; i++) {
2968 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
2969 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2970 if (check_in_dac_nids(spec, nid))
2974 add_spec_dacs(spec, nid);
2976 for (i = 0; i < cfg->line_outs; i++) {
2977 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
2978 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2979 if (check_in_dac_nids(spec, nid))
2983 add_spec_dacs(spec, nid);
2985 for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
2986 static const char *pfxs[] = {
2987 "Speaker", "External Speaker", "Speaker2",
2989 err = create_controls(spec, pfxs[i - old_num_dacs],
2990 spec->multiout.dac_nids[i], 3);
2994 if (spec->multiout.hp_nid) {
2995 err = create_controls(spec, "Headphone",
2996 spec->multiout.hp_nid, 3);
3004 /* labels for mono mux outputs */
3005 static const char *stac92xx_mono_labels[4] = {
3006 "DAC0", "DAC1", "Mixer", "DAC2"
3009 /* create mono mux for mono out on capable codecs */
3010 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3012 struct sigmatel_spec *spec = codec->spec;
3013 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3015 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3017 num_cons = snd_hda_get_connections(codec,
3020 HDA_MAX_NUM_INPUTS);
3021 if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3024 for (i = 0; i < num_cons; i++) {
3025 mono_mux->items[mono_mux->num_items].label =
3026 stac92xx_mono_labels[i];
3027 mono_mux->items[mono_mux->num_items].index = i;
3028 mono_mux->num_items++;
3031 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3032 "Mono Mux", spec->mono_nid);
3035 /* labels for amp mux outputs */
3036 static const char *stac92xx_amp_labels[3] = {
3037 "Front Microphone", "Microphone", "Line In",
3040 /* create amp out controls mux on capable codecs */
3041 static int stac92xx_auto_create_amp_output_ctls(struct hda_codec *codec)
3043 struct sigmatel_spec *spec = codec->spec;
3044 struct hda_input_mux *amp_mux = &spec->private_amp_mux;
3047 for (i = 0; i < spec->num_amps; i++) {
3048 amp_mux->items[amp_mux->num_items].label =
3049 stac92xx_amp_labels[i];
3050 amp_mux->items[amp_mux->num_items].index = i;
3051 amp_mux->num_items++;
3054 if (spec->num_amps > 1) {
3055 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_MUX,
3056 "Amp Selector Capture Switch", 0);
3060 return stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_VOL,
3061 "Amp Capture Volume",
3062 HDA_COMPOSE_AMP_VAL(spec->amp_nids[0], 3, 0, HDA_INPUT));
3066 /* create PC beep volume controls */
3067 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3070 struct sigmatel_spec *spec = codec->spec;
3071 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3074 /* check for mute support for the the amp */
3075 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3076 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3077 "PC Beep Playback Switch",
3078 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3083 /* check to see if there is volume support for the amp */
3084 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3085 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3086 "PC Beep Playback Volume",
3087 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3094 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3095 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3097 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3098 struct snd_ctl_elem_value *ucontrol)
3100 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3101 ucontrol->value.integer.value[0] = codec->beep->enabled;
3105 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3106 struct snd_ctl_elem_value *ucontrol)
3108 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3109 int enabled = !!ucontrol->value.integer.value[0];
3110 if (codec->beep->enabled != enabled) {
3111 codec->beep->enabled = enabled;
3117 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3118 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3119 .info = stac92xx_dig_beep_switch_info,
3120 .get = stac92xx_dig_beep_switch_get,
3121 .put = stac92xx_dig_beep_switch_put,
3124 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3126 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3127 0, "PC Beep Playback Switch", 0);
3131 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3133 struct sigmatel_spec *spec = codec->spec;
3134 int wcaps, nid, i, err = 0;
3136 for (i = 0; i < spec->num_muxes; i++) {
3137 nid = spec->mux_nids[i];
3138 wcaps = get_wcaps(codec, nid);
3140 if (wcaps & AC_WCAP_OUT_AMP) {
3141 err = stac92xx_add_control_idx(spec,
3142 STAC_CTL_WIDGET_VOL, i, "Mux Capture Volume",
3143 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3151 static const char *stac92xx_spdif_labels[3] = {
3152 "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3155 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3157 struct sigmatel_spec *spec = codec->spec;
3158 struct hda_input_mux *spdif_mux = &spec->private_smux;
3159 const char **labels = spec->spdif_labels;
3161 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3163 num_cons = snd_hda_get_connections(codec,
3166 HDA_MAX_NUM_INPUTS);
3171 labels = stac92xx_spdif_labels;
3173 for (i = 0; i < num_cons; i++) {
3174 spdif_mux->items[spdif_mux->num_items].label = labels[i];
3175 spdif_mux->items[spdif_mux->num_items].index = i;
3176 spdif_mux->num_items++;
3182 /* labels for dmic mux inputs */
3183 static const char *stac92xx_dmic_labels[5] = {
3184 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3185 "Digital Mic 3", "Digital Mic 4"
3188 /* create playback/capture controls for input pins on dmic capable codecs */
3189 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3190 const struct auto_pin_cfg *cfg)
3192 struct sigmatel_spec *spec = codec->spec;
3193 struct hda_input_mux *dimux = &spec->private_dimux;
3194 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3198 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
3199 dimux->items[dimux->num_items].index = 0;
3202 for (i = 0; i < spec->num_dmics; i++) {
3207 unsigned int def_conf;
3209 def_conf = snd_hda_codec_read(codec,
3212 AC_VERB_GET_CONFIG_DEFAULT,
3214 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3217 nid = spec->dmic_nids[i];
3218 num_cons = snd_hda_get_connections(codec,
3221 HDA_MAX_NUM_INPUTS);
3222 for (j = 0; j < num_cons; j++)
3223 if (con_lst[j] == nid) {
3229 wcaps = get_wcaps(codec, nid) &
3230 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3233 sprintf(name, "%s Capture Volume",
3234 stac92xx_dmic_labels[dimux->num_items]);
3236 err = stac92xx_add_control(spec,
3237 STAC_CTL_WIDGET_VOL,
3239 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3240 (wcaps & AC_WCAP_OUT_AMP) ?
3241 HDA_OUTPUT : HDA_INPUT));
3246 dimux->items[dimux->num_items].label =
3247 stac92xx_dmic_labels[dimux->num_items];
3248 dimux->items[dimux->num_items].index = index;
3255 /* create playback/capture controls for input pins */
3256 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3258 struct sigmatel_spec *spec = codec->spec;
3259 struct hda_input_mux *imux = &spec->private_imux;
3260 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3263 for (i = 0; i < AUTO_PIN_LAST; i++) {
3266 if (!cfg->input_pins[i])
3269 for (j = 0; j < spec->num_muxes; j++) {
3271 num_cons = snd_hda_get_connections(codec,
3274 HDA_MAX_NUM_INPUTS);
3275 for (k = 0; k < num_cons; k++)
3276 if (con_lst[k] == cfg->input_pins[i]) {
3283 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3284 imux->items[imux->num_items].index = index;
3288 if (imux->num_items) {
3290 * Set the current input for the muxes.
3291 * The STAC9221 has two input muxes with identical source
3292 * NID lists. Hopefully this won't get confused.
3294 for (i = 0; i < spec->num_muxes; i++) {
3295 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3296 AC_VERB_SET_CONNECT_SEL,
3297 imux->items[0].index);
3304 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3306 struct sigmatel_spec *spec = codec->spec;
3309 for (i = 0; i < spec->autocfg.line_outs; i++) {
3310 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3311 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3315 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3317 struct sigmatel_spec *spec = codec->spec;
3320 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3322 pin = spec->autocfg.hp_pins[i];
3323 if (pin) /* connect to front */
3324 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3326 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3328 pin = spec->autocfg.speaker_pins[i];
3329 if (pin) /* connect to front */
3330 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3334 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3336 struct sigmatel_spec *spec = codec->spec;
3338 int hp_speaker_swap = 0;
3340 if ((err = snd_hda_parse_pin_def_config(codec,
3342 spec->dmic_nids)) < 0)
3344 if (! spec->autocfg.line_outs)
3345 return 0; /* can't find valid pin config */
3347 /* If we have no real line-out pin and multiple hp-outs, HPs should
3348 * be set up as multi-channel outputs.
3350 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
3351 spec->autocfg.hp_outs > 1) {
3352 /* Copy hp_outs to line_outs, backup line_outs in
3353 * speaker_outs so that the following routines can handle
3354 * HP pins as primary outputs.
3356 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3357 sizeof(spec->autocfg.line_out_pins));
3358 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3359 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3360 sizeof(spec->autocfg.hp_pins));
3361 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3362 hp_speaker_swap = 1;
3364 if (spec->autocfg.mono_out_pin) {
3365 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3366 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3367 u32 caps = query_amp_caps(codec,
3368 spec->autocfg.mono_out_pin, dir);
3369 hda_nid_t conn_list[1];
3371 /* get the mixer node and then the mono mux if it exists */
3372 if (snd_hda_get_connections(codec,
3373 spec->autocfg.mono_out_pin, conn_list, 1) &&
3374 snd_hda_get_connections(codec, conn_list[0],
3377 int wcaps = get_wcaps(codec, conn_list[0]);
3378 int wid_type = (wcaps & AC_WCAP_TYPE)
3379 >> AC_WCAP_TYPE_SHIFT;
3380 /* LR swap check, some stac925x have a mux that
3381 * changes the DACs output path instead of the
3384 if (wid_type == AC_WID_AUD_SEL &&
3385 !(wcaps & AC_WCAP_LR_SWAP))
3386 spec->mono_nid = conn_list[0];
3389 hda_nid_t nid = spec->autocfg.mono_out_pin;
3391 /* most mono outs have a least a mute/unmute switch */
3392 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3393 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3394 "Mono Playback Switch",
3395 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3398 /* check for volume support for the amp */
3399 if ((caps & AC_AMPCAP_NUM_STEPS)
3400 >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3401 err = stac92xx_add_control(spec,
3402 STAC_CTL_WIDGET_VOL,
3403 "Mono Playback Volume",
3404 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3410 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3414 if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
3416 if (spec->multiout.num_dacs == 0)
3417 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
3420 err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
3425 /* setup analog beep controls */
3426 if (spec->anabeep_nid > 0) {
3427 err = stac92xx_auto_create_beep_ctls(codec,
3433 /* setup digital beep controls and input device */
3434 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3435 if (spec->digbeep_nid > 0) {
3436 hda_nid_t nid = spec->digbeep_nid;
3439 err = stac92xx_auto_create_beep_ctls(codec, nid);
3442 err = snd_hda_attach_beep_device(codec, nid);
3445 /* if no beep switch is available, make its own one */
3446 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3448 !((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT)) {
3449 err = stac92xx_beep_switch_ctl(codec);
3456 if (hp_speaker_swap == 1) {
3457 /* Restore the hp_outs and line_outs */
3458 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3459 sizeof(spec->autocfg.line_out_pins));
3460 spec->autocfg.hp_outs = spec->autocfg.line_outs;
3461 memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins,
3462 sizeof(spec->autocfg.speaker_pins));
3463 spec->autocfg.line_outs = spec->autocfg.speaker_outs;
3464 memset(spec->autocfg.speaker_pins, 0,
3465 sizeof(spec->autocfg.speaker_pins));
3466 spec->autocfg.speaker_outs = 0;
3469 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3474 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3479 if (spec->mono_nid > 0) {
3480 err = stac92xx_auto_create_mono_output_ctls(codec);
3484 if (spec->num_amps > 0) {
3485 err = stac92xx_auto_create_amp_output_ctls(codec);
3489 if (spec->num_dmics > 0 && !spec->dinput_mux)
3490 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3491 &spec->autocfg)) < 0)
3493 if (spec->num_muxes > 0) {
3494 err = stac92xx_auto_create_mux_input_ctls(codec);
3498 if (spec->num_smuxes > 0) {
3499 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3504 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3505 if (spec->multiout.max_channels > 2)
3506 spec->surr_switch = 1;
3508 if (spec->autocfg.dig_out_pin)
3509 spec->multiout.dig_out_nid = dig_out;
3510 if (dig_in && spec->autocfg.dig_in_pin)
3511 spec->dig_in_nid = dig_in;
3513 if (spec->kctl_alloc)
3514 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3516 spec->input_mux = &spec->private_imux;
3517 spec->dinput_mux = &spec->private_dimux;
3518 spec->sinput_mux = &spec->private_smux;
3519 spec->mono_mux = &spec->private_mono_mux;
3520 spec->amp_mux = &spec->private_amp_mux;
3524 /* add playback controls for HP output */
3525 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3526 struct auto_pin_cfg *cfg)
3528 struct sigmatel_spec *spec = codec->spec;
3529 hda_nid_t pin = cfg->hp_pins[0];
3530 unsigned int wid_caps;
3535 wid_caps = get_wcaps(codec, pin);
3536 if (wid_caps & AC_WCAP_UNSOL_CAP)
3537 spec->hp_detect = 1;
3542 /* add playback controls for LFE output */
3543 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3544 struct auto_pin_cfg *cfg)
3546 struct sigmatel_spec *spec = codec->spec;
3548 hda_nid_t lfe_pin = 0x0;
3552 * search speaker outs and line outs for a mono speaker pin
3553 * with an amp. If one is found, add LFE controls
3556 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3557 hda_nid_t pin = spec->autocfg.speaker_pins[i];
3558 unsigned int wcaps = get_wcaps(codec, pin);
3559 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3560 if (wcaps == AC_WCAP_OUT_AMP)
3561 /* found a mono speaker with an amp, must be lfe */
3565 /* if speaker_outs is 0, then speakers may be in line_outs */
3566 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3567 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3568 hda_nid_t pin = spec->autocfg.line_out_pins[i];
3569 unsigned int defcfg;
3570 defcfg = snd_hda_codec_read(codec, pin, 0,
3571 AC_VERB_GET_CONFIG_DEFAULT,
3573 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3574 unsigned int wcaps = get_wcaps(codec, pin);
3575 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3576 if (wcaps == AC_WCAP_OUT_AMP)
3577 /* found a mono speaker with an amp,
3585 err = create_controls(spec, "LFE", lfe_pin, 1);
3593 static int stac9200_parse_auto_config(struct hda_codec *codec)
3595 struct sigmatel_spec *spec = codec->spec;
3598 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3601 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3604 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
3607 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
3610 if (spec->num_muxes > 0) {
3611 err = stac92xx_auto_create_mux_input_ctls(codec);
3616 if (spec->autocfg.dig_out_pin)
3617 spec->multiout.dig_out_nid = 0x05;
3618 if (spec->autocfg.dig_in_pin)
3619 spec->dig_in_nid = 0x04;
3621 if (spec->kctl_alloc)
3622 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3624 spec->input_mux = &spec->private_imux;
3625 spec->dinput_mux = &spec->private_dimux;
3631 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
3632 * funky external mute control using GPIO pins.
3635 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
3636 unsigned int dir_mask, unsigned int data)
3638 unsigned int gpiostate, gpiomask, gpiodir;
3640 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
3641 AC_VERB_GET_GPIO_DATA, 0);
3642 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
3644 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
3645 AC_VERB_GET_GPIO_MASK, 0);
3648 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
3649 AC_VERB_GET_GPIO_DIRECTION, 0);
3650 gpiodir |= dir_mask;
3652 /* Configure GPIOx as CMOS */
3653 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
3655 snd_hda_codec_write(codec, codec->afg, 0,
3656 AC_VERB_SET_GPIO_MASK, gpiomask);
3657 snd_hda_codec_read(codec, codec->afg, 0,
3658 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
3662 snd_hda_codec_read(codec, codec->afg, 0,
3663 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
3666 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
3669 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
3670 snd_hda_codec_write_cache(codec, nid, 0,
3671 AC_VERB_SET_UNSOLICITED_ENABLE,
3672 (AC_USRSP_EN | event));
3675 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
3678 for (i = 0; i < cfg->hp_outs; i++)
3679 if (cfg->hp_pins[i] == nid)
3680 return 1; /* nid is a HP-Out */
3682 return 0; /* nid is not a HP-Out */
3685 static void stac92xx_power_down(struct hda_codec *codec)
3687 struct sigmatel_spec *spec = codec->spec;
3689 /* power down inactive DACs */
3691 for (dac = spec->dac_list; *dac; dac++)
3692 if (!is_in_dac_nids(spec, *dac) &&
3693 spec->multiout.hp_nid != *dac)
3694 snd_hda_codec_write_cache(codec, *dac, 0,
3695 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3698 static int stac92xx_init(struct hda_codec *codec)
3700 struct sigmatel_spec *spec = codec->spec;
3701 struct auto_pin_cfg *cfg = &spec->autocfg;
3704 snd_hda_sequence_write(codec, spec->init);
3706 /* power down adcs initially */
3707 if (spec->powerdown_adcs)
3708 for (i = 0; i < spec->num_adcs; i++)
3709 snd_hda_codec_write_cache(codec,
3710 spec->adc_nids[i], 0,
3711 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3713 if (spec->hp_detect) {
3714 /* Enable unsolicited responses on the HP widget */
3715 for (i = 0; i < cfg->hp_outs; i++)
3716 enable_pin_detect(codec, cfg->hp_pins[i],
3718 /* force to enable the first line-out; the others are set up
3721 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
3723 stac92xx_auto_init_hp_out(codec);
3724 /* fake event to set up pins */
3725 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3727 stac92xx_auto_init_multi_out(codec);
3728 stac92xx_auto_init_hp_out(codec);
3730 for (i = 0; i < AUTO_PIN_LAST; i++) {
3731 hda_nid_t nid = cfg->input_pins[i];
3733 unsigned int pinctl;
3734 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
3735 /* for mic pins, force to initialize */
3736 pinctl = stac92xx_get_vref(codec, nid);
3738 pinctl = snd_hda_codec_read(codec, nid, 0,
3739 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3740 /* if PINCTL already set then skip */
3741 if (pinctl & AC_PINCTL_IN_EN)
3744 pinctl |= AC_PINCTL_IN_EN;
3745 stac92xx_auto_set_pinctl(codec, nid, pinctl);
3748 for (i = 0; i < spec->num_dmics; i++)
3749 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
3751 for (i = 0; i < spec->num_pwrs; i++) {
3752 int event = is_nid_hp_pin(cfg, spec->pwr_nids[i])
3753 ? STAC_HP_EVENT : STAC_PWR_EVENT;
3754 int pinctl = snd_hda_codec_read(codec, spec->pwr_nids[i],
3755 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3756 int def_conf = snd_hda_codec_read(codec, spec->pwr_nids[i],
3757 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
3758 def_conf = get_defcfg_connect(def_conf);
3759 /* outputs are only ports capable of power management
3760 * any attempts on powering down a input port cause the
3761 * referenced VREF to act quirky.
3763 if (pinctl & AC_PINCTL_IN_EN)
3765 /* skip any ports that don't have jacks since presence
3766 * detection is useless */
3767 if (def_conf && def_conf != AC_JACK_PORT_FIXED)
3769 enable_pin_detect(codec, spec->pwr_nids[i], event | i);
3770 codec->patch_ops.unsol_event(codec, (event | i) << 26);
3773 stac92xx_power_down(codec);
3774 if (cfg->dig_out_pin)
3775 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
3777 if (cfg->dig_in_pin)
3778 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
3781 stac_gpio_set(codec, spec->gpio_mask,
3782 spec->gpio_dir, spec->gpio_data);
3787 static void stac92xx_free(struct hda_codec *codec)
3789 struct sigmatel_spec *spec = codec->spec;
3795 if (spec->kctl_alloc) {
3796 for (i = 0; i < spec->num_kctl_used; i++)
3797 kfree(spec->kctl_alloc[i].name);
3798 kfree(spec->kctl_alloc);
3801 if (spec->bios_pin_configs)
3802 kfree(spec->bios_pin_configs);
3805 snd_hda_detach_beep_device(codec);
3808 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
3811 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
3812 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
3814 if (pin_ctl & AC_PINCTL_IN_EN) {
3816 * we need to check the current set-up direction of
3817 * shared input pins since they can be switched via
3818 * "xxx as Output" mixer switch
3820 struct sigmatel_spec *spec = codec->spec;
3821 struct auto_pin_cfg *cfg = &spec->autocfg;
3822 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
3823 spec->line_switch) ||
3824 (nid == cfg->input_pins[AUTO_PIN_MIC] &&
3829 /* if setting pin direction bits, clear the current
3830 direction bits first */
3831 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
3832 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
3834 snd_hda_codec_write_cache(codec, nid, 0,
3835 AC_VERB_SET_PIN_WIDGET_CONTROL,
3839 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
3842 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
3843 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
3844 snd_hda_codec_write_cache(codec, nid, 0,
3845 AC_VERB_SET_PIN_WIDGET_CONTROL,
3849 static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid)
3853 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
3855 unsigned int pinctl;
3856 pinctl = snd_hda_codec_read(codec, nid, 0,
3857 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3858 if (pinctl & AC_PINCTL_IN_EN)
3859 return 0; /* mic- or line-input */
3861 return 1; /* HP-output */
3866 /* return non-zero if the hp-pin of the given array index isn't
3867 * a jack-detection target
3869 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
3871 struct auto_pin_cfg *cfg = &spec->autocfg;
3873 /* ignore sensing of shared line and mic jacks */
3874 if (spec->line_switch &&
3875 cfg->hp_pins[i] == cfg->input_pins[AUTO_PIN_LINE])
3877 if (spec->mic_switch &&
3878 cfg->hp_pins[i] == cfg->input_pins[AUTO_PIN_MIC])
3880 /* ignore if the pin is set as line-out */
3881 if (cfg->hp_pins[i] == spec->hp_switch)
3886 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
3888 struct sigmatel_spec *spec = codec->spec;
3889 struct auto_pin_cfg *cfg = &spec->autocfg;
3893 if (spec->gpio_mute)
3894 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
3895 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
3897 for (i = 0; i < cfg->hp_outs; i++) {
3900 if (no_hp_sensing(spec, i))
3902 presence = get_hp_pin_presence(codec, cfg->hp_pins[i]);
3906 /* disable lineouts */
3907 if (spec->hp_switch)
3908 stac92xx_reset_pinctl(codec, spec->hp_switch,
3910 for (i = 0; i < cfg->line_outs; i++)
3911 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
3913 for (i = 0; i < cfg->speaker_outs; i++)
3914 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
3916 if (spec->eapd_mask && spec->eapd_switch)
3917 stac_gpio_set(codec, spec->gpio_mask,
3918 spec->gpio_dir, spec->gpio_data &
3921 /* enable lineouts */
3922 if (spec->hp_switch)
3923 stac92xx_set_pinctl(codec, spec->hp_switch,
3925 for (i = 0; i < cfg->line_outs; i++)
3926 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
3928 for (i = 0; i < cfg->speaker_outs; i++)
3929 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
3931 if (spec->eapd_mask && spec->eapd_switch)
3932 stac_gpio_set(codec, spec->gpio_mask,
3933 spec->gpio_dir, spec->gpio_data |
3936 /* toggle hp outs */
3937 for (i = 0; i < cfg->hp_outs; i++) {
3938 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
3939 if (no_hp_sensing(spec, i))
3942 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
3944 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
3948 static void stac92xx_pin_sense(struct hda_codec *codec, int idx)
3950 struct sigmatel_spec *spec = codec->spec;
3951 hda_nid_t nid = spec->pwr_nids[idx];
3953 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0)
3955 presence = get_hp_pin_presence(codec, nid);
3957 /* several codecs have two power down bits */
3958 if (spec->pwr_mapping)
3959 idx = spec->pwr_mapping[idx];
3968 /* power down unused output ports */
3969 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
3972 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
3974 struct sigmatel_spec *spec = codec->spec;
3975 int idx = res >> 26 & 0x0f;
3977 switch ((res >> 26) & 0x70) {
3979 stac92xx_hp_detect(codec, res);
3981 case STAC_PWR_EVENT:
3982 if (spec->num_pwrs > 0)
3983 stac92xx_pin_sense(codec, idx);
3985 case STAC_VREF_EVENT: {
3986 int data = snd_hda_codec_read(codec, codec->afg, 0,
3987 AC_VERB_GET_GPIO_DATA, 0);
3988 /* toggle VREF state based on GPIOx status */
3989 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
3990 !!(data & (1 << idx)));
3996 #ifdef SND_HDA_NEEDS_RESUME
3997 static int stac92xx_resume(struct hda_codec *codec)
3999 struct sigmatel_spec *spec = codec->spec;
4001 stac92xx_set_config_regs(codec);
4002 snd_hda_sequence_write(codec, spec->init);
4003 stac_gpio_set(codec, spec->gpio_mask,
4004 spec->gpio_dir, spec->gpio_data);
4005 snd_hda_codec_resume_amp(codec);
4006 snd_hda_codec_resume_cache(codec);
4007 /* power down inactive DACs */
4009 stac92xx_power_down(codec);
4010 /* invoke unsolicited event to reset the HP state */
4011 if (spec->hp_detect)
4012 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
4017 static struct hda_codec_ops stac92xx_patch_ops = {
4018 .build_controls = stac92xx_build_controls,
4019 .build_pcms = stac92xx_build_pcms,
4020 .init = stac92xx_init,
4021 .free = stac92xx_free,
4022 .unsol_event = stac92xx_unsol_event,
4023 #ifdef SND_HDA_NEEDS_RESUME
4024 .resume = stac92xx_resume,
4028 static int patch_stac9200(struct hda_codec *codec)
4030 struct sigmatel_spec *spec;
4033 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4038 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
4039 spec->pin_nids = stac9200_pin_nids;
4040 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
4043 if (spec->board_config < 0) {
4044 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
4045 err = stac92xx_save_bios_config_regs(codec);
4047 stac92xx_free(codec);
4050 spec->pin_configs = spec->bios_pin_configs;
4052 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
4053 stac92xx_set_config_regs(codec);
4056 spec->multiout.max_channels = 2;
4057 spec->multiout.num_dacs = 1;
4058 spec->multiout.dac_nids = stac9200_dac_nids;
4059 spec->adc_nids = stac9200_adc_nids;
4060 spec->mux_nids = stac9200_mux_nids;
4061 spec->num_muxes = 1;
4062 spec->num_dmics = 0;
4066 if (spec->board_config == STAC_9200_GATEWAY ||
4067 spec->board_config == STAC_9200_OQO)
4068 spec->init = stac9200_eapd_init;
4070 spec->init = stac9200_core_init;
4071 spec->mixer = stac9200_mixer;
4073 if (spec->board_config == STAC_9200_PANASONIC) {
4074 spec->gpio_mask = spec->gpio_dir = 0x09;
4075 spec->gpio_data = 0x00;
4078 err = stac9200_parse_auto_config(codec);
4080 stac92xx_free(codec);
4084 codec->patch_ops = stac92xx_patch_ops;
4089 static int patch_stac925x(struct hda_codec *codec)
4091 struct sigmatel_spec *spec;
4094 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4099 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
4100 spec->pin_nids = stac925x_pin_nids;
4101 spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
4105 if (spec->board_config < 0) {
4106 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
4107 "using BIOS defaults\n");
4108 err = stac92xx_save_bios_config_regs(codec);
4110 stac92xx_free(codec);
4113 spec->pin_configs = spec->bios_pin_configs;
4114 } else if (stac925x_brd_tbl[spec->board_config] != NULL){
4115 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
4116 stac92xx_set_config_regs(codec);
4119 spec->multiout.max_channels = 2;
4120 spec->multiout.num_dacs = 1;
4121 spec->multiout.dac_nids = stac925x_dac_nids;
4122 spec->adc_nids = stac925x_adc_nids;
4123 spec->mux_nids = stac925x_mux_nids;
4124 spec->num_muxes = 1;
4127 switch (codec->vendor_id) {
4128 case 0x83847632: /* STAC9202 */
4129 case 0x83847633: /* STAC9202D */
4130 case 0x83847636: /* STAC9251 */
4131 case 0x83847637: /* STAC9251D */
4132 spec->num_dmics = STAC925X_NUM_DMICS;
4133 spec->dmic_nids = stac925x_dmic_nids;
4134 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
4135 spec->dmux_nids = stac925x_dmux_nids;
4138 spec->num_dmics = 0;
4142 spec->init = stac925x_core_init;
4143 spec->mixer = stac925x_mixer;
4145 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
4147 if (spec->board_config < 0) {
4148 printk(KERN_WARNING "hda_codec: No auto-config is "
4149 "available, default to model=ref\n");
4150 spec->board_config = STAC_925x_REF;
4156 stac92xx_free(codec);
4160 codec->patch_ops = stac92xx_patch_ops;
4165 static struct hda_input_mux stac92hd73xx_dmux = {
4168 { "Analog Inputs", 0x0b },
4169 { "Digital Mic 1", 0x09 },
4170 { "Digital Mic 2", 0x0a },
4175 static int patch_stac92hd73xx(struct hda_codec *codec)
4177 struct sigmatel_spec *spec;
4178 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
4181 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4186 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
4187 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
4188 spec->pin_nids = stac92hd73xx_pin_nids;
4189 spec->board_config = snd_hda_check_board_config(codec,
4190 STAC_92HD73XX_MODELS,
4191 stac92hd73xx_models,
4192 stac92hd73xx_cfg_tbl);
4194 if (spec->board_config < 0) {
4195 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4196 " STAC92HD73XX, using BIOS defaults\n");
4197 err = stac92xx_save_bios_config_regs(codec);
4199 stac92xx_free(codec);
4202 spec->pin_configs = spec->bios_pin_configs;
4204 spec->pin_configs = stac92hd73xx_brd_tbl[spec->board_config];
4205 stac92xx_set_config_regs(codec);
4208 spec->multiout.num_dacs = snd_hda_get_connections(codec, 0x0a,
4209 conn, STAC92HD73_DAC_COUNT + 2) - 1;
4211 if (spec->multiout.num_dacs < 0) {
4212 printk(KERN_WARNING "hda_codec: Could not determine "
4213 "number of channels defaulting to DAC count\n");
4214 spec->multiout.num_dacs = STAC92HD73_DAC_COUNT;
4217 switch (spec->multiout.num_dacs) {
4218 case 0x3: /* 6 Channel */
4219 spec->mixer = stac92hd73xx_6ch_mixer;
4220 spec->init = stac92hd73xx_6ch_core_init;
4222 case 0x4: /* 8 Channel */
4223 spec->mixer = stac92hd73xx_8ch_mixer;
4224 spec->init = stac92hd73xx_8ch_core_init;
4226 case 0x5: /* 10 Channel */
4227 spec->mixer = stac92hd73xx_10ch_mixer;
4228 spec->init = stac92hd73xx_10ch_core_init;
4231 spec->multiout.dac_nids = stac92hd73xx_dac_nids;
4232 spec->aloopback_mask = 0x01;
4233 spec->aloopback_shift = 8;
4235 spec->digbeep_nid = 0x1c;
4236 spec->mux_nids = stac92hd73xx_mux_nids;
4237 spec->adc_nids = stac92hd73xx_adc_nids;
4238 spec->dmic_nids = stac92hd73xx_dmic_nids;
4239 spec->dmux_nids = stac92hd73xx_dmux_nids;
4240 spec->smux_nids = stac92hd73xx_smux_nids;
4241 spec->amp_nids = stac92hd73xx_amp_nids;
4242 spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
4244 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
4245 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
4246 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
4247 memcpy(&spec->private_dimux, &stac92hd73xx_dmux,
4248 sizeof(stac92hd73xx_dmux));
4250 switch (spec->board_config) {
4252 spec->init = dell_eq_core_init;
4255 spec->num_smuxes = 0;
4256 spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
4257 spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
4258 spec->eapd_switch = 0;
4262 spec->init = dell_m6_core_init;
4263 switch (codec->subsystem_id) {
4264 case 0x1028025e: /* Analog Mics */
4266 stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
4267 spec->num_dmics = 0;
4268 spec->private_dimux.num_items = 1;
4270 case 0x10280271: /* Digital Mics */
4274 stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
4275 spec->num_dmics = 1;
4276 spec->private_dimux.num_items = 2;
4278 case 0x10280256: /* Both */
4280 stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
4281 stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
4282 spec->num_dmics = 1;
4283 spec->private_dimux.num_items = 2;
4288 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
4289 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
4290 spec->eapd_switch = 1;
4292 if (spec->board_config > STAC_92HD73XX_REF) {
4293 /* GPIO0 High = Enable EAPD */
4294 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4295 spec->gpio_data = 0x01;
4297 spec->dinput_mux = &spec->private_dimux;
4299 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
4300 spec->pwr_nids = stac92hd73xx_pwr_nids;
4302 err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
4305 if (spec->board_config < 0) {
4306 printk(KERN_WARNING "hda_codec: No auto-config is "
4307 "available, default to model=ref\n");
4308 spec->board_config = STAC_92HD73XX_REF;
4315 stac92xx_free(codec);
4319 codec->patch_ops = stac92xx_patch_ops;
4324 static struct hda_input_mux stac92hd83xxx_dmux = {
4327 { "Analog Inputs", 0x03 },
4328 { "Digital Mic 1", 0x04 },
4329 { "Digital Mic 2", 0x05 },
4333 static int patch_stac92hd83xxx(struct hda_codec *codec)
4335 struct sigmatel_spec *spec;
4338 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4343 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
4344 spec->mono_nid = 0x19;
4345 spec->digbeep_nid = 0x21;
4346 spec->dmic_nids = stac92hd83xxx_dmic_nids;
4347 spec->dmux_nids = stac92hd83xxx_dmux_nids;
4348 spec->adc_nids = stac92hd83xxx_adc_nids;
4349 spec->pwr_nids = stac92hd83xxx_pwr_nids;
4350 spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
4351 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
4352 spec->multiout.dac_nids = stac92hd83xxx_dac_nids;
4354 spec->init = stac92hd83xxx_core_init;
4355 switch (codec->vendor_id) {
4357 spec->multiout.num_dacs = STAC92HD81_DAC_COUNT;
4361 spec->init++; /* switch to config #2 */
4362 spec->multiout.num_dacs = STAC92HD83_DAC_COUNT;
4365 spec->mixer = stac92hd83xxx_mixer;
4366 spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
4367 spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
4368 spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
4369 spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
4370 spec->dinput_mux = &stac92hd83xxx_dmux;
4371 spec->pin_nids = stac92hd83xxx_pin_nids;
4372 spec->board_config = snd_hda_check_board_config(codec,
4373 STAC_92HD83XXX_MODELS,
4374 stac92hd83xxx_models,
4375 stac92hd83xxx_cfg_tbl);
4377 if (spec->board_config < 0) {
4378 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4379 " STAC92HD83XXX, using BIOS defaults\n");
4380 err = stac92xx_save_bios_config_regs(codec);
4382 stac92xx_free(codec);
4385 spec->pin_configs = spec->bios_pin_configs;
4387 spec->pin_configs = stac92hd83xxx_brd_tbl[spec->board_config];
4388 stac92xx_set_config_regs(codec);
4391 err = stac92xx_parse_auto_config(codec, 0x1d, 0);
4393 if (spec->board_config < 0) {
4394 printk(KERN_WARNING "hda_codec: No auto-config is "
4395 "available, default to model=ref\n");
4396 spec->board_config = STAC_92HD83XXX_REF;
4403 stac92xx_free(codec);
4407 codec->patch_ops = stac92xx_patch_ops;
4412 #ifdef SND_HDA_NEEDS_RESUME
4413 static void stac92hd71xx_set_power_state(struct hda_codec *codec, int pwr)
4415 struct sigmatel_spec *spec = codec->spec;
4417 snd_hda_codec_write_cache(codec, codec->afg, 0,
4418 AC_VERB_SET_POWER_STATE, pwr);
4421 for (i = 0; i < spec->num_adcs; i++) {
4422 snd_hda_codec_write_cache(codec,
4423 spec->adc_nids[i], 0,
4424 AC_VERB_SET_POWER_STATE, pwr);
4428 static int stac92hd71xx_resume(struct hda_codec *codec)
4430 stac92hd71xx_set_power_state(codec, AC_PWRST_D0);
4431 return stac92xx_resume(codec);
4434 static int stac92hd71xx_suspend(struct hda_codec *codec, pm_message_t state)
4436 struct sigmatel_spec *spec = codec->spec;
4438 stac92hd71xx_set_power_state(codec, AC_PWRST_D3);
4439 if (spec->eapd_mask)
4440 stac_gpio_set(codec, spec->gpio_mask,
4441 spec->gpio_dir, spec->gpio_data &
4448 static struct hda_codec_ops stac92hd71bxx_patch_ops = {
4449 .build_controls = stac92xx_build_controls,
4450 .build_pcms = stac92xx_build_pcms,
4451 .init = stac92xx_init,
4452 .free = stac92xx_free,
4453 .unsol_event = stac92xx_unsol_event,
4454 #ifdef SND_HDA_NEEDS_RESUME
4455 .resume = stac92hd71xx_resume,
4456 .suspend = stac92hd71xx_suspend,
4460 static struct hda_input_mux stac92hd71bxx_dmux = {
4463 { "Analog Inputs", 0x00 },
4465 { "Digital Mic 1", 0x02 },
4466 { "Digital Mic 2", 0x03 },
4470 static int patch_stac92hd71bxx(struct hda_codec *codec)
4472 struct sigmatel_spec *spec;
4475 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4480 codec->patch_ops = stac92xx_patch_ops;
4481 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
4482 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
4483 spec->pin_nids = stac92hd71bxx_pin_nids;
4484 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux,
4485 sizeof(stac92hd71bxx_dmux));
4486 spec->board_config = snd_hda_check_board_config(codec,
4487 STAC_92HD71BXX_MODELS,
4488 stac92hd71bxx_models,
4489 stac92hd71bxx_cfg_tbl);
4491 if (spec->board_config < 0) {
4492 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4493 " STAC92HD71BXX, using BIOS defaults\n");
4494 err = stac92xx_save_bios_config_regs(codec);
4496 stac92xx_free(codec);
4499 spec->pin_configs = spec->bios_pin_configs;
4501 spec->pin_configs = stac92hd71bxx_brd_tbl[spec->board_config];
4502 stac92xx_set_config_regs(codec);
4505 if (spec->board_config > STAC_92HD71BXX_REF) {
4507 spec->gpio_mask = 0x01;
4508 spec->gpio_dir = 0x01;
4509 spec->gpio_data = 0x01;
4512 switch (codec->vendor_id) {
4513 case 0x111d76b6: /* 4 Port without Analog Mixer */
4515 case 0x111d76b4: /* 6 Port without Analog Mixer */
4517 spec->mixer = stac92hd71bxx_mixer;
4518 spec->init = stac92hd71bxx_core_init;
4519 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4521 case 0x111d7608: /* 5 Port with Analog Mixer */
4522 switch (spec->board_config) {
4524 /* Enable VREF power saving on GPIO1 detect */
4525 snd_hda_codec_write_cache(codec, codec->afg, 0,
4526 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
4527 snd_hda_codec_write_cache(codec, codec->afg, 0,
4528 AC_VERB_SET_UNSOLICITED_ENABLE,
4529 (AC_USRSP_EN | STAC_VREF_EVENT | 0x01));
4530 spec->gpio_mask |= 0x02;
4533 if ((codec->revision_id & 0xf) == 0 ||
4534 (codec->revision_id & 0xf) == 1) {
4535 #ifdef SND_HDA_NEEDS_RESUME
4536 codec->patch_ops = stac92hd71bxx_patch_ops;
4538 spec->stream_delay = 40; /* 40 milliseconds */
4541 /* no output amps */
4543 spec->mixer = stac92hd71bxx_analog_mixer;
4544 spec->dinput_mux = &spec->private_dimux;
4547 spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
4548 stac92xx_set_config_reg(codec, 0xf, 0x40f000f0);
4550 case 0x111d7603: /* 6 Port with Analog Mixer */
4551 if ((codec->revision_id & 0xf) == 1) {
4552 #ifdef SND_HDA_NEEDS_RESUME
4553 codec->patch_ops = stac92hd71bxx_patch_ops;
4555 spec->stream_delay = 40; /* 40 milliseconds */
4558 /* no output amps */
4562 spec->dinput_mux = &spec->private_dimux;
4563 spec->mixer = stac92hd71bxx_analog_mixer;
4564 spec->init = stac92hd71bxx_analog_core_init;
4565 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4568 spec->aloopback_mask = 0x50;
4569 spec->aloopback_shift = 0;
4571 spec->powerdown_adcs = 1;
4572 spec->digbeep_nid = 0x26;
4573 spec->mux_nids = stac92hd71bxx_mux_nids;
4574 spec->adc_nids = stac92hd71bxx_adc_nids;
4575 spec->dmic_nids = stac92hd71bxx_dmic_nids;
4576 spec->dmux_nids = stac92hd71bxx_dmux_nids;
4577 spec->smux_nids = stac92hd71bxx_smux_nids;
4578 spec->pwr_nids = stac92hd71bxx_pwr_nids;
4580 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
4581 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
4583 switch (spec->board_config) {
4585 /* enable internal microphone */
4586 stac92xx_set_config_reg(codec, 0x0e, 0x01813040);
4587 stac92xx_auto_set_pinctl(codec, 0x0e,
4588 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
4590 case STAC_DELL_M4_2:
4591 spec->num_dmics = 0;
4592 spec->num_smuxes = 0;
4593 spec->num_dmuxes = 0;
4595 case STAC_DELL_M4_1:
4596 case STAC_DELL_M4_3:
4597 spec->num_dmics = 1;
4598 spec->num_smuxes = 0;
4599 spec->num_dmuxes = 0;
4602 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
4603 spec->num_smuxes = ARRAY_SIZE(stac92hd71bxx_smux_nids);
4604 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
4607 spec->multiout.num_dacs = 1;
4608 spec->multiout.hp_nid = 0x11;
4609 spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
4610 if (spec->dinput_mux)
4611 spec->private_dimux.num_items +=
4613 (ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1);
4615 err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
4617 if (spec->board_config < 0) {
4618 printk(KERN_WARNING "hda_codec: No auto-config is "
4619 "available, default to model=ref\n");
4620 spec->board_config = STAC_92HD71BXX_REF;
4627 stac92xx_free(codec);
4634 static int patch_stac922x(struct hda_codec *codec)
4636 struct sigmatel_spec *spec;
4639 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4644 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
4645 spec->pin_nids = stac922x_pin_nids;
4646 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
4649 if (spec->board_config == STAC_INTEL_MAC_AUTO) {
4650 spec->gpio_mask = spec->gpio_dir = 0x03;
4651 spec->gpio_data = 0x03;
4652 /* Intel Macs have all same PCI SSID, so we need to check
4653 * codec SSID to distinguish the exact models
4655 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
4656 switch (codec->subsystem_id) {
4659 spec->board_config = STAC_INTEL_MAC_V1;
4663 spec->board_config = STAC_INTEL_MAC_V2;
4671 spec->board_config = STAC_INTEL_MAC_V3;
4675 spec->board_config = STAC_INTEL_MAC_V4;
4679 spec->board_config = STAC_INTEL_MAC_V5;
4682 spec->board_config = STAC_INTEL_MAC_V3;
4688 if (spec->board_config < 0) {
4689 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
4690 "using BIOS defaults\n");
4691 err = stac92xx_save_bios_config_regs(codec);
4693 stac92xx_free(codec);
4696 spec->pin_configs = spec->bios_pin_configs;
4697 } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
4698 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
4699 stac92xx_set_config_regs(codec);
4702 spec->adc_nids = stac922x_adc_nids;
4703 spec->mux_nids = stac922x_mux_nids;
4704 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
4705 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
4706 spec->num_dmics = 0;
4709 spec->init = stac922x_core_init;
4710 spec->mixer = stac922x_mixer;
4712 spec->multiout.dac_nids = spec->dac_nids;
4714 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
4716 if (spec->board_config < 0) {
4717 printk(KERN_WARNING "hda_codec: No auto-config is "
4718 "available, default to model=ref\n");
4719 spec->board_config = STAC_D945_REF;
4725 stac92xx_free(codec);
4729 codec->patch_ops = stac92xx_patch_ops;
4731 /* Fix Mux capture level; max to 2 */
4732 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
4733 (0 << AC_AMPCAP_OFFSET_SHIFT) |
4734 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4735 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4736 (0 << AC_AMPCAP_MUTE_SHIFT));
4741 static int patch_stac927x(struct hda_codec *codec)
4743 struct sigmatel_spec *spec;
4746 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4751 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
4752 spec->pin_nids = stac927x_pin_nids;
4753 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
4757 if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
4758 if (spec->board_config < 0)
4759 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4760 "STAC927x, using BIOS defaults\n");
4761 err = stac92xx_save_bios_config_regs(codec);
4763 stac92xx_free(codec);
4766 spec->pin_configs = spec->bios_pin_configs;
4768 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
4769 stac92xx_set_config_regs(codec);
4772 spec->digbeep_nid = 0x23;
4773 spec->adc_nids = stac927x_adc_nids;
4774 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
4775 spec->mux_nids = stac927x_mux_nids;
4776 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
4777 spec->smux_nids = stac927x_smux_nids;
4778 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
4779 spec->spdif_labels = stac927x_spdif_labels;
4780 spec->dac_list = stac927x_dac_nids;
4781 spec->multiout.dac_nids = spec->dac_nids;
4783 switch (spec->board_config) {
4786 /* GPIO0 High = Enable EAPD */
4787 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01;
4788 spec->gpio_data = 0x01;
4789 spec->num_dmics = 0;
4791 spec->init = d965_core_init;
4792 spec->mixer = stac927x_mixer;
4794 case STAC_DELL_BIOS:
4795 switch (codec->subsystem_id) {
4798 /* correct the device field to SPDIF out */
4799 stac92xx_set_config_reg(codec, 0x21, 0x01442070);
4802 /* configure the analog microphone on some laptops */
4803 stac92xx_set_config_reg(codec, 0x0c, 0x90a79130);
4804 /* correct the front output jack as a hp out */
4805 stac92xx_set_config_reg(codec, 0x0f, 0x0227011f);
4806 /* correct the front input jack as a mic */
4807 stac92xx_set_config_reg(codec, 0x0e, 0x02a79130);
4810 /* GPIO2 High = Enable EAPD */
4811 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
4812 spec->gpio_data = 0x04;
4813 spec->dmic_nids = stac927x_dmic_nids;
4814 spec->num_dmics = STAC927X_NUM_DMICS;
4816 spec->init = d965_core_init;
4817 spec->mixer = stac927x_mixer;
4818 spec->dmux_nids = stac927x_dmux_nids;
4819 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
4822 if (spec->board_config > STAC_D965_REF) {
4823 /* GPIO0 High = Enable EAPD */
4824 spec->eapd_mask = spec->gpio_mask = 0x01;
4825 spec->gpio_dir = spec->gpio_data = 0x01;
4827 spec->num_dmics = 0;
4829 spec->init = stac927x_core_init;
4830 spec->mixer = stac927x_mixer;
4834 spec->aloopback_mask = 0x40;
4835 spec->aloopback_shift = 0;
4836 spec->eapd_switch = 1;
4838 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
4840 if (spec->board_config < 0) {
4841 printk(KERN_WARNING "hda_codec: No auto-config is "
4842 "available, default to model=ref\n");
4843 spec->board_config = STAC_D965_REF;
4849 stac92xx_free(codec);
4853 codec->patch_ops = stac92xx_patch_ops;
4857 * The STAC927x seem to require fairly long delays for certain
4858 * command sequences. With too short delays (even if the answer
4859 * is set to RIRB properly), it results in the silence output
4860 * on some hardwares like Dell.
4862 * The below flag enables the longer delay (see get_response
4865 codec->bus->needs_damn_long_delay = 1;
4870 static int patch_stac9205(struct hda_codec *codec)
4872 struct sigmatel_spec *spec;
4875 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4880 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
4881 spec->pin_nids = stac9205_pin_nids;
4882 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
4886 if (spec->board_config < 0) {
4887 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
4888 err = stac92xx_save_bios_config_regs(codec);
4890 stac92xx_free(codec);
4893 spec->pin_configs = spec->bios_pin_configs;
4895 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
4896 stac92xx_set_config_regs(codec);
4899 spec->digbeep_nid = 0x23;
4900 spec->adc_nids = stac9205_adc_nids;
4901 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
4902 spec->mux_nids = stac9205_mux_nids;
4903 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
4904 spec->smux_nids = stac9205_smux_nids;
4905 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
4906 spec->dmic_nids = stac9205_dmic_nids;
4907 spec->num_dmics = STAC9205_NUM_DMICS;
4908 spec->dmux_nids = stac9205_dmux_nids;
4909 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
4912 spec->init = stac9205_core_init;
4913 spec->mixer = stac9205_mixer;
4915 spec->aloopback_mask = 0x40;
4916 spec->aloopback_shift = 0;
4917 spec->eapd_switch = 1;
4918 spec->multiout.dac_nids = spec->dac_nids;
4920 switch (spec->board_config){
4921 case STAC_9205_DELL_M43:
4922 /* Enable SPDIF in/out */
4923 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
4924 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
4926 /* Enable unsol response for GPIO4/Dock HP connection */
4927 snd_hda_codec_write_cache(codec, codec->afg, 0,
4928 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
4929 snd_hda_codec_write_cache(codec, codec->afg, 0,
4930 AC_VERB_SET_UNSOLICITED_ENABLE,
4931 (AC_USRSP_EN | STAC_HP_EVENT));
4933 spec->gpio_dir = 0x0b;
4934 spec->eapd_mask = 0x01;
4935 spec->gpio_mask = 0x1b;
4936 spec->gpio_mute = 0x10;
4937 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
4940 spec->gpio_data = 0x01;
4943 /* SPDIF-In enabled */
4946 /* GPIO0 High = EAPD */
4947 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4948 spec->gpio_data = 0x01;
4952 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
4954 if (spec->board_config < 0) {
4955 printk(KERN_WARNING "hda_codec: No auto-config is "
4956 "available, default to model=ref\n");
4957 spec->board_config = STAC_9205_REF;
4963 stac92xx_free(codec);
4967 codec->patch_ops = stac92xx_patch_ops;
4976 /* static config for Sony VAIO FE550G and Sony VAIO AR */
4977 static hda_nid_t vaio_dacs[] = { 0x2 };
4978 #define VAIO_HP_DAC 0x5
4979 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
4980 static hda_nid_t vaio_mux_nids[] = { 0x15 };
4982 static struct hda_input_mux vaio_mux = {
4985 /* { "HP", 0x0 }, */
4986 { "Mic Jack", 0x1 },
4987 { "Internal Mic", 0x2 },
4992 static struct hda_verb vaio_init[] = {
4993 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
4994 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
4995 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
4996 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
4997 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
4998 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
4999 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5000 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
5001 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
5002 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
5003 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
5004 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5008 static struct hda_verb vaio_ar_init[] = {
5009 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
5010 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
5011 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
5012 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
5013 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
5014 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
5015 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5016 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
5017 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
5018 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
5019 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
5020 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
5021 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
5025 /* bind volumes of both NID 0x02 and 0x05 */
5026 static struct hda_bind_ctls vaio_bind_master_vol = {
5027 .ops = &snd_hda_bind_vol,
5029 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
5030 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
5035 /* bind volumes of both NID 0x02 and 0x05 */
5036 static struct hda_bind_ctls vaio_bind_master_sw = {
5037 .ops = &snd_hda_bind_sw,
5039 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
5040 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
5045 static struct snd_kcontrol_new vaio_mixer[] = {
5046 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
5047 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
5048 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
5049 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5050 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5052 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5053 .name = "Capture Source",
5055 .info = stac92xx_mux_enum_info,
5056 .get = stac92xx_mux_enum_get,
5057 .put = stac92xx_mux_enum_put,
5062 static struct snd_kcontrol_new vaio_ar_mixer[] = {
5063 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
5064 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
5065 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
5066 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5067 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5068 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
5069 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
5071 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5072 .name = "Capture Source",
5074 .info = stac92xx_mux_enum_info,
5075 .get = stac92xx_mux_enum_get,
5076 .put = stac92xx_mux_enum_put,
5081 static struct hda_codec_ops stac9872_patch_ops = {
5082 .build_controls = stac92xx_build_controls,
5083 .build_pcms = stac92xx_build_pcms,
5084 .init = stac92xx_init,
5085 .free = stac92xx_free,
5086 #ifdef SND_HDA_NEEDS_RESUME
5087 .resume = stac92xx_resume,
5091 static int stac9872_vaio_init(struct hda_codec *codec)
5095 err = stac92xx_init(codec);
5098 if (codec->patch_ops.unsol_event)
5099 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
5103 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
5105 if (get_hp_pin_presence(codec, 0x0a)) {
5106 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
5107 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
5109 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
5110 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
5114 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
5116 switch (res >> 26) {
5118 stac9872_vaio_hp_detect(codec, res);
5123 static struct hda_codec_ops stac9872_vaio_patch_ops = {
5124 .build_controls = stac92xx_build_controls,
5125 .build_pcms = stac92xx_build_pcms,
5126 .init = stac9872_vaio_init,
5127 .free = stac92xx_free,
5128 .unsol_event = stac9872_vaio_unsol_event,
5130 .resume = stac92xx_resume,
5134 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
5136 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
5138 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
5140 /* AR Series. id=0x83847664 and subsys=104D1300 */
5145 static const char *stac9872_models[STAC_9872_MODELS] = {
5146 [CXD9872RD_VAIO] = "vaio",
5147 [CXD9872AKD_VAIO] = "vaio-ar",
5150 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
5151 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
5152 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
5153 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
5154 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
5158 static int patch_stac9872(struct hda_codec *codec)
5160 struct sigmatel_spec *spec;
5163 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
5166 if (board_config < 0)
5167 /* unknown config, let generic-parser do its job... */
5168 return snd_hda_parse_generic_codec(codec);
5170 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5175 switch (board_config) {
5176 case CXD9872RD_VAIO:
5177 case STAC9872AK_VAIO:
5178 case STAC9872K_VAIO:
5179 spec->mixer = vaio_mixer;
5180 spec->init = vaio_init;
5181 spec->multiout.max_channels = 2;
5182 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
5183 spec->multiout.dac_nids = vaio_dacs;
5184 spec->multiout.hp_nid = VAIO_HP_DAC;
5185 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
5186 spec->adc_nids = vaio_adcs;
5188 spec->input_mux = &vaio_mux;
5189 spec->mux_nids = vaio_mux_nids;
5190 codec->patch_ops = stac9872_vaio_patch_ops;
5193 case CXD9872AKD_VAIO:
5194 spec->mixer = vaio_ar_mixer;
5195 spec->init = vaio_ar_init;
5196 spec->multiout.max_channels = 2;
5197 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
5198 spec->multiout.dac_nids = vaio_dacs;
5199 spec->multiout.hp_nid = VAIO_HP_DAC;
5200 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
5202 spec->adc_nids = vaio_adcs;
5203 spec->input_mux = &vaio_mux;
5204 spec->mux_nids = vaio_mux_nids;
5205 codec->patch_ops = stac9872_patch_ops;
5216 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
5217 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
5218 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
5219 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
5220 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
5221 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
5222 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
5223 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
5224 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
5225 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
5226 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
5227 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
5228 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
5229 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
5230 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
5231 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
5232 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
5233 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
5234 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
5235 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
5236 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
5237 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
5238 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
5239 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
5240 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
5241 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
5242 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
5243 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
5244 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
5245 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
5246 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
5247 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
5248 /* The following does not take into account .id=0x83847661 when subsys =
5249 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
5250 * currently not fully supported.
5252 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
5253 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
5254 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
5255 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
5256 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
5257 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
5258 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
5259 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
5260 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
5261 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
5262 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
5263 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
5264 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
5265 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
5266 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
5267 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
5268 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
5269 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
5270 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5271 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5272 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5273 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5274 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5275 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5276 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5277 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },