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"
36 #define NUM_CONTROL_ALLOC 32
37 #define STAC_PWR_EVENT 0x20
38 #define STAC_HP_EVENT 0x30
92 /* for backward compatibility */
115 struct sigmatel_spec {
116 struct snd_kcontrol_new *mixers[4];
117 unsigned int num_mixers;
120 unsigned int surr_switch: 1;
121 unsigned int line_switch: 1;
122 unsigned int mic_switch: 1;
123 unsigned int alt_switch: 1;
124 unsigned int hp_detect: 1;
127 unsigned int gpio_mask;
128 unsigned int gpio_dir;
129 unsigned int gpio_data;
130 unsigned int gpio_mute;
132 /* analog loopback */
133 unsigned char aloopback_mask;
134 unsigned char aloopback_shift;
136 /* power management */
137 unsigned int num_pwrs;
142 struct hda_input_mux *mono_mux;
143 unsigned int cur_mmux;
144 struct hda_multi_out multiout;
145 hda_nid_t dac_nids[5];
149 unsigned int num_adcs;
151 unsigned int num_muxes;
152 hda_nid_t *dmic_nids;
153 unsigned int num_dmics;
154 hda_nid_t *dmux_nids;
155 unsigned int num_dmuxes;
156 hda_nid_t dig_in_nid;
161 unsigned int num_pins;
162 unsigned int *pin_configs;
163 unsigned int *bios_pin_configs;
165 /* codec specific stuff */
166 struct hda_verb *init;
167 struct snd_kcontrol_new *mixer;
170 struct hda_input_mux *dinput_mux;
171 unsigned int cur_dmux[2];
172 struct hda_input_mux *input_mux;
173 unsigned int cur_mux[3];
176 unsigned int io_switch[2];
177 unsigned int clfe_swap;
178 unsigned int aloopback;
180 struct hda_pcm pcm_rec[2]; /* PCM information */
182 /* dynamic controls and input_mux */
183 struct auto_pin_cfg autocfg;
184 unsigned int num_kctl_alloc, num_kctl_used;
185 struct snd_kcontrol_new *kctl_alloc;
186 struct hda_input_mux private_dimux;
187 struct hda_input_mux private_imux;
188 struct hda_input_mux private_mono_mux;
191 unsigned int vmaster_tlv[4];
194 static hda_nid_t stac9200_adc_nids[1] = {
198 static hda_nid_t stac9200_mux_nids[1] = {
202 static hda_nid_t stac9200_dac_nids[1] = {
206 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
207 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
211 static hda_nid_t stac92hd73xx_adc_nids[2] = {
215 #define STAC92HD73XX_NUM_DMICS 2
216 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
220 #define STAC92HD73_DAC_COUNT 5
221 static hda_nid_t stac92hd73xx_dac_nids[STAC92HD73_DAC_COUNT] = {
222 0x15, 0x16, 0x17, 0x18, 0x19,
225 static hda_nid_t stac92hd73xx_mux_nids[4] = {
226 0x28, 0x29, 0x2a, 0x2b,
229 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
233 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
237 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
241 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
245 static hda_nid_t stac92hd71bxx_dmux_nids[1] = {
249 static hda_nid_t stac92hd71bxx_dac_nids[2] = {
253 #define STAC92HD71BXX_NUM_DMICS 2
254 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
258 static hda_nid_t stac925x_adc_nids[1] = {
262 static hda_nid_t stac925x_mux_nids[1] = {
266 static hda_nid_t stac925x_dac_nids[1] = {
270 #define STAC925X_NUM_DMICS 1
271 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
275 static hda_nid_t stac925x_dmux_nids[1] = {
279 static hda_nid_t stac922x_adc_nids[2] = {
283 static hda_nid_t stac922x_mux_nids[2] = {
287 static hda_nid_t stac927x_adc_nids[3] = {
291 static hda_nid_t stac927x_mux_nids[3] = {
295 static hda_nid_t stac927x_dac_nids[6] = {
296 0x02, 0x03, 0x04, 0x05, 0x06, 0
299 static hda_nid_t stac927x_dmux_nids[1] = {
303 #define STAC927X_NUM_DMICS 2
304 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
308 static hda_nid_t stac9205_adc_nids[2] = {
312 static hda_nid_t stac9205_mux_nids[2] = {
316 static hda_nid_t stac9205_dmux_nids[1] = {
320 #define STAC9205_NUM_DMICS 2
321 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
325 static hda_nid_t stac9200_pin_nids[8] = {
326 0x08, 0x09, 0x0d, 0x0e,
327 0x0f, 0x10, 0x11, 0x12,
330 static hda_nid_t stac925x_pin_nids[8] = {
331 0x07, 0x08, 0x0a, 0x0b,
332 0x0c, 0x0d, 0x10, 0x11,
335 static hda_nid_t stac922x_pin_nids[10] = {
336 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
337 0x0f, 0x10, 0x11, 0x15, 0x1b,
340 static hda_nid_t stac92hd73xx_pin_nids[12] = {
341 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
342 0x0f, 0x10, 0x11, 0x12, 0x13,
346 static hda_nid_t stac92hd71bxx_pin_nids[10] = {
347 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
348 0x0f, 0x14, 0x18, 0x19, 0x1e,
351 static hda_nid_t stac927x_pin_nids[14] = {
352 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
353 0x0f, 0x10, 0x11, 0x12, 0x13,
354 0x14, 0x21, 0x22, 0x23,
357 static hda_nid_t stac9205_pin_nids[12] = {
358 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
359 0x0f, 0x14, 0x16, 0x17, 0x18,
363 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
364 struct snd_ctl_elem_info *uinfo)
366 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
367 struct sigmatel_spec *spec = codec->spec;
368 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
371 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
372 struct snd_ctl_elem_value *ucontrol)
374 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
375 struct sigmatel_spec *spec = codec->spec;
376 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
378 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
382 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
383 struct snd_ctl_elem_value *ucontrol)
385 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
386 struct sigmatel_spec *spec = codec->spec;
387 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
389 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
390 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
393 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
395 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
396 struct sigmatel_spec *spec = codec->spec;
397 return snd_hda_input_mux_info(spec->input_mux, uinfo);
400 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
402 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
403 struct sigmatel_spec *spec = codec->spec;
404 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
406 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
410 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
412 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
413 struct sigmatel_spec *spec = codec->spec;
414 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
416 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
417 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
420 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
421 struct snd_ctl_elem_info *uinfo)
423 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
424 struct sigmatel_spec *spec = codec->spec;
425 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
428 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
429 struct snd_ctl_elem_value *ucontrol)
431 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
432 struct sigmatel_spec *spec = codec->spec;
434 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
438 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
439 struct snd_ctl_elem_value *ucontrol)
441 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
442 struct sigmatel_spec *spec = codec->spec;
444 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
445 spec->mono_nid, &spec->cur_mmux);
448 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
450 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
451 struct snd_ctl_elem_value *ucontrol)
453 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
454 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
455 struct sigmatel_spec *spec = codec->spec;
457 ucontrol->value.integer.value[0] = !!(spec->aloopback &
458 (spec->aloopback_mask << idx));
462 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
463 struct snd_ctl_elem_value *ucontrol)
465 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
466 struct sigmatel_spec *spec = codec->spec;
467 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
468 unsigned int dac_mode;
469 unsigned int val, idx_val;
471 idx_val = spec->aloopback_mask << idx;
472 if (ucontrol->value.integer.value[0])
473 val = spec->aloopback | idx_val;
475 val = spec->aloopback & ~idx_val;
476 if (spec->aloopback == val)
479 spec->aloopback = val;
481 /* Only return the bits defined by the shift value of the
482 * first two bytes of the mask
484 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
485 kcontrol->private_value & 0xFFFF, 0x0);
486 dac_mode >>= spec->aloopback_shift;
488 if (spec->aloopback & idx_val) {
489 snd_hda_power_up(codec);
492 snd_hda_power_down(codec);
493 dac_mode &= ~idx_val;
496 snd_hda_codec_write_cache(codec, codec->afg, 0,
497 kcontrol->private_value >> 16, dac_mode);
502 static struct hda_verb stac9200_core_init[] = {
503 /* set dac0mux for dac converter */
504 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
508 static struct hda_verb stac9200_eapd_init[] = {
509 /* set dac0mux for dac converter */
510 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
511 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
515 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
516 /* set master volume and direct control */
517 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
518 /* setup audio connections */
519 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
520 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
521 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
522 /* setup adcs to point to mixer */
523 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
524 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
525 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
526 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
527 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
528 /* setup import muxs */
529 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
530 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
531 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
532 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
536 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
537 /* set master volume and direct control */
538 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
539 /* setup audio connections */
540 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
541 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
542 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
543 /* connect hp ports to dac3 */
544 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x03},
545 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x03},
546 /* setup adcs to point to mixer */
547 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
548 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
549 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
550 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
551 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
552 /* setup import muxs */
553 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
554 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
555 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
556 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
560 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
561 /* set master volume and direct control */
562 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
563 /* setup audio connections */
564 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
565 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01 },
566 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02 },
567 /* dac3 is connected to import3 mux */
568 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
569 /* connect hp ports to dac4 */
570 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x04},
571 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x04},
572 /* setup adcs to point to mixer */
573 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
574 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
575 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
576 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
577 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
578 /* setup import muxs */
579 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
580 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
581 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
582 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
586 static struct hda_verb stac92hd71bxx_core_init[] = {
587 /* set master volume and direct control */
588 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
589 /* connect headphone jack to dac1 */
590 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
591 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */
592 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
593 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
594 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
595 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
598 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
599 /* set master volume and direct control */
600 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
601 /* connect headphone jack to dac1 */
602 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
603 /* connect ports 0d and 0f to audio mixer */
604 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x2},
605 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
606 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */
607 /* unmute dac0 input in audio mixer */
608 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
609 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
610 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
611 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
612 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
616 static struct hda_verb stac925x_core_init[] = {
617 /* set dac0mux for dac converter */
618 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
622 static struct hda_verb stac922x_core_init[] = {
623 /* set master volume and direct control */
624 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
628 static struct hda_verb d965_core_init[] = {
629 /* set master volume and direct control */
630 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
631 /* unmute node 0x1b */
632 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
633 /* select node 0x03 as DAC */
634 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
638 static struct hda_verb stac927x_core_init[] = {
639 /* set master volume and direct control */
640 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
644 static struct hda_verb stac9205_core_init[] = {
645 /* set master volume and direct control */
646 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
650 #define STAC_MONO_MUX \
652 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
653 .name = "Mono Mux", \
655 .info = stac92xx_mono_mux_enum_info, \
656 .get = stac92xx_mono_mux_enum_get, \
657 .put = stac92xx_mono_mux_enum_put, \
660 #define STAC_INPUT_SOURCE(cnt) \
662 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
663 .name = "Input Source", \
665 .info = stac92xx_mux_enum_info, \
666 .get = stac92xx_mux_enum_get, \
667 .put = stac92xx_mux_enum_put, \
670 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
672 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
673 .name = "Analog Loopback", \
675 .info = stac92xx_aloopback_info, \
676 .get = stac92xx_aloopback_get, \
677 .put = stac92xx_aloopback_put, \
678 .private_value = verb_read | (verb_write << 16), \
681 static struct snd_kcontrol_new stac9200_mixer[] = {
682 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
683 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
684 STAC_INPUT_SOURCE(1),
685 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
686 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
687 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT),
691 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
692 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
694 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
695 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
697 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
698 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
700 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
701 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
703 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
704 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
706 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
707 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
709 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
710 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
712 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
713 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
717 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
718 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
720 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
721 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
723 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
724 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
726 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
727 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
729 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
730 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
732 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
733 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
735 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
736 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
738 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
739 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
743 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
744 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
746 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
747 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
749 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
750 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
752 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
753 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
755 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
756 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
758 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
759 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
761 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
762 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
764 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
765 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
769 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
770 STAC_INPUT_SOURCE(2),
772 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
773 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
774 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
776 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
777 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
778 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
780 HDA_CODEC_MUTE("Analog Loopback 1", 0x17, 0x3, HDA_INPUT),
781 HDA_CODEC_MUTE("Analog Loopback 2", 0x17, 0x4, HDA_INPUT),
785 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
786 STAC_INPUT_SOURCE(2),
787 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
789 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
790 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
791 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
793 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
794 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
795 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
799 static struct snd_kcontrol_new stac925x_mixer[] = {
800 STAC_INPUT_SOURCE(1),
801 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
802 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_OUTPUT),
803 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT),
807 static struct snd_kcontrol_new stac9205_mixer[] = {
808 STAC_INPUT_SOURCE(2),
809 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
811 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
812 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
813 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT),
815 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
816 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
817 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT),
822 /* This needs to be generated dynamically based on sequence */
823 static struct snd_kcontrol_new stac922x_mixer[] = {
824 STAC_INPUT_SOURCE(2),
825 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
826 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
827 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT),
829 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
830 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
831 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT),
836 static struct snd_kcontrol_new stac927x_mixer[] = {
837 STAC_INPUT_SOURCE(3),
838 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
840 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
841 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
842 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT),
844 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
845 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
846 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT),
848 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
849 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
850 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT),
854 static struct snd_kcontrol_new stac_dmux_mixer = {
855 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
856 .name = "Digital Input Source",
857 /* count set later */
858 .info = stac92xx_dmux_enum_info,
859 .get = stac92xx_dmux_enum_get,
860 .put = stac92xx_dmux_enum_put,
863 static const char *slave_vols[] = {
864 "Front Playback Volume",
865 "Surround Playback Volume",
866 "Center Playback Volume",
867 "LFE Playback Volume",
868 "Side Playback Volume",
869 "Headphone Playback Volume",
870 "Headphone Playback Volume",
871 "Speaker Playback Volume",
872 "External Speaker Playback Volume",
873 "Speaker2 Playback Volume",
877 static const char *slave_sws[] = {
878 "Front Playback Switch",
879 "Surround Playback Switch",
880 "Center Playback Switch",
881 "LFE Playback Switch",
882 "Side Playback Switch",
883 "Headphone Playback Switch",
884 "Headphone Playback Switch",
885 "Speaker Playback Switch",
886 "External Speaker Playback Switch",
887 "Speaker2 Playback Switch",
888 "IEC958 Playback Switch",
892 static int stac92xx_build_controls(struct hda_codec *codec)
894 struct sigmatel_spec *spec = codec->spec;
898 err = snd_hda_add_new_ctls(codec, spec->mixer);
902 for (i = 0; i < spec->num_mixers; i++) {
903 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
907 if (spec->num_dmuxes > 0) {
908 stac_dmux_mixer.count = spec->num_dmuxes;
909 err = snd_ctl_add(codec->bus->card,
910 snd_ctl_new1(&stac_dmux_mixer, codec));
915 if (spec->multiout.dig_out_nid) {
916 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
919 err = snd_hda_create_spdif_share_sw(codec,
923 spec->multiout.share_spdif = 1;
925 if (spec->dig_in_nid) {
926 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
931 /* if we have no master control, let's create it */
932 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
933 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
934 HDA_OUTPUT, spec->vmaster_tlv);
935 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
936 spec->vmaster_tlv, slave_vols);
940 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
941 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
950 static unsigned int ref9200_pin_configs[8] = {
951 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
952 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
956 STAC 9200 pin configs for
961 static unsigned int dell9200_d21_pin_configs[8] = {
962 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
963 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
967 STAC 9200 pin configs for
971 static unsigned int dell9200_d22_pin_configs[8] = {
972 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
973 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
977 STAC 9200 pin configs for
978 102801C4 (Dell Dimension E310)
985 static unsigned int dell9200_d23_pin_configs[8] = {
986 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
987 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
992 STAC 9200-32 pin configs for
993 102801B5 (Dell Inspiron 630m)
994 102801D8 (Dell Inspiron 640m)
996 static unsigned int dell9200_m21_pin_configs[8] = {
997 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
998 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1002 STAC 9200-32 pin configs for
1003 102801C2 (Dell Latitude D620)
1005 102801CC (Dell Latitude D820)
1009 static unsigned int dell9200_m22_pin_configs[8] = {
1010 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1011 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1015 STAC 9200-32 pin configs for
1016 102801CE (Dell XPS M1710)
1017 102801CF (Dell Precision M90)
1019 static unsigned int dell9200_m23_pin_configs[8] = {
1020 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1021 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1025 STAC 9200-32 pin configs for
1028 102801CB (Dell Latitude 120L)
1031 static unsigned int dell9200_m24_pin_configs[8] = {
1032 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1033 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1037 STAC 9200-32 pin configs for
1038 102801BD (Dell Inspiron E1505n)
1042 static unsigned int dell9200_m25_pin_configs[8] = {
1043 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1044 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1048 STAC 9200-32 pin configs for
1049 102801F5 (Dell Inspiron 1501)
1052 static unsigned int dell9200_m26_pin_configs[8] = {
1053 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1054 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1059 102801CD (Dell Inspiron E1705/9400)
1061 static unsigned int dell9200_m27_pin_configs[8] = {
1062 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1063 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1066 static unsigned int oqo9200_pin_configs[8] = {
1067 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1068 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1072 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1073 [STAC_REF] = ref9200_pin_configs,
1074 [STAC_9200_OQO] = oqo9200_pin_configs,
1075 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1076 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1077 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1078 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1079 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1080 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1081 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1082 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1083 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1084 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1087 static const char *stac9200_models[STAC_9200_MODELS] = {
1089 [STAC_9200_OQO] = "oqo",
1090 [STAC_9200_DELL_D21] = "dell-d21",
1091 [STAC_9200_DELL_D22] = "dell-d22",
1092 [STAC_9200_DELL_D23] = "dell-d23",
1093 [STAC_9200_DELL_M21] = "dell-m21",
1094 [STAC_9200_DELL_M22] = "dell-m22",
1095 [STAC_9200_DELL_M23] = "dell-m23",
1096 [STAC_9200_DELL_M24] = "dell-m24",
1097 [STAC_9200_DELL_M25] = "dell-m25",
1098 [STAC_9200_DELL_M26] = "dell-m26",
1099 [STAC_9200_DELL_M27] = "dell-m27",
1100 [STAC_9200_GATEWAY] = "gateway",
1103 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1104 /* SigmaTel reference board */
1105 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1106 "DFI LanParty", STAC_REF),
1107 /* Dell laptops have BIOS problem */
1108 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1109 "unknown Dell", STAC_9200_DELL_D21),
1110 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1111 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1112 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1113 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1114 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1115 "unknown Dell", STAC_9200_DELL_D22),
1116 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1117 "unknown Dell", STAC_9200_DELL_D22),
1118 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1119 "Dell Latitude D620", STAC_9200_DELL_M22),
1120 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1121 "unknown Dell", STAC_9200_DELL_D23),
1122 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1123 "unknown Dell", STAC_9200_DELL_D23),
1124 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1125 "unknown Dell", STAC_9200_DELL_M22),
1126 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1127 "unknown Dell", STAC_9200_DELL_M24),
1128 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1129 "unknown Dell", STAC_9200_DELL_M24),
1130 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1131 "Dell Latitude 120L", STAC_9200_DELL_M24),
1132 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1133 "Dell Latitude D820", STAC_9200_DELL_M22),
1134 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1135 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1136 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1137 "Dell XPS M1710", STAC_9200_DELL_M23),
1138 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1139 "Dell Precision M90", STAC_9200_DELL_M23),
1140 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1141 "unknown Dell", STAC_9200_DELL_M22),
1142 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1143 "unknown Dell", STAC_9200_DELL_M22),
1144 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1145 "unknown Dell", STAC_9200_DELL_M22),
1146 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1147 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1148 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1149 "unknown Dell", STAC_9200_DELL_D23),
1150 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1151 "unknown Dell", STAC_9200_DELL_D23),
1152 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1153 "unknown Dell", STAC_9200_DELL_D21),
1154 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1155 "unknown Dell", STAC_9200_DELL_D23),
1156 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1157 "unknown Dell", STAC_9200_DELL_D21),
1158 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1159 "unknown Dell", STAC_9200_DELL_M25),
1160 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1161 "unknown Dell", STAC_9200_DELL_M25),
1162 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1163 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1164 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1165 "unknown Dell", STAC_9200_DELL_M26),
1167 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_REF),
1168 /* Gateway machines needs EAPD to be set on resume */
1169 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
1170 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
1172 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
1175 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1179 static unsigned int ref925x_pin_configs[8] = {
1180 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1181 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1184 static unsigned int stac925x_MA6_pin_configs[8] = {
1185 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1186 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
1189 static unsigned int stac925x_PA6_pin_configs[8] = {
1190 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1191 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
1194 static unsigned int stac925xM2_2_pin_configs[8] = {
1195 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
1196 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
1199 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1200 [STAC_REF] = ref925x_pin_configs,
1201 [STAC_M2_2] = stac925xM2_2_pin_configs,
1202 [STAC_MA6] = stac925x_MA6_pin_configs,
1203 [STAC_PA6] = stac925x_PA6_pin_configs,
1206 static const char *stac925x_models[STAC_925x_MODELS] = {
1208 [STAC_M2_2] = "m2-2",
1213 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1214 /* SigmaTel reference board */
1215 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1216 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1217 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
1218 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
1219 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
1220 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
1221 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
1225 static unsigned int ref92hd73xx_pin_configs[12] = {
1226 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1227 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1228 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1231 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1232 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1235 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1236 [STAC_92HD73XX_REF] = "ref",
1239 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1240 /* SigmaTel reference board */
1241 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1242 "DFI LanParty", STAC_92HD73XX_REF),
1246 static unsigned int ref92hd71bxx_pin_configs[10] = {
1247 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1248 0x0181302e, 0x01114010, 0x01019020, 0x90a000f0,
1249 0x90a000f0, 0x01452050,
1252 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1253 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1256 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1257 [STAC_92HD71BXX_REF] = "ref",
1260 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1261 /* SigmaTel reference board */
1262 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1263 "DFI LanParty", STAC_92HD71BXX_REF),
1267 static unsigned int ref922x_pin_configs[10] = {
1268 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1269 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1270 0x40000100, 0x40000100,
1274 STAC 922X pin configs for
1281 static unsigned int dell_922x_d81_pin_configs[10] = {
1282 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1283 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1284 0x01813122, 0x400001f2,
1288 STAC 922X pin configs for
1292 static unsigned int dell_922x_d82_pin_configs[10] = {
1293 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1294 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1295 0x01813122, 0x400001f1,
1299 STAC 922X pin configs for
1302 static unsigned int dell_922x_m81_pin_configs[10] = {
1303 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1304 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1305 0x40C003f1, 0x405003f0,
1309 STAC 9221 A1 pin configs for
1310 102801D7 (Dell XPS M1210)
1312 static unsigned int dell_922x_m82_pin_configs[10] = {
1313 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1314 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1315 0x508003f3, 0x405003f4,
1318 static unsigned int d945gtp3_pin_configs[10] = {
1319 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1320 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1321 0x02a19120, 0x40000100,
1324 static unsigned int d945gtp5_pin_configs[10] = {
1325 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1326 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1327 0x02a19320, 0x40000100,
1330 static unsigned int intel_mac_v1_pin_configs[10] = {
1331 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1332 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1333 0x400000fc, 0x400000fb,
1336 static unsigned int intel_mac_v2_pin_configs[10] = {
1337 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1338 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1339 0x400000fc, 0x400000fb,
1342 static unsigned int intel_mac_v3_pin_configs[10] = {
1343 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1344 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1345 0x400000fc, 0x400000fb,
1348 static unsigned int intel_mac_v4_pin_configs[10] = {
1349 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1350 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1351 0x400000fc, 0x400000fb,
1354 static unsigned int intel_mac_v5_pin_configs[10] = {
1355 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1356 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1357 0x400000fc, 0x400000fb,
1361 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1362 [STAC_D945_REF] = ref922x_pin_configs,
1363 [STAC_D945GTP3] = d945gtp3_pin_configs,
1364 [STAC_D945GTP5] = d945gtp5_pin_configs,
1365 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1366 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1367 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1368 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1369 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1370 /* for backward compatibility */
1371 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1372 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1373 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1374 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1375 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1376 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1377 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1378 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1379 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1380 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1383 static const char *stac922x_models[STAC_922X_MODELS] = {
1384 [STAC_D945_REF] = "ref",
1385 [STAC_D945GTP5] = "5stack",
1386 [STAC_D945GTP3] = "3stack",
1387 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1388 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1389 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1390 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1391 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1392 /* for backward compatibility */
1393 [STAC_MACMINI] = "macmini",
1394 [STAC_MACBOOK] = "macbook",
1395 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1396 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1397 [STAC_IMAC_INTEL] = "imac-intel",
1398 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1399 [STAC_922X_DELL_D81] = "dell-d81",
1400 [STAC_922X_DELL_D82] = "dell-d82",
1401 [STAC_922X_DELL_M81] = "dell-m81",
1402 [STAC_922X_DELL_M82] = "dell-m82",
1405 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1406 /* SigmaTel reference board */
1407 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1408 "DFI LanParty", STAC_D945_REF),
1409 /* Intel 945G based systems */
1410 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1411 "Intel D945G", STAC_D945GTP3),
1412 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1413 "Intel D945G", STAC_D945GTP3),
1414 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1415 "Intel D945G", STAC_D945GTP3),
1416 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1417 "Intel D945G", STAC_D945GTP3),
1418 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1419 "Intel D945G", STAC_D945GTP3),
1420 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1421 "Intel D945G", STAC_D945GTP3),
1422 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1423 "Intel D945G", STAC_D945GTP3),
1424 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1425 "Intel D945G", STAC_D945GTP3),
1426 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1427 "Intel D945G", STAC_D945GTP3),
1428 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1429 "Intel D945G", STAC_D945GTP3),
1430 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1431 "Intel D945G", STAC_D945GTP3),
1432 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1433 "Intel D945G", STAC_D945GTP3),
1434 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1435 "Intel D945G", STAC_D945GTP3),
1436 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1437 "Intel D945G", STAC_D945GTP3),
1438 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1439 "Intel D945G", STAC_D945GTP3),
1440 /* Intel D945G 5-stack systems */
1441 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1442 "Intel D945G", STAC_D945GTP5),
1443 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1444 "Intel D945G", STAC_D945GTP5),
1445 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1446 "Intel D945G", STAC_D945GTP5),
1447 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1448 "Intel D945G", STAC_D945GTP5),
1449 /* Intel 945P based systems */
1450 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1451 "Intel D945P", STAC_D945GTP3),
1452 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1453 "Intel D945P", STAC_D945GTP3),
1454 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1455 "Intel D945P", STAC_D945GTP3),
1456 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1457 "Intel D945P", STAC_D945GTP3),
1458 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1459 "Intel D945P", STAC_D945GTP3),
1460 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1461 "Intel D945P", STAC_D945GTP5),
1463 /* Apple Mac Mini (early 2006) */
1464 SND_PCI_QUIRK(0x8384, 0x7680,
1465 "Mac Mini", STAC_INTEL_MAC_V3),
1467 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1468 "unknown Dell", STAC_922X_DELL_D81),
1469 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1470 "unknown Dell", STAC_922X_DELL_D81),
1471 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1472 "unknown Dell", STAC_922X_DELL_D81),
1473 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1474 "unknown Dell", STAC_922X_DELL_D82),
1475 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1476 "unknown Dell", STAC_922X_DELL_M81),
1477 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1478 "unknown Dell", STAC_922X_DELL_D82),
1479 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1480 "unknown Dell", STAC_922X_DELL_D81),
1481 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1482 "unknown Dell", STAC_922X_DELL_D81),
1483 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1484 "Dell XPS M1210", STAC_922X_DELL_M82),
1488 static unsigned int ref927x_pin_configs[14] = {
1489 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1490 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1491 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1492 0x01c42190, 0x40000100,
1495 static unsigned int d965_3st_pin_configs[14] = {
1496 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
1497 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
1498 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1499 0x40000100, 0x40000100
1502 static unsigned int d965_5st_pin_configs[14] = {
1503 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1504 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
1505 0x40000100, 0x40000100, 0x40000100, 0x01442070,
1506 0x40000100, 0x40000100
1509 static unsigned int dell_3st_pin_configs[14] = {
1510 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
1511 0x01111212, 0x01116211, 0x01813050, 0x01112214,
1512 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
1513 0x40c003fc, 0x40000100
1516 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
1517 [STAC_D965_REF] = ref927x_pin_configs,
1518 [STAC_D965_3ST] = d965_3st_pin_configs,
1519 [STAC_D965_5ST] = d965_5st_pin_configs,
1520 [STAC_DELL_3ST] = dell_3st_pin_configs,
1521 [STAC_DELL_BIOS] = NULL,
1524 static const char *stac927x_models[STAC_927X_MODELS] = {
1525 [STAC_D965_REF] = "ref",
1526 [STAC_D965_3ST] = "3stack",
1527 [STAC_D965_5ST] = "5stack",
1528 [STAC_DELL_3ST] = "dell-3stack",
1529 [STAC_DELL_BIOS] = "dell-bios",
1532 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
1533 /* SigmaTel reference board */
1534 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1535 "DFI LanParty", STAC_D965_REF),
1536 /* Intel 946 based systems */
1537 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
1538 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
1539 /* 965 based 3 stack systems */
1540 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
1541 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
1542 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
1543 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
1544 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
1545 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
1546 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
1547 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
1548 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
1549 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
1550 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
1551 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
1552 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
1553 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
1554 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
1555 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
1556 /* Dell 3 stack systems */
1557 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
1558 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
1559 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
1560 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
1561 /* Dell 3 stack systems with verb table in BIOS */
1562 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
1563 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
1564 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell ", STAC_DELL_BIOS),
1565 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
1566 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
1567 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
1568 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
1569 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
1570 /* 965 based 5 stack systems */
1571 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
1572 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
1573 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
1574 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
1575 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
1576 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
1577 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
1578 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
1579 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
1583 static unsigned int ref9205_pin_configs[12] = {
1584 0x40000100, 0x40000100, 0x01016011, 0x01014010,
1585 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
1586 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
1590 STAC 9205 pin configs for
1597 10280228 (Dell Vostro 1500)
1599 static unsigned int dell_9205_m42_pin_configs[12] = {
1600 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
1601 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
1602 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
1606 STAC 9205 pin configs for
1610 102801FF (Dell Precision M4300)
1615 static unsigned int dell_9205_m43_pin_configs[12] = {
1616 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
1617 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
1618 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
1621 static unsigned int dell_9205_m44_pin_configs[12] = {
1622 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
1623 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
1624 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
1627 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
1628 [STAC_9205_REF] = ref9205_pin_configs,
1629 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
1630 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
1631 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
1634 static const char *stac9205_models[STAC_9205_MODELS] = {
1635 [STAC_9205_REF] = "ref",
1636 [STAC_9205_DELL_M42] = "dell-m42",
1637 [STAC_9205_DELL_M43] = "dell-m43",
1638 [STAC_9205_DELL_M44] = "dell-m44",
1641 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
1642 /* SigmaTel reference board */
1643 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1644 "DFI LanParty", STAC_9205_REF),
1645 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1646 "unknown Dell", STAC_9205_DELL_M42),
1647 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1648 "unknown Dell", STAC_9205_DELL_M42),
1649 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
1650 "Dell Precision", STAC_9205_DELL_M43),
1651 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
1652 "Dell Precision", STAC_9205_DELL_M43),
1653 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
1654 "Dell Precision", STAC_9205_DELL_M43),
1655 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
1656 "Dell Precision", STAC_9205_DELL_M43),
1657 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
1658 "Dell Precision", STAC_9205_DELL_M43),
1659 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1660 "unknown Dell", STAC_9205_DELL_M42),
1661 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1662 "unknown Dell", STAC_9205_DELL_M42),
1663 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
1664 "Dell Precision", STAC_9205_DELL_M43),
1665 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
1666 "Dell Precision M4300", STAC_9205_DELL_M43),
1667 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
1668 "Dell Precision", STAC_9205_DELL_M43),
1669 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1670 "Dell Inspiron", STAC_9205_DELL_M44),
1671 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1672 "Dell Inspiron", STAC_9205_DELL_M44),
1673 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1674 "Dell Inspiron", STAC_9205_DELL_M44),
1675 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1676 "Dell Inspiron", STAC_9205_DELL_M44),
1677 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
1678 "unknown Dell", STAC_9205_DELL_M42),
1679 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
1680 "Dell Inspiron", STAC_9205_DELL_M44),
1681 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
1682 "Dell Vostro 1500", STAC_9205_DELL_M42),
1686 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
1689 struct sigmatel_spec *spec = codec->spec;
1691 if (! spec->bios_pin_configs) {
1692 spec->bios_pin_configs = kcalloc(spec->num_pins,
1693 sizeof(*spec->bios_pin_configs), GFP_KERNEL);
1694 if (! spec->bios_pin_configs)
1698 for (i = 0; i < spec->num_pins; i++) {
1699 hda_nid_t nid = spec->pin_nids[i];
1700 unsigned int pin_cfg;
1702 pin_cfg = snd_hda_codec_read(codec, nid, 0,
1703 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
1704 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
1706 spec->bios_pin_configs[i] = pin_cfg;
1712 static void stac92xx_set_config_reg(struct hda_codec *codec,
1713 hda_nid_t pin_nid, unsigned int pin_config)
1716 snd_hda_codec_write(codec, pin_nid, 0,
1717 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
1718 pin_config & 0x000000ff);
1719 snd_hda_codec_write(codec, pin_nid, 0,
1720 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
1721 (pin_config & 0x0000ff00) >> 8);
1722 snd_hda_codec_write(codec, pin_nid, 0,
1723 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
1724 (pin_config & 0x00ff0000) >> 16);
1725 snd_hda_codec_write(codec, pin_nid, 0,
1726 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
1728 i = snd_hda_codec_read(codec, pin_nid, 0,
1729 AC_VERB_GET_CONFIG_DEFAULT,
1731 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
1735 static void stac92xx_set_config_regs(struct hda_codec *codec)
1738 struct sigmatel_spec *spec = codec->spec;
1740 if (!spec->pin_configs)
1743 for (i = 0; i < spec->num_pins; i++)
1744 stac92xx_set_config_reg(codec, spec->pin_nids[i],
1745 spec->pin_configs[i]);
1749 * Analog playback callbacks
1751 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
1752 struct hda_codec *codec,
1753 struct snd_pcm_substream *substream)
1755 struct sigmatel_spec *spec = codec->spec;
1756 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
1760 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1761 struct hda_codec *codec,
1762 unsigned int stream_tag,
1763 unsigned int format,
1764 struct snd_pcm_substream *substream)
1766 struct sigmatel_spec *spec = codec->spec;
1767 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
1770 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1771 struct hda_codec *codec,
1772 struct snd_pcm_substream *substream)
1774 struct sigmatel_spec *spec = codec->spec;
1775 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1779 * Digital playback callbacks
1781 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1782 struct hda_codec *codec,
1783 struct snd_pcm_substream *substream)
1785 struct sigmatel_spec *spec = codec->spec;
1786 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1789 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1790 struct hda_codec *codec,
1791 struct snd_pcm_substream *substream)
1793 struct sigmatel_spec *spec = codec->spec;
1794 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1797 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1798 struct hda_codec *codec,
1799 unsigned int stream_tag,
1800 unsigned int format,
1801 struct snd_pcm_substream *substream)
1803 struct sigmatel_spec *spec = codec->spec;
1804 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1805 stream_tag, format, substream);
1810 * Analog capture callbacks
1812 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1813 struct hda_codec *codec,
1814 unsigned int stream_tag,
1815 unsigned int format,
1816 struct snd_pcm_substream *substream)
1818 struct sigmatel_spec *spec = codec->spec;
1820 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1821 stream_tag, 0, format);
1825 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1826 struct hda_codec *codec,
1827 struct snd_pcm_substream *substream)
1829 struct sigmatel_spec *spec = codec->spec;
1831 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
1835 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
1839 /* NID is set in stac92xx_build_pcms */
1841 .open = stac92xx_dig_playback_pcm_open,
1842 .close = stac92xx_dig_playback_pcm_close,
1843 .prepare = stac92xx_dig_playback_pcm_prepare
1847 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
1851 /* NID is set in stac92xx_build_pcms */
1854 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
1858 .nid = 0x02, /* NID to query formats and rates */
1860 .open = stac92xx_playback_pcm_open,
1861 .prepare = stac92xx_playback_pcm_prepare,
1862 .cleanup = stac92xx_playback_pcm_cleanup
1866 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
1870 .nid = 0x06, /* NID to query formats and rates */
1872 .open = stac92xx_playback_pcm_open,
1873 .prepare = stac92xx_playback_pcm_prepare,
1874 .cleanup = stac92xx_playback_pcm_cleanup
1878 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
1881 /* NID + .substreams is set in stac92xx_build_pcms */
1883 .prepare = stac92xx_capture_pcm_prepare,
1884 .cleanup = stac92xx_capture_pcm_cleanup
1888 static int stac92xx_build_pcms(struct hda_codec *codec)
1890 struct sigmatel_spec *spec = codec->spec;
1891 struct hda_pcm *info = spec->pcm_rec;
1893 codec->num_pcms = 1;
1894 codec->pcm_info = info;
1896 info->name = "STAC92xx Analog";
1897 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
1898 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
1899 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1900 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
1902 if (spec->alt_switch) {
1905 info->name = "STAC92xx Analog Alt";
1906 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
1909 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1912 info->name = "STAC92xx Digital";
1913 info->pcm_type = HDA_PCM_TYPE_SPDIF;
1914 if (spec->multiout.dig_out_nid) {
1915 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
1916 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
1918 if (spec->dig_in_nid) {
1919 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
1920 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
1927 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
1929 unsigned int pincap = snd_hda_param_read(codec, nid,
1931 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
1932 if (pincap & AC_PINCAP_VREF_100)
1933 return AC_PINCTL_VREF_100;
1934 if (pincap & AC_PINCAP_VREF_80)
1935 return AC_PINCTL_VREF_80;
1936 if (pincap & AC_PINCAP_VREF_50)
1937 return AC_PINCTL_VREF_50;
1938 if (pincap & AC_PINCAP_VREF_GRD)
1939 return AC_PINCTL_VREF_GRD;
1943 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
1946 snd_hda_codec_write_cache(codec, nid, 0,
1947 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
1950 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
1952 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1954 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1955 struct sigmatel_spec *spec = codec->spec;
1956 int io_idx = kcontrol-> private_value & 0xff;
1958 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
1962 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1964 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1965 struct sigmatel_spec *spec = codec->spec;
1966 hda_nid_t nid = kcontrol->private_value >> 8;
1967 int io_idx = kcontrol-> private_value & 0xff;
1968 unsigned short val = !!ucontrol->value.integer.value[0];
1970 spec->io_switch[io_idx] = val;
1973 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
1975 unsigned int pinctl = AC_PINCTL_IN_EN;
1976 if (io_idx) /* set VREF for mic */
1977 pinctl |= stac92xx_get_vref(codec, nid);
1978 stac92xx_auto_set_pinctl(codec, nid, pinctl);
1981 /* check the auto-mute again: we need to mute/unmute the speaker
1982 * appropriately according to the pin direction
1984 if (spec->hp_detect)
1985 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
1990 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
1992 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
1993 struct snd_ctl_elem_value *ucontrol)
1995 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1996 struct sigmatel_spec *spec = codec->spec;
1998 ucontrol->value.integer.value[0] = spec->clfe_swap;
2002 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2003 struct snd_ctl_elem_value *ucontrol)
2005 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2006 struct sigmatel_spec *spec = codec->spec;
2007 hda_nid_t nid = kcontrol->private_value & 0xff;
2008 unsigned int val = !!ucontrol->value.integer.value[0];
2010 if (spec->clfe_swap == val)
2013 spec->clfe_swap = val;
2015 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2016 spec->clfe_swap ? 0x4 : 0x0);
2021 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2022 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2025 .info = stac92xx_io_switch_info, \
2026 .get = stac92xx_io_switch_get, \
2027 .put = stac92xx_io_switch_put, \
2028 .private_value = xpval, \
2031 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2032 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2035 .info = stac92xx_clfe_switch_info, \
2036 .get = stac92xx_clfe_switch_get, \
2037 .put = stac92xx_clfe_switch_put, \
2038 .private_value = xpval, \
2042 STAC_CTL_WIDGET_VOL,
2043 STAC_CTL_WIDGET_MUTE,
2044 STAC_CTL_WIDGET_MONO_MUX,
2045 STAC_CTL_WIDGET_IO_SWITCH,
2046 STAC_CTL_WIDGET_CLFE_SWITCH
2049 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2050 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2051 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2053 STAC_CODEC_IO_SWITCH(NULL, 0),
2054 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2057 /* add dynamic controls */
2058 static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val)
2060 struct snd_kcontrol_new *knew;
2062 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
2063 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
2065 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
2068 if (spec->kctl_alloc) {
2069 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
2070 kfree(spec->kctl_alloc);
2072 spec->kctl_alloc = knew;
2073 spec->num_kctl_alloc = num;
2076 knew = &spec->kctl_alloc[spec->num_kctl_used];
2077 *knew = stac92xx_control_templates[type];
2078 knew->name = kstrdup(name, GFP_KERNEL);
2081 knew->private_value = val;
2082 spec->num_kctl_used++;
2086 /* flag inputs as additional dynamic lineouts */
2087 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
2089 struct sigmatel_spec *spec = codec->spec;
2090 unsigned int wcaps, wtype;
2091 int i, num_dacs = 0;
2093 /* use the wcaps cache to count all DACs available for line-outs */
2094 for (i = 0; i < codec->num_nodes; i++) {
2095 wcaps = codec->wcaps[i];
2096 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2098 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
2102 snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
2104 switch (cfg->line_outs) {
2106 /* add line-in as side */
2107 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
2108 cfg->line_out_pins[cfg->line_outs] =
2109 cfg->input_pins[AUTO_PIN_LINE];
2110 spec->line_switch = 1;
2115 /* add line-in as clfe and mic as side */
2116 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
2117 cfg->line_out_pins[cfg->line_outs] =
2118 cfg->input_pins[AUTO_PIN_LINE];
2119 spec->line_switch = 1;
2122 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
2123 cfg->line_out_pins[cfg->line_outs] =
2124 cfg->input_pins[AUTO_PIN_MIC];
2125 spec->mic_switch = 1;
2130 /* add line-in as surr and mic as clfe */
2131 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
2132 cfg->line_out_pins[cfg->line_outs] =
2133 cfg->input_pins[AUTO_PIN_LINE];
2134 spec->line_switch = 1;
2137 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
2138 cfg->line_out_pins[cfg->line_outs] =
2139 cfg->input_pins[AUTO_PIN_MIC];
2140 spec->mic_switch = 1;
2150 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2154 for (i = 0; i < spec->multiout.num_dacs; i++) {
2155 if (spec->multiout.dac_nids[i] == nid)
2163 * Fill in the dac_nids table from the parsed pin configuration
2164 * This function only works when every pin in line_out_pins[]
2165 * contains atleast one DAC in its connection list. Some 92xx
2166 * codecs are not connected directly to a DAC, such as the 9200
2167 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2169 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
2170 struct auto_pin_cfg *cfg)
2172 struct sigmatel_spec *spec = codec->spec;
2173 int i, j, conn_len = 0;
2174 hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
2175 unsigned int wcaps, wtype;
2177 for (i = 0; i < cfg->line_outs; i++) {
2178 nid = cfg->line_out_pins[i];
2179 conn_len = snd_hda_get_connections(codec, nid, conn,
2180 HDA_MAX_CONNECTIONS);
2181 for (j = 0; j < conn_len; j++) {
2182 wcaps = snd_hda_param_read(codec, conn[j],
2183 AC_PAR_AUDIO_WIDGET_CAP);
2184 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2185 if (wtype != AC_WID_AUD_OUT ||
2186 (wcaps & AC_WCAP_DIGITAL))
2188 /* conn[j] is a DAC routed to this line-out */
2189 if (!is_in_dac_nids(spec, conn[j]))
2193 if (j == conn_len) {
2194 if (spec->multiout.num_dacs > 0) {
2195 /* we have already working output pins,
2196 * so let's drop the broken ones again
2198 cfg->line_outs = spec->multiout.num_dacs;
2201 /* error out, no available DAC found */
2203 "%s: No available DAC for pin 0x%x\n",
2208 spec->multiout.dac_nids[i] = conn[j];
2209 spec->multiout.num_dacs++;
2211 /* select this DAC in the pin's input mux */
2212 snd_hda_codec_write_cache(codec, nid, 0,
2213 AC_VERB_SET_CONNECT_SEL, j);
2218 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2219 spec->multiout.num_dacs,
2220 spec->multiout.dac_nids[0],
2221 spec->multiout.dac_nids[1],
2222 spec->multiout.dac_nids[2],
2223 spec->multiout.dac_nids[3],
2224 spec->multiout.dac_nids[4]);
2228 /* create volume control/switch for the given prefx type */
2229 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
2234 sprintf(name, "%s Playback Volume", pfx);
2235 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
2236 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2239 sprintf(name, "%s Playback Switch", pfx);
2240 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
2241 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2247 /* add playback controls from the parsed DAC table */
2248 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
2249 const struct auto_pin_cfg *cfg)
2251 static const char *chname[4] = {
2252 "Front", "Surround", NULL /*CLFE*/, "Side"
2257 struct sigmatel_spec *spec = codec->spec;
2258 unsigned int wid_caps, pincap;
2261 for (i = 0; i < cfg->line_outs; i++) {
2262 if (!spec->multiout.dac_nids[i])
2265 nid = spec->multiout.dac_nids[i];
2269 err = create_controls(spec, "Center", nid, 1);
2272 err = create_controls(spec, "LFE", nid, 2);
2276 wid_caps = get_wcaps(codec, nid);
2278 if (wid_caps & AC_WCAP_LR_SWAP) {
2279 err = stac92xx_add_control(spec,
2280 STAC_CTL_WIDGET_CLFE_SWITCH,
2281 "Swap Center/LFE Playback Switch", nid);
2288 err = create_controls(spec, chname[i], nid, 3);
2294 if (spec->line_switch) {
2295 nid = cfg->input_pins[AUTO_PIN_LINE];
2296 pincap = snd_hda_param_read(codec, nid,
2298 if (pincap & AC_PINCAP_OUT) {
2299 err = stac92xx_add_control(spec,
2300 STAC_CTL_WIDGET_IO_SWITCH,
2301 "Line In as Output Switch", nid << 8);
2307 if (spec->mic_switch) {
2308 unsigned int def_conf;
2309 nid = cfg->input_pins[AUTO_PIN_MIC];
2310 def_conf = snd_hda_codec_read(codec, nid, 0,
2311 AC_VERB_GET_CONFIG_DEFAULT, 0);
2313 /* some laptops have an internal analog microphone
2314 * which can't be used as a output */
2315 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2316 pincap = snd_hda_param_read(codec, nid,
2318 if (pincap & AC_PINCAP_OUT) {
2319 err = stac92xx_add_control(spec,
2320 STAC_CTL_WIDGET_IO_SWITCH,
2321 "Mic as Output Switch", (nid << 8) | 1);
2331 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2333 if (is_in_dac_nids(spec, nid))
2335 if (spec->multiout.hp_nid == nid)
2340 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
2342 if (!spec->multiout.hp_nid)
2343 spec->multiout.hp_nid = nid;
2344 else if (spec->multiout.num_dacs > 4) {
2345 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
2348 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
2349 spec->multiout.num_dacs++;
2354 /* add playback controls for Speaker and HP outputs */
2355 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
2356 struct auto_pin_cfg *cfg)
2358 struct sigmatel_spec *spec = codec->spec;
2360 int i, old_num_dacs, err;
2362 old_num_dacs = spec->multiout.num_dacs;
2363 for (i = 0; i < cfg->hp_outs; i++) {
2364 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
2365 if (wid_caps & AC_WCAP_UNSOL_CAP)
2366 spec->hp_detect = 1;
2367 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
2368 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2369 if (check_in_dac_nids(spec, nid))
2373 add_spec_dacs(spec, nid);
2375 for (i = 0; i < cfg->speaker_outs; i++) {
2376 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
2377 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2378 if (check_in_dac_nids(spec, nid))
2382 add_spec_dacs(spec, nid);
2384 for (i = 0; i < cfg->line_outs; i++) {
2385 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
2386 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2387 if (check_in_dac_nids(spec, nid))
2391 add_spec_dacs(spec, nid);
2393 for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
2394 static const char *pfxs[] = {
2395 "Speaker", "External Speaker", "Speaker2",
2397 err = create_controls(spec, pfxs[i - old_num_dacs],
2398 spec->multiout.dac_nids[i], 3);
2402 if (spec->multiout.hp_nid) {
2404 if (old_num_dacs == spec->multiout.num_dacs)
2408 err = create_controls(spec, pfx, spec->multiout.hp_nid, 3);
2416 /* labels for mono mux outputs */
2417 static const char *stac92xx_mono_labels[3] = {
2418 "DAC0", "DAC1", "Mixer"
2421 /* create mono mux for mono out on capable codecs */
2422 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
2424 struct sigmatel_spec *spec = codec->spec;
2425 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
2427 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
2429 num_cons = snd_hda_get_connections(codec,
2432 HDA_MAX_NUM_INPUTS);
2433 if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
2436 for (i = 0; i < num_cons; i++) {
2437 mono_mux->items[mono_mux->num_items].label =
2438 stac92xx_mono_labels[i];
2439 mono_mux->items[mono_mux->num_items].index = i;
2440 mono_mux->num_items++;
2443 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
2444 "Mono Mux", spec->mono_nid);
2447 /* labels for dmic mux inputs */
2448 static const char *stac92xx_dmic_labels[5] = {
2449 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
2450 "Digital Mic 3", "Digital Mic 4"
2453 /* create playback/capture controls for input pins on dmic capable codecs */
2454 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
2455 const struct auto_pin_cfg *cfg)
2457 struct sigmatel_spec *spec = codec->spec;
2458 struct hda_input_mux *dimux = &spec->private_dimux;
2459 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2463 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
2464 dimux->items[dimux->num_items].index = 0;
2467 for (i = 0; i < spec->num_dmics; i++) {
2472 unsigned int def_conf;
2474 def_conf = snd_hda_codec_read(codec,
2477 AC_VERB_GET_CONFIG_DEFAULT,
2479 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
2482 nid = spec->dmic_nids[i];
2483 num_cons = snd_hda_get_connections(codec,
2486 HDA_MAX_NUM_INPUTS);
2487 for (j = 0; j < num_cons; j++)
2488 if (con_lst[j] == nid) {
2494 wcaps = get_wcaps(codec, nid);
2496 if (wcaps & AC_WCAP_OUT_AMP) {
2497 sprintf(name, "%s Capture Volume",
2498 stac92xx_dmic_labels[dimux->num_items]);
2500 err = stac92xx_add_control(spec,
2501 STAC_CTL_WIDGET_VOL,
2503 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
2508 dimux->items[dimux->num_items].label =
2509 stac92xx_dmic_labels[dimux->num_items];
2510 dimux->items[dimux->num_items].index = index;
2517 /* create playback/capture controls for input pins */
2518 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
2520 struct sigmatel_spec *spec = codec->spec;
2521 struct hda_input_mux *imux = &spec->private_imux;
2522 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2525 for (i = 0; i < AUTO_PIN_LAST; i++) {
2528 if (!cfg->input_pins[i])
2531 for (j = 0; j < spec->num_muxes; j++) {
2533 num_cons = snd_hda_get_connections(codec,
2536 HDA_MAX_NUM_INPUTS);
2537 for (k = 0; k < num_cons; k++)
2538 if (con_lst[k] == cfg->input_pins[i]) {
2545 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2546 imux->items[imux->num_items].index = index;
2550 if (imux->num_items) {
2552 * Set the current input for the muxes.
2553 * The STAC9221 has two input muxes with identical source
2554 * NID lists. Hopefully this won't get confused.
2556 for (i = 0; i < spec->num_muxes; i++) {
2557 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
2558 AC_VERB_SET_CONNECT_SEL,
2559 imux->items[0].index);
2566 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
2568 struct sigmatel_spec *spec = codec->spec;
2571 for (i = 0; i < spec->autocfg.line_outs; i++) {
2572 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2573 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2577 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
2579 struct sigmatel_spec *spec = codec->spec;
2582 for (i = 0; i < spec->autocfg.hp_outs; i++) {
2584 pin = spec->autocfg.hp_pins[i];
2585 if (pin) /* connect to front */
2586 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
2588 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
2590 pin = spec->autocfg.speaker_pins[i];
2591 if (pin) /* connect to front */
2592 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
2596 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
2598 struct sigmatel_spec *spec = codec->spec;
2600 int hp_speaker_swap = 0;
2602 if ((err = snd_hda_parse_pin_def_config(codec,
2604 spec->dmic_nids)) < 0)
2606 if (! spec->autocfg.line_outs)
2607 return 0; /* can't find valid pin config */
2609 /* If we have no real line-out pin and multiple hp-outs, HPs should
2610 * be set up as multi-channel outputs.
2612 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
2613 spec->autocfg.hp_outs > 1) {
2614 /* Copy hp_outs to line_outs, backup line_outs in
2615 * speaker_outs so that the following routines can handle
2616 * HP pins as primary outputs.
2618 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
2619 sizeof(spec->autocfg.line_out_pins));
2620 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
2621 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
2622 sizeof(spec->autocfg.hp_pins));
2623 spec->autocfg.line_outs = spec->autocfg.hp_outs;
2624 hp_speaker_swap = 1;
2626 if (spec->autocfg.mono_out_pin) {
2627 int dir = (get_wcaps(codec, spec->autocfg.mono_out_pin)
2628 & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
2629 u32 caps = query_amp_caps(codec,
2630 spec->autocfg.mono_out_pin, dir);
2631 hda_nid_t conn_list[1];
2633 /* get the mixer node and then the mono mux if it exists */
2634 if (snd_hda_get_connections(codec,
2635 spec->autocfg.mono_out_pin, conn_list, 1) &&
2636 snd_hda_get_connections(codec, conn_list[0],
2639 int wcaps = get_wcaps(codec, conn_list[0]);
2640 int wid_type = (wcaps & AC_WCAP_TYPE)
2641 >> AC_WCAP_TYPE_SHIFT;
2642 /* LR swap check, some stac925x have a mux that
2643 * changes the DACs output path instead of the
2646 if (wid_type == AC_WID_AUD_SEL &&
2647 !(wcaps & AC_WCAP_LR_SWAP))
2648 spec->mono_nid = conn_list[0];
2650 /* all mono outs have a least a mute/unmute switch */
2651 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
2652 "Mono Playback Switch",
2653 HDA_COMPOSE_AMP_VAL(spec->autocfg.mono_out_pin,
2657 /* check to see if there is volume support for the amp */
2658 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
2659 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
2660 "Mono Playback Volume",
2661 HDA_COMPOSE_AMP_VAL(spec->autocfg.mono_out_pin,
2667 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
2671 if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
2673 if (spec->multiout.num_dacs == 0)
2674 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2677 err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
2682 if (hp_speaker_swap == 1) {
2683 /* Restore the hp_outs and line_outs */
2684 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
2685 sizeof(spec->autocfg.line_out_pins));
2686 spec->autocfg.hp_outs = spec->autocfg.line_outs;
2687 memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins,
2688 sizeof(spec->autocfg.speaker_pins));
2689 spec->autocfg.line_outs = spec->autocfg.speaker_outs;
2690 memset(spec->autocfg.speaker_pins, 0,
2691 sizeof(spec->autocfg.speaker_pins));
2692 spec->autocfg.speaker_outs = 0;
2695 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
2700 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
2705 if (spec->mono_nid > 0) {
2706 err = stac92xx_auto_create_mono_output_ctls(codec);
2711 if (spec->num_dmics > 0)
2712 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
2713 &spec->autocfg)) < 0)
2716 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2717 if (spec->multiout.max_channels > 2)
2718 spec->surr_switch = 1;
2720 if (spec->autocfg.dig_out_pin)
2721 spec->multiout.dig_out_nid = dig_out;
2722 if (spec->autocfg.dig_in_pin)
2723 spec->dig_in_nid = dig_in;
2725 if (spec->kctl_alloc)
2726 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2728 spec->input_mux = &spec->private_imux;
2729 if (!spec->dinput_mux)
2730 spec->dinput_mux = &spec->private_dimux;
2731 spec->mono_mux = &spec->private_mono_mux;
2736 /* add playback controls for HP output */
2737 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
2738 struct auto_pin_cfg *cfg)
2740 struct sigmatel_spec *spec = codec->spec;
2741 hda_nid_t pin = cfg->hp_pins[0];
2742 unsigned int wid_caps;
2747 wid_caps = get_wcaps(codec, pin);
2748 if (wid_caps & AC_WCAP_UNSOL_CAP)
2749 spec->hp_detect = 1;
2754 /* add playback controls for LFE output */
2755 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
2756 struct auto_pin_cfg *cfg)
2758 struct sigmatel_spec *spec = codec->spec;
2760 hda_nid_t lfe_pin = 0x0;
2764 * search speaker outs and line outs for a mono speaker pin
2765 * with an amp. If one is found, add LFE controls
2768 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
2769 hda_nid_t pin = spec->autocfg.speaker_pins[i];
2770 unsigned long wcaps = get_wcaps(codec, pin);
2771 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2772 if (wcaps == AC_WCAP_OUT_AMP)
2773 /* found a mono speaker with an amp, must be lfe */
2777 /* if speaker_outs is 0, then speakers may be in line_outs */
2778 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
2779 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
2780 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2782 cfg = snd_hda_codec_read(codec, pin, 0,
2783 AC_VERB_GET_CONFIG_DEFAULT,
2785 if (get_defcfg_device(cfg) == AC_JACK_SPEAKER) {
2786 unsigned long wcaps = get_wcaps(codec, pin);
2787 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2788 if (wcaps == AC_WCAP_OUT_AMP)
2789 /* found a mono speaker with an amp,
2797 err = create_controls(spec, "LFE", lfe_pin, 1);
2805 static int stac9200_parse_auto_config(struct hda_codec *codec)
2807 struct sigmatel_spec *spec = codec->spec;
2810 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2813 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
2816 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
2819 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
2822 if (spec->autocfg.dig_out_pin)
2823 spec->multiout.dig_out_nid = 0x05;
2824 if (spec->autocfg.dig_in_pin)
2825 spec->dig_in_nid = 0x04;
2827 if (spec->kctl_alloc)
2828 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2830 spec->input_mux = &spec->private_imux;
2831 spec->dinput_mux = &spec->private_dimux;
2837 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
2838 * funky external mute control using GPIO pins.
2841 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
2842 unsigned int dir_mask, unsigned int data)
2844 unsigned int gpiostate, gpiomask, gpiodir;
2846 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
2847 AC_VERB_GET_GPIO_DATA, 0);
2848 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
2850 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
2851 AC_VERB_GET_GPIO_MASK, 0);
2854 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
2855 AC_VERB_GET_GPIO_DIRECTION, 0);
2856 gpiodir |= dir_mask;
2858 /* Configure GPIOx as CMOS */
2859 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
2861 snd_hda_codec_write(codec, codec->afg, 0,
2862 AC_VERB_SET_GPIO_MASK, gpiomask);
2863 snd_hda_codec_read(codec, codec->afg, 0,
2864 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
2868 snd_hda_codec_read(codec, codec->afg, 0,
2869 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
2872 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
2875 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
2876 snd_hda_codec_write_cache(codec, nid, 0,
2877 AC_VERB_SET_UNSOLICITED_ENABLE,
2878 (AC_USRSP_EN | event));
2881 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
2884 for (i = 0; i < cfg->hp_outs; i++)
2885 if (cfg->hp_pins[i] == nid)
2886 return 1; /* nid is a HP-Out */
2888 return 0; /* nid is not a HP-Out */
2891 static void stac92xx_power_down(struct hda_codec *codec)
2893 struct sigmatel_spec *spec = codec->spec;
2895 /* power down inactive DACs */
2897 for (dac = spec->dac_list; *dac; dac++)
2898 if (!is_in_dac_nids(spec, *dac))
2899 snd_hda_codec_write_cache(codec, *dac, 0,
2900 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2903 static int stac92xx_init(struct hda_codec *codec)
2905 struct sigmatel_spec *spec = codec->spec;
2906 struct auto_pin_cfg *cfg = &spec->autocfg;
2909 snd_hda_sequence_write(codec, spec->init);
2912 if (spec->hp_detect) {
2913 /* Enable unsolicited responses on the HP widget */
2914 for (i = 0; i < cfg->hp_outs; i++)
2915 enable_pin_detect(codec, cfg->hp_pins[i],
2917 /* force to enable the first line-out; the others are set up
2920 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
2922 stac92xx_auto_init_hp_out(codec);
2923 /* fake event to set up pins */
2924 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2926 stac92xx_auto_init_multi_out(codec);
2927 stac92xx_auto_init_hp_out(codec);
2929 for (i = 0; i < AUTO_PIN_LAST; i++) {
2930 hda_nid_t nid = cfg->input_pins[i];
2932 unsigned int pinctl = AC_PINCTL_IN_EN;
2933 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
2934 pinctl |= stac92xx_get_vref(codec, nid);
2935 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2938 for (i = 0; i < spec->num_dmics; i++)
2939 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
2941 for (i = 0; i < spec->num_pwrs; i++) {
2942 int event = is_nid_hp_pin(cfg, spec->pwr_nids[i])
2943 ? STAC_HP_EVENT : STAC_PWR_EVENT;
2944 int pinctl = snd_hda_codec_read(codec, spec->pwr_nids[i],
2945 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2946 /* outputs are only ports capable of power management
2947 * any attempts on powering down a input port cause the
2948 * referenced VREF to act quirky.
2950 if (pinctl & AC_PINCTL_IN_EN)
2952 enable_pin_detect(codec, spec->pwr_nids[i], event | i);
2953 codec->patch_ops.unsol_event(codec, (event | i) << 26);
2956 stac92xx_power_down(codec);
2957 if (cfg->dig_out_pin)
2958 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
2960 if (cfg->dig_in_pin)
2961 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
2964 stac_gpio_set(codec, spec->gpio_mask,
2965 spec->gpio_dir, spec->gpio_data);
2970 static void stac92xx_free(struct hda_codec *codec)
2972 struct sigmatel_spec *spec = codec->spec;
2978 if (spec->kctl_alloc) {
2979 for (i = 0; i < spec->num_kctl_used; i++)
2980 kfree(spec->kctl_alloc[i].name);
2981 kfree(spec->kctl_alloc);
2984 if (spec->bios_pin_configs)
2985 kfree(spec->bios_pin_configs);
2990 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
2993 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2994 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2996 if (pin_ctl & AC_PINCTL_IN_EN) {
2998 * we need to check the current set-up direction of
2999 * shared input pins since they can be switched via
3000 * "xxx as Output" mixer switch
3002 struct sigmatel_spec *spec = codec->spec;
3003 struct auto_pin_cfg *cfg = &spec->autocfg;
3004 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
3005 spec->line_switch) ||
3006 (nid == cfg->input_pins[AUTO_PIN_MIC] &&
3011 /* if setting pin direction bits, clear the current
3012 direction bits first */
3013 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
3014 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
3016 snd_hda_codec_write_cache(codec, nid, 0,
3017 AC_VERB_SET_PIN_WIDGET_CONTROL,
3021 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
3024 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
3025 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
3026 snd_hda_codec_write_cache(codec, nid, 0,
3027 AC_VERB_SET_PIN_WIDGET_CONTROL,
3031 static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid)
3035 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
3037 unsigned int pinctl;
3038 pinctl = snd_hda_codec_read(codec, nid, 0,
3039 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3040 if (pinctl & AC_PINCTL_IN_EN)
3041 return 0; /* mic- or line-input */
3043 return 1; /* HP-output */
3048 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
3050 struct sigmatel_spec *spec = codec->spec;
3051 struct auto_pin_cfg *cfg = &spec->autocfg;
3055 if (spec->gpio_mute)
3056 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
3057 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
3059 for (i = 0; i < cfg->hp_outs; i++) {
3062 presence = get_hp_pin_presence(codec, cfg->hp_pins[i]);
3066 /* disable lineouts, enable hp */
3067 for (i = 0; i < cfg->line_outs; i++)
3068 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
3070 for (i = 0; i < cfg->speaker_outs; i++)
3071 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
3074 /* enable lineouts, disable hp */
3075 for (i = 0; i < cfg->line_outs; i++)
3076 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
3078 for (i = 0; i < cfg->speaker_outs; i++)
3079 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
3084 static void stac92xx_pin_sense(struct hda_codec *codec, int idx)
3086 struct sigmatel_spec *spec = codec->spec;
3087 hda_nid_t nid = spec->pwr_nids[idx];
3089 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0)
3091 presence = get_hp_pin_presence(codec, nid);
3099 /* power down unused output ports */
3100 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
3103 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
3105 struct sigmatel_spec *spec = codec->spec;
3106 int idx = res >> 26 & 0x0f;
3108 switch ((res >> 26) & 0x30) {
3110 stac92xx_hp_detect(codec, res);
3112 case STAC_PWR_EVENT:
3113 if (spec->num_pwrs > 0)
3114 stac92xx_pin_sense(codec, idx);
3118 #ifdef SND_HDA_NEEDS_RESUME
3119 static int stac92xx_resume(struct hda_codec *codec)
3121 struct sigmatel_spec *spec = codec->spec;
3123 stac92xx_set_config_regs(codec);
3124 snd_hda_sequence_write(codec, spec->init);
3125 stac_gpio_set(codec, spec->gpio_mask,
3126 spec->gpio_dir, spec->gpio_data);
3127 snd_hda_codec_resume_amp(codec);
3128 snd_hda_codec_resume_cache(codec);
3129 /* power down inactive DACs */
3131 stac92xx_power_down(codec);
3132 /* invoke unsolicited event to reset the HP state */
3133 if (spec->hp_detect)
3134 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3139 static struct hda_codec_ops stac92xx_patch_ops = {
3140 .build_controls = stac92xx_build_controls,
3141 .build_pcms = stac92xx_build_pcms,
3142 .init = stac92xx_init,
3143 .free = stac92xx_free,
3144 .unsol_event = stac92xx_unsol_event,
3145 #ifdef SND_HDA_NEEDS_RESUME
3146 .resume = stac92xx_resume,
3150 static int patch_stac9200(struct hda_codec *codec)
3152 struct sigmatel_spec *spec;
3155 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3160 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
3161 spec->pin_nids = stac9200_pin_nids;
3162 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
3165 if (spec->board_config < 0) {
3166 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
3167 err = stac92xx_save_bios_config_regs(codec);
3169 stac92xx_free(codec);
3172 spec->pin_configs = spec->bios_pin_configs;
3174 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
3175 stac92xx_set_config_regs(codec);
3178 spec->multiout.max_channels = 2;
3179 spec->multiout.num_dacs = 1;
3180 spec->multiout.dac_nids = stac9200_dac_nids;
3181 spec->adc_nids = stac9200_adc_nids;
3182 spec->mux_nids = stac9200_mux_nids;
3183 spec->num_muxes = 1;
3184 spec->num_dmics = 0;
3188 if (spec->board_config == STAC_9200_GATEWAY ||
3189 spec->board_config == STAC_9200_OQO)
3190 spec->init = stac9200_eapd_init;
3192 spec->init = stac9200_core_init;
3193 spec->mixer = stac9200_mixer;
3195 err = stac9200_parse_auto_config(codec);
3197 stac92xx_free(codec);
3201 codec->patch_ops = stac92xx_patch_ops;
3206 static int patch_stac925x(struct hda_codec *codec)
3208 struct sigmatel_spec *spec;
3211 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3216 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
3217 spec->pin_nids = stac925x_pin_nids;
3218 spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
3222 if (spec->board_config < 0) {
3223 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
3224 "using BIOS defaults\n");
3225 err = stac92xx_save_bios_config_regs(codec);
3227 stac92xx_free(codec);
3230 spec->pin_configs = spec->bios_pin_configs;
3231 } else if (stac925x_brd_tbl[spec->board_config] != NULL){
3232 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
3233 stac92xx_set_config_regs(codec);
3236 spec->multiout.max_channels = 2;
3237 spec->multiout.num_dacs = 1;
3238 spec->multiout.dac_nids = stac925x_dac_nids;
3239 spec->adc_nids = stac925x_adc_nids;
3240 spec->mux_nids = stac925x_mux_nids;
3241 spec->num_muxes = 1;
3244 switch (codec->vendor_id) {
3245 case 0x83847632: /* STAC9202 */
3246 case 0x83847633: /* STAC9202D */
3247 case 0x83847636: /* STAC9251 */
3248 case 0x83847637: /* STAC9251D */
3249 spec->num_dmics = STAC925X_NUM_DMICS;
3250 spec->dmic_nids = stac925x_dmic_nids;
3251 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
3252 spec->dmux_nids = stac925x_dmux_nids;
3255 spec->num_dmics = 0;
3259 spec->init = stac925x_core_init;
3260 spec->mixer = stac925x_mixer;
3262 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
3264 if (spec->board_config < 0) {
3265 printk(KERN_WARNING "hda_codec: No auto-config is "
3266 "available, default to model=ref\n");
3267 spec->board_config = STAC_925x_REF;
3273 stac92xx_free(codec);
3277 codec->patch_ops = stac92xx_patch_ops;
3282 static struct hda_input_mux stac92hd73xx_dmux = {
3285 { "Analog Inputs", 0x0b },
3287 { "Digital Mic 1", 0x09 },
3288 { "Digital Mic 2", 0x0a },
3292 static int patch_stac92hd73xx(struct hda_codec *codec)
3294 struct sigmatel_spec *spec;
3295 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
3298 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3303 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
3304 spec->pin_nids = stac92hd73xx_pin_nids;
3305 spec->board_config = snd_hda_check_board_config(codec,
3306 STAC_92HD73XX_MODELS,
3307 stac92hd73xx_models,
3308 stac92hd73xx_cfg_tbl);
3310 if (spec->board_config < 0) {
3311 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3312 " STAC92HD73XX, using BIOS defaults\n");
3313 err = stac92xx_save_bios_config_regs(codec);
3315 stac92xx_free(codec);
3318 spec->pin_configs = spec->bios_pin_configs;
3320 spec->pin_configs = stac92hd73xx_brd_tbl[spec->board_config];
3321 stac92xx_set_config_regs(codec);
3324 spec->multiout.num_dacs = snd_hda_get_connections(codec, 0x0a,
3325 conn, STAC92HD73_DAC_COUNT + 2) - 1;
3327 if (spec->multiout.num_dacs < 0) {
3328 printk(KERN_WARNING "hda_codec: Could not determine "
3329 "number of channels defaulting to DAC count\n");
3330 spec->multiout.num_dacs = STAC92HD73_DAC_COUNT;
3333 switch (spec->multiout.num_dacs) {
3334 case 0x3: /* 6 Channel */
3335 spec->mixer = stac92hd73xx_6ch_mixer;
3336 spec->init = stac92hd73xx_6ch_core_init;
3338 case 0x4: /* 8 Channel */
3339 spec->multiout.hp_nid = 0x18;
3340 spec->mixer = stac92hd73xx_8ch_mixer;
3341 spec->init = stac92hd73xx_8ch_core_init;
3343 case 0x5: /* 10 Channel */
3344 spec->multiout.hp_nid = 0x19;
3345 spec->mixer = stac92hd73xx_10ch_mixer;
3346 spec->init = stac92hd73xx_10ch_core_init;
3349 spec->multiout.dac_nids = stac92hd73xx_dac_nids;
3350 spec->aloopback_mask = 0x01;
3351 spec->aloopback_shift = 8;
3353 spec->mux_nids = stac92hd73xx_mux_nids;
3354 spec->adc_nids = stac92hd73xx_adc_nids;
3355 spec->dmic_nids = stac92hd73xx_dmic_nids;
3356 spec->dmux_nids = stac92hd73xx_dmux_nids;
3358 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
3359 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
3360 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
3361 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
3362 spec->dinput_mux = &stac92hd73xx_dmux;
3363 /* GPIO0 High = Enable EAPD */
3364 spec->gpio_mask = spec->gpio_dir = 0x1;
3365 spec->gpio_data = 0x01;
3367 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
3368 spec->pwr_nids = stac92hd73xx_pwr_nids;
3370 err = stac92xx_parse_auto_config(codec, 0x22, 0x24);
3373 if (spec->board_config < 0) {
3374 printk(KERN_WARNING "hda_codec: No auto-config is "
3375 "available, default to model=ref\n");
3376 spec->board_config = STAC_92HD73XX_REF;
3383 stac92xx_free(codec);
3387 codec->patch_ops = stac92xx_patch_ops;
3392 static int patch_stac92hd71bxx(struct hda_codec *codec)
3394 struct sigmatel_spec *spec;
3397 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3402 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
3403 spec->pin_nids = stac92hd71bxx_pin_nids;
3404 spec->board_config = snd_hda_check_board_config(codec,
3405 STAC_92HD71BXX_MODELS,
3406 stac92hd71bxx_models,
3407 stac92hd71bxx_cfg_tbl);
3409 if (spec->board_config < 0) {
3410 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3411 " STAC92HD71BXX, using BIOS defaults\n");
3412 err = stac92xx_save_bios_config_regs(codec);
3414 stac92xx_free(codec);
3417 spec->pin_configs = spec->bios_pin_configs;
3419 spec->pin_configs = stac92hd71bxx_brd_tbl[spec->board_config];
3420 stac92xx_set_config_regs(codec);
3423 switch (codec->vendor_id) {
3424 case 0x111d76b6: /* 4 Port without Analog Mixer */
3426 case 0x111d76b4: /* 6 Port without Analog Mixer */
3428 spec->mixer = stac92hd71bxx_mixer;
3429 spec->init = stac92hd71bxx_core_init;
3432 spec->mixer = stac92hd71bxx_analog_mixer;
3433 spec->init = stac92hd71bxx_analog_core_init;
3436 spec->aloopback_mask = 0x20;
3437 spec->aloopback_shift = 0;
3439 /* GPIO0 High = EAPD */
3440 spec->gpio_mask = spec->gpio_dir = spec->gpio_data = 0x1;
3442 spec->mux_nids = stac92hd71bxx_mux_nids;
3443 spec->adc_nids = stac92hd71bxx_adc_nids;
3444 spec->dmic_nids = stac92hd71bxx_dmic_nids;
3445 spec->dmux_nids = stac92hd71bxx_dmux_nids;
3447 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
3448 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
3449 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
3450 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
3452 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
3453 spec->pwr_nids = stac92hd71bxx_pwr_nids;
3455 spec->multiout.num_dacs = 2;
3456 spec->multiout.hp_nid = 0x11;
3457 spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
3459 err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
3461 if (spec->board_config < 0) {
3462 printk(KERN_WARNING "hda_codec: No auto-config is "
3463 "available, default to model=ref\n");
3464 spec->board_config = STAC_92HD71BXX_REF;
3471 stac92xx_free(codec);
3475 codec->patch_ops = stac92xx_patch_ops;
3480 static int patch_stac922x(struct hda_codec *codec)
3482 struct sigmatel_spec *spec;
3485 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3490 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
3491 spec->pin_nids = stac922x_pin_nids;
3492 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
3495 if (spec->board_config == STAC_INTEL_MAC_V3) {
3496 spec->gpio_mask = spec->gpio_dir = 0x03;
3497 spec->gpio_data = 0x03;
3498 /* Intel Macs have all same PCI SSID, so we need to check
3499 * codec SSID to distinguish the exact models
3501 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
3502 switch (codec->subsystem_id) {
3505 spec->board_config = STAC_INTEL_MAC_V1;
3509 spec->board_config = STAC_INTEL_MAC_V2;
3517 spec->board_config = STAC_INTEL_MAC_V3;
3521 spec->board_config = STAC_INTEL_MAC_V4;
3525 spec->board_config = STAC_INTEL_MAC_V5;
3531 if (spec->board_config < 0) {
3532 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
3533 "using BIOS defaults\n");
3534 err = stac92xx_save_bios_config_regs(codec);
3536 stac92xx_free(codec);
3539 spec->pin_configs = spec->bios_pin_configs;
3540 } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
3541 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
3542 stac92xx_set_config_regs(codec);
3545 spec->adc_nids = stac922x_adc_nids;
3546 spec->mux_nids = stac922x_mux_nids;
3547 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
3548 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
3549 spec->num_dmics = 0;
3552 spec->init = stac922x_core_init;
3553 spec->mixer = stac922x_mixer;
3555 spec->multiout.dac_nids = spec->dac_nids;
3557 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
3559 if (spec->board_config < 0) {
3560 printk(KERN_WARNING "hda_codec: No auto-config is "
3561 "available, default to model=ref\n");
3562 spec->board_config = STAC_D945_REF;
3568 stac92xx_free(codec);
3572 codec->patch_ops = stac92xx_patch_ops;
3574 /* Fix Mux capture level; max to 2 */
3575 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
3576 (0 << AC_AMPCAP_OFFSET_SHIFT) |
3577 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3578 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3579 (0 << AC_AMPCAP_MUTE_SHIFT));
3584 static int patch_stac927x(struct hda_codec *codec)
3586 struct sigmatel_spec *spec;
3589 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3594 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
3595 spec->pin_nids = stac927x_pin_nids;
3596 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
3600 if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
3601 if (spec->board_config < 0)
3602 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3603 "STAC927x, using BIOS defaults\n");
3604 err = stac92xx_save_bios_config_regs(codec);
3606 stac92xx_free(codec);
3609 spec->pin_configs = spec->bios_pin_configs;
3611 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
3612 stac92xx_set_config_regs(codec);
3615 spec->adc_nids = stac927x_adc_nids;
3616 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
3617 spec->mux_nids = stac927x_mux_nids;
3618 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
3619 spec->dac_list = stac927x_dac_nids;
3620 spec->multiout.dac_nids = spec->dac_nids;
3622 switch (spec->board_config) {
3625 /* GPIO0 High = Enable EAPD */
3626 spec->gpio_mask = spec->gpio_dir = 0x01;
3627 spec->gpio_data = 0x01;
3628 spec->num_dmics = 0;
3630 spec->init = d965_core_init;
3631 spec->mixer = stac927x_mixer;
3633 case STAC_DELL_BIOS:
3634 /* correct the front output jack as a hp out */
3635 stac92xx_set_config_reg(codec, 0x0f, 0x02270110);
3636 /* correct the front input jack as a mic */
3637 stac92xx_set_config_reg(codec, 0x0e, 0x02a79130);
3640 /* GPIO2 High = Enable EAPD */
3641 spec->gpio_mask = spec->gpio_dir = 0x04;
3642 spec->gpio_data = 0x04;
3643 spec->dmic_nids = stac927x_dmic_nids;
3644 spec->num_dmics = STAC927X_NUM_DMICS;
3646 spec->init = d965_core_init;
3647 spec->mixer = stac927x_mixer;
3648 spec->dmux_nids = stac927x_dmux_nids;
3649 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
3652 /* GPIO0 High = Enable EAPD */
3653 spec->gpio_mask = spec->gpio_dir = 0x1;
3654 spec->gpio_data = 0x01;
3655 spec->num_dmics = 0;
3657 spec->init = stac927x_core_init;
3658 spec->mixer = stac927x_mixer;
3662 spec->aloopback_mask = 0x40;
3663 spec->aloopback_shift = 0;
3665 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
3667 if (spec->board_config < 0) {
3668 printk(KERN_WARNING "hda_codec: No auto-config is "
3669 "available, default to model=ref\n");
3670 spec->board_config = STAC_D965_REF;
3676 stac92xx_free(codec);
3680 codec->patch_ops = stac92xx_patch_ops;
3684 * The STAC927x seem to require fairly long delays for certain
3685 * command sequences. With too short delays (even if the answer
3686 * is set to RIRB properly), it results in the silence output
3687 * on some hardwares like Dell.
3689 * The below flag enables the longer delay (see get_response
3692 codec->bus->needs_damn_long_delay = 1;
3697 static int patch_stac9205(struct hda_codec *codec)
3699 struct sigmatel_spec *spec;
3702 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3707 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
3708 spec->pin_nids = stac9205_pin_nids;
3709 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
3713 if (spec->board_config < 0) {
3714 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
3715 err = stac92xx_save_bios_config_regs(codec);
3717 stac92xx_free(codec);
3720 spec->pin_configs = spec->bios_pin_configs;
3722 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
3723 stac92xx_set_config_regs(codec);
3726 spec->adc_nids = stac9205_adc_nids;
3727 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
3728 spec->mux_nids = stac9205_mux_nids;
3729 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
3730 spec->dmic_nids = stac9205_dmic_nids;
3731 spec->num_dmics = STAC9205_NUM_DMICS;
3732 spec->dmux_nids = stac9205_dmux_nids;
3733 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
3736 spec->init = stac9205_core_init;
3737 spec->mixer = stac9205_mixer;
3739 spec->aloopback_mask = 0x40;
3740 spec->aloopback_shift = 0;
3741 spec->multiout.dac_nids = spec->dac_nids;
3743 switch (spec->board_config){
3744 case STAC_9205_DELL_M43:
3745 /* Enable SPDIF in/out */
3746 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
3747 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
3749 /* Enable unsol response for GPIO4/Dock HP connection */
3750 snd_hda_codec_write(codec, codec->afg, 0,
3751 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
3752 snd_hda_codec_write_cache(codec, codec->afg, 0,
3753 AC_VERB_SET_UNSOLICITED_ENABLE,
3754 (AC_USRSP_EN | STAC_HP_EVENT));
3756 spec->gpio_dir = 0x0b;
3757 spec->gpio_mask = 0x1b;
3758 spec->gpio_mute = 0x10;
3759 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
3762 spec->gpio_data = 0x01;
3765 /* GPIO0 High = EAPD */
3766 spec->gpio_mask = spec->gpio_dir = 0x1;
3767 spec->gpio_data = 0x01;
3771 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
3773 if (spec->board_config < 0) {
3774 printk(KERN_WARNING "hda_codec: No auto-config is "
3775 "available, default to model=ref\n");
3776 spec->board_config = STAC_9205_REF;
3782 stac92xx_free(codec);
3786 codec->patch_ops = stac92xx_patch_ops;
3795 /* static config for Sony VAIO FE550G and Sony VAIO AR */
3796 static hda_nid_t vaio_dacs[] = { 0x2 };
3797 #define VAIO_HP_DAC 0x5
3798 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
3799 static hda_nid_t vaio_mux_nids[] = { 0x15 };
3801 static struct hda_input_mux vaio_mux = {
3804 /* { "HP", 0x0 }, */
3805 { "Mic Jack", 0x1 },
3806 { "Internal Mic", 0x2 },
3811 static struct hda_verb vaio_init[] = {
3812 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3813 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
3814 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3815 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3816 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3817 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3818 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3819 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3820 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3821 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3822 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3823 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3827 static struct hda_verb vaio_ar_init[] = {
3828 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3829 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3830 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3831 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3832 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
3833 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3834 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3835 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3836 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3837 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
3838 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3839 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3840 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3844 /* bind volumes of both NID 0x02 and 0x05 */
3845 static struct hda_bind_ctls vaio_bind_master_vol = {
3846 .ops = &snd_hda_bind_vol,
3848 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3849 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3854 /* bind volumes of both NID 0x02 and 0x05 */
3855 static struct hda_bind_ctls vaio_bind_master_sw = {
3856 .ops = &snd_hda_bind_sw,
3858 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3859 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3864 static struct snd_kcontrol_new vaio_mixer[] = {
3865 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3866 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3867 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3868 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3869 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3871 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3872 .name = "Capture Source",
3874 .info = stac92xx_mux_enum_info,
3875 .get = stac92xx_mux_enum_get,
3876 .put = stac92xx_mux_enum_put,
3881 static struct snd_kcontrol_new vaio_ar_mixer[] = {
3882 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3883 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3884 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3885 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3886 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3887 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
3888 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
3890 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3891 .name = "Capture Source",
3893 .info = stac92xx_mux_enum_info,
3894 .get = stac92xx_mux_enum_get,
3895 .put = stac92xx_mux_enum_put,
3900 static struct hda_codec_ops stac9872_patch_ops = {
3901 .build_controls = stac92xx_build_controls,
3902 .build_pcms = stac92xx_build_pcms,
3903 .init = stac92xx_init,
3904 .free = stac92xx_free,
3905 #ifdef SND_HDA_NEEDS_RESUME
3906 .resume = stac92xx_resume,
3910 static int stac9872_vaio_init(struct hda_codec *codec)
3914 err = stac92xx_init(codec);
3917 if (codec->patch_ops.unsol_event)
3918 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3922 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
3924 if (get_hp_pin_presence(codec, 0x0a)) {
3925 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3926 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3928 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3929 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3933 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
3935 switch (res >> 26) {
3937 stac9872_vaio_hp_detect(codec, res);
3942 static struct hda_codec_ops stac9872_vaio_patch_ops = {
3943 .build_controls = stac92xx_build_controls,
3944 .build_pcms = stac92xx_build_pcms,
3945 .init = stac9872_vaio_init,
3946 .free = stac92xx_free,
3947 .unsol_event = stac9872_vaio_unsol_event,
3949 .resume = stac92xx_resume,
3953 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
3955 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
3957 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
3959 /* AR Series. id=0x83847664 and subsys=104D1300 */
3964 static const char *stac9872_models[STAC_9872_MODELS] = {
3965 [CXD9872RD_VAIO] = "vaio",
3966 [CXD9872AKD_VAIO] = "vaio-ar",
3969 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
3970 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
3971 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
3972 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
3973 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
3977 static int patch_stac9872(struct hda_codec *codec)
3979 struct sigmatel_spec *spec;
3982 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
3985 if (board_config < 0)
3986 /* unknown config, let generic-parser do its job... */
3987 return snd_hda_parse_generic_codec(codec);
3989 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3994 switch (board_config) {
3995 case CXD9872RD_VAIO:
3996 case STAC9872AK_VAIO:
3997 case STAC9872K_VAIO:
3998 spec->mixer = vaio_mixer;
3999 spec->init = vaio_init;
4000 spec->multiout.max_channels = 2;
4001 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
4002 spec->multiout.dac_nids = vaio_dacs;
4003 spec->multiout.hp_nid = VAIO_HP_DAC;
4004 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
4005 spec->adc_nids = vaio_adcs;
4007 spec->input_mux = &vaio_mux;
4008 spec->mux_nids = vaio_mux_nids;
4009 codec->patch_ops = stac9872_vaio_patch_ops;
4012 case CXD9872AKD_VAIO:
4013 spec->mixer = vaio_ar_mixer;
4014 spec->init = vaio_ar_init;
4015 spec->multiout.max_channels = 2;
4016 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
4017 spec->multiout.dac_nids = vaio_dacs;
4018 spec->multiout.hp_nid = VAIO_HP_DAC;
4019 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
4021 spec->adc_nids = vaio_adcs;
4022 spec->input_mux = &vaio_mux;
4023 spec->mux_nids = vaio_mux_nids;
4024 codec->patch_ops = stac9872_patch_ops;
4035 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
4036 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
4037 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
4038 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
4039 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
4040 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
4041 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
4042 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
4043 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
4044 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
4045 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
4046 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
4047 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
4048 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
4049 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
4050 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
4051 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
4052 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
4053 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
4054 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
4055 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
4056 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
4057 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
4058 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
4059 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
4060 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
4061 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
4062 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
4063 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
4064 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
4065 /* The following does not take into account .id=0x83847661 when subsys =
4066 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
4067 * currently not fully supported.
4069 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
4070 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
4071 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
4072 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
4073 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
4074 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
4075 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
4076 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
4077 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
4078 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
4079 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
4080 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
4081 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
4082 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
4083 { .id = 0x111d7608, .name = "92HD71BXX", .patch = patch_stac92hd71bxx },
4084 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
4085 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
4086 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
4087 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
4088 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
4089 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
4090 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
4091 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },