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
108 STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
109 * is given, one of the above models will be
110 * chosen according to the subsystem id. */
111 /* for backward compatibility */
135 struct sigmatel_spec {
136 struct snd_kcontrol_new *mixers[4];
137 unsigned int num_mixers;
140 unsigned int surr_switch: 1;
141 unsigned int line_switch: 1;
142 unsigned int mic_switch: 1;
143 unsigned int alt_switch: 1;
144 unsigned int hp_detect: 1;
145 unsigned int spdif_mute: 1;
148 unsigned int eapd_mask;
149 unsigned int gpio_mask;
150 unsigned int gpio_dir;
151 unsigned int gpio_data;
152 unsigned int gpio_mute;
155 unsigned int stream_delay;
157 /* analog loopback */
158 unsigned char aloopback_mask;
159 unsigned char aloopback_shift;
161 /* power management */
162 unsigned int num_pwrs;
163 unsigned int *pwr_mapping;
168 struct hda_input_mux *mono_mux;
169 struct hda_input_mux *amp_mux;
170 unsigned int cur_mmux;
171 struct hda_multi_out multiout;
172 hda_nid_t dac_nids[5];
176 unsigned int num_adcs;
178 unsigned int num_muxes;
179 hda_nid_t *dmic_nids;
180 unsigned int num_dmics;
181 hda_nid_t *dmux_nids;
182 unsigned int num_dmuxes;
183 hda_nid_t *smux_nids;
184 unsigned int num_smuxes;
185 const char **spdif_labels;
187 hda_nid_t dig_in_nid;
189 hda_nid_t anabeep_nid;
190 hda_nid_t digbeep_nid;
194 unsigned int num_pins;
195 unsigned int *pin_configs;
196 unsigned int *bios_pin_configs;
198 /* codec specific stuff */
199 struct hda_verb *init;
200 struct snd_kcontrol_new *mixer;
203 struct hda_input_mux *dinput_mux;
204 unsigned int cur_dmux[2];
205 struct hda_input_mux *input_mux;
206 unsigned int cur_mux[3];
207 struct hda_input_mux *sinput_mux;
208 unsigned int cur_smux[2];
209 unsigned int cur_amux;
211 unsigned int num_amps;
212 unsigned int powerdown_adcs;
215 unsigned int io_switch[2];
216 unsigned int clfe_swap;
217 unsigned int hp_switch; /* NID of HP as line-out */
218 unsigned int aloopback;
220 struct hda_pcm pcm_rec[2]; /* PCM information */
222 /* dynamic controls and input_mux */
223 struct auto_pin_cfg autocfg;
224 unsigned int num_kctl_alloc, num_kctl_used;
225 struct snd_kcontrol_new *kctl_alloc;
226 struct hda_input_mux private_dimux;
227 struct hda_input_mux private_imux;
228 struct hda_input_mux private_smux;
229 struct hda_input_mux private_amp_mux;
230 struct hda_input_mux private_mono_mux;
233 static hda_nid_t stac9200_adc_nids[1] = {
237 static hda_nid_t stac9200_mux_nids[1] = {
241 static hda_nid_t stac9200_dac_nids[1] = {
245 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
246 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
250 static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
254 static hda_nid_t stac92hd73xx_adc_nids[2] = {
258 #define DELL_M6_AMP 2
259 static hda_nid_t stac92hd73xx_amp_nids[3] = {
263 #define STAC92HD73XX_NUM_DMICS 2
264 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
268 #define STAC92HD73_DAC_COUNT 5
269 static hda_nid_t stac92hd73xx_dac_nids[STAC92HD73_DAC_COUNT] = {
270 0x15, 0x16, 0x17, 0x18, 0x19,
273 static hda_nid_t stac92hd73xx_mux_nids[4] = {
274 0x28, 0x29, 0x2a, 0x2b,
277 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
281 static hda_nid_t stac92hd73xx_smux_nids[2] = {
285 #define STAC92HD83XXX_NUM_DMICS 2
286 static hda_nid_t stac92hd83xxx_dmic_nids[STAC92HD83XXX_NUM_DMICS + 1] = {
290 #define STAC92HD81_DAC_COUNT 2
291 #define STAC92HD83_DAC_COUNT 3
292 static hda_nid_t stac92hd83xxx_dac_nids[STAC92HD73_DAC_COUNT] = {
296 static hda_nid_t stac92hd83xxx_dmux_nids[2] = {
300 static hda_nid_t stac92hd83xxx_adc_nids[2] = {
304 static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
308 static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
312 static unsigned int stac92hd83xxx_pwr_mapping[4] = {
313 0x03, 0x0c, 0x10, 0x40,
316 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
320 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
324 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
328 static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
332 static hda_nid_t stac92hd71bxx_smux_nids[2] = {
336 static hda_nid_t stac92hd71bxx_dac_nids[1] = {
340 #define STAC92HD71BXX_NUM_DMICS 2
341 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
345 static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
349 static hda_nid_t stac925x_adc_nids[1] = {
353 static hda_nid_t stac925x_mux_nids[1] = {
357 static hda_nid_t stac925x_dac_nids[1] = {
361 #define STAC925X_NUM_DMICS 1
362 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
366 static hda_nid_t stac925x_dmux_nids[1] = {
370 static hda_nid_t stac922x_adc_nids[2] = {
374 static hda_nid_t stac922x_mux_nids[2] = {
378 static hda_nid_t stac927x_adc_nids[3] = {
382 static hda_nid_t stac927x_mux_nids[3] = {
386 static hda_nid_t stac927x_smux_nids[1] = {
390 static hda_nid_t stac927x_dac_nids[6] = {
391 0x02, 0x03, 0x04, 0x05, 0x06, 0
394 static hda_nid_t stac927x_dmux_nids[1] = {
398 #define STAC927X_NUM_DMICS 2
399 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
403 static const char *stac927x_spdif_labels[5] = {
404 "Digital Playback", "ADAT", "Analog Mux 1",
405 "Analog Mux 2", "Analog Mux 3"
408 static hda_nid_t stac9205_adc_nids[2] = {
412 static hda_nid_t stac9205_mux_nids[2] = {
416 static hda_nid_t stac9205_dmux_nids[1] = {
420 static hda_nid_t stac9205_smux_nids[1] = {
424 #define STAC9205_NUM_DMICS 2
425 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
429 static hda_nid_t stac9200_pin_nids[8] = {
430 0x08, 0x09, 0x0d, 0x0e,
431 0x0f, 0x10, 0x11, 0x12,
434 static hda_nid_t stac925x_pin_nids[8] = {
435 0x07, 0x08, 0x0a, 0x0b,
436 0x0c, 0x0d, 0x10, 0x11,
439 static hda_nid_t stac922x_pin_nids[10] = {
440 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
441 0x0f, 0x10, 0x11, 0x15, 0x1b,
444 static hda_nid_t stac92hd73xx_pin_nids[13] = {
445 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
446 0x0f, 0x10, 0x11, 0x12, 0x13,
450 static hda_nid_t stac92hd83xxx_pin_nids[14] = {
451 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
452 0x0f, 0x10, 0x11, 0x12, 0x13,
453 0x1d, 0x1e, 0x1f, 0x20
455 static hda_nid_t stac92hd71bxx_pin_nids[11] = {
456 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
457 0x0f, 0x14, 0x18, 0x19, 0x1e,
461 static hda_nid_t stac927x_pin_nids[14] = {
462 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
463 0x0f, 0x10, 0x11, 0x12, 0x13,
464 0x14, 0x21, 0x22, 0x23,
467 static hda_nid_t stac9205_pin_nids[12] = {
468 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
469 0x0f, 0x14, 0x16, 0x17, 0x18,
473 #define stac92xx_amp_volume_info snd_hda_mixer_amp_volume_info
475 static int stac92xx_amp_volume_get(struct snd_kcontrol *kcontrol,
476 struct snd_ctl_elem_value *ucontrol)
478 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
479 struct sigmatel_spec *spec = codec->spec;
480 hda_nid_t nid = spec->amp_nids[spec->cur_amux];
482 kcontrol->private_value ^= get_amp_nid(kcontrol);
483 kcontrol->private_value |= nid;
485 return snd_hda_mixer_amp_volume_get(kcontrol, ucontrol);
488 static int stac92xx_amp_volume_put(struct snd_kcontrol *kcontrol,
489 struct snd_ctl_elem_value *ucontrol)
491 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
492 struct sigmatel_spec *spec = codec->spec;
493 hda_nid_t nid = spec->amp_nids[spec->cur_amux];
495 kcontrol->private_value ^= get_amp_nid(kcontrol);
496 kcontrol->private_value |= nid;
498 return snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
501 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
502 struct snd_ctl_elem_info *uinfo)
504 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
505 struct sigmatel_spec *spec = codec->spec;
506 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
509 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
510 struct snd_ctl_elem_value *ucontrol)
512 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
513 struct sigmatel_spec *spec = codec->spec;
514 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
516 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
520 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
521 struct snd_ctl_elem_value *ucontrol)
523 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
524 struct sigmatel_spec *spec = codec->spec;
525 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
527 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
528 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
531 static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
532 struct snd_ctl_elem_info *uinfo)
534 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
535 struct sigmatel_spec *spec = codec->spec;
536 return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
539 static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
540 struct snd_ctl_elem_value *ucontrol)
542 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
543 struct sigmatel_spec *spec = codec->spec;
544 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
546 ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
550 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
551 struct snd_ctl_elem_value *ucontrol)
553 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
554 struct sigmatel_spec *spec = codec->spec;
555 struct hda_input_mux *smux = &spec->private_smux;
556 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
560 err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
561 spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
565 if (spec->spdif_mute) {
567 nid = spec->multiout.dig_out_nid;
569 nid = codec->slave_dig_outs[smux_idx - 1];
570 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
573 val = AMP_OUT_UNMUTE;
574 /* un/mute SPDIF out */
575 snd_hda_codec_write_cache(codec, nid, 0,
576 AC_VERB_SET_AMP_GAIN_MUTE, val);
581 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
583 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
584 struct sigmatel_spec *spec = codec->spec;
585 return snd_hda_input_mux_info(spec->input_mux, uinfo);
588 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
590 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
591 struct sigmatel_spec *spec = codec->spec;
592 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
594 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
598 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
600 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
601 struct sigmatel_spec *spec = codec->spec;
602 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
604 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
605 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
608 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
609 struct snd_ctl_elem_info *uinfo)
611 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
612 struct sigmatel_spec *spec = codec->spec;
613 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
616 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
617 struct snd_ctl_elem_value *ucontrol)
619 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
620 struct sigmatel_spec *spec = codec->spec;
622 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
626 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
627 struct snd_ctl_elem_value *ucontrol)
629 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
630 struct sigmatel_spec *spec = codec->spec;
632 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
633 spec->mono_nid, &spec->cur_mmux);
636 static int stac92xx_amp_mux_enum_info(struct snd_kcontrol *kcontrol,
637 struct snd_ctl_elem_info *uinfo)
639 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
640 struct sigmatel_spec *spec = codec->spec;
641 return snd_hda_input_mux_info(spec->amp_mux, uinfo);
644 static int stac92xx_amp_mux_enum_get(struct snd_kcontrol *kcontrol,
645 struct snd_ctl_elem_value *ucontrol)
647 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
648 struct sigmatel_spec *spec = codec->spec;
650 ucontrol->value.enumerated.item[0] = spec->cur_amux;
654 static int stac92xx_amp_mux_enum_put(struct snd_kcontrol *kcontrol,
655 struct snd_ctl_elem_value *ucontrol)
657 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
658 struct sigmatel_spec *spec = codec->spec;
659 struct snd_kcontrol *ctl =
660 snd_hda_find_mixer_ctl(codec, "Amp Capture Volume");
664 snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE |
665 SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
667 return snd_hda_input_mux_put(codec, spec->amp_mux, ucontrol,
671 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
673 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
674 struct snd_ctl_elem_value *ucontrol)
676 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
677 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
678 struct sigmatel_spec *spec = codec->spec;
680 ucontrol->value.integer.value[0] = !!(spec->aloopback &
681 (spec->aloopback_mask << idx));
685 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
686 struct snd_ctl_elem_value *ucontrol)
688 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
689 struct sigmatel_spec *spec = codec->spec;
690 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
691 unsigned int dac_mode;
692 unsigned int val, idx_val;
694 idx_val = spec->aloopback_mask << idx;
695 if (ucontrol->value.integer.value[0])
696 val = spec->aloopback | idx_val;
698 val = spec->aloopback & ~idx_val;
699 if (spec->aloopback == val)
702 spec->aloopback = val;
704 /* Only return the bits defined by the shift value of the
705 * first two bytes of the mask
707 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
708 kcontrol->private_value & 0xFFFF, 0x0);
709 dac_mode >>= spec->aloopback_shift;
711 if (spec->aloopback & idx_val) {
712 snd_hda_power_up(codec);
715 snd_hda_power_down(codec);
716 dac_mode &= ~idx_val;
719 snd_hda_codec_write_cache(codec, codec->afg, 0,
720 kcontrol->private_value >> 16, dac_mode);
725 static struct hda_verb stac9200_core_init[] = {
726 /* set dac0mux for dac converter */
727 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
731 static struct hda_verb stac9200_eapd_init[] = {
732 /* set dac0mux for dac converter */
733 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
734 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
738 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
739 /* set master volume and direct control */
740 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
741 /* setup audio connections */
742 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
743 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
744 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
745 /* setup adcs to point to mixer */
746 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
747 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
748 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
749 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
750 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
751 /* setup import muxs */
752 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
753 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
754 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
755 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
759 static struct hda_verb dell_eq_core_init[] = {
760 /* set master volume to max value without distortion
761 * and direct control */
762 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
763 /* setup audio connections */
764 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
765 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x02},
766 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x01},
767 /* setup adcs to point to mixer */
768 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
769 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
770 /* setup import muxs */
771 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
772 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
773 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
774 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
778 static struct hda_verb dell_m6_core_init[] = {
779 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
780 /* setup audio connections */
781 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
782 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
783 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x02},
784 /* setup adcs to point to mixer */
785 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
786 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
787 /* setup import muxs */
788 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
789 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
790 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
791 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
795 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
796 /* set master volume and direct control */
797 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
798 /* setup audio connections */
799 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
800 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
801 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
802 /* connect hp ports to dac3 */
803 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x03},
804 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x03},
805 /* setup adcs to point to mixer */
806 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
807 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
808 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
809 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
810 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
811 /* setup import muxs */
812 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
813 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
814 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
815 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
819 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
820 /* set master volume and direct control */
821 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
822 /* setup audio connections */
823 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
824 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01 },
825 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02 },
826 /* dac3 is connected to import3 mux */
827 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
828 /* connect hp ports to dac4 */
829 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x04},
830 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x04},
831 /* setup adcs to point to mixer */
832 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
833 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
834 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
835 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
836 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
837 /* setup import muxs */
838 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
839 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
840 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
841 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
845 static struct hda_verb stac92hd83xxx_core_init[] = {
846 /* start of config #1 */
847 { 0xe, AC_VERB_SET_CONNECT_SEL, 0x3},
849 /* start of config #2 */
850 { 0xa, AC_VERB_SET_CONNECT_SEL, 0x0},
851 { 0xb, AC_VERB_SET_CONNECT_SEL, 0x0},
852 { 0xd, AC_VERB_SET_CONNECT_SEL, 0x1},
854 /* power state controls amps */
855 { 0x01, AC_VERB_SET_EAPD, 1 << 2},
858 static struct hda_verb stac92hd71bxx_core_init[] = {
859 /* set master volume and direct control */
860 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
861 /* connect headphone jack to dac1 */
862 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
863 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
864 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
865 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
866 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
869 #define HD_DISABLE_PORTF 2
870 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
871 /* start of config #1 */
873 /* connect port 0f to audio mixer */
874 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
875 /* unmute right and left channels for node 0x0f */
876 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
877 /* start of config #2 */
879 /* set master volume and direct control */
880 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
881 /* connect headphone jack to dac1 */
882 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
883 /* unmute right and left channels for nodes 0x0a, 0xd */
884 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
885 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
889 static struct hda_verb stac925x_core_init[] = {
890 /* set dac0mux for dac converter */
891 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
895 static struct hda_verb stac922x_core_init[] = {
896 /* set master volume and direct control */
897 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
901 static struct hda_verb d965_core_init[] = {
902 /* set master volume and direct control */
903 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
904 /* unmute node 0x1b */
905 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
906 /* select node 0x03 as DAC */
907 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
911 static struct hda_verb stac927x_core_init[] = {
912 /* set master volume and direct control */
913 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
914 /* enable analog pc beep path */
915 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
919 static struct hda_verb stac9205_core_init[] = {
920 /* set master volume and direct control */
921 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
922 /* enable analog pc beep path */
923 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
927 #define STAC_MONO_MUX \
929 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
930 .name = "Mono Mux", \
932 .info = stac92xx_mono_mux_enum_info, \
933 .get = stac92xx_mono_mux_enum_get, \
934 .put = stac92xx_mono_mux_enum_put, \
937 #define STAC_AMP_MUX \
939 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
940 .name = "Amp Selector Capture Switch", \
942 .info = stac92xx_amp_mux_enum_info, \
943 .get = stac92xx_amp_mux_enum_get, \
944 .put = stac92xx_amp_mux_enum_put, \
947 #define STAC_AMP_VOL(xname, nid, chs, idx, dir) \
949 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
952 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
953 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
954 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
955 .info = stac92xx_amp_volume_info, \
956 .get = stac92xx_amp_volume_get, \
957 .put = stac92xx_amp_volume_put, \
958 .tlv = { .c = snd_hda_mixer_amp_tlv }, \
959 .private_value = HDA_COMPOSE_AMP_VAL(nid, chs, idx, dir) \
962 #define STAC_INPUT_SOURCE(cnt) \
964 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
965 .name = "Input Source", \
967 .info = stac92xx_mux_enum_info, \
968 .get = stac92xx_mux_enum_get, \
969 .put = stac92xx_mux_enum_put, \
972 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
974 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
975 .name = "Analog Loopback", \
977 .info = stac92xx_aloopback_info, \
978 .get = stac92xx_aloopback_get, \
979 .put = stac92xx_aloopback_put, \
980 .private_value = verb_read | (verb_write << 16), \
983 static struct snd_kcontrol_new stac9200_mixer[] = {
984 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
985 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
986 STAC_INPUT_SOURCE(1),
987 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
988 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
992 #define DELL_M6_MIXER 6
993 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
994 /* start of config #1 */
995 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
996 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
998 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
999 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1001 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1002 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1004 /* start of config #2 */
1005 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1006 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1008 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1009 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1011 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
1013 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1014 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1016 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1017 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1022 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
1023 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1025 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1026 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1028 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1029 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1031 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1032 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1034 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1035 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1037 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1038 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1040 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1041 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1043 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1044 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1048 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
1049 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1051 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
1052 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
1054 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
1055 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
1057 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1058 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1060 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1061 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1063 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1064 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1066 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1067 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1069 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1070 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1075 static struct snd_kcontrol_new stac92hd83xxx_mixer[] = {
1076 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_OUTPUT),
1077 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_OUTPUT),
1079 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_OUTPUT),
1080 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_OUTPUT),
1082 HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x1b, 0, HDA_INPUT),
1083 HDA_CODEC_MUTE("DAC0 Capture Switch", 0x1b, 0, HDA_INPUT),
1085 HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x1b, 0x1, HDA_INPUT),
1086 HDA_CODEC_MUTE("DAC1 Capture Switch", 0x1b, 0x1, HDA_INPUT),
1088 HDA_CODEC_VOLUME("Front Mic Capture Volume", 0x1b, 0x2, HDA_INPUT),
1089 HDA_CODEC_MUTE("Front Mic Capture Switch", 0x1b, 0x2, HDA_INPUT),
1091 HDA_CODEC_VOLUME("Line In Capture Volume", 0x1b, 0x3, HDA_INPUT),
1092 HDA_CODEC_MUTE("Line In Capture Switch", 0x1b, 0x3, HDA_INPUT),
1095 HDA_CODEC_VOLUME("Mic Capture Volume", 0x1b, 0x4, HDA_INPUT),
1096 HDA_CODEC_MUTE("Mic Capture Switch", 0x1b 0x4, HDA_INPUT),
1101 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
1102 STAC_INPUT_SOURCE(2),
1103 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
1105 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1106 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1108 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1109 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1110 /* analog pc-beep replaced with digital beep support */
1112 HDA_CODEC_VOLUME("PC Beep Volume", 0x17, 0x2, HDA_INPUT),
1113 HDA_CODEC_MUTE("PC Beep Switch", 0x17, 0x2, HDA_INPUT),
1116 HDA_CODEC_MUTE("Import0 Mux Capture Switch", 0x17, 0x0, HDA_INPUT),
1117 HDA_CODEC_VOLUME("Import0 Mux Capture Volume", 0x17, 0x0, HDA_INPUT),
1119 HDA_CODEC_MUTE("Import1 Mux Capture Switch", 0x17, 0x1, HDA_INPUT),
1120 HDA_CODEC_VOLUME("Import1 Mux Capture Volume", 0x17, 0x1, HDA_INPUT),
1122 HDA_CODEC_MUTE("DAC0 Capture Switch", 0x17, 0x3, HDA_INPUT),
1123 HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x17, 0x3, HDA_INPUT),
1125 HDA_CODEC_MUTE("DAC1 Capture Switch", 0x17, 0x4, HDA_INPUT),
1126 HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x17, 0x4, HDA_INPUT),
1130 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
1131 STAC_INPUT_SOURCE(2),
1132 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
1134 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1135 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
1137 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1138 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1142 static struct snd_kcontrol_new stac925x_mixer[] = {
1143 STAC_INPUT_SOURCE(1),
1144 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
1145 HDA_CODEC_MUTE("Capture Switch", 0x14, 0, HDA_OUTPUT),
1149 static struct snd_kcontrol_new stac9205_mixer[] = {
1150 STAC_INPUT_SOURCE(2),
1151 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1153 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
1154 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
1156 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
1157 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
1161 /* This needs to be generated dynamically based on sequence */
1162 static struct snd_kcontrol_new stac922x_mixer[] = {
1163 STAC_INPUT_SOURCE(2),
1164 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
1165 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
1167 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
1168 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
1173 static struct snd_kcontrol_new stac927x_mixer[] = {
1174 STAC_INPUT_SOURCE(3),
1175 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1177 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
1178 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
1180 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
1181 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
1183 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
1184 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
1188 static struct snd_kcontrol_new stac_dmux_mixer = {
1189 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1190 .name = "Digital Input Source",
1191 /* count set later */
1192 .info = stac92xx_dmux_enum_info,
1193 .get = stac92xx_dmux_enum_get,
1194 .put = stac92xx_dmux_enum_put,
1197 static struct snd_kcontrol_new stac_smux_mixer = {
1198 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1199 .name = "IEC958 Playback Source",
1200 /* count set later */
1201 .info = stac92xx_smux_enum_info,
1202 .get = stac92xx_smux_enum_get,
1203 .put = stac92xx_smux_enum_put,
1206 static const char *slave_vols[] = {
1207 "Front Playback Volume",
1208 "Surround Playback Volume",
1209 "Center Playback Volume",
1210 "LFE Playback Volume",
1211 "Side Playback Volume",
1212 "Headphone Playback Volume",
1213 "Headphone Playback Volume",
1214 "Speaker Playback Volume",
1215 "External Speaker Playback Volume",
1216 "Speaker2 Playback Volume",
1220 static const char *slave_sws[] = {
1221 "Front Playback Switch",
1222 "Surround Playback Switch",
1223 "Center Playback Switch",
1224 "LFE Playback Switch",
1225 "Side Playback Switch",
1226 "Headphone Playback Switch",
1227 "Headphone Playback Switch",
1228 "Speaker Playback Switch",
1229 "External Speaker Playback Switch",
1230 "Speaker2 Playback Switch",
1231 "IEC958 Playback Switch",
1235 static int stac92xx_build_controls(struct hda_codec *codec)
1237 struct sigmatel_spec *spec = codec->spec;
1241 err = snd_hda_add_new_ctls(codec, spec->mixer);
1245 for (i = 0; i < spec->num_mixers; i++) {
1246 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1250 if (spec->num_dmuxes > 0) {
1251 stac_dmux_mixer.count = spec->num_dmuxes;
1252 err = snd_ctl_add(codec->bus->card,
1253 snd_ctl_new1(&stac_dmux_mixer, codec));
1257 if (spec->num_smuxes > 0) {
1258 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1259 struct hda_input_mux *smux = &spec->private_smux;
1260 /* check for mute support on SPDIF out */
1261 if (wcaps & AC_WCAP_OUT_AMP) {
1262 smux->items[smux->num_items].label = "Off";
1263 smux->items[smux->num_items].index = 0;
1265 spec->spdif_mute = 1;
1267 stac_smux_mixer.count = spec->num_smuxes;
1268 err = snd_ctl_add(codec->bus->card,
1269 snd_ctl_new1(&stac_smux_mixer, codec));
1274 if (spec->multiout.dig_out_nid) {
1275 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1278 err = snd_hda_create_spdif_share_sw(codec,
1282 spec->multiout.share_spdif = 1;
1284 if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1285 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1290 /* if we have no master control, let's create it */
1291 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1292 unsigned int vmaster_tlv[4];
1293 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1294 HDA_OUTPUT, vmaster_tlv);
1295 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1296 vmaster_tlv, slave_vols);
1300 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1301 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1310 static unsigned int ref9200_pin_configs[8] = {
1311 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1312 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1316 STAC 9200 pin configs for
1321 static unsigned int dell9200_d21_pin_configs[8] = {
1322 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
1323 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1327 STAC 9200 pin configs for
1331 static unsigned int dell9200_d22_pin_configs[8] = {
1332 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1333 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1337 STAC 9200 pin configs for
1338 102801C4 (Dell Dimension E310)
1345 static unsigned int dell9200_d23_pin_configs[8] = {
1346 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1347 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
1352 STAC 9200-32 pin configs for
1353 102801B5 (Dell Inspiron 630m)
1354 102801D8 (Dell Inspiron 640m)
1356 static unsigned int dell9200_m21_pin_configs[8] = {
1357 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1358 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1362 STAC 9200-32 pin configs for
1363 102801C2 (Dell Latitude D620)
1365 102801CC (Dell Latitude D820)
1369 static unsigned int dell9200_m22_pin_configs[8] = {
1370 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1371 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1375 STAC 9200-32 pin configs for
1376 102801CE (Dell XPS M1710)
1377 102801CF (Dell Precision M90)
1379 static unsigned int dell9200_m23_pin_configs[8] = {
1380 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1381 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1385 STAC 9200-32 pin configs for
1388 102801CB (Dell Latitude 120L)
1391 static unsigned int dell9200_m24_pin_configs[8] = {
1392 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1393 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1397 STAC 9200-32 pin configs for
1398 102801BD (Dell Inspiron E1505n)
1402 static unsigned int dell9200_m25_pin_configs[8] = {
1403 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1404 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1408 STAC 9200-32 pin configs for
1409 102801F5 (Dell Inspiron 1501)
1412 static unsigned int dell9200_m26_pin_configs[8] = {
1413 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1414 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1419 102801CD (Dell Inspiron E1705/9400)
1421 static unsigned int dell9200_m27_pin_configs[8] = {
1422 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1423 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1426 static unsigned int oqo9200_pin_configs[8] = {
1427 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1428 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1432 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1433 [STAC_REF] = ref9200_pin_configs,
1434 [STAC_9200_OQO] = oqo9200_pin_configs,
1435 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1436 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1437 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1438 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1439 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1440 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1441 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1442 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1443 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1444 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1445 [STAC_9200_PANASONIC] = ref9200_pin_configs,
1448 static const char *stac9200_models[STAC_9200_MODELS] = {
1450 [STAC_9200_OQO] = "oqo",
1451 [STAC_9200_DELL_D21] = "dell-d21",
1452 [STAC_9200_DELL_D22] = "dell-d22",
1453 [STAC_9200_DELL_D23] = "dell-d23",
1454 [STAC_9200_DELL_M21] = "dell-m21",
1455 [STAC_9200_DELL_M22] = "dell-m22",
1456 [STAC_9200_DELL_M23] = "dell-m23",
1457 [STAC_9200_DELL_M24] = "dell-m24",
1458 [STAC_9200_DELL_M25] = "dell-m25",
1459 [STAC_9200_DELL_M26] = "dell-m26",
1460 [STAC_9200_DELL_M27] = "dell-m27",
1461 [STAC_9200_GATEWAY] = "gateway",
1462 [STAC_9200_PANASONIC] = "panasonic",
1465 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1466 /* SigmaTel reference board */
1467 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1468 "DFI LanParty", STAC_REF),
1469 /* Dell laptops have BIOS problem */
1470 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1471 "unknown Dell", STAC_9200_DELL_D21),
1472 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1473 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1474 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1475 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1476 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1477 "unknown Dell", STAC_9200_DELL_D22),
1478 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1479 "unknown Dell", STAC_9200_DELL_D22),
1480 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1481 "Dell Latitude D620", STAC_9200_DELL_M22),
1482 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1483 "unknown Dell", STAC_9200_DELL_D23),
1484 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1485 "unknown Dell", STAC_9200_DELL_D23),
1486 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1487 "unknown Dell", STAC_9200_DELL_M22),
1488 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1489 "unknown Dell", STAC_9200_DELL_M24),
1490 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1491 "unknown Dell", STAC_9200_DELL_M24),
1492 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1493 "Dell Latitude 120L", STAC_9200_DELL_M24),
1494 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1495 "Dell Latitude D820", STAC_9200_DELL_M22),
1496 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1497 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1498 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1499 "Dell XPS M1710", STAC_9200_DELL_M23),
1500 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1501 "Dell Precision M90", STAC_9200_DELL_M23),
1502 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1503 "unknown Dell", STAC_9200_DELL_M22),
1504 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1505 "unknown Dell", STAC_9200_DELL_M22),
1506 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1507 "unknown Dell", STAC_9200_DELL_M22),
1508 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1509 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1510 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1511 "unknown Dell", STAC_9200_DELL_D23),
1512 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1513 "unknown Dell", STAC_9200_DELL_D23),
1514 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1515 "unknown Dell", STAC_9200_DELL_D21),
1516 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1517 "unknown Dell", STAC_9200_DELL_D23),
1518 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1519 "unknown Dell", STAC_9200_DELL_D21),
1520 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1521 "unknown Dell", STAC_9200_DELL_M25),
1522 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1523 "unknown Dell", STAC_9200_DELL_M25),
1524 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1525 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1526 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1527 "unknown Dell", STAC_9200_DELL_M26),
1529 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1530 /* Gateway machines needs EAPD to be set on resume */
1531 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
1532 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
1534 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
1537 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1541 static unsigned int ref925x_pin_configs[8] = {
1542 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1543 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1546 static unsigned int stac925x_MA6_pin_configs[8] = {
1547 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1548 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
1551 static unsigned int stac925x_PA6_pin_configs[8] = {
1552 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1553 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
1556 static unsigned int stac925xM2_2_pin_configs[8] = {
1557 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
1558 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
1561 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1562 [STAC_REF] = ref925x_pin_configs,
1563 [STAC_M2_2] = stac925xM2_2_pin_configs,
1564 [STAC_MA6] = stac925x_MA6_pin_configs,
1565 [STAC_PA6] = stac925x_PA6_pin_configs,
1568 static const char *stac925x_models[STAC_925x_MODELS] = {
1570 [STAC_M2_2] = "m2-2",
1575 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1576 /* SigmaTel reference board */
1577 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1578 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1579 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
1580 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
1581 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
1582 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
1583 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
1587 static unsigned int ref92hd73xx_pin_configs[13] = {
1588 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1589 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1590 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1594 static unsigned int dell_m6_pin_configs[13] = {
1595 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1596 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1597 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1601 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1602 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1603 [STAC_DELL_M6] = dell_m6_pin_configs,
1604 [STAC_DELL_EQ] = dell_m6_pin_configs,
1607 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1608 [STAC_92HD73XX_REF] = "ref",
1609 [STAC_DELL_M6] = "dell-m6",
1610 [STAC_DELL_EQ] = "dell-eq",
1613 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1614 /* SigmaTel reference board */
1615 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1616 "DFI LanParty", STAC_92HD73XX_REF),
1617 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1618 "unknown Dell", STAC_DELL_M6),
1619 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1620 "unknown Dell", STAC_DELL_M6),
1621 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1622 "unknown Dell", STAC_DELL_M6),
1623 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1624 "unknown Dell", STAC_DELL_M6),
1625 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1626 "unknown Dell", STAC_DELL_M6),
1627 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1628 "unknown Dell", STAC_DELL_M6),
1629 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1630 "unknown Dell", STAC_DELL_M6),
1634 static unsigned int ref92hd83xxx_pin_configs[14] = {
1635 0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1636 0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1637 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x40f000f0,
1638 0x01451160, 0x98560170,
1641 static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1642 [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1645 static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1646 [STAC_92HD83XXX_REF] = "ref",
1649 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1650 /* SigmaTel reference board */
1651 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1652 "DFI LanParty", STAC_92HD71BXX_REF),
1655 static unsigned int ref92hd71bxx_pin_configs[11] = {
1656 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1657 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1658 0x90a000f0, 0x01452050, 0x01452050,
1661 static unsigned int dell_m4_1_pin_configs[11] = {
1662 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1663 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1664 0x40f000f0, 0x4f0000f0, 0x4f0000f0,
1667 static unsigned int dell_m4_2_pin_configs[11] = {
1668 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1669 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1670 0x40f000f0, 0x044413b0, 0x044413b0,
1673 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1674 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1675 [STAC_DELL_M4_1] = dell_m4_1_pin_configs,
1676 [STAC_DELL_M4_2] = dell_m4_2_pin_configs,
1677 [STAC_HP_M4] = NULL,
1680 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1681 [STAC_92HD71BXX_REF] = "ref",
1682 [STAC_DELL_M4_1] = "dell-m4-1",
1683 [STAC_DELL_M4_2] = "dell-m4-2",
1684 [STAC_HP_M4] = "hp-m4",
1687 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1688 /* SigmaTel reference board */
1689 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1690 "DFI LanParty", STAC_92HD71BXX_REF),
1691 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1692 "unknown HP", STAC_HP_M4),
1693 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1694 "unknown Dell", STAC_DELL_M4_1),
1695 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1696 "unknown Dell", STAC_DELL_M4_1),
1697 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1698 "unknown Dell", STAC_DELL_M4_1),
1699 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1700 "unknown Dell", STAC_DELL_M4_1),
1701 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1702 "unknown Dell", STAC_DELL_M4_1),
1703 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1704 "unknown Dell", STAC_DELL_M4_1),
1705 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1706 "unknown Dell", STAC_DELL_M4_1),
1707 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1708 "unknown Dell", STAC_DELL_M4_2),
1709 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1710 "unknown Dell", STAC_DELL_M4_2),
1711 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1712 "unknown Dell", STAC_DELL_M4_2),
1713 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1714 "unknown Dell", STAC_DELL_M4_2),
1718 static unsigned int ref922x_pin_configs[10] = {
1719 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1720 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1721 0x40000100, 0x40000100,
1725 STAC 922X pin configs for
1732 static unsigned int dell_922x_d81_pin_configs[10] = {
1733 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1734 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1735 0x01813122, 0x400001f2,
1739 STAC 922X pin configs for
1743 static unsigned int dell_922x_d82_pin_configs[10] = {
1744 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1745 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1746 0x01813122, 0x400001f1,
1750 STAC 922X pin configs for
1753 static unsigned int dell_922x_m81_pin_configs[10] = {
1754 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1755 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1756 0x40C003f1, 0x405003f0,
1760 STAC 9221 A1 pin configs for
1761 102801D7 (Dell XPS M1210)
1763 static unsigned int dell_922x_m82_pin_configs[10] = {
1764 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1765 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1766 0x508003f3, 0x405003f4,
1769 static unsigned int d945gtp3_pin_configs[10] = {
1770 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1771 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1772 0x02a19120, 0x40000100,
1775 static unsigned int d945gtp5_pin_configs[10] = {
1776 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1777 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1778 0x02a19320, 0x40000100,
1781 static unsigned int intel_mac_v1_pin_configs[10] = {
1782 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1783 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1784 0x400000fc, 0x400000fb,
1787 static unsigned int intel_mac_v2_pin_configs[10] = {
1788 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1789 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1790 0x400000fc, 0x400000fb,
1793 static unsigned int intel_mac_v3_pin_configs[10] = {
1794 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1795 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1796 0x400000fc, 0x400000fb,
1799 static unsigned int intel_mac_v4_pin_configs[10] = {
1800 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1801 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1802 0x400000fc, 0x400000fb,
1805 static unsigned int intel_mac_v5_pin_configs[10] = {
1806 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1807 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1808 0x400000fc, 0x400000fb,
1811 static unsigned int ecs202_pin_configs[10] = {
1812 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1813 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1814 0x9037012e, 0x40e000f2,
1817 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1818 [STAC_D945_REF] = ref922x_pin_configs,
1819 [STAC_D945GTP3] = d945gtp3_pin_configs,
1820 [STAC_D945GTP5] = d945gtp5_pin_configs,
1821 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1822 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1823 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1824 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1825 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1826 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1827 /* for backward compatibility */
1828 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1829 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1830 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1831 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1832 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1833 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1834 [STAC_ECS_202] = ecs202_pin_configs,
1835 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1836 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1837 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1838 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1841 static const char *stac922x_models[STAC_922X_MODELS] = {
1842 [STAC_D945_REF] = "ref",
1843 [STAC_D945GTP5] = "5stack",
1844 [STAC_D945GTP3] = "3stack",
1845 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1846 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1847 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1848 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1849 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1850 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1851 /* for backward compatibility */
1852 [STAC_MACMINI] = "macmini",
1853 [STAC_MACBOOK] = "macbook",
1854 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1855 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1856 [STAC_IMAC_INTEL] = "imac-intel",
1857 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1858 [STAC_ECS_202] = "ecs202",
1859 [STAC_922X_DELL_D81] = "dell-d81",
1860 [STAC_922X_DELL_D82] = "dell-d82",
1861 [STAC_922X_DELL_M81] = "dell-m81",
1862 [STAC_922X_DELL_M82] = "dell-m82",
1865 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1866 /* SigmaTel reference board */
1867 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1868 "DFI LanParty", STAC_D945_REF),
1869 /* Intel 945G based systems */
1870 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1871 "Intel D945G", STAC_D945GTP3),
1872 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1873 "Intel D945G", STAC_D945GTP3),
1874 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1875 "Intel D945G", STAC_D945GTP3),
1876 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1877 "Intel D945G", STAC_D945GTP3),
1878 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1879 "Intel D945G", STAC_D945GTP3),
1880 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1881 "Intel D945G", STAC_D945GTP3),
1882 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1883 "Intel D945G", STAC_D945GTP3),
1884 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1885 "Intel D945G", STAC_D945GTP3),
1886 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1887 "Intel D945G", STAC_D945GTP3),
1888 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1889 "Intel D945G", STAC_D945GTP3),
1890 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1891 "Intel D945G", STAC_D945GTP3),
1892 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1893 "Intel D945G", STAC_D945GTP3),
1894 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1895 "Intel D945G", STAC_D945GTP3),
1896 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1897 "Intel D945G", STAC_D945GTP3),
1898 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1899 "Intel D945G", STAC_D945GTP3),
1900 /* Intel D945G 5-stack systems */
1901 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1902 "Intel D945G", STAC_D945GTP5),
1903 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1904 "Intel D945G", STAC_D945GTP5),
1905 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1906 "Intel D945G", STAC_D945GTP5),
1907 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1908 "Intel D945G", STAC_D945GTP5),
1909 /* Intel 945P based systems */
1910 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1911 "Intel D945P", STAC_D945GTP3),
1912 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1913 "Intel D945P", STAC_D945GTP3),
1914 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1915 "Intel D945P", STAC_D945GTP3),
1916 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1917 "Intel D945P", STAC_D945GTP3),
1918 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1919 "Intel D945P", STAC_D945GTP3),
1920 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1921 "Intel D945P", STAC_D945GTP5),
1923 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
1924 SND_PCI_QUIRK(0x8384, 0x7680,
1925 "Mac", STAC_INTEL_MAC_AUTO),
1927 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1928 "unknown Dell", STAC_922X_DELL_D81),
1929 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1930 "unknown Dell", STAC_922X_DELL_D81),
1931 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1932 "unknown Dell", STAC_922X_DELL_D81),
1933 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1934 "unknown Dell", STAC_922X_DELL_D82),
1935 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1936 "unknown Dell", STAC_922X_DELL_M81),
1937 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1938 "unknown Dell", STAC_922X_DELL_D82),
1939 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1940 "unknown Dell", STAC_922X_DELL_D81),
1941 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1942 "unknown Dell", STAC_922X_DELL_D81),
1943 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1944 "Dell XPS M1210", STAC_922X_DELL_M82),
1945 /* ECS/PC Chips boards */
1946 SND_PCI_QUIRK(0x1019, 0x2144,
1947 "ECS/PC chips", STAC_ECS_202),
1948 SND_PCI_QUIRK(0x1019, 0x2608,
1949 "ECS/PC chips", STAC_ECS_202),
1950 SND_PCI_QUIRK(0x1019, 0x2633,
1951 "ECS/PC chips P17G/1333", STAC_ECS_202),
1952 SND_PCI_QUIRK(0x1019, 0x2811,
1953 "ECS/PC chips", STAC_ECS_202),
1954 SND_PCI_QUIRK(0x1019, 0x2812,
1955 "ECS/PC chips", STAC_ECS_202),
1956 SND_PCI_QUIRK(0x1019, 0x2813,
1957 "ECS/PC chips", STAC_ECS_202),
1958 SND_PCI_QUIRK(0x1019, 0x2814,
1959 "ECS/PC chips", STAC_ECS_202),
1960 SND_PCI_QUIRK(0x1019, 0x2815,
1961 "ECS/PC chips", STAC_ECS_202),
1962 SND_PCI_QUIRK(0x1019, 0x2816,
1963 "ECS/PC chips", STAC_ECS_202),
1964 SND_PCI_QUIRK(0x1019, 0x2817,
1965 "ECS/PC chips", STAC_ECS_202),
1966 SND_PCI_QUIRK(0x1019, 0x2818,
1967 "ECS/PC chips", STAC_ECS_202),
1968 SND_PCI_QUIRK(0x1019, 0x2819,
1969 "ECS/PC chips", STAC_ECS_202),
1970 SND_PCI_QUIRK(0x1019, 0x2820,
1971 "ECS/PC chips", STAC_ECS_202),
1975 static unsigned int ref927x_pin_configs[14] = {
1976 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1977 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1978 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1979 0x01c42190, 0x40000100,
1982 static unsigned int d965_3st_pin_configs[14] = {
1983 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
1984 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
1985 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1986 0x40000100, 0x40000100
1989 static unsigned int d965_5st_pin_configs[14] = {
1990 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1991 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
1992 0x40000100, 0x40000100, 0x40000100, 0x01442070,
1993 0x40000100, 0x40000100
1996 static unsigned int dell_3st_pin_configs[14] = {
1997 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
1998 0x01111212, 0x01116211, 0x01813050, 0x01112214,
1999 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2000 0x40c003fc, 0x40000100
2003 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2004 [STAC_D965_REF] = ref927x_pin_configs,
2005 [STAC_D965_3ST] = d965_3st_pin_configs,
2006 [STAC_D965_5ST] = d965_5st_pin_configs,
2007 [STAC_DELL_3ST] = dell_3st_pin_configs,
2008 [STAC_DELL_BIOS] = NULL,
2011 static const char *stac927x_models[STAC_927X_MODELS] = {
2012 [STAC_D965_REF] = "ref",
2013 [STAC_D965_3ST] = "3stack",
2014 [STAC_D965_5ST] = "5stack",
2015 [STAC_DELL_3ST] = "dell-3stack",
2016 [STAC_DELL_BIOS] = "dell-bios",
2019 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2020 /* SigmaTel reference board */
2021 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2022 "DFI LanParty", STAC_D965_REF),
2023 /* Intel 946 based systems */
2024 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2025 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2026 /* 965 based 3 stack systems */
2027 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
2028 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
2029 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
2030 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
2031 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
2032 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
2033 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
2034 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
2035 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
2036 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
2037 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
2038 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
2039 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
2040 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
2041 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
2042 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
2043 /* Dell 3 stack systems */
2044 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
2045 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2046 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
2047 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
2048 /* Dell 3 stack systems with verb table in BIOS */
2049 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2050 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
2051 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
2052 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_3ST),
2053 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
2054 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
2055 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
2056 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2057 /* 965 based 5 stack systems */
2058 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
2059 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
2060 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
2061 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
2062 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
2063 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
2064 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
2065 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
2066 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
2070 static unsigned int ref9205_pin_configs[12] = {
2071 0x40000100, 0x40000100, 0x01016011, 0x01014010,
2072 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2073 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2077 STAC 9205 pin configs for
2084 10280228 (Dell Vostro 1500)
2086 static unsigned int dell_9205_m42_pin_configs[12] = {
2087 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2088 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2089 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2093 STAC 9205 pin configs for
2097 102801FF (Dell Precision M4300)
2102 static unsigned int dell_9205_m43_pin_configs[12] = {
2103 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2104 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2105 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2108 static unsigned int dell_9205_m44_pin_configs[12] = {
2109 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2110 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2111 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2114 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2115 [STAC_9205_REF] = ref9205_pin_configs,
2116 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2117 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2118 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2121 static const char *stac9205_models[STAC_9205_MODELS] = {
2122 [STAC_9205_REF] = "ref",
2123 [STAC_9205_DELL_M42] = "dell-m42",
2124 [STAC_9205_DELL_M43] = "dell-m43",
2125 [STAC_9205_DELL_M44] = "dell-m44",
2128 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
2129 /* SigmaTel reference board */
2130 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2131 "DFI LanParty", STAC_9205_REF),
2132 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2133 "unknown Dell", STAC_9205_DELL_M42),
2134 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2135 "unknown Dell", STAC_9205_DELL_M42),
2136 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2137 "Dell Precision", STAC_9205_DELL_M43),
2138 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2139 "Dell Precision", STAC_9205_DELL_M43),
2140 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2141 "Dell Precision", STAC_9205_DELL_M43),
2142 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2143 "unknown Dell", STAC_9205_DELL_M42),
2144 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2145 "unknown Dell", STAC_9205_DELL_M42),
2146 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2147 "Dell Precision", STAC_9205_DELL_M43),
2148 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2149 "Dell Precision M4300", STAC_9205_DELL_M43),
2150 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2151 "unknown Dell", STAC_9205_DELL_M42),
2152 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2153 "Dell Precision", STAC_9205_DELL_M43),
2154 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2155 "Dell Precision", STAC_9205_DELL_M43),
2156 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2157 "Dell Precision", STAC_9205_DELL_M43),
2158 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2159 "Dell Inspiron", STAC_9205_DELL_M44),
2160 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2161 "Dell Vostro 1500", STAC_9205_DELL_M42),
2165 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
2168 struct sigmatel_spec *spec = codec->spec;
2170 if (! spec->bios_pin_configs) {
2171 spec->bios_pin_configs = kcalloc(spec->num_pins,
2172 sizeof(*spec->bios_pin_configs), GFP_KERNEL);
2173 if (! spec->bios_pin_configs)
2177 for (i = 0; i < spec->num_pins; i++) {
2178 hda_nid_t nid = spec->pin_nids[i];
2179 unsigned int pin_cfg;
2181 pin_cfg = snd_hda_codec_read(codec, nid, 0,
2182 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
2183 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
2185 spec->bios_pin_configs[i] = pin_cfg;
2191 static void stac92xx_set_config_reg(struct hda_codec *codec,
2192 hda_nid_t pin_nid, unsigned int pin_config)
2195 snd_hda_codec_write(codec, pin_nid, 0,
2196 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
2197 pin_config & 0x000000ff);
2198 snd_hda_codec_write(codec, pin_nid, 0,
2199 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
2200 (pin_config & 0x0000ff00) >> 8);
2201 snd_hda_codec_write(codec, pin_nid, 0,
2202 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
2203 (pin_config & 0x00ff0000) >> 16);
2204 snd_hda_codec_write(codec, pin_nid, 0,
2205 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
2207 i = snd_hda_codec_read(codec, pin_nid, 0,
2208 AC_VERB_GET_CONFIG_DEFAULT,
2210 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
2214 static void stac92xx_set_config_regs(struct hda_codec *codec)
2217 struct sigmatel_spec *spec = codec->spec;
2219 if (!spec->pin_configs)
2222 for (i = 0; i < spec->num_pins; i++)
2223 stac92xx_set_config_reg(codec, spec->pin_nids[i],
2224 spec->pin_configs[i]);
2228 * Analog playback callbacks
2230 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2231 struct hda_codec *codec,
2232 struct snd_pcm_substream *substream)
2234 struct sigmatel_spec *spec = codec->spec;
2235 if (spec->stream_delay)
2236 msleep(spec->stream_delay);
2237 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2241 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2242 struct hda_codec *codec,
2243 unsigned int stream_tag,
2244 unsigned int format,
2245 struct snd_pcm_substream *substream)
2247 struct sigmatel_spec *spec = codec->spec;
2248 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2251 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2252 struct hda_codec *codec,
2253 struct snd_pcm_substream *substream)
2255 struct sigmatel_spec *spec = codec->spec;
2256 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2260 * Digital playback callbacks
2262 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2263 struct hda_codec *codec,
2264 struct snd_pcm_substream *substream)
2266 struct sigmatel_spec *spec = codec->spec;
2267 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2270 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2271 struct hda_codec *codec,
2272 struct snd_pcm_substream *substream)
2274 struct sigmatel_spec *spec = codec->spec;
2275 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2278 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2279 struct hda_codec *codec,
2280 unsigned int stream_tag,
2281 unsigned int format,
2282 struct snd_pcm_substream *substream)
2284 struct sigmatel_spec *spec = codec->spec;
2285 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2286 stream_tag, format, substream);
2291 * Analog capture callbacks
2293 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2294 struct hda_codec *codec,
2295 unsigned int stream_tag,
2296 unsigned int format,
2297 struct snd_pcm_substream *substream)
2299 struct sigmatel_spec *spec = codec->spec;
2300 hda_nid_t nid = spec->adc_nids[substream->number];
2302 if (spec->powerdown_adcs) {
2304 snd_hda_codec_write_cache(codec, nid, 0,
2305 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2307 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2311 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2312 struct hda_codec *codec,
2313 struct snd_pcm_substream *substream)
2315 struct sigmatel_spec *spec = codec->spec;
2316 hda_nid_t nid = spec->adc_nids[substream->number];
2318 snd_hda_codec_cleanup_stream(codec, nid);
2319 if (spec->powerdown_adcs)
2320 snd_hda_codec_write_cache(codec, nid, 0,
2321 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2325 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2329 /* NID is set in stac92xx_build_pcms */
2331 .open = stac92xx_dig_playback_pcm_open,
2332 .close = stac92xx_dig_playback_pcm_close,
2333 .prepare = stac92xx_dig_playback_pcm_prepare
2337 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2341 /* NID is set in stac92xx_build_pcms */
2344 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2348 .nid = 0x02, /* NID to query formats and rates */
2350 .open = stac92xx_playback_pcm_open,
2351 .prepare = stac92xx_playback_pcm_prepare,
2352 .cleanup = stac92xx_playback_pcm_cleanup
2356 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2360 .nid = 0x06, /* NID to query formats and rates */
2362 .open = stac92xx_playback_pcm_open,
2363 .prepare = stac92xx_playback_pcm_prepare,
2364 .cleanup = stac92xx_playback_pcm_cleanup
2368 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2371 /* NID + .substreams is set in stac92xx_build_pcms */
2373 .prepare = stac92xx_capture_pcm_prepare,
2374 .cleanup = stac92xx_capture_pcm_cleanup
2378 static int stac92xx_build_pcms(struct hda_codec *codec)
2380 struct sigmatel_spec *spec = codec->spec;
2381 struct hda_pcm *info = spec->pcm_rec;
2383 codec->num_pcms = 1;
2384 codec->pcm_info = info;
2386 info->name = "STAC92xx Analog";
2387 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2388 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2389 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2390 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2392 if (spec->alt_switch) {
2395 info->name = "STAC92xx Analog Alt";
2396 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2399 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2402 info->name = "STAC92xx Digital";
2403 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2404 if (spec->multiout.dig_out_nid) {
2405 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2406 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2408 if (spec->dig_in_nid) {
2409 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2410 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2417 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
2419 unsigned int pincap = snd_hda_param_read(codec, nid,
2421 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2422 if (pincap & AC_PINCAP_VREF_100)
2423 return AC_PINCTL_VREF_100;
2424 if (pincap & AC_PINCAP_VREF_80)
2425 return AC_PINCTL_VREF_80;
2426 if (pincap & AC_PINCAP_VREF_50)
2427 return AC_PINCTL_VREF_50;
2428 if (pincap & AC_PINCAP_VREF_GRD)
2429 return AC_PINCTL_VREF_GRD;
2433 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2436 snd_hda_codec_write_cache(codec, nid, 0,
2437 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2440 #define stac92xx_hp_switch_info snd_ctl_boolean_mono_info
2442 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2443 struct snd_ctl_elem_value *ucontrol)
2445 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2446 struct sigmatel_spec *spec = codec->spec;
2448 ucontrol->value.integer.value[0] = !!spec->hp_switch;
2452 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2453 struct snd_ctl_elem_value *ucontrol)
2455 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2456 struct sigmatel_spec *spec = codec->spec;
2457 int nid = kcontrol->private_value;
2459 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2461 /* check to be sure that the ports are upto date with
2464 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2469 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
2471 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2473 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2474 struct sigmatel_spec *spec = codec->spec;
2475 int io_idx = kcontrol-> private_value & 0xff;
2477 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
2481 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2483 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2484 struct sigmatel_spec *spec = codec->spec;
2485 hda_nid_t nid = kcontrol->private_value >> 8;
2486 int io_idx = kcontrol-> private_value & 0xff;
2487 unsigned short val = !!ucontrol->value.integer.value[0];
2489 spec->io_switch[io_idx] = val;
2492 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2494 unsigned int pinctl = AC_PINCTL_IN_EN;
2495 if (io_idx) /* set VREF for mic */
2496 pinctl |= stac92xx_get_vref(codec, nid);
2497 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2500 /* check the auto-mute again: we need to mute/unmute the speaker
2501 * appropriately according to the pin direction
2503 if (spec->hp_detect)
2504 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2509 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2511 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2512 struct snd_ctl_elem_value *ucontrol)
2514 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2515 struct sigmatel_spec *spec = codec->spec;
2517 ucontrol->value.integer.value[0] = spec->clfe_swap;
2521 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2522 struct snd_ctl_elem_value *ucontrol)
2524 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2525 struct sigmatel_spec *spec = codec->spec;
2526 hda_nid_t nid = kcontrol->private_value & 0xff;
2527 unsigned int val = !!ucontrol->value.integer.value[0];
2529 if (spec->clfe_swap == val)
2532 spec->clfe_swap = val;
2534 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2535 spec->clfe_swap ? 0x4 : 0x0);
2540 #define STAC_CODEC_HP_SWITCH(xname) \
2541 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2544 .info = stac92xx_hp_switch_info, \
2545 .get = stac92xx_hp_switch_get, \
2546 .put = stac92xx_hp_switch_put, \
2549 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2550 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2553 .info = stac92xx_io_switch_info, \
2554 .get = stac92xx_io_switch_get, \
2555 .put = stac92xx_io_switch_put, \
2556 .private_value = xpval, \
2559 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2560 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2563 .info = stac92xx_clfe_switch_info, \
2564 .get = stac92xx_clfe_switch_get, \
2565 .put = stac92xx_clfe_switch_put, \
2566 .private_value = xpval, \
2570 STAC_CTL_WIDGET_VOL,
2571 STAC_CTL_WIDGET_MUTE,
2572 STAC_CTL_WIDGET_MONO_MUX,
2573 STAC_CTL_WIDGET_AMP_MUX,
2574 STAC_CTL_WIDGET_AMP_VOL,
2575 STAC_CTL_WIDGET_HP_SWITCH,
2576 STAC_CTL_WIDGET_IO_SWITCH,
2577 STAC_CTL_WIDGET_CLFE_SWITCH
2580 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2581 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2582 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2585 STAC_AMP_VOL(NULL, 0, 0, 0, 0),
2586 STAC_CODEC_HP_SWITCH(NULL),
2587 STAC_CODEC_IO_SWITCH(NULL, 0),
2588 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2591 /* add dynamic controls */
2592 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2593 struct snd_kcontrol_new *ktemp,
2594 int idx, const char *name,
2597 struct snd_kcontrol_new *knew;
2599 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
2600 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
2602 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
2605 if (spec->kctl_alloc) {
2606 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
2607 kfree(spec->kctl_alloc);
2609 spec->kctl_alloc = knew;
2610 spec->num_kctl_alloc = num;
2613 knew = &spec->kctl_alloc[spec->num_kctl_used];
2616 knew->name = kstrdup(name, GFP_KERNEL);
2619 knew->private_value = val;
2620 spec->num_kctl_used++;
2624 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2625 int type, int idx, const char *name,
2628 return stac92xx_add_control_temp(spec,
2629 &stac92xx_control_templates[type],
2634 /* add dynamic controls */
2635 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2636 const char *name, unsigned long val)
2638 return stac92xx_add_control_idx(spec, type, 0, name, val);
2641 /* flag inputs as additional dynamic lineouts */
2642 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
2644 struct sigmatel_spec *spec = codec->spec;
2645 unsigned int wcaps, wtype;
2646 int i, num_dacs = 0;
2648 /* use the wcaps cache to count all DACs available for line-outs */
2649 for (i = 0; i < codec->num_nodes; i++) {
2650 wcaps = codec->wcaps[i];
2651 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2653 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
2657 snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
2659 switch (cfg->line_outs) {
2661 /* add line-in as side */
2662 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
2663 cfg->line_out_pins[cfg->line_outs] =
2664 cfg->input_pins[AUTO_PIN_LINE];
2665 spec->line_switch = 1;
2670 /* add line-in as clfe and mic as side */
2671 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
2672 cfg->line_out_pins[cfg->line_outs] =
2673 cfg->input_pins[AUTO_PIN_LINE];
2674 spec->line_switch = 1;
2677 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
2678 cfg->line_out_pins[cfg->line_outs] =
2679 cfg->input_pins[AUTO_PIN_MIC];
2680 spec->mic_switch = 1;
2685 /* add line-in as surr and mic as clfe */
2686 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
2687 cfg->line_out_pins[cfg->line_outs] =
2688 cfg->input_pins[AUTO_PIN_LINE];
2689 spec->line_switch = 1;
2692 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
2693 cfg->line_out_pins[cfg->line_outs] =
2694 cfg->input_pins[AUTO_PIN_MIC];
2695 spec->mic_switch = 1;
2705 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2709 for (i = 0; i < spec->multiout.num_dacs; i++) {
2710 if (spec->multiout.dac_nids[i] == nid)
2718 * Fill in the dac_nids table from the parsed pin configuration
2719 * This function only works when every pin in line_out_pins[]
2720 * contains atleast one DAC in its connection list. Some 92xx
2721 * codecs are not connected directly to a DAC, such as the 9200
2722 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2724 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
2725 struct auto_pin_cfg *cfg)
2727 struct sigmatel_spec *spec = codec->spec;
2728 int i, j, conn_len = 0;
2729 hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
2730 unsigned int wcaps, wtype;
2732 for (i = 0; i < cfg->line_outs; i++) {
2733 nid = cfg->line_out_pins[i];
2734 conn_len = snd_hda_get_connections(codec, nid, conn,
2735 HDA_MAX_CONNECTIONS);
2736 for (j = 0; j < conn_len; j++) {
2737 wcaps = snd_hda_param_read(codec, conn[j],
2738 AC_PAR_AUDIO_WIDGET_CAP);
2739 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2740 if (wtype != AC_WID_AUD_OUT ||
2741 (wcaps & AC_WCAP_DIGITAL))
2743 /* conn[j] is a DAC routed to this line-out */
2744 if (!is_in_dac_nids(spec, conn[j]))
2748 if (j == conn_len) {
2749 if (spec->multiout.num_dacs > 0) {
2750 /* we have already working output pins,
2751 * so let's drop the broken ones again
2753 cfg->line_outs = spec->multiout.num_dacs;
2756 /* error out, no available DAC found */
2758 "%s: No available DAC for pin 0x%x\n",
2763 spec->multiout.dac_nids[i] = conn[j];
2764 spec->multiout.num_dacs++;
2766 /* select this DAC in the pin's input mux */
2767 snd_hda_codec_write_cache(codec, nid, 0,
2768 AC_VERB_SET_CONNECT_SEL, j);
2773 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2774 spec->multiout.num_dacs,
2775 spec->multiout.dac_nids[0],
2776 spec->multiout.dac_nids[1],
2777 spec->multiout.dac_nids[2],
2778 spec->multiout.dac_nids[3],
2779 spec->multiout.dac_nids[4]);
2783 /* create volume control/switch for the given prefx type */
2784 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
2789 sprintf(name, "%s Playback Volume", pfx);
2790 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
2791 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2794 sprintf(name, "%s Playback Switch", pfx);
2795 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
2796 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2802 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
2804 if (!spec->multiout.hp_nid)
2805 spec->multiout.hp_nid = nid;
2806 else if (spec->multiout.num_dacs > 4) {
2807 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
2810 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
2811 spec->multiout.num_dacs++;
2816 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2818 if (is_in_dac_nids(spec, nid))
2820 if (spec->multiout.hp_nid == nid)
2825 /* add playback controls from the parsed DAC table */
2826 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
2827 const struct auto_pin_cfg *cfg)
2829 static const char *chname[4] = {
2830 "Front", "Surround", NULL /*CLFE*/, "Side"
2835 struct sigmatel_spec *spec = codec->spec;
2836 unsigned int wid_caps, pincap;
2839 for (i = 0; i < cfg->line_outs && i < spec->multiout.num_dacs; i++) {
2840 if (!spec->multiout.dac_nids[i])
2843 nid = spec->multiout.dac_nids[i];
2847 err = create_controls(spec, "Center", nid, 1);
2850 err = create_controls(spec, "LFE", nid, 2);
2854 wid_caps = get_wcaps(codec, nid);
2856 if (wid_caps & AC_WCAP_LR_SWAP) {
2857 err = stac92xx_add_control(spec,
2858 STAC_CTL_WIDGET_CLFE_SWITCH,
2859 "Swap Center/LFE Playback Switch", nid);
2866 err = create_controls(spec, chname[i], nid, 3);
2872 if ((spec->multiout.num_dacs - cfg->line_outs) > 0 &&
2873 cfg->hp_outs && !spec->multiout.hp_nid)
2874 spec->multiout.hp_nid = nid;
2876 if (cfg->hp_outs > 1) {
2877 err = stac92xx_add_control(spec,
2878 STAC_CTL_WIDGET_HP_SWITCH,
2879 "Headphone as Line Out Switch",
2880 cfg->hp_pins[cfg->hp_outs - 1]);
2885 if (spec->line_switch) {
2886 nid = cfg->input_pins[AUTO_PIN_LINE];
2887 pincap = snd_hda_param_read(codec, nid,
2889 if (pincap & AC_PINCAP_OUT) {
2890 err = stac92xx_add_control(spec,
2891 STAC_CTL_WIDGET_IO_SWITCH,
2892 "Line In as Output Switch", nid << 8);
2898 if (spec->mic_switch) {
2899 unsigned int def_conf;
2900 unsigned int mic_pin = AUTO_PIN_MIC;
2902 nid = cfg->input_pins[mic_pin];
2903 def_conf = snd_hda_codec_read(codec, nid, 0,
2904 AC_VERB_GET_CONFIG_DEFAULT, 0);
2905 /* some laptops have an internal analog microphone
2906 * which can't be used as a output */
2907 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2908 pincap = snd_hda_param_read(codec, nid,
2910 if (pincap & AC_PINCAP_OUT) {
2911 err = stac92xx_add_control(spec,
2912 STAC_CTL_WIDGET_IO_SWITCH,
2913 "Mic as Output Switch", (nid << 8) | 1);
2914 nid = snd_hda_codec_read(codec, nid, 0,
2915 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2916 if (!check_in_dac_nids(spec, nid))
2917 add_spec_dacs(spec, nid);
2921 } else if (mic_pin == AUTO_PIN_MIC) {
2922 mic_pin = AUTO_PIN_FRONT_MIC;
2930 /* add playback controls for Speaker and HP outputs */
2931 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
2932 struct auto_pin_cfg *cfg)
2934 struct sigmatel_spec *spec = codec->spec;
2936 int i, old_num_dacs, err;
2938 old_num_dacs = spec->multiout.num_dacs;
2939 for (i = 0; i < cfg->hp_outs; i++) {
2940 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
2941 if (wid_caps & AC_WCAP_UNSOL_CAP)
2942 spec->hp_detect = 1;
2943 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
2944 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2945 if (check_in_dac_nids(spec, nid))
2949 add_spec_dacs(spec, nid);
2951 for (i = 0; i < cfg->speaker_outs; i++) {
2952 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
2953 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2954 if (check_in_dac_nids(spec, nid))
2958 add_spec_dacs(spec, nid);
2960 for (i = 0; i < cfg->line_outs; i++) {
2961 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
2962 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2963 if (check_in_dac_nids(spec, nid))
2967 add_spec_dacs(spec, nid);
2969 for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
2970 static const char *pfxs[] = {
2971 "Speaker", "External Speaker", "Speaker2",
2973 err = create_controls(spec, pfxs[i - old_num_dacs],
2974 spec->multiout.dac_nids[i], 3);
2978 if (spec->multiout.hp_nid) {
2979 err = create_controls(spec, "Headphone",
2980 spec->multiout.hp_nid, 3);
2988 /* labels for mono mux outputs */
2989 static const char *stac92xx_mono_labels[4] = {
2990 "DAC0", "DAC1", "Mixer", "DAC2"
2993 /* create mono mux for mono out on capable codecs */
2994 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
2996 struct sigmatel_spec *spec = codec->spec;
2997 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
2999 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3001 num_cons = snd_hda_get_connections(codec,
3004 HDA_MAX_NUM_INPUTS);
3005 if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3008 for (i = 0; i < num_cons; i++) {
3009 mono_mux->items[mono_mux->num_items].label =
3010 stac92xx_mono_labels[i];
3011 mono_mux->items[mono_mux->num_items].index = i;
3012 mono_mux->num_items++;
3015 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3016 "Mono Mux", spec->mono_nid);
3019 /* labels for amp mux outputs */
3020 static const char *stac92xx_amp_labels[3] = {
3021 "Front Microphone", "Microphone", "Line In",
3024 /* create amp out controls mux on capable codecs */
3025 static int stac92xx_auto_create_amp_output_ctls(struct hda_codec *codec)
3027 struct sigmatel_spec *spec = codec->spec;
3028 struct hda_input_mux *amp_mux = &spec->private_amp_mux;
3031 for (i = 0; i < spec->num_amps; i++) {
3032 amp_mux->items[amp_mux->num_items].label =
3033 stac92xx_amp_labels[i];
3034 amp_mux->items[amp_mux->num_items].index = i;
3035 amp_mux->num_items++;
3038 if (spec->num_amps > 1) {
3039 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_MUX,
3040 "Amp Selector Capture Switch", 0);
3044 return stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_VOL,
3045 "Amp Capture Volume",
3046 HDA_COMPOSE_AMP_VAL(spec->amp_nids[0], 3, 0, HDA_INPUT));
3050 /* create PC beep volume controls */
3051 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3054 struct sigmatel_spec *spec = codec->spec;
3055 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3058 /* check for mute support for the the amp */
3059 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3060 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3061 "PC Beep Playback Switch",
3062 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3067 /* check to see if there is volume support for the amp */
3068 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3069 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3070 "PC Beep Playback Volume",
3071 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3078 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3079 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3081 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3082 struct snd_ctl_elem_value *ucontrol)
3084 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3085 ucontrol->value.integer.value[0] = codec->beep->enabled;
3089 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3090 struct snd_ctl_elem_value *ucontrol)
3092 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3093 int enabled = !!ucontrol->value.integer.value[0];
3094 if (codec->beep->enabled != enabled) {
3095 codec->beep->enabled = enabled;
3101 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3102 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3103 .info = stac92xx_dig_beep_switch_info,
3104 .get = stac92xx_dig_beep_switch_get,
3105 .put = stac92xx_dig_beep_switch_put,
3108 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3110 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3111 0, "PC Beep Playback Switch", 0);
3115 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3117 struct sigmatel_spec *spec = codec->spec;
3118 int wcaps, nid, i, err = 0;
3120 for (i = 0; i < spec->num_muxes; i++) {
3121 nid = spec->mux_nids[i];
3122 wcaps = get_wcaps(codec, nid);
3124 if (wcaps & AC_WCAP_OUT_AMP) {
3125 err = stac92xx_add_control_idx(spec,
3126 STAC_CTL_WIDGET_VOL, i, "Mux Capture Volume",
3127 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3135 static const char *stac92xx_spdif_labels[3] = {
3136 "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3139 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3141 struct sigmatel_spec *spec = codec->spec;
3142 struct hda_input_mux *spdif_mux = &spec->private_smux;
3143 const char **labels = spec->spdif_labels;
3145 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3147 num_cons = snd_hda_get_connections(codec,
3150 HDA_MAX_NUM_INPUTS);
3155 labels = stac92xx_spdif_labels;
3157 for (i = 0; i < num_cons; i++) {
3158 spdif_mux->items[spdif_mux->num_items].label = labels[i];
3159 spdif_mux->items[spdif_mux->num_items].index = i;
3160 spdif_mux->num_items++;
3166 /* labels for dmic mux inputs */
3167 static const char *stac92xx_dmic_labels[5] = {
3168 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3169 "Digital Mic 3", "Digital Mic 4"
3172 /* create playback/capture controls for input pins on dmic capable codecs */
3173 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3174 const struct auto_pin_cfg *cfg)
3176 struct sigmatel_spec *spec = codec->spec;
3177 struct hda_input_mux *dimux = &spec->private_dimux;
3178 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3182 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
3183 dimux->items[dimux->num_items].index = 0;
3186 for (i = 0; i < spec->num_dmics; i++) {
3191 unsigned int def_conf;
3193 def_conf = snd_hda_codec_read(codec,
3196 AC_VERB_GET_CONFIG_DEFAULT,
3198 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3201 nid = spec->dmic_nids[i];
3202 num_cons = snd_hda_get_connections(codec,
3205 HDA_MAX_NUM_INPUTS);
3206 for (j = 0; j < num_cons; j++)
3207 if (con_lst[j] == nid) {
3213 wcaps = get_wcaps(codec, nid) &
3214 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3217 sprintf(name, "%s Capture Volume",
3218 stac92xx_dmic_labels[dimux->num_items]);
3220 err = stac92xx_add_control(spec,
3221 STAC_CTL_WIDGET_VOL,
3223 HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3224 (wcaps & AC_WCAP_OUT_AMP) ?
3225 HDA_OUTPUT : HDA_INPUT));
3230 dimux->items[dimux->num_items].label =
3231 stac92xx_dmic_labels[dimux->num_items];
3232 dimux->items[dimux->num_items].index = index;
3239 /* create playback/capture controls for input pins */
3240 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3242 struct sigmatel_spec *spec = codec->spec;
3243 struct hda_input_mux *imux = &spec->private_imux;
3244 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3247 for (i = 0; i < AUTO_PIN_LAST; i++) {
3250 if (!cfg->input_pins[i])
3253 for (j = 0; j < spec->num_muxes; j++) {
3255 num_cons = snd_hda_get_connections(codec,
3258 HDA_MAX_NUM_INPUTS);
3259 for (k = 0; k < num_cons; k++)
3260 if (con_lst[k] == cfg->input_pins[i]) {
3267 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3268 imux->items[imux->num_items].index = index;
3272 if (imux->num_items) {
3274 * Set the current input for the muxes.
3275 * The STAC9221 has two input muxes with identical source
3276 * NID lists. Hopefully this won't get confused.
3278 for (i = 0; i < spec->num_muxes; i++) {
3279 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3280 AC_VERB_SET_CONNECT_SEL,
3281 imux->items[0].index);
3288 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3290 struct sigmatel_spec *spec = codec->spec;
3293 for (i = 0; i < spec->autocfg.line_outs; i++) {
3294 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3295 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3299 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3301 struct sigmatel_spec *spec = codec->spec;
3304 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3306 pin = spec->autocfg.hp_pins[i];
3307 if (pin) /* connect to front */
3308 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3310 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3312 pin = spec->autocfg.speaker_pins[i];
3313 if (pin) /* connect to front */
3314 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3318 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3320 struct sigmatel_spec *spec = codec->spec;
3322 int hp_speaker_swap = 0;
3324 if ((err = snd_hda_parse_pin_def_config(codec,
3326 spec->dmic_nids)) < 0)
3328 if (! spec->autocfg.line_outs)
3329 return 0; /* can't find valid pin config */
3331 /* If we have no real line-out pin and multiple hp-outs, HPs should
3332 * be set up as multi-channel outputs.
3334 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
3335 spec->autocfg.hp_outs > 1) {
3336 /* Copy hp_outs to line_outs, backup line_outs in
3337 * speaker_outs so that the following routines can handle
3338 * HP pins as primary outputs.
3340 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3341 sizeof(spec->autocfg.line_out_pins));
3342 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3343 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3344 sizeof(spec->autocfg.hp_pins));
3345 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3346 hp_speaker_swap = 1;
3348 if (spec->autocfg.mono_out_pin) {
3349 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3350 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3351 u32 caps = query_amp_caps(codec,
3352 spec->autocfg.mono_out_pin, dir);
3353 hda_nid_t conn_list[1];
3355 /* get the mixer node and then the mono mux if it exists */
3356 if (snd_hda_get_connections(codec,
3357 spec->autocfg.mono_out_pin, conn_list, 1) &&
3358 snd_hda_get_connections(codec, conn_list[0],
3361 int wcaps = get_wcaps(codec, conn_list[0]);
3362 int wid_type = (wcaps & AC_WCAP_TYPE)
3363 >> AC_WCAP_TYPE_SHIFT;
3364 /* LR swap check, some stac925x have a mux that
3365 * changes the DACs output path instead of the
3368 if (wid_type == AC_WID_AUD_SEL &&
3369 !(wcaps & AC_WCAP_LR_SWAP))
3370 spec->mono_nid = conn_list[0];
3373 hda_nid_t nid = spec->autocfg.mono_out_pin;
3375 /* most mono outs have a least a mute/unmute switch */
3376 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3377 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3378 "Mono Playback Switch",
3379 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3382 /* check for volume support for the amp */
3383 if ((caps & AC_AMPCAP_NUM_STEPS)
3384 >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3385 err = stac92xx_add_control(spec,
3386 STAC_CTL_WIDGET_VOL,
3387 "Mono Playback Volume",
3388 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3394 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3398 if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
3400 if (spec->multiout.num_dacs == 0)
3401 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
3404 err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
3409 /* setup analog beep controls */
3410 if (spec->anabeep_nid > 0) {
3411 err = stac92xx_auto_create_beep_ctls(codec,
3417 /* setup digital beep controls and input device */
3418 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3419 if (spec->digbeep_nid > 0) {
3420 hda_nid_t nid = spec->digbeep_nid;
3423 err = stac92xx_auto_create_beep_ctls(codec, nid);
3426 err = snd_hda_attach_beep_device(codec, nid);
3429 /* if no beep switch is available, make its own one */
3430 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3432 !((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT)) {
3433 err = stac92xx_beep_switch_ctl(codec);
3440 if (hp_speaker_swap == 1) {
3441 /* Restore the hp_outs and line_outs */
3442 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3443 sizeof(spec->autocfg.line_out_pins));
3444 spec->autocfg.hp_outs = spec->autocfg.line_outs;
3445 memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins,
3446 sizeof(spec->autocfg.speaker_pins));
3447 spec->autocfg.line_outs = spec->autocfg.speaker_outs;
3448 memset(spec->autocfg.speaker_pins, 0,
3449 sizeof(spec->autocfg.speaker_pins));
3450 spec->autocfg.speaker_outs = 0;
3453 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3458 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3463 if (spec->mono_nid > 0) {
3464 err = stac92xx_auto_create_mono_output_ctls(codec);
3468 if (spec->num_amps > 0) {
3469 err = stac92xx_auto_create_amp_output_ctls(codec);
3473 if (spec->num_dmics > 0 && !spec->dinput_mux)
3474 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3475 &spec->autocfg)) < 0)
3477 if (spec->num_muxes > 0) {
3478 err = stac92xx_auto_create_mux_input_ctls(codec);
3482 if (spec->num_smuxes > 0) {
3483 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3488 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3489 if (spec->multiout.max_channels > 2)
3490 spec->surr_switch = 1;
3492 if (spec->autocfg.dig_out_pin)
3493 spec->multiout.dig_out_nid = dig_out;
3494 if (dig_in && spec->autocfg.dig_in_pin)
3495 spec->dig_in_nid = dig_in;
3497 if (spec->kctl_alloc)
3498 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3500 spec->input_mux = &spec->private_imux;
3501 spec->dinput_mux = &spec->private_dimux;
3502 spec->sinput_mux = &spec->private_smux;
3503 spec->mono_mux = &spec->private_mono_mux;
3504 spec->amp_mux = &spec->private_amp_mux;
3508 /* add playback controls for HP output */
3509 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3510 struct auto_pin_cfg *cfg)
3512 struct sigmatel_spec *spec = codec->spec;
3513 hda_nid_t pin = cfg->hp_pins[0];
3514 unsigned int wid_caps;
3519 wid_caps = get_wcaps(codec, pin);
3520 if (wid_caps & AC_WCAP_UNSOL_CAP)
3521 spec->hp_detect = 1;
3526 /* add playback controls for LFE output */
3527 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3528 struct auto_pin_cfg *cfg)
3530 struct sigmatel_spec *spec = codec->spec;
3532 hda_nid_t lfe_pin = 0x0;
3536 * search speaker outs and line outs for a mono speaker pin
3537 * with an amp. If one is found, add LFE controls
3540 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3541 hda_nid_t pin = spec->autocfg.speaker_pins[i];
3542 unsigned int wcaps = get_wcaps(codec, pin);
3543 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3544 if (wcaps == AC_WCAP_OUT_AMP)
3545 /* found a mono speaker with an amp, must be lfe */
3549 /* if speaker_outs is 0, then speakers may be in line_outs */
3550 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3551 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3552 hda_nid_t pin = spec->autocfg.line_out_pins[i];
3553 unsigned int defcfg;
3554 defcfg = snd_hda_codec_read(codec, pin, 0,
3555 AC_VERB_GET_CONFIG_DEFAULT,
3557 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
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,
3569 err = create_controls(spec, "LFE", lfe_pin, 1);
3577 static int stac9200_parse_auto_config(struct hda_codec *codec)
3579 struct sigmatel_spec *spec = codec->spec;
3582 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3585 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3588 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
3591 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
3594 if (spec->num_muxes > 0) {
3595 err = stac92xx_auto_create_mux_input_ctls(codec);
3600 if (spec->autocfg.dig_out_pin)
3601 spec->multiout.dig_out_nid = 0x05;
3602 if (spec->autocfg.dig_in_pin)
3603 spec->dig_in_nid = 0x04;
3605 if (spec->kctl_alloc)
3606 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3608 spec->input_mux = &spec->private_imux;
3609 spec->dinput_mux = &spec->private_dimux;
3615 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
3616 * funky external mute control using GPIO pins.
3619 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
3620 unsigned int dir_mask, unsigned int data)
3622 unsigned int gpiostate, gpiomask, gpiodir;
3624 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
3625 AC_VERB_GET_GPIO_DATA, 0);
3626 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
3628 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
3629 AC_VERB_GET_GPIO_MASK, 0);
3632 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
3633 AC_VERB_GET_GPIO_DIRECTION, 0);
3634 gpiodir |= dir_mask;
3636 /* Configure GPIOx as CMOS */
3637 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
3639 snd_hda_codec_write(codec, codec->afg, 0,
3640 AC_VERB_SET_GPIO_MASK, gpiomask);
3641 snd_hda_codec_read(codec, codec->afg, 0,
3642 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
3646 snd_hda_codec_read(codec, codec->afg, 0,
3647 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
3650 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
3653 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
3654 snd_hda_codec_write_cache(codec, nid, 0,
3655 AC_VERB_SET_UNSOLICITED_ENABLE,
3656 (AC_USRSP_EN | event));
3659 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
3662 for (i = 0; i < cfg->hp_outs; i++)
3663 if (cfg->hp_pins[i] == nid)
3664 return 1; /* nid is a HP-Out */
3666 return 0; /* nid is not a HP-Out */
3669 static void stac92xx_power_down(struct hda_codec *codec)
3671 struct sigmatel_spec *spec = codec->spec;
3673 /* power down inactive DACs */
3675 for (dac = spec->dac_list; *dac; dac++)
3676 if (!is_in_dac_nids(spec, *dac) &&
3677 spec->multiout.hp_nid != *dac)
3678 snd_hda_codec_write_cache(codec, *dac, 0,
3679 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3682 static int stac92xx_init(struct hda_codec *codec)
3684 struct sigmatel_spec *spec = codec->spec;
3685 struct auto_pin_cfg *cfg = &spec->autocfg;
3688 snd_hda_sequence_write(codec, spec->init);
3690 /* power down adcs initially */
3691 if (spec->powerdown_adcs)
3692 for (i = 0; i < spec->num_adcs; i++)
3693 snd_hda_codec_write_cache(codec,
3694 spec->adc_nids[i], 0,
3695 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3697 if (spec->hp_detect) {
3698 /* Enable unsolicited responses on the HP widget */
3699 for (i = 0; i < cfg->hp_outs; i++)
3700 enable_pin_detect(codec, cfg->hp_pins[i],
3702 /* force to enable the first line-out; the others are set up
3705 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
3707 stac92xx_auto_init_hp_out(codec);
3708 /* fake event to set up pins */
3709 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3711 stac92xx_auto_init_multi_out(codec);
3712 stac92xx_auto_init_hp_out(codec);
3714 for (i = 0; i < AUTO_PIN_LAST; i++) {
3715 hda_nid_t nid = cfg->input_pins[i];
3717 unsigned int pinctl;
3718 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
3719 /* for mic pins, force to initialize */
3720 pinctl = stac92xx_get_vref(codec, nid);
3722 pinctl = snd_hda_codec_read(codec, nid, 0,
3723 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3724 /* if PINCTL already set then skip */
3725 if (pinctl & AC_PINCTL_IN_EN)
3728 pinctl |= AC_PINCTL_IN_EN;
3729 stac92xx_auto_set_pinctl(codec, nid, pinctl);
3732 for (i = 0; i < spec->num_dmics; i++)
3733 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
3735 for (i = 0; i < spec->num_pwrs; i++) {
3736 int event = is_nid_hp_pin(cfg, spec->pwr_nids[i])
3737 ? STAC_HP_EVENT : STAC_PWR_EVENT;
3738 int pinctl = snd_hda_codec_read(codec, spec->pwr_nids[i],
3739 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3740 int def_conf = snd_hda_codec_read(codec, spec->pwr_nids[i],
3741 0, AC_VERB_GET_CONFIG_DEFAULT, 0);
3742 def_conf = get_defcfg_connect(def_conf);
3743 /* outputs are only ports capable of power management
3744 * any attempts on powering down a input port cause the
3745 * referenced VREF to act quirky.
3747 if (pinctl & AC_PINCTL_IN_EN)
3749 /* skip any ports that don't have jacks since presence
3750 * detection is useless */
3751 if (def_conf && def_conf != AC_JACK_PORT_FIXED)
3753 enable_pin_detect(codec, spec->pwr_nids[i], event | i);
3754 codec->patch_ops.unsol_event(codec, (event | i) << 26);
3757 stac92xx_power_down(codec);
3758 if (cfg->dig_out_pin)
3759 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
3761 if (cfg->dig_in_pin)
3762 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
3765 stac_gpio_set(codec, spec->gpio_mask,
3766 spec->gpio_dir, spec->gpio_data);
3771 static void stac92xx_free(struct hda_codec *codec)
3773 struct sigmatel_spec *spec = codec->spec;
3779 if (spec->kctl_alloc) {
3780 for (i = 0; i < spec->num_kctl_used; i++)
3781 kfree(spec->kctl_alloc[i].name);
3782 kfree(spec->kctl_alloc);
3785 if (spec->bios_pin_configs)
3786 kfree(spec->bios_pin_configs);
3789 snd_hda_detach_beep_device(codec);
3792 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
3795 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
3796 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
3798 if (pin_ctl & AC_PINCTL_IN_EN) {
3800 * we need to check the current set-up direction of
3801 * shared input pins since they can be switched via
3802 * "xxx as Output" mixer switch
3804 struct sigmatel_spec *spec = codec->spec;
3805 struct auto_pin_cfg *cfg = &spec->autocfg;
3806 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
3807 spec->line_switch) ||
3808 (nid == cfg->input_pins[AUTO_PIN_MIC] &&
3813 /* if setting pin direction bits, clear the current
3814 direction bits first */
3815 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
3816 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
3818 snd_hda_codec_write_cache(codec, nid, 0,
3819 AC_VERB_SET_PIN_WIDGET_CONTROL,
3823 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
3826 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
3827 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
3828 snd_hda_codec_write_cache(codec, nid, 0,
3829 AC_VERB_SET_PIN_WIDGET_CONTROL,
3833 static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid)
3837 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
3839 unsigned int pinctl;
3840 pinctl = snd_hda_codec_read(codec, nid, 0,
3841 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3842 if (pinctl & AC_PINCTL_IN_EN)
3843 return 0; /* mic- or line-input */
3845 return 1; /* HP-output */
3850 /* return non-zero if the hp-pin of the given array index isn't
3851 * a jack-detection target
3853 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
3855 struct auto_pin_cfg *cfg = &spec->autocfg;
3857 /* ignore sensing of shared line and mic jacks */
3858 if (spec->line_switch &&
3859 cfg->hp_pins[i] == cfg->input_pins[AUTO_PIN_LINE])
3861 if (spec->mic_switch &&
3862 cfg->hp_pins[i] == cfg->input_pins[AUTO_PIN_MIC])
3864 /* ignore if the pin is set as line-out */
3865 if (cfg->hp_pins[i] == spec->hp_switch)
3870 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
3872 struct sigmatel_spec *spec = codec->spec;
3873 struct auto_pin_cfg *cfg = &spec->autocfg;
3877 if (spec->gpio_mute)
3878 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
3879 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
3881 for (i = 0; i < cfg->hp_outs; i++) {
3884 if (no_hp_sensing(spec, i))
3886 presence = get_hp_pin_presence(codec, cfg->hp_pins[i]);
3890 /* disable lineouts */
3891 if (spec->hp_switch)
3892 stac92xx_reset_pinctl(codec, spec->hp_switch,
3894 for (i = 0; i < cfg->line_outs; i++)
3895 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
3897 for (i = 0; i < cfg->speaker_outs; i++)
3898 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
3900 if (spec->eapd_mask)
3901 stac_gpio_set(codec, spec->gpio_mask,
3902 spec->gpio_dir, spec->gpio_data &
3905 /* enable lineouts */
3906 if (spec->hp_switch)
3907 stac92xx_set_pinctl(codec, spec->hp_switch,
3909 for (i = 0; i < cfg->line_outs; i++)
3910 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
3912 for (i = 0; i < cfg->speaker_outs; i++)
3913 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
3915 if (spec->eapd_mask)
3916 stac_gpio_set(codec, spec->gpio_mask,
3917 spec->gpio_dir, spec->gpio_data |
3920 /* toggle hp outs */
3921 for (i = 0; i < cfg->hp_outs; i++) {
3922 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
3923 if (no_hp_sensing(spec, i))
3926 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
3928 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
3932 static void stac92xx_pin_sense(struct hda_codec *codec, int idx)
3934 struct sigmatel_spec *spec = codec->spec;
3935 hda_nid_t nid = spec->pwr_nids[idx];
3937 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0)
3939 presence = get_hp_pin_presence(codec, nid);
3941 /* several codecs have two power down bits */
3942 if (spec->pwr_mapping)
3943 idx = spec->pwr_mapping[idx];
3952 /* power down unused output ports */
3953 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
3956 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
3958 struct sigmatel_spec *spec = codec->spec;
3959 int idx = res >> 26 & 0x0f;
3961 switch ((res >> 26) & 0x70) {
3963 stac92xx_hp_detect(codec, res);
3965 case STAC_PWR_EVENT:
3966 if (spec->num_pwrs > 0)
3967 stac92xx_pin_sense(codec, idx);
3969 case STAC_VREF_EVENT: {
3970 int data = snd_hda_codec_read(codec, codec->afg, 0,
3971 AC_VERB_GET_GPIO_DATA, 0);
3972 /* toggle VREF state based on GPIOx status */
3973 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
3974 !!(data & (1 << idx)));
3980 #ifdef SND_HDA_NEEDS_RESUME
3981 static int stac92xx_resume(struct hda_codec *codec)
3983 struct sigmatel_spec *spec = codec->spec;
3985 stac92xx_set_config_regs(codec);
3986 snd_hda_sequence_write(codec, spec->init);
3987 stac_gpio_set(codec, spec->gpio_mask,
3988 spec->gpio_dir, spec->gpio_data);
3989 snd_hda_codec_resume_amp(codec);
3990 snd_hda_codec_resume_cache(codec);
3991 /* power down inactive DACs */
3993 stac92xx_power_down(codec);
3994 /* invoke unsolicited event to reset the HP state */
3995 if (spec->hp_detect)
3996 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
4001 static struct hda_codec_ops stac92xx_patch_ops = {
4002 .build_controls = stac92xx_build_controls,
4003 .build_pcms = stac92xx_build_pcms,
4004 .init = stac92xx_init,
4005 .free = stac92xx_free,
4006 .unsol_event = stac92xx_unsol_event,
4007 #ifdef SND_HDA_NEEDS_RESUME
4008 .resume = stac92xx_resume,
4012 static int patch_stac9200(struct hda_codec *codec)
4014 struct sigmatel_spec *spec;
4017 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4022 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
4023 spec->pin_nids = stac9200_pin_nids;
4024 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
4027 if (spec->board_config < 0) {
4028 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
4029 err = stac92xx_save_bios_config_regs(codec);
4031 stac92xx_free(codec);
4034 spec->pin_configs = spec->bios_pin_configs;
4036 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
4037 stac92xx_set_config_regs(codec);
4040 spec->multiout.max_channels = 2;
4041 spec->multiout.num_dacs = 1;
4042 spec->multiout.dac_nids = stac9200_dac_nids;
4043 spec->adc_nids = stac9200_adc_nids;
4044 spec->mux_nids = stac9200_mux_nids;
4045 spec->num_muxes = 1;
4046 spec->num_dmics = 0;
4050 if (spec->board_config == STAC_9200_GATEWAY ||
4051 spec->board_config == STAC_9200_OQO)
4052 spec->init = stac9200_eapd_init;
4054 spec->init = stac9200_core_init;
4055 spec->mixer = stac9200_mixer;
4057 if (spec->board_config == STAC_9200_PANASONIC) {
4058 spec->gpio_mask = spec->gpio_dir = 0x09;
4059 spec->gpio_data = 0x00;
4062 err = stac9200_parse_auto_config(codec);
4064 stac92xx_free(codec);
4068 codec->patch_ops = stac92xx_patch_ops;
4073 static int patch_stac925x(struct hda_codec *codec)
4075 struct sigmatel_spec *spec;
4078 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4083 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
4084 spec->pin_nids = stac925x_pin_nids;
4085 spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
4089 if (spec->board_config < 0) {
4090 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
4091 "using BIOS defaults\n");
4092 err = stac92xx_save_bios_config_regs(codec);
4094 stac92xx_free(codec);
4097 spec->pin_configs = spec->bios_pin_configs;
4098 } else if (stac925x_brd_tbl[spec->board_config] != NULL){
4099 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
4100 stac92xx_set_config_regs(codec);
4103 spec->multiout.max_channels = 2;
4104 spec->multiout.num_dacs = 1;
4105 spec->multiout.dac_nids = stac925x_dac_nids;
4106 spec->adc_nids = stac925x_adc_nids;
4107 spec->mux_nids = stac925x_mux_nids;
4108 spec->num_muxes = 1;
4111 switch (codec->vendor_id) {
4112 case 0x83847632: /* STAC9202 */
4113 case 0x83847633: /* STAC9202D */
4114 case 0x83847636: /* STAC9251 */
4115 case 0x83847637: /* STAC9251D */
4116 spec->num_dmics = STAC925X_NUM_DMICS;
4117 spec->dmic_nids = stac925x_dmic_nids;
4118 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
4119 spec->dmux_nids = stac925x_dmux_nids;
4122 spec->num_dmics = 0;
4126 spec->init = stac925x_core_init;
4127 spec->mixer = stac925x_mixer;
4129 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
4131 if (spec->board_config < 0) {
4132 printk(KERN_WARNING "hda_codec: No auto-config is "
4133 "available, default to model=ref\n");
4134 spec->board_config = STAC_925x_REF;
4140 stac92xx_free(codec);
4144 codec->patch_ops = stac92xx_patch_ops;
4149 static struct hda_input_mux stac92hd73xx_dmux = {
4152 { "Analog Inputs", 0x0b },
4153 { "Digital Mic 1", 0x09 },
4154 { "Digital Mic 2", 0x0a },
4159 static int patch_stac92hd73xx(struct hda_codec *codec)
4161 struct sigmatel_spec *spec;
4162 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
4165 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4170 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
4171 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
4172 spec->pin_nids = stac92hd73xx_pin_nids;
4173 spec->board_config = snd_hda_check_board_config(codec,
4174 STAC_92HD73XX_MODELS,
4175 stac92hd73xx_models,
4176 stac92hd73xx_cfg_tbl);
4178 if (spec->board_config < 0) {
4179 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4180 " STAC92HD73XX, using BIOS defaults\n");
4181 err = stac92xx_save_bios_config_regs(codec);
4183 stac92xx_free(codec);
4186 spec->pin_configs = spec->bios_pin_configs;
4188 spec->pin_configs = stac92hd73xx_brd_tbl[spec->board_config];
4189 stac92xx_set_config_regs(codec);
4192 spec->multiout.num_dacs = snd_hda_get_connections(codec, 0x0a,
4193 conn, STAC92HD73_DAC_COUNT + 2) - 1;
4195 if (spec->multiout.num_dacs < 0) {
4196 printk(KERN_WARNING "hda_codec: Could not determine "
4197 "number of channels defaulting to DAC count\n");
4198 spec->multiout.num_dacs = STAC92HD73_DAC_COUNT;
4201 switch (spec->multiout.num_dacs) {
4202 case 0x3: /* 6 Channel */
4203 spec->mixer = stac92hd73xx_6ch_mixer;
4204 spec->init = stac92hd73xx_6ch_core_init;
4206 case 0x4: /* 8 Channel */
4207 spec->mixer = stac92hd73xx_8ch_mixer;
4208 spec->init = stac92hd73xx_8ch_core_init;
4210 case 0x5: /* 10 Channel */
4211 spec->mixer = stac92hd73xx_10ch_mixer;
4212 spec->init = stac92hd73xx_10ch_core_init;
4215 spec->multiout.dac_nids = stac92hd73xx_dac_nids;
4216 spec->aloopback_mask = 0x01;
4217 spec->aloopback_shift = 8;
4219 spec->digbeep_nid = 0x1c;
4220 spec->mux_nids = stac92hd73xx_mux_nids;
4221 spec->adc_nids = stac92hd73xx_adc_nids;
4222 spec->dmic_nids = stac92hd73xx_dmic_nids;
4223 spec->dmux_nids = stac92hd73xx_dmux_nids;
4224 spec->smux_nids = stac92hd73xx_smux_nids;
4225 spec->amp_nids = stac92hd73xx_amp_nids;
4226 spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
4228 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
4229 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
4230 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
4231 memcpy(&spec->private_dimux, &stac92hd73xx_dmux,
4232 sizeof(stac92hd73xx_dmux));
4234 switch (spec->board_config) {
4236 spec->init = dell_eq_core_init;
4239 spec->num_smuxes = 0;
4240 spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
4241 spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
4245 spec->init = dell_m6_core_init;
4246 switch (codec->subsystem_id) {
4247 case 0x1028025e: /* Analog Mics */
4249 stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
4250 spec->num_dmics = 0;
4251 spec->private_dimux.num_items = 1;
4253 case 0x10280271: /* Digital Mics */
4257 stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
4258 spec->num_dmics = 1;
4259 spec->private_dimux.num_items = 2;
4261 case 0x10280256: /* Both */
4263 stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
4264 stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
4265 spec->num_dmics = 1;
4266 spec->private_dimux.num_items = 2;
4271 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
4272 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
4274 if (spec->board_config > STAC_92HD73XX_REF) {
4275 /* GPIO0 High = Enable EAPD */
4276 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4277 spec->gpio_data = 0x01;
4279 spec->dinput_mux = &spec->private_dimux;
4281 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
4282 spec->pwr_nids = stac92hd73xx_pwr_nids;
4284 err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
4287 if (spec->board_config < 0) {
4288 printk(KERN_WARNING "hda_codec: No auto-config is "
4289 "available, default to model=ref\n");
4290 spec->board_config = STAC_92HD73XX_REF;
4297 stac92xx_free(codec);
4301 codec->patch_ops = stac92xx_patch_ops;
4306 static struct hda_input_mux stac92hd83xxx_dmux = {
4309 { "Analog Inputs", 0x03 },
4310 { "Digital Mic 1", 0x04 },
4311 { "Digital Mic 2", 0x05 },
4315 static int patch_stac92hd83xxx(struct hda_codec *codec)
4317 struct sigmatel_spec *spec;
4320 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4325 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
4326 spec->mono_nid = 0x19;
4327 spec->digbeep_nid = 0x21;
4328 spec->dmic_nids = stac92hd83xxx_dmic_nids;
4329 spec->dmux_nids = stac92hd83xxx_dmux_nids;
4330 spec->adc_nids = stac92hd83xxx_adc_nids;
4331 spec->pwr_nids = stac92hd83xxx_pwr_nids;
4332 spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
4333 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
4334 spec->multiout.dac_nids = stac92hd83xxx_dac_nids;
4336 spec->init = stac92hd83xxx_core_init;
4337 switch (codec->vendor_id) {
4339 spec->multiout.num_dacs = STAC92HD81_DAC_COUNT;
4343 spec->init++; /* switch to config #2 */
4344 spec->multiout.num_dacs = STAC92HD83_DAC_COUNT;
4347 spec->mixer = stac92hd83xxx_mixer;
4348 spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
4349 spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
4350 spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
4351 spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
4352 spec->dinput_mux = &stac92hd83xxx_dmux;
4353 spec->pin_nids = stac92hd83xxx_pin_nids;
4354 spec->board_config = snd_hda_check_board_config(codec,
4355 STAC_92HD83XXX_MODELS,
4356 stac92hd83xxx_models,
4357 stac92hd83xxx_cfg_tbl);
4359 if (spec->board_config < 0) {
4360 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4361 " STAC92HD83XXX, using BIOS defaults\n");
4362 err = stac92xx_save_bios_config_regs(codec);
4364 stac92xx_free(codec);
4367 spec->pin_configs = spec->bios_pin_configs;
4369 spec->pin_configs = stac92hd83xxx_brd_tbl[spec->board_config];
4370 stac92xx_set_config_regs(codec);
4373 err = stac92xx_parse_auto_config(codec, 0x1d, 0);
4375 if (spec->board_config < 0) {
4376 printk(KERN_WARNING "hda_codec: No auto-config is "
4377 "available, default to model=ref\n");
4378 spec->board_config = STAC_92HD83XXX_REF;
4385 stac92xx_free(codec);
4389 codec->patch_ops = stac92xx_patch_ops;
4394 #ifdef SND_HDA_NEEDS_RESUME
4395 static void stac92hd71xx_set_power_state(struct hda_codec *codec, int pwr)
4397 struct sigmatel_spec *spec = codec->spec;
4399 snd_hda_codec_write_cache(codec, codec->afg, 0,
4400 AC_VERB_SET_POWER_STATE, pwr);
4403 for (i = 0; i < spec->num_adcs; i++) {
4404 snd_hda_codec_write_cache(codec,
4405 spec->adc_nids[i], 0,
4406 AC_VERB_SET_POWER_STATE, pwr);
4410 static int stac92hd71xx_resume(struct hda_codec *codec)
4412 stac92hd71xx_set_power_state(codec, AC_PWRST_D0);
4413 return stac92xx_resume(codec);
4416 static int stac92hd71xx_suspend(struct hda_codec *codec, pm_message_t state)
4418 stac92hd71xx_set_power_state(codec, AC_PWRST_D3);
4424 static struct hda_codec_ops stac92hd71bxx_patch_ops = {
4425 .build_controls = stac92xx_build_controls,
4426 .build_pcms = stac92xx_build_pcms,
4427 .init = stac92xx_init,
4428 .free = stac92xx_free,
4429 .unsol_event = stac92xx_unsol_event,
4430 #ifdef SND_HDA_NEEDS_RESUME
4431 .resume = stac92hd71xx_resume,
4432 .suspend = stac92hd71xx_suspend,
4436 static struct hda_input_mux stac92hd71bxx_dmux = {
4439 { "Analog Inputs", 0x00 },
4441 { "Digital Mic 1", 0x02 },
4442 { "Digital Mic 2", 0x03 },
4446 static int patch_stac92hd71bxx(struct hda_codec *codec)
4448 struct sigmatel_spec *spec;
4451 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4456 codec->patch_ops = stac92xx_patch_ops;
4457 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
4458 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
4459 spec->pin_nids = stac92hd71bxx_pin_nids;
4460 memcpy(&spec->private_dimux, &stac92hd71bxx_dmux,
4461 sizeof(stac92hd71bxx_dmux));
4462 spec->board_config = snd_hda_check_board_config(codec,
4463 STAC_92HD71BXX_MODELS,
4464 stac92hd71bxx_models,
4465 stac92hd71bxx_cfg_tbl);
4467 if (spec->board_config < 0) {
4468 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4469 " STAC92HD71BXX, using BIOS defaults\n");
4470 err = stac92xx_save_bios_config_regs(codec);
4472 stac92xx_free(codec);
4475 spec->pin_configs = spec->bios_pin_configs;
4477 spec->pin_configs = stac92hd71bxx_brd_tbl[spec->board_config];
4478 stac92xx_set_config_regs(codec);
4481 if (spec->board_config > STAC_92HD71BXX_REF) {
4483 spec->gpio_mask = 0x01;
4484 spec->gpio_dir = 0x01;
4485 spec->gpio_data = 0x01;
4488 switch (codec->vendor_id) {
4489 case 0x111d76b6: /* 4 Port without Analog Mixer */
4491 case 0x111d76b4: /* 6 Port without Analog Mixer */
4493 spec->mixer = stac92hd71bxx_mixer;
4494 spec->init = stac92hd71bxx_core_init;
4495 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4497 case 0x111d7608: /* 5 Port with Analog Mixer */
4498 switch (spec->board_config) {
4500 /* Enable VREF power saving on GPIO1 detect */
4501 snd_hda_codec_write(codec, codec->afg, 0,
4502 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
4503 snd_hda_codec_write_cache(codec, codec->afg, 0,
4504 AC_VERB_SET_UNSOLICITED_ENABLE,
4505 (AC_USRSP_EN | STAC_VREF_EVENT | 0x01));
4506 spec->gpio_mask |= 0x02;
4509 if ((codec->revision_id & 0xf) == 0 ||
4510 (codec->revision_id & 0xf) == 1) {
4511 #ifdef SND_HDA_NEEDS_RESUME
4512 codec->patch_ops = stac92hd71bxx_patch_ops;
4514 spec->stream_delay = 40; /* 40 milliseconds */
4517 /* no output amps */
4519 spec->mixer = stac92hd71bxx_analog_mixer;
4520 spec->dinput_mux = &spec->private_dimux;
4523 spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
4524 stac92xx_set_config_reg(codec, 0xf, 0x40f000f0);
4526 case 0x111d7603: /* 6 Port with Analog Mixer */
4527 if ((codec->revision_id & 0xf) == 1) {
4528 #ifdef SND_HDA_NEEDS_RESUME
4529 codec->patch_ops = stac92hd71bxx_patch_ops;
4531 spec->stream_delay = 40; /* 40 milliseconds */
4534 /* no output amps */
4538 spec->dinput_mux = &spec->private_dimux;
4539 spec->mixer = stac92hd71bxx_analog_mixer;
4540 spec->init = stac92hd71bxx_analog_core_init;
4541 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4544 spec->aloopback_mask = 0x50;
4545 spec->aloopback_shift = 0;
4547 spec->powerdown_adcs = 1;
4548 spec->digbeep_nid = 0x26;
4549 spec->mux_nids = stac92hd71bxx_mux_nids;
4550 spec->adc_nids = stac92hd71bxx_adc_nids;
4551 spec->dmic_nids = stac92hd71bxx_dmic_nids;
4552 spec->dmux_nids = stac92hd71bxx_dmux_nids;
4553 spec->smux_nids = stac92hd71bxx_smux_nids;
4554 spec->pwr_nids = stac92hd71bxx_pwr_nids;
4556 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
4557 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
4559 switch (spec->board_config) {
4561 spec->num_dmics = 0;
4562 spec->num_smuxes = 0;
4563 spec->num_dmuxes = 0;
4565 /* enable internal microphone */
4566 stac92xx_set_config_reg(codec, 0x0e, 0x01813040);
4567 stac92xx_auto_set_pinctl(codec, 0x0e,
4568 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
4571 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
4572 spec->num_smuxes = ARRAY_SIZE(stac92hd71bxx_smux_nids);
4573 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
4576 spec->multiout.num_dacs = 1;
4577 spec->multiout.hp_nid = 0x11;
4578 spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
4579 if (spec->dinput_mux)
4580 spec->private_dimux.num_items +=
4582 (ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1);
4584 err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
4586 if (spec->board_config < 0) {
4587 printk(KERN_WARNING "hda_codec: No auto-config is "
4588 "available, default to model=ref\n");
4589 spec->board_config = STAC_92HD71BXX_REF;
4596 stac92xx_free(codec);
4603 static int patch_stac922x(struct hda_codec *codec)
4605 struct sigmatel_spec *spec;
4608 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4613 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
4614 spec->pin_nids = stac922x_pin_nids;
4615 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
4618 if (spec->board_config == STAC_INTEL_MAC_AUTO) {
4619 spec->gpio_mask = spec->gpio_dir = 0x03;
4620 spec->gpio_data = 0x03;
4621 /* Intel Macs have all same PCI SSID, so we need to check
4622 * codec SSID to distinguish the exact models
4624 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
4625 switch (codec->subsystem_id) {
4628 spec->board_config = STAC_INTEL_MAC_V1;
4632 spec->board_config = STAC_INTEL_MAC_V2;
4640 spec->board_config = STAC_INTEL_MAC_V3;
4644 spec->board_config = STAC_INTEL_MAC_V4;
4648 spec->board_config = STAC_INTEL_MAC_V5;
4651 spec->board_config = STAC_INTEL_MAC_V3;
4657 if (spec->board_config < 0) {
4658 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
4659 "using BIOS defaults\n");
4660 err = stac92xx_save_bios_config_regs(codec);
4662 stac92xx_free(codec);
4665 spec->pin_configs = spec->bios_pin_configs;
4666 } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
4667 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
4668 stac92xx_set_config_regs(codec);
4671 spec->adc_nids = stac922x_adc_nids;
4672 spec->mux_nids = stac922x_mux_nids;
4673 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
4674 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
4675 spec->num_dmics = 0;
4678 spec->init = stac922x_core_init;
4679 spec->mixer = stac922x_mixer;
4681 spec->multiout.dac_nids = spec->dac_nids;
4683 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
4685 if (spec->board_config < 0) {
4686 printk(KERN_WARNING "hda_codec: No auto-config is "
4687 "available, default to model=ref\n");
4688 spec->board_config = STAC_D945_REF;
4694 stac92xx_free(codec);
4698 codec->patch_ops = stac92xx_patch_ops;
4700 /* Fix Mux capture level; max to 2 */
4701 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
4702 (0 << AC_AMPCAP_OFFSET_SHIFT) |
4703 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4704 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4705 (0 << AC_AMPCAP_MUTE_SHIFT));
4710 static int patch_stac927x(struct hda_codec *codec)
4712 struct sigmatel_spec *spec;
4715 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4720 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
4721 spec->pin_nids = stac927x_pin_nids;
4722 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
4726 if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
4727 if (spec->board_config < 0)
4728 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
4729 "STAC927x, using BIOS defaults\n");
4730 err = stac92xx_save_bios_config_regs(codec);
4732 stac92xx_free(codec);
4735 spec->pin_configs = spec->bios_pin_configs;
4737 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
4738 stac92xx_set_config_regs(codec);
4741 spec->digbeep_nid = 0x23;
4742 spec->adc_nids = stac927x_adc_nids;
4743 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
4744 spec->mux_nids = stac927x_mux_nids;
4745 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
4746 spec->smux_nids = stac927x_smux_nids;
4747 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
4748 spec->spdif_labels = stac927x_spdif_labels;
4749 spec->dac_list = stac927x_dac_nids;
4750 spec->multiout.dac_nids = spec->dac_nids;
4752 switch (spec->board_config) {
4755 /* GPIO0 High = Enable EAPD */
4756 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01;
4757 spec->gpio_data = 0x01;
4758 spec->num_dmics = 0;
4760 spec->init = d965_core_init;
4761 spec->mixer = stac927x_mixer;
4763 case STAC_DELL_BIOS:
4764 switch (codec->subsystem_id) {
4767 /* correct the device field to SPDIF out */
4768 stac92xx_set_config_reg(codec, 0x21, 0x01442070);
4771 /* configure the analog microphone on some laptops */
4772 stac92xx_set_config_reg(codec, 0x0c, 0x90a79130);
4773 /* correct the front output jack as a hp out */
4774 stac92xx_set_config_reg(codec, 0x0f, 0x0227011f);
4775 /* correct the front input jack as a mic */
4776 stac92xx_set_config_reg(codec, 0x0e, 0x02a79130);
4779 /* GPIO2 High = Enable EAPD */
4780 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
4781 spec->gpio_data = 0x04;
4782 spec->dmic_nids = stac927x_dmic_nids;
4783 spec->num_dmics = STAC927X_NUM_DMICS;
4785 spec->init = d965_core_init;
4786 spec->mixer = stac927x_mixer;
4787 spec->dmux_nids = stac927x_dmux_nids;
4788 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
4791 if (spec->board_config > STAC_D965_REF) {
4792 /* GPIO0 High = Enable EAPD */
4793 spec->eapd_mask = spec->gpio_mask = 0x01;
4794 spec->gpio_dir = spec->gpio_data = 0x01;
4796 spec->num_dmics = 0;
4798 spec->init = stac927x_core_init;
4799 spec->mixer = stac927x_mixer;
4803 spec->aloopback_mask = 0x40;
4804 spec->aloopback_shift = 0;
4806 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
4808 if (spec->board_config < 0) {
4809 printk(KERN_WARNING "hda_codec: No auto-config is "
4810 "available, default to model=ref\n");
4811 spec->board_config = STAC_D965_REF;
4817 stac92xx_free(codec);
4821 codec->patch_ops = stac92xx_patch_ops;
4825 * The STAC927x seem to require fairly long delays for certain
4826 * command sequences. With too short delays (even if the answer
4827 * is set to RIRB properly), it results in the silence output
4828 * on some hardwares like Dell.
4830 * The below flag enables the longer delay (see get_response
4833 codec->bus->needs_damn_long_delay = 1;
4838 static int patch_stac9205(struct hda_codec *codec)
4840 struct sigmatel_spec *spec;
4843 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4848 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
4849 spec->pin_nids = stac9205_pin_nids;
4850 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
4854 if (spec->board_config < 0) {
4855 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
4856 err = stac92xx_save_bios_config_regs(codec);
4858 stac92xx_free(codec);
4861 spec->pin_configs = spec->bios_pin_configs;
4863 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
4864 stac92xx_set_config_regs(codec);
4867 spec->digbeep_nid = 0x23;
4868 spec->adc_nids = stac9205_adc_nids;
4869 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
4870 spec->mux_nids = stac9205_mux_nids;
4871 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
4872 spec->smux_nids = stac9205_smux_nids;
4873 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
4874 spec->dmic_nids = stac9205_dmic_nids;
4875 spec->num_dmics = STAC9205_NUM_DMICS;
4876 spec->dmux_nids = stac9205_dmux_nids;
4877 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
4880 spec->init = stac9205_core_init;
4881 spec->mixer = stac9205_mixer;
4883 spec->aloopback_mask = 0x40;
4884 spec->aloopback_shift = 0;
4885 spec->multiout.dac_nids = spec->dac_nids;
4887 switch (spec->board_config){
4888 case STAC_9205_DELL_M43:
4889 /* Enable SPDIF in/out */
4890 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
4891 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
4893 /* Enable unsol response for GPIO4/Dock HP connection */
4894 snd_hda_codec_write(codec, codec->afg, 0,
4895 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
4896 snd_hda_codec_write_cache(codec, codec->afg, 0,
4897 AC_VERB_SET_UNSOLICITED_ENABLE,
4898 (AC_USRSP_EN | STAC_HP_EVENT));
4900 spec->gpio_dir = 0x0b;
4901 spec->eapd_mask = 0x01;
4902 spec->gpio_mask = 0x1b;
4903 spec->gpio_mute = 0x10;
4904 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
4907 spec->gpio_data = 0x01;
4910 /* SPDIF-In enabled */
4913 /* GPIO0 High = EAPD */
4914 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4915 spec->gpio_data = 0x01;
4919 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
4921 if (spec->board_config < 0) {
4922 printk(KERN_WARNING "hda_codec: No auto-config is "
4923 "available, default to model=ref\n");
4924 spec->board_config = STAC_9205_REF;
4930 stac92xx_free(codec);
4934 codec->patch_ops = stac92xx_patch_ops;
4943 /* static config for Sony VAIO FE550G and Sony VAIO AR */
4944 static hda_nid_t vaio_dacs[] = { 0x2 };
4945 #define VAIO_HP_DAC 0x5
4946 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
4947 static hda_nid_t vaio_mux_nids[] = { 0x15 };
4949 static struct hda_input_mux vaio_mux = {
4952 /* { "HP", 0x0 }, */
4953 { "Mic Jack", 0x1 },
4954 { "Internal Mic", 0x2 },
4959 static struct hda_verb vaio_init[] = {
4960 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
4961 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
4962 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
4963 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
4964 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
4965 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
4966 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
4967 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
4968 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
4969 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
4970 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
4971 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
4975 static struct hda_verb vaio_ar_init[] = {
4976 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
4977 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
4978 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
4979 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
4980 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
4981 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
4982 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
4983 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
4984 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
4985 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
4986 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
4987 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
4988 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
4992 /* bind volumes of both NID 0x02 and 0x05 */
4993 static struct hda_bind_ctls vaio_bind_master_vol = {
4994 .ops = &snd_hda_bind_vol,
4996 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
4997 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
5002 /* bind volumes of both NID 0x02 and 0x05 */
5003 static struct hda_bind_ctls vaio_bind_master_sw = {
5004 .ops = &snd_hda_bind_sw,
5006 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
5007 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
5012 static struct snd_kcontrol_new vaio_mixer[] = {
5013 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
5014 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
5015 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
5016 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5017 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5019 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5020 .name = "Capture Source",
5022 .info = stac92xx_mux_enum_info,
5023 .get = stac92xx_mux_enum_get,
5024 .put = stac92xx_mux_enum_put,
5029 static struct snd_kcontrol_new vaio_ar_mixer[] = {
5030 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
5031 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
5032 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
5033 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
5034 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
5035 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
5036 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
5038 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5039 .name = "Capture Source",
5041 .info = stac92xx_mux_enum_info,
5042 .get = stac92xx_mux_enum_get,
5043 .put = stac92xx_mux_enum_put,
5048 static struct hda_codec_ops stac9872_patch_ops = {
5049 .build_controls = stac92xx_build_controls,
5050 .build_pcms = stac92xx_build_pcms,
5051 .init = stac92xx_init,
5052 .free = stac92xx_free,
5053 #ifdef SND_HDA_NEEDS_RESUME
5054 .resume = stac92xx_resume,
5058 static int stac9872_vaio_init(struct hda_codec *codec)
5062 err = stac92xx_init(codec);
5065 if (codec->patch_ops.unsol_event)
5066 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
5070 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
5072 if (get_hp_pin_presence(codec, 0x0a)) {
5073 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
5074 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
5076 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
5077 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
5081 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
5083 switch (res >> 26) {
5085 stac9872_vaio_hp_detect(codec, res);
5090 static struct hda_codec_ops stac9872_vaio_patch_ops = {
5091 .build_controls = stac92xx_build_controls,
5092 .build_pcms = stac92xx_build_pcms,
5093 .init = stac9872_vaio_init,
5094 .free = stac92xx_free,
5095 .unsol_event = stac9872_vaio_unsol_event,
5097 .resume = stac92xx_resume,
5101 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
5103 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
5105 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
5107 /* AR Series. id=0x83847664 and subsys=104D1300 */
5112 static const char *stac9872_models[STAC_9872_MODELS] = {
5113 [CXD9872RD_VAIO] = "vaio",
5114 [CXD9872AKD_VAIO] = "vaio-ar",
5117 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
5118 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
5119 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
5120 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
5121 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
5125 static int patch_stac9872(struct hda_codec *codec)
5127 struct sigmatel_spec *spec;
5130 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
5133 if (board_config < 0)
5134 /* unknown config, let generic-parser do its job... */
5135 return snd_hda_parse_generic_codec(codec);
5137 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5142 switch (board_config) {
5143 case CXD9872RD_VAIO:
5144 case STAC9872AK_VAIO:
5145 case STAC9872K_VAIO:
5146 spec->mixer = vaio_mixer;
5147 spec->init = vaio_init;
5148 spec->multiout.max_channels = 2;
5149 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
5150 spec->multiout.dac_nids = vaio_dacs;
5151 spec->multiout.hp_nid = VAIO_HP_DAC;
5152 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
5153 spec->adc_nids = vaio_adcs;
5155 spec->input_mux = &vaio_mux;
5156 spec->mux_nids = vaio_mux_nids;
5157 codec->patch_ops = stac9872_vaio_patch_ops;
5160 case CXD9872AKD_VAIO:
5161 spec->mixer = vaio_ar_mixer;
5162 spec->init = vaio_ar_init;
5163 spec->multiout.max_channels = 2;
5164 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
5165 spec->multiout.dac_nids = vaio_dacs;
5166 spec->multiout.hp_nid = VAIO_HP_DAC;
5167 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
5169 spec->adc_nids = vaio_adcs;
5170 spec->input_mux = &vaio_mux;
5171 spec->mux_nids = vaio_mux_nids;
5172 codec->patch_ops = stac9872_patch_ops;
5183 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
5184 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
5185 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
5186 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
5187 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
5188 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
5189 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
5190 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
5191 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
5192 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
5193 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
5194 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
5195 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
5196 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
5197 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
5198 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
5199 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
5200 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
5201 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
5202 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
5203 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
5204 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
5205 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
5206 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
5207 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
5208 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
5209 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
5210 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
5211 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
5212 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
5213 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
5214 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
5215 /* The following does not take into account .id=0x83847661 when subsys =
5216 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
5217 * currently not fully supported.
5219 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
5220 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
5221 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
5222 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
5223 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
5224 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
5225 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
5226 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
5227 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
5228 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
5229 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
5230 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
5231 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
5232 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
5233 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
5234 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
5235 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
5236 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
5237 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5238 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
5239 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5240 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
5241 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5242 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
5243 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
5244 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },