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 <sound/driver.h>
28 #include <linux/init.h>
29 #include <linux/delay.h>
30 #include <linux/slab.h>
31 #include <linux/pci.h>
32 #include <sound/core.h>
33 #include <sound/asoundef.h>
34 #include "hda_codec.h"
35 #include "hda_local.h"
37 #define NUM_CONTROL_ALLOC 32
38 #define STAC_HP_EVENT 0x37
86 /* for backward compatibility */
108 struct sigmatel_spec {
109 struct snd_kcontrol_new *mixers[4];
110 unsigned int num_mixers;
113 unsigned int surr_switch: 1;
114 unsigned int line_switch: 1;
115 unsigned int mic_switch: 1;
116 unsigned int alt_switch: 1;
117 unsigned int hp_detect: 1;
118 unsigned int gpio_mute: 1;
120 unsigned int gpio_mask, gpio_data;
123 struct hda_multi_out multiout;
124 hda_nid_t dac_nids[5];
128 unsigned int num_adcs;
130 unsigned int num_muxes;
131 hda_nid_t *dmic_nids;
132 unsigned int num_dmics;
134 hda_nid_t dig_in_nid;
138 unsigned int num_pins;
139 unsigned int *pin_configs;
140 unsigned int *bios_pin_configs;
142 /* codec specific stuff */
143 struct hda_verb *init;
144 struct snd_kcontrol_new *mixer;
147 struct hda_input_mux *dinput_mux;
148 unsigned int cur_dmux;
149 struct hda_input_mux *input_mux;
150 unsigned int cur_mux[3];
153 unsigned int io_switch[2];
154 unsigned int clfe_swap;
155 unsigned int aloopback;
157 struct hda_pcm pcm_rec[2]; /* PCM information */
159 /* dynamic controls and input_mux */
160 struct auto_pin_cfg autocfg;
161 unsigned int num_kctl_alloc, num_kctl_used;
162 struct snd_kcontrol_new *kctl_alloc;
163 struct hda_input_mux private_dimux;
164 struct hda_input_mux private_imux;
167 static hda_nid_t stac9200_adc_nids[1] = {
171 static hda_nid_t stac9200_mux_nids[1] = {
175 static hda_nid_t stac9200_dac_nids[1] = {
179 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
183 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
187 static hda_nid_t stac92hd71bxx_dac_nids[2] = {
191 #define STAC92HD71BXX_NUM_DMICS 2
192 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
196 static hda_nid_t stac925x_adc_nids[1] = {
200 static hda_nid_t stac925x_mux_nids[1] = {
204 static hda_nid_t stac925x_dac_nids[1] = {
208 #define STAC925X_NUM_DMICS 1
209 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
213 static hda_nid_t stac922x_adc_nids[2] = {
217 static hda_nid_t stac922x_mux_nids[2] = {
221 static hda_nid_t stac927x_adc_nids[3] = {
225 static hda_nid_t stac927x_mux_nids[3] = {
229 #define STAC927X_NUM_DMICS 2
230 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
234 static hda_nid_t stac9205_adc_nids[2] = {
238 static hda_nid_t stac9205_mux_nids[2] = {
242 #define STAC9205_NUM_DMICS 2
243 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
247 static hda_nid_t stac9200_pin_nids[8] = {
248 0x08, 0x09, 0x0d, 0x0e,
249 0x0f, 0x10, 0x11, 0x12,
252 static hda_nid_t stac925x_pin_nids[8] = {
253 0x07, 0x08, 0x0a, 0x0b,
254 0x0c, 0x0d, 0x10, 0x11,
257 static hda_nid_t stac922x_pin_nids[10] = {
258 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
259 0x0f, 0x10, 0x11, 0x15, 0x1b,
262 static hda_nid_t stac92hd71bxx_pin_nids[10] = {
263 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
264 0x0f, 0x14, 0x18, 0x19, 0x1e,
267 static hda_nid_t stac927x_pin_nids[14] = {
268 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
269 0x0f, 0x10, 0x11, 0x12, 0x13,
270 0x14, 0x21, 0x22, 0x23,
273 static hda_nid_t stac9205_pin_nids[12] = {
274 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
275 0x0f, 0x14, 0x16, 0x17, 0x18,
279 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
280 struct snd_ctl_elem_info *uinfo)
282 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
283 struct sigmatel_spec *spec = codec->spec;
284 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
287 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
288 struct snd_ctl_elem_value *ucontrol)
290 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
291 struct sigmatel_spec *spec = codec->spec;
293 ucontrol->value.enumerated.item[0] = spec->cur_dmux;
297 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
298 struct snd_ctl_elem_value *ucontrol)
300 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
301 struct sigmatel_spec *spec = codec->spec;
303 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
304 spec->dmux_nid, &spec->cur_dmux);
307 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
309 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
310 struct sigmatel_spec *spec = codec->spec;
311 return snd_hda_input_mux_info(spec->input_mux, uinfo);
314 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
316 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
317 struct sigmatel_spec *spec = codec->spec;
318 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
320 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
324 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
326 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
327 struct sigmatel_spec *spec = codec->spec;
328 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
330 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
331 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
334 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
336 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
337 struct snd_ctl_elem_value *ucontrol)
339 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
340 struct sigmatel_spec *spec = codec->spec;
342 ucontrol->value.integer.value[0] = spec->aloopback;
346 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
347 struct snd_ctl_elem_value *ucontrol)
349 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
350 struct sigmatel_spec *spec = codec->spec;
351 unsigned int dac_mode;
353 if (spec->aloopback == ucontrol->value.integer.value[0])
356 spec->aloopback = ucontrol->value.integer.value[0];
359 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
360 kcontrol->private_value & 0xFFFF, 0x0);
362 if (spec->aloopback) {
363 snd_hda_power_up(codec);
366 snd_hda_power_down(codec);
370 snd_hda_codec_write_cache(codec, codec->afg, 0,
371 kcontrol->private_value >> 16, dac_mode);
376 static struct hda_verb stac9200_core_init[] = {
377 /* set dac0mux for dac converter */
378 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
382 static struct hda_verb stac9200_eapd_init[] = {
383 /* set dac0mux for dac converter */
384 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
385 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
389 static struct hda_verb stac92hd71bxx_core_init[] = {
390 /* set master volume and direct control */
391 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
392 /* connect headphone jack to dac1 */
393 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
394 /* connect ports 0d and 0f to audio mixer */
395 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x2},
396 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
397 /* unmute dac0 input in audio mixer */
398 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
399 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
400 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
401 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
402 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
403 /* unmute mono out node */
404 { 0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
408 static struct hda_verb stac925x_core_init[] = {
409 /* set dac0mux for dac converter */
410 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
414 static struct hda_verb stac922x_core_init[] = {
415 /* set master volume and direct control */
416 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
420 static struct hda_verb d965_core_init[] = {
421 /* set master volume and direct control */
422 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
423 /* unmute node 0x1b */
424 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
425 /* select node 0x03 as DAC */
426 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
430 static struct hda_verb stac927x_core_init[] = {
431 /* set master volume and direct control */
432 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
436 static struct hda_verb stac9205_core_init[] = {
437 /* set master volume and direct control */
438 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
442 #define STAC_DIGITAL_INPUT_SOURCE(cnt) \
444 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
445 .name = "Digital Input Source", \
447 .info = stac92xx_dmux_enum_info, \
448 .get = stac92xx_dmux_enum_get, \
449 .put = stac92xx_dmux_enum_put,\
452 #define STAC_INPUT_SOURCE(cnt) \
454 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
455 .name = "Input Source", \
457 .info = stac92xx_mux_enum_info, \
458 .get = stac92xx_mux_enum_get, \
459 .put = stac92xx_mux_enum_put, \
462 #define STAC_ANALOG_LOOPBACK(verb_read,verb_write) \
464 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
465 .name = "Analog Loopback", \
467 .info = stac92xx_aloopback_info, \
468 .get = stac92xx_aloopback_get, \
469 .put = stac92xx_aloopback_put, \
470 .private_value = verb_read | (verb_write << 16), \
473 #define STAC_VOLKNOB(knob_nid) \
475 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
476 .name = "Master Playback Volume", \
478 .info = stac92xx_volknob_info, \
479 .get = stac92xx_volknob_get, \
480 .put = stac92xx_volknob_put, \
481 .private_value = 127 | (knob_nid << 16), \
484 static struct snd_kcontrol_new stac9200_mixer[] = {
485 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
486 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
487 STAC_INPUT_SOURCE(1),
488 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
489 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
490 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT),
494 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
495 STAC_DIGITAL_INPUT_SOURCE(1),
496 STAC_INPUT_SOURCE(2),
499 /* hardware gain controls */
500 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x18, 0x0, HDA_OUTPUT),
501 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x19, 0x0, HDA_OUTPUT),
503 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
504 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
505 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
507 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
508 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
509 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
511 HDA_CODEC_MUTE("Analog Loopback 1", 0x17, 0x3, HDA_INPUT),
512 HDA_CODEC_MUTE("Analog Loopback 2", 0x17, 0x4, HDA_INPUT),
516 static struct snd_kcontrol_new stac925x_mixer[] = {
517 STAC_INPUT_SOURCE(1),
518 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
519 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_OUTPUT),
520 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT),
524 static struct snd_kcontrol_new stac9205_mixer[] = {
525 STAC_DIGITAL_INPUT_SOURCE(1),
526 STAC_INPUT_SOURCE(2),
527 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0),
529 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
530 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
531 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT),
533 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
534 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
535 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT),
540 /* This needs to be generated dynamically based on sequence */
541 static struct snd_kcontrol_new stac922x_mixer[] = {
542 STAC_INPUT_SOURCE(2),
543 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
544 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
545 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT),
547 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
548 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
549 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT),
554 static struct snd_kcontrol_new stac927x_mixer[] = {
555 STAC_DIGITAL_INPUT_SOURCE(1),
556 STAC_INPUT_SOURCE(3),
557 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB),
559 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
560 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
561 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT),
563 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
564 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
565 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT),
567 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
568 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
569 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT),
573 static int stac92xx_build_controls(struct hda_codec *codec)
575 struct sigmatel_spec *spec = codec->spec;
579 err = snd_hda_add_new_ctls(codec, spec->mixer);
583 for (i = 0; i < spec->num_mixers; i++) {
584 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
589 if (spec->multiout.dig_out_nid) {
590 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
594 if (spec->dig_in_nid) {
595 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
602 static unsigned int ref9200_pin_configs[8] = {
603 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
604 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
608 STAC 9200 pin configs for
613 static unsigned int dell9200_d21_pin_configs[8] = {
614 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
615 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
619 STAC 9200 pin configs for
623 static unsigned int dell9200_d22_pin_configs[8] = {
624 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
625 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
629 STAC 9200 pin configs for
630 102801C4 (Dell Dimension E310)
637 static unsigned int dell9200_d23_pin_configs[8] = {
638 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
639 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
644 STAC 9200-32 pin configs for
645 102801B5 (Dell Inspiron 630m)
646 102801D8 (Dell Inspiron 640m)
648 static unsigned int dell9200_m21_pin_configs[8] = {
649 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
650 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
654 STAC 9200-32 pin configs for
655 102801C2 (Dell Latitude D620)
657 102801CC (Dell Latitude D820)
661 static unsigned int dell9200_m22_pin_configs[8] = {
662 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
663 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
667 STAC 9200-32 pin configs for
668 102801CE (Dell XPS M1710)
669 102801CF (Dell Precision M90)
671 static unsigned int dell9200_m23_pin_configs[8] = {
672 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
673 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
677 STAC 9200-32 pin configs for
680 102801CB (Dell Latitude 120L)
683 static unsigned int dell9200_m24_pin_configs[8] = {
684 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
685 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
689 STAC 9200-32 pin configs for
690 102801BD (Dell Inspiron E1505n)
694 static unsigned int dell9200_m25_pin_configs[8] = {
695 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
696 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
700 STAC 9200-32 pin configs for
701 102801F5 (Dell Inspiron 1501)
704 static unsigned int dell9200_m26_pin_configs[8] = {
705 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
706 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
711 102801CD (Dell Inspiron E1705/9400)
713 static unsigned int dell9200_m27_pin_configs[8] = {
714 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
715 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
719 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
720 [STAC_REF] = ref9200_pin_configs,
721 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
722 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
723 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
724 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
725 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
726 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
727 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
728 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
729 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
730 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
733 static const char *stac9200_models[STAC_9200_MODELS] = {
735 [STAC_9200_DELL_D21] = "dell-d21",
736 [STAC_9200_DELL_D22] = "dell-d22",
737 [STAC_9200_DELL_D23] = "dell-d23",
738 [STAC_9200_DELL_M21] = "dell-m21",
739 [STAC_9200_DELL_M22] = "dell-m22",
740 [STAC_9200_DELL_M23] = "dell-m23",
741 [STAC_9200_DELL_M24] = "dell-m24",
742 [STAC_9200_DELL_M25] = "dell-m25",
743 [STAC_9200_DELL_M26] = "dell-m26",
744 [STAC_9200_DELL_M27] = "dell-m27",
745 [STAC_9200_GATEWAY] = "gateway",
748 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
749 /* SigmaTel reference board */
750 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
751 "DFI LanParty", STAC_REF),
752 /* Dell laptops have BIOS problem */
753 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
754 "unknown Dell", STAC_9200_DELL_D21),
755 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
756 "Dell Inspiron 630m", STAC_9200_DELL_M21),
757 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
758 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
759 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
760 "unknown Dell", STAC_9200_DELL_D22),
761 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
762 "unknown Dell", STAC_9200_DELL_D22),
763 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
764 "Dell Latitude D620", STAC_9200_DELL_M22),
765 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
766 "unknown Dell", STAC_9200_DELL_D23),
767 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
768 "unknown Dell", STAC_9200_DELL_D23),
769 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
770 "unknown Dell", STAC_9200_DELL_M22),
771 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
772 "unknown Dell", STAC_9200_DELL_M24),
773 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
774 "unknown Dell", STAC_9200_DELL_M24),
775 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
776 "Dell Latitude 120L", STAC_9200_DELL_M24),
777 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
778 "Dell Latitude D820", STAC_9200_DELL_M22),
779 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
780 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
781 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
782 "Dell XPS M1710", STAC_9200_DELL_M23),
783 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
784 "Dell Precision M90", STAC_9200_DELL_M23),
785 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
786 "unknown Dell", STAC_9200_DELL_M22),
787 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
788 "unknown Dell", STAC_9200_DELL_M22),
789 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
790 "unknown Dell", STAC_9200_DELL_M22),
791 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
792 "Dell Inspiron 640m", STAC_9200_DELL_M21),
793 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
794 "unknown Dell", STAC_9200_DELL_D23),
795 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
796 "unknown Dell", STAC_9200_DELL_D23),
797 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
798 "unknown Dell", STAC_9200_DELL_D21),
799 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
800 "unknown Dell", STAC_9200_DELL_D23),
801 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
802 "unknown Dell", STAC_9200_DELL_D21),
803 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
804 "unknown Dell", STAC_9200_DELL_M25),
805 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
806 "unknown Dell", STAC_9200_DELL_M25),
807 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
808 "Dell Inspiron 1501", STAC_9200_DELL_M26),
809 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
810 "unknown Dell", STAC_9200_DELL_M26),
812 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_REF),
813 /* Gateway machines needs EAPD to be set on resume */
814 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
815 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
817 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
822 static unsigned int ref925x_pin_configs[8] = {
823 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
824 0x90a70320, 0x02214210, 0x400003f1, 0x9033032e,
827 static unsigned int stac925x_MA6_pin_configs[8] = {
828 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
829 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
832 static unsigned int stac925x_PA6_pin_configs[8] = {
833 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
834 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
837 static unsigned int stac925xM2_2_pin_configs[8] = {
838 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
839 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
842 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
843 [STAC_REF] = ref925x_pin_configs,
844 [STAC_M2_2] = stac925xM2_2_pin_configs,
845 [STAC_MA6] = stac925x_MA6_pin_configs,
846 [STAC_PA6] = stac925x_PA6_pin_configs,
849 static const char *stac925x_models[STAC_925x_MODELS] = {
851 [STAC_M2_2] = "m2-2",
856 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
857 /* SigmaTel reference board */
858 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
859 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
860 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
861 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
862 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
863 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
864 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
868 static unsigned int ref92hd71bxx_pin_configs[10] = {
869 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
870 0x0181302e, 0x01114010, 0x01a19020, 0x90a000f0,
871 0x90a000f0, 0x01452050,
874 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
875 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
878 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
879 [STAC_92HD71BXX_REF] = "ref",
882 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
883 /* SigmaTel reference board */
884 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
885 "DFI LanParty", STAC_92HD71BXX_REF),
889 static unsigned int ref922x_pin_configs[10] = {
890 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
891 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
892 0x40000100, 0x40000100,
896 STAC 922X pin configs for
903 static unsigned int dell_922x_d81_pin_configs[10] = {
904 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
905 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
906 0x01813122, 0x400001f2,
910 STAC 922X pin configs for
914 static unsigned int dell_922x_d82_pin_configs[10] = {
915 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
916 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
917 0x01813122, 0x400001f1,
921 STAC 922X pin configs for
924 static unsigned int dell_922x_m81_pin_configs[10] = {
925 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
926 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
927 0x40C003f1, 0x405003f0,
931 STAC 9221 A1 pin configs for
932 102801D7 (Dell XPS M1210)
934 static unsigned int dell_922x_m82_pin_configs[10] = {
935 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
936 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
937 0x508003f3, 0x405003f4,
940 static unsigned int d945gtp3_pin_configs[10] = {
941 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
942 0x40000100, 0x40000100, 0x40000100, 0x40000100,
943 0x02a19120, 0x40000100,
946 static unsigned int d945gtp5_pin_configs[10] = {
947 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
948 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
949 0x02a19320, 0x40000100,
952 static unsigned int intel_mac_v1_pin_configs[10] = {
953 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
954 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
955 0x400000fc, 0x400000fb,
958 static unsigned int intel_mac_v2_pin_configs[10] = {
959 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
960 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
961 0x400000fc, 0x400000fb,
964 static unsigned int intel_mac_v3_pin_configs[10] = {
965 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
966 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
967 0x400000fc, 0x400000fb,
970 static unsigned int intel_mac_v4_pin_configs[10] = {
971 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
972 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
973 0x400000fc, 0x400000fb,
976 static unsigned int intel_mac_v5_pin_configs[10] = {
977 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
978 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
979 0x400000fc, 0x400000fb,
983 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
984 [STAC_D945_REF] = ref922x_pin_configs,
985 [STAC_D945GTP3] = d945gtp3_pin_configs,
986 [STAC_D945GTP5] = d945gtp5_pin_configs,
987 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
988 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
989 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
990 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
991 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
992 /* for backward compatibility */
993 [STAC_MACMINI] = intel_mac_v3_pin_configs,
994 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
995 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
996 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
997 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
998 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
999 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1000 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1001 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1002 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1005 static const char *stac922x_models[STAC_922X_MODELS] = {
1006 [STAC_D945_REF] = "ref",
1007 [STAC_D945GTP5] = "5stack",
1008 [STAC_D945GTP3] = "3stack",
1009 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1010 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1011 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1012 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1013 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1014 /* for backward compatibility */
1015 [STAC_MACMINI] = "macmini",
1016 [STAC_MACBOOK] = "macbook",
1017 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1018 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1019 [STAC_IMAC_INTEL] = "imac-intel",
1020 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1021 [STAC_922X_DELL_D81] = "dell-d81",
1022 [STAC_922X_DELL_D82] = "dell-d82",
1023 [STAC_922X_DELL_M81] = "dell-m81",
1024 [STAC_922X_DELL_M82] = "dell-m82",
1027 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1028 /* SigmaTel reference board */
1029 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1030 "DFI LanParty", STAC_D945_REF),
1031 /* Intel 945G based systems */
1032 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1033 "Intel D945G", STAC_D945GTP3),
1034 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1035 "Intel D945G", STAC_D945GTP3),
1036 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1037 "Intel D945G", STAC_D945GTP3),
1038 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1039 "Intel D945G", STAC_D945GTP3),
1040 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1041 "Intel D945G", STAC_D945GTP3),
1042 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1043 "Intel D945G", STAC_D945GTP3),
1044 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1045 "Intel D945G", STAC_D945GTP3),
1046 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1047 "Intel D945G", STAC_D945GTP3),
1048 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1049 "Intel D945G", STAC_D945GTP3),
1050 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1051 "Intel D945G", STAC_D945GTP3),
1052 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1053 "Intel D945G", STAC_D945GTP3),
1054 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1055 "Intel D945G", STAC_D945GTP3),
1056 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1057 "Intel D945G", STAC_D945GTP3),
1058 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1059 "Intel D945G", STAC_D945GTP3),
1060 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1061 "Intel D945G", STAC_D945GTP3),
1062 /* Intel D945G 5-stack systems */
1063 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1064 "Intel D945G", STAC_D945GTP5),
1065 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1066 "Intel D945G", STAC_D945GTP5),
1067 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1068 "Intel D945G", STAC_D945GTP5),
1069 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1070 "Intel D945G", STAC_D945GTP5),
1071 /* Intel 945P based systems */
1072 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1073 "Intel D945P", STAC_D945GTP3),
1074 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1075 "Intel D945P", STAC_D945GTP3),
1076 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1077 "Intel D945P", STAC_D945GTP3),
1078 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1079 "Intel D945P", STAC_D945GTP3),
1080 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1081 "Intel D945P", STAC_D945GTP3),
1082 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1083 "Intel D945P", STAC_D945GTP5),
1085 /* Apple Mac Mini (early 2006) */
1086 SND_PCI_QUIRK(0x8384, 0x7680,
1087 "Mac Mini", STAC_INTEL_MAC_V3),
1089 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1090 "unknown Dell", STAC_922X_DELL_D81),
1091 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1092 "unknown Dell", STAC_922X_DELL_D81),
1093 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1094 "unknown Dell", STAC_922X_DELL_D81),
1095 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1096 "unknown Dell", STAC_922X_DELL_D82),
1097 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1098 "unknown Dell", STAC_922X_DELL_M81),
1099 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1100 "unknown Dell", STAC_922X_DELL_D82),
1101 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1102 "unknown Dell", STAC_922X_DELL_D81),
1103 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1104 "unknown Dell", STAC_922X_DELL_D81),
1105 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1106 "Dell XPS M1210", STAC_922X_DELL_M82),
1110 static unsigned int ref927x_pin_configs[14] = {
1111 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1112 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1113 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1114 0x01c42190, 0x40000100,
1117 static unsigned int d965_3st_pin_configs[14] = {
1118 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
1119 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
1120 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1121 0x40000100, 0x40000100
1124 static unsigned int d965_5st_pin_configs[14] = {
1125 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1126 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
1127 0x40000100, 0x40000100, 0x40000100, 0x01442070,
1128 0x40000100, 0x40000100
1131 static unsigned int dell_3st_pin_configs[14] = {
1132 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
1133 0x01111212, 0x01116211, 0x01813050, 0x01112214,
1134 0x403003fa, 0x40000100, 0x40000100, 0x404003fb,
1135 0x40c003fc, 0x40000100
1138 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
1139 [STAC_D965_REF] = ref927x_pin_configs,
1140 [STAC_D965_3ST] = d965_3st_pin_configs,
1141 [STAC_D965_5ST] = d965_5st_pin_configs,
1142 [STAC_DELL_3ST] = dell_3st_pin_configs,
1145 static const char *stac927x_models[STAC_927X_MODELS] = {
1146 [STAC_D965_REF] = "ref",
1147 [STAC_D965_3ST] = "3stack",
1148 [STAC_D965_5ST] = "5stack",
1149 [STAC_DELL_3ST] = "dell-3stack",
1152 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
1153 /* SigmaTel reference board */
1154 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1155 "DFI LanParty", STAC_D965_REF),
1156 /* Intel 946 based systems */
1157 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
1158 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
1159 /* 965 based 3 stack systems */
1160 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
1161 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
1162 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
1163 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
1164 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
1165 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
1166 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
1167 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
1168 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
1169 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
1170 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
1171 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
1172 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
1173 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
1174 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
1175 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
1176 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_D965_3ST),
1177 /* Dell 3 stack systems */
1178 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
1179 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
1180 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
1181 /* 965 based 5 stack systems */
1182 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_D965_5ST),
1183 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
1184 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
1185 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
1186 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
1187 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
1188 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
1189 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
1190 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
1191 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
1195 static unsigned int ref9205_pin_configs[12] = {
1196 0x40000100, 0x40000100, 0x01016011, 0x01014010,
1197 0x01813122, 0x01a19021, 0x40000100, 0x40000100,
1198 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
1202 STAC 9205 pin configs for
1210 static unsigned int dell_9205_m42_pin_configs[12] = {
1211 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
1212 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
1213 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
1217 STAC 9205 pin configs for
1221 102801FF (Dell Precision M4300)
1226 static unsigned int dell_9205_m43_pin_configs[12] = {
1227 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
1228 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
1229 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
1232 static unsigned int dell_9205_m44_pin_configs[12] = {
1233 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
1234 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
1235 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
1238 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
1239 [STAC_9205_REF] = ref9205_pin_configs,
1240 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
1241 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
1242 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
1245 static const char *stac9205_models[STAC_9205_MODELS] = {
1246 [STAC_9205_REF] = "ref",
1247 [STAC_9205_DELL_M42] = "dell-m42",
1248 [STAC_9205_DELL_M43] = "dell-m43",
1249 [STAC_9205_DELL_M44] = "dell-m44",
1252 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
1253 /* SigmaTel reference board */
1254 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1255 "DFI LanParty", STAC_9205_REF),
1256 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1257 "unknown Dell", STAC_9205_DELL_M42),
1258 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1259 "unknown Dell", STAC_9205_DELL_M42),
1260 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
1261 "Dell Precision", STAC_9205_DELL_M43),
1262 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
1263 "Dell Precision", STAC_9205_DELL_M43),
1264 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
1265 "Dell Precision", STAC_9205_DELL_M43),
1266 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
1267 "Dell Precision", STAC_9205_DELL_M43),
1268 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
1269 "Dell Precision", STAC_9205_DELL_M43),
1270 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1271 "unknown Dell", STAC_9205_DELL_M42),
1272 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1273 "unknown Dell", STAC_9205_DELL_M42),
1274 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
1275 "Dell Precision", STAC_9205_DELL_M43),
1276 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
1277 "Dell Precision M4300", STAC_9205_DELL_M43),
1278 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
1279 "Dell Precision", STAC_9205_DELL_M43),
1280 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1281 "Dell Inspiron", STAC_9205_DELL_M44),
1282 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1283 "Dell Inspiron", STAC_9205_DELL_M44),
1284 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1285 "Dell Inspiron", STAC_9205_DELL_M44),
1286 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1287 "Dell Inspiron", STAC_9205_DELL_M44),
1288 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
1289 "unknown Dell", STAC_9205_DELL_M42),
1290 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
1291 "Dell Inspiron", STAC_9205_DELL_M44),
1295 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
1298 struct sigmatel_spec *spec = codec->spec;
1300 if (! spec->bios_pin_configs) {
1301 spec->bios_pin_configs = kcalloc(spec->num_pins,
1302 sizeof(*spec->bios_pin_configs), GFP_KERNEL);
1303 if (! spec->bios_pin_configs)
1307 for (i = 0; i < spec->num_pins; i++) {
1308 hda_nid_t nid = spec->pin_nids[i];
1309 unsigned int pin_cfg;
1311 pin_cfg = snd_hda_codec_read(codec, nid, 0,
1312 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
1313 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
1315 spec->bios_pin_configs[i] = pin_cfg;
1321 static void stac92xx_set_config_reg(struct hda_codec *codec,
1322 hda_nid_t pin_nid, unsigned int pin_config)
1325 snd_hda_codec_write(codec, pin_nid, 0,
1326 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
1327 pin_config & 0x000000ff);
1328 snd_hda_codec_write(codec, pin_nid, 0,
1329 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
1330 (pin_config & 0x0000ff00) >> 8);
1331 snd_hda_codec_write(codec, pin_nid, 0,
1332 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
1333 (pin_config & 0x00ff0000) >> 16);
1334 snd_hda_codec_write(codec, pin_nid, 0,
1335 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
1337 i = snd_hda_codec_read(codec, pin_nid, 0,
1338 AC_VERB_GET_CONFIG_DEFAULT,
1340 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
1344 static void stac92xx_set_config_regs(struct hda_codec *codec)
1347 struct sigmatel_spec *spec = codec->spec;
1349 if (!spec->pin_configs)
1352 for (i = 0; i < spec->num_pins; i++)
1353 stac92xx_set_config_reg(codec, spec->pin_nids[i],
1354 spec->pin_configs[i]);
1357 static void stac92xx_enable_gpio_mask(struct hda_codec *codec)
1359 struct sigmatel_spec *spec = codec->spec;
1360 /* Configure GPIOx as output */
1361 snd_hda_codec_write_cache(codec, codec->afg, 0,
1362 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_mask);
1363 /* Configure GPIOx as CMOS */
1364 snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7e7, 0x00000000);
1366 snd_hda_codec_write_cache(codec, codec->afg, 0,
1367 AC_VERB_SET_GPIO_DATA, spec->gpio_data);
1369 snd_hda_codec_write_cache(codec, codec->afg, 0,
1370 AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
1374 * Analog playback callbacks
1376 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
1377 struct hda_codec *codec,
1378 struct snd_pcm_substream *substream)
1380 struct sigmatel_spec *spec = codec->spec;
1381 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
1384 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1385 struct hda_codec *codec,
1386 unsigned int stream_tag,
1387 unsigned int format,
1388 struct snd_pcm_substream *substream)
1390 struct sigmatel_spec *spec = codec->spec;
1391 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
1394 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1395 struct hda_codec *codec,
1396 struct snd_pcm_substream *substream)
1398 struct sigmatel_spec *spec = codec->spec;
1399 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1403 * Digital playback callbacks
1405 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1406 struct hda_codec *codec,
1407 struct snd_pcm_substream *substream)
1409 struct sigmatel_spec *spec = codec->spec;
1410 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1413 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1414 struct hda_codec *codec,
1415 struct snd_pcm_substream *substream)
1417 struct sigmatel_spec *spec = codec->spec;
1418 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1421 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1422 struct hda_codec *codec,
1423 unsigned int stream_tag,
1424 unsigned int format,
1425 struct snd_pcm_substream *substream)
1427 struct sigmatel_spec *spec = codec->spec;
1428 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1429 stream_tag, format, substream);
1434 * Analog capture callbacks
1436 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1437 struct hda_codec *codec,
1438 unsigned int stream_tag,
1439 unsigned int format,
1440 struct snd_pcm_substream *substream)
1442 struct sigmatel_spec *spec = codec->spec;
1444 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1445 stream_tag, 0, format);
1449 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1450 struct hda_codec *codec,
1451 struct snd_pcm_substream *substream)
1453 struct sigmatel_spec *spec = codec->spec;
1455 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
1459 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
1463 /* NID is set in stac92xx_build_pcms */
1465 .open = stac92xx_dig_playback_pcm_open,
1466 .close = stac92xx_dig_playback_pcm_close,
1467 .prepare = stac92xx_dig_playback_pcm_prepare
1471 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
1475 /* NID is set in stac92xx_build_pcms */
1478 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
1482 .nid = 0x02, /* NID to query formats and rates */
1484 .open = stac92xx_playback_pcm_open,
1485 .prepare = stac92xx_playback_pcm_prepare,
1486 .cleanup = stac92xx_playback_pcm_cleanup
1490 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
1494 .nid = 0x06, /* NID to query formats and rates */
1496 .open = stac92xx_playback_pcm_open,
1497 .prepare = stac92xx_playback_pcm_prepare,
1498 .cleanup = stac92xx_playback_pcm_cleanup
1502 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
1505 /* NID + .substreams is set in stac92xx_build_pcms */
1507 .prepare = stac92xx_capture_pcm_prepare,
1508 .cleanup = stac92xx_capture_pcm_cleanup
1512 static int stac92xx_build_pcms(struct hda_codec *codec)
1514 struct sigmatel_spec *spec = codec->spec;
1515 struct hda_pcm *info = spec->pcm_rec;
1517 codec->num_pcms = 1;
1518 codec->pcm_info = info;
1520 info->name = "STAC92xx Analog";
1521 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
1522 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
1523 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1524 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
1526 if (spec->alt_switch) {
1529 info->name = "STAC92xx Analog Alt";
1530 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
1533 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1536 info->name = "STAC92xx Digital";
1537 if (spec->multiout.dig_out_nid) {
1538 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
1539 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
1541 if (spec->dig_in_nid) {
1542 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
1543 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
1550 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
1552 unsigned int pincap = snd_hda_param_read(codec, nid,
1554 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
1555 if (pincap & AC_PINCAP_VREF_100)
1556 return AC_PINCTL_VREF_100;
1557 if (pincap & AC_PINCAP_VREF_80)
1558 return AC_PINCTL_VREF_80;
1559 if (pincap & AC_PINCAP_VREF_50)
1560 return AC_PINCTL_VREF_50;
1561 if (pincap & AC_PINCAP_VREF_GRD)
1562 return AC_PINCTL_VREF_GRD;
1566 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
1569 snd_hda_codec_write_cache(codec, nid, 0,
1570 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
1573 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
1575 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1577 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1578 struct sigmatel_spec *spec = codec->spec;
1579 int io_idx = kcontrol-> private_value & 0xff;
1581 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
1585 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1587 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1588 struct sigmatel_spec *spec = codec->spec;
1589 hda_nid_t nid = kcontrol->private_value >> 8;
1590 int io_idx = kcontrol-> private_value & 0xff;
1591 unsigned short val = ucontrol->value.integer.value[0];
1593 spec->io_switch[io_idx] = val;
1596 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
1598 unsigned int pinctl = AC_PINCTL_IN_EN;
1599 if (io_idx) /* set VREF for mic */
1600 pinctl |= stac92xx_get_vref(codec, nid);
1601 stac92xx_auto_set_pinctl(codec, nid, pinctl);
1604 /* check the auto-mute again: we need to mute/unmute the speaker
1605 * appropriately according to the pin direction
1607 if (spec->hp_detect)
1608 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
1613 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
1615 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
1616 struct snd_ctl_elem_value *ucontrol)
1618 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1619 struct sigmatel_spec *spec = codec->spec;
1621 ucontrol->value.integer.value[0] = spec->clfe_swap;
1625 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
1626 struct snd_ctl_elem_value *ucontrol)
1628 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1629 struct sigmatel_spec *spec = codec->spec;
1630 hda_nid_t nid = kcontrol->private_value & 0xff;
1632 if (spec->clfe_swap == ucontrol->value.integer.value[0])
1635 spec->clfe_swap = ucontrol->value.integer.value[0];
1637 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1638 spec->clfe_swap ? 0x4 : 0x0);
1643 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
1644 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1647 .info = stac92xx_io_switch_info, \
1648 .get = stac92xx_io_switch_get, \
1649 .put = stac92xx_io_switch_put, \
1650 .private_value = xpval, \
1653 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
1654 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1657 .info = stac92xx_clfe_switch_info, \
1658 .get = stac92xx_clfe_switch_get, \
1659 .put = stac92xx_clfe_switch_put, \
1660 .private_value = xpval, \
1664 STAC_CTL_WIDGET_VOL,
1665 STAC_CTL_WIDGET_MUTE,
1666 STAC_CTL_WIDGET_IO_SWITCH,
1667 STAC_CTL_WIDGET_CLFE_SWITCH
1670 static struct snd_kcontrol_new stac92xx_control_templates[] = {
1671 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
1672 HDA_CODEC_MUTE(NULL, 0, 0, 0),
1673 STAC_CODEC_IO_SWITCH(NULL, 0),
1674 STAC_CODEC_CLFE_SWITCH(NULL, 0),
1677 /* add dynamic controls */
1678 static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val)
1680 struct snd_kcontrol_new *knew;
1682 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
1683 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
1685 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
1688 if (spec->kctl_alloc) {
1689 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
1690 kfree(spec->kctl_alloc);
1692 spec->kctl_alloc = knew;
1693 spec->num_kctl_alloc = num;
1696 knew = &spec->kctl_alloc[spec->num_kctl_used];
1697 *knew = stac92xx_control_templates[type];
1698 knew->name = kstrdup(name, GFP_KERNEL);
1701 knew->private_value = val;
1702 spec->num_kctl_used++;
1706 /* flag inputs as additional dynamic lineouts */
1707 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
1709 struct sigmatel_spec *spec = codec->spec;
1710 unsigned int wcaps, wtype;
1711 int i, num_dacs = 0;
1713 /* use the wcaps cache to count all DACs available for line-outs */
1714 for (i = 0; i < codec->num_nodes; i++) {
1715 wcaps = codec->wcaps[i];
1716 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
1717 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
1721 snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
1723 switch (cfg->line_outs) {
1725 /* add line-in as side */
1726 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
1727 cfg->line_out_pins[cfg->line_outs] =
1728 cfg->input_pins[AUTO_PIN_LINE];
1729 spec->line_switch = 1;
1734 /* add line-in as clfe and mic as side */
1735 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
1736 cfg->line_out_pins[cfg->line_outs] =
1737 cfg->input_pins[AUTO_PIN_LINE];
1738 spec->line_switch = 1;
1741 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
1742 cfg->line_out_pins[cfg->line_outs] =
1743 cfg->input_pins[AUTO_PIN_MIC];
1744 spec->mic_switch = 1;
1749 /* add line-in as surr and mic as clfe */
1750 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
1751 cfg->line_out_pins[cfg->line_outs] =
1752 cfg->input_pins[AUTO_PIN_LINE];
1753 spec->line_switch = 1;
1756 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
1757 cfg->line_out_pins[cfg->line_outs] =
1758 cfg->input_pins[AUTO_PIN_MIC];
1759 spec->mic_switch = 1;
1769 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
1773 for (i = 0; i < spec->multiout.num_dacs; i++) {
1774 if (spec->multiout.dac_nids[i] == nid)
1782 * Fill in the dac_nids table from the parsed pin configuration
1783 * This function only works when every pin in line_out_pins[]
1784 * contains atleast one DAC in its connection list. Some 92xx
1785 * codecs are not connected directly to a DAC, such as the 9200
1786 * and 9202/925x. For those, dac_nids[] must be hard-coded.
1788 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
1789 struct auto_pin_cfg *cfg)
1791 struct sigmatel_spec *spec = codec->spec;
1792 int i, j, conn_len = 0;
1793 hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
1794 unsigned int wcaps, wtype;
1796 for (i = 0; i < cfg->line_outs; i++) {
1797 nid = cfg->line_out_pins[i];
1798 conn_len = snd_hda_get_connections(codec, nid, conn,
1799 HDA_MAX_CONNECTIONS);
1800 for (j = 0; j < conn_len; j++) {
1801 wcaps = snd_hda_param_read(codec, conn[j],
1802 AC_PAR_AUDIO_WIDGET_CAP);
1803 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
1805 if (wtype != AC_WID_AUD_OUT ||
1806 (wcaps & AC_WCAP_DIGITAL))
1808 /* conn[j] is a DAC routed to this line-out */
1809 if (!is_in_dac_nids(spec, conn[j]))
1813 if (j == conn_len) {
1814 if (spec->multiout.num_dacs > 0) {
1815 /* we have already working output pins,
1816 * so let's drop the broken ones again
1818 cfg->line_outs = spec->multiout.num_dacs;
1821 /* error out, no available DAC found */
1823 "%s: No available DAC for pin 0x%x\n",
1828 spec->multiout.dac_nids[i] = conn[j];
1829 spec->multiout.num_dacs++;
1831 /* select this DAC in the pin's input mux */
1832 snd_hda_codec_write_cache(codec, nid, 0,
1833 AC_VERB_SET_CONNECT_SEL, j);
1838 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
1839 spec->multiout.num_dacs,
1840 spec->multiout.dac_nids[0],
1841 spec->multiout.dac_nids[1],
1842 spec->multiout.dac_nids[2],
1843 spec->multiout.dac_nids[3],
1844 spec->multiout.dac_nids[4]);
1848 /* create volume control/switch for the given prefx type */
1849 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
1854 sprintf(name, "%s Playback Volume", pfx);
1855 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
1856 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1859 sprintf(name, "%s Playback Switch", pfx);
1860 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
1861 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1867 /* add playback controls from the parsed DAC table */
1868 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
1869 const struct auto_pin_cfg *cfg)
1871 static const char *chname[4] = {
1872 "Front", "Surround", NULL /*CLFE*/, "Side"
1877 struct sigmatel_spec *spec = codec->spec;
1878 unsigned int wid_caps;
1881 for (i = 0; i < cfg->line_outs; i++) {
1882 if (!spec->multiout.dac_nids[i])
1885 nid = spec->multiout.dac_nids[i];
1889 err = create_controls(spec, "Center", nid, 1);
1892 err = create_controls(spec, "LFE", nid, 2);
1896 wid_caps = get_wcaps(codec, nid);
1898 if (wid_caps & AC_WCAP_LR_SWAP) {
1899 err = stac92xx_add_control(spec,
1900 STAC_CTL_WIDGET_CLFE_SWITCH,
1901 "Swap Center/LFE Playback Switch", nid);
1908 err = create_controls(spec, chname[i], nid, 3);
1914 if (spec->line_switch)
1915 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Line In as Output Switch", cfg->input_pins[AUTO_PIN_LINE] << 8)) < 0)
1918 if (spec->mic_switch)
1919 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Mic as Output Switch", (cfg->input_pins[AUTO_PIN_MIC] << 8) | 1)) < 0)
1925 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
1927 if (is_in_dac_nids(spec, nid))
1929 if (spec->multiout.hp_nid == nid)
1934 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
1936 if (!spec->multiout.hp_nid)
1937 spec->multiout.hp_nid = nid;
1938 else if (spec->multiout.num_dacs > 4) {
1939 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
1942 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
1943 spec->multiout.num_dacs++;
1948 /* add playback controls for Speaker and HP outputs */
1949 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
1950 struct auto_pin_cfg *cfg)
1952 struct sigmatel_spec *spec = codec->spec;
1954 int i, old_num_dacs, err;
1956 old_num_dacs = spec->multiout.num_dacs;
1957 for (i = 0; i < cfg->hp_outs; i++) {
1958 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
1959 if (wid_caps & AC_WCAP_UNSOL_CAP)
1960 spec->hp_detect = 1;
1961 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
1962 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
1963 if (check_in_dac_nids(spec, nid))
1967 add_spec_dacs(spec, nid);
1969 for (i = 0; i < cfg->speaker_outs; i++) {
1970 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
1971 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
1972 if (check_in_dac_nids(spec, nid))
1976 add_spec_dacs(spec, nid);
1978 for (i = 0; i < cfg->line_outs; i++) {
1979 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
1980 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
1981 if (check_in_dac_nids(spec, nid))
1985 add_spec_dacs(spec, nid);
1987 for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
1988 static const char *pfxs[] = {
1989 "Speaker", "External Speaker", "Speaker2",
1991 err = create_controls(spec, pfxs[i - old_num_dacs],
1992 spec->multiout.dac_nids[i], 3);
1996 if (spec->multiout.hp_nid) {
1998 if (old_num_dacs == spec->multiout.num_dacs)
2002 err = create_controls(spec, pfx, spec->multiout.hp_nid, 3);
2010 /* labels for dmic mux inputs */
2011 static const char *stac92xx_dmic_labels[5] = {
2012 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
2013 "Digital Mic 3", "Digital Mic 4"
2016 /* create playback/capture controls for input pins on dmic capable codecs */
2017 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
2018 const struct auto_pin_cfg *cfg)
2020 struct sigmatel_spec *spec = codec->spec;
2021 struct hda_input_mux *dimux = &spec->private_dimux;
2022 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2025 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
2026 dimux->items[dimux->num_items].index = 0;
2029 for (i = 0; i < spec->num_dmics; i++) {
2032 unsigned int def_conf;
2034 def_conf = snd_hda_codec_read(codec,
2037 AC_VERB_GET_CONFIG_DEFAULT,
2039 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
2042 num_cons = snd_hda_get_connections(codec,
2045 HDA_MAX_NUM_INPUTS);
2046 for (j = 0; j < num_cons; j++)
2047 if (con_lst[j] == spec->dmic_nids[i]) {
2053 dimux->items[dimux->num_items].label =
2054 stac92xx_dmic_labels[dimux->num_items];
2055 dimux->items[dimux->num_items].index = index;
2062 /* create playback/capture controls for input pins */
2063 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
2065 struct sigmatel_spec *spec = codec->spec;
2066 struct hda_input_mux *imux = &spec->private_imux;
2067 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2070 for (i = 0; i < AUTO_PIN_LAST; i++) {
2073 if (!cfg->input_pins[i])
2076 for (j = 0; j < spec->num_muxes; j++) {
2078 num_cons = snd_hda_get_connections(codec,
2081 HDA_MAX_NUM_INPUTS);
2082 for (k = 0; k < num_cons; k++)
2083 if (con_lst[k] == cfg->input_pins[i]) {
2090 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2091 imux->items[imux->num_items].index = index;
2095 if (imux->num_items) {
2097 * Set the current input for the muxes.
2098 * The STAC9221 has two input muxes with identical source
2099 * NID lists. Hopefully this won't get confused.
2101 for (i = 0; i < spec->num_muxes; i++) {
2102 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
2103 AC_VERB_SET_CONNECT_SEL,
2104 imux->items[0].index);
2111 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
2113 struct sigmatel_spec *spec = codec->spec;
2116 for (i = 0; i < spec->autocfg.line_outs; i++) {
2117 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2118 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2122 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
2124 struct sigmatel_spec *spec = codec->spec;
2127 for (i = 0; i < spec->autocfg.hp_outs; i++) {
2129 pin = spec->autocfg.hp_pins[i];
2130 if (pin) /* connect to front */
2131 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
2133 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
2135 pin = spec->autocfg.speaker_pins[i];
2136 if (pin) /* connect to front */
2137 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
2141 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
2143 struct sigmatel_spec *spec = codec->spec;
2145 int hp_speaker_swap = 0;
2147 if ((err = snd_hda_parse_pin_def_config(codec,
2149 spec->dmic_nids)) < 0)
2151 if (! spec->autocfg.line_outs)
2152 return 0; /* can't find valid pin config */
2154 /* If we have no real line-out pin and multiple hp-outs, HPs should
2155 * be set up as multi-channel outputs.
2157 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
2158 spec->autocfg.hp_outs > 1) {
2159 /* Copy hp_outs to line_outs, backup line_outs in
2160 * speaker_outs so that the following routines can handle
2161 * HP pins as primary outputs.
2163 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
2164 sizeof(spec->autocfg.line_out_pins));
2165 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
2166 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
2167 sizeof(spec->autocfg.hp_pins));
2168 spec->autocfg.line_outs = spec->autocfg.hp_outs;
2169 hp_speaker_swap = 1;
2172 if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
2174 if (spec->multiout.num_dacs == 0)
2175 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2178 err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
2183 if (hp_speaker_swap == 1) {
2184 /* Restore the hp_outs and line_outs */
2185 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
2186 sizeof(spec->autocfg.line_out_pins));
2187 spec->autocfg.hp_outs = spec->autocfg.line_outs;
2188 memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins,
2189 sizeof(spec->autocfg.speaker_pins));
2190 spec->autocfg.line_outs = spec->autocfg.speaker_outs;
2191 memset(spec->autocfg.speaker_pins, 0,
2192 sizeof(spec->autocfg.speaker_pins));
2193 spec->autocfg.speaker_outs = 0;
2196 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
2201 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
2206 if (spec->num_dmics > 0)
2207 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
2208 &spec->autocfg)) < 0)
2211 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2212 if (spec->multiout.max_channels > 2)
2213 spec->surr_switch = 1;
2215 if (spec->autocfg.dig_out_pin)
2216 spec->multiout.dig_out_nid = dig_out;
2217 if (spec->autocfg.dig_in_pin)
2218 spec->dig_in_nid = dig_in;
2220 if (spec->kctl_alloc)
2221 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2223 spec->input_mux = &spec->private_imux;
2224 spec->dinput_mux = &spec->private_dimux;
2229 /* add playback controls for HP output */
2230 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
2231 struct auto_pin_cfg *cfg)
2233 struct sigmatel_spec *spec = codec->spec;
2234 hda_nid_t pin = cfg->hp_pins[0];
2235 unsigned int wid_caps;
2240 wid_caps = get_wcaps(codec, pin);
2241 if (wid_caps & AC_WCAP_UNSOL_CAP)
2242 spec->hp_detect = 1;
2247 /* add playback controls for LFE output */
2248 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
2249 struct auto_pin_cfg *cfg)
2251 struct sigmatel_spec *spec = codec->spec;
2253 hda_nid_t lfe_pin = 0x0;
2257 * search speaker outs and line outs for a mono speaker pin
2258 * with an amp. If one is found, add LFE controls
2261 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
2262 hda_nid_t pin = spec->autocfg.speaker_pins[i];
2263 unsigned long wcaps = get_wcaps(codec, pin);
2264 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2265 if (wcaps == AC_WCAP_OUT_AMP)
2266 /* found a mono speaker with an amp, must be lfe */
2270 /* if speaker_outs is 0, then speakers may be in line_outs */
2271 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
2272 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
2273 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2275 cfg = snd_hda_codec_read(codec, pin, 0,
2276 AC_VERB_GET_CONFIG_DEFAULT,
2278 if (get_defcfg_device(cfg) == AC_JACK_SPEAKER) {
2279 unsigned long wcaps = get_wcaps(codec, pin);
2280 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2281 if (wcaps == AC_WCAP_OUT_AMP)
2282 /* found a mono speaker with an amp,
2290 err = create_controls(spec, "LFE", lfe_pin, 1);
2298 static int stac9200_parse_auto_config(struct hda_codec *codec)
2300 struct sigmatel_spec *spec = codec->spec;
2303 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2306 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
2309 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
2312 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
2315 if (spec->autocfg.dig_out_pin)
2316 spec->multiout.dig_out_nid = 0x05;
2317 if (spec->autocfg.dig_in_pin)
2318 spec->dig_in_nid = 0x04;
2320 if (spec->kctl_alloc)
2321 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2323 spec->input_mux = &spec->private_imux;
2324 spec->dinput_mux = &spec->private_dimux;
2330 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
2331 * funky external mute control using GPIO pins.
2334 static void stac922x_gpio_mute(struct hda_codec *codec, int pin, int muted)
2336 unsigned int gpiostate, gpiomask, gpiodir;
2338 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
2339 AC_VERB_GET_GPIO_DATA, 0);
2342 gpiostate |= (1 << pin);
2344 gpiostate &= ~(1 << pin);
2346 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
2347 AC_VERB_GET_GPIO_MASK, 0);
2348 gpiomask |= (1 << pin);
2350 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
2351 AC_VERB_GET_GPIO_DIRECTION, 0);
2352 gpiodir |= (1 << pin);
2354 /* AppleHDA seems to do this -- WTF is this verb?? */
2355 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
2357 snd_hda_codec_write(codec, codec->afg, 0,
2358 AC_VERB_SET_GPIO_MASK, gpiomask);
2359 snd_hda_codec_write(codec, codec->afg, 0,
2360 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
2364 snd_hda_codec_write(codec, codec->afg, 0,
2365 AC_VERB_SET_GPIO_DATA, gpiostate);
2368 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
2371 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
2372 snd_hda_codec_write_cache(codec, nid, 0,
2373 AC_VERB_SET_UNSOLICITED_ENABLE,
2374 (AC_USRSP_EN | event));
2377 static int stac92xx_init(struct hda_codec *codec)
2379 struct sigmatel_spec *spec = codec->spec;
2380 struct auto_pin_cfg *cfg = &spec->autocfg;
2383 snd_hda_sequence_write(codec, spec->init);
2386 if (spec->hp_detect) {
2387 /* Enable unsolicited responses on the HP widget */
2388 for (i = 0; i < cfg->hp_outs; i++)
2389 enable_pin_detect(codec, cfg->hp_pins[i],
2391 /* force to enable the first line-out; the others are set up
2394 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
2396 stac92xx_auto_init_hp_out(codec);
2397 /* fake event to set up pins */
2398 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2400 stac92xx_auto_init_multi_out(codec);
2401 stac92xx_auto_init_hp_out(codec);
2403 for (i = 0; i < AUTO_PIN_LAST; i++) {
2404 hda_nid_t nid = cfg->input_pins[i];
2406 unsigned int pinctl = AC_PINCTL_IN_EN;
2407 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
2408 pinctl |= stac92xx_get_vref(codec, nid);
2409 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2412 if (spec->num_dmics > 0)
2413 for (i = 0; i < spec->num_dmics; i++)
2414 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
2417 if (cfg->dig_out_pin)
2418 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
2420 if (cfg->dig_in_pin)
2421 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
2424 if (spec->gpio_mute) {
2425 stac922x_gpio_mute(codec, 0, 0);
2426 stac922x_gpio_mute(codec, 1, 0);
2432 static void stac92xx_free(struct hda_codec *codec)
2434 struct sigmatel_spec *spec = codec->spec;
2440 if (spec->kctl_alloc) {
2441 for (i = 0; i < spec->num_kctl_used; i++)
2442 kfree(spec->kctl_alloc[i].name);
2443 kfree(spec->kctl_alloc);
2446 if (spec->bios_pin_configs)
2447 kfree(spec->bios_pin_configs);
2452 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
2455 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2456 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2458 if (pin_ctl & AC_PINCTL_IN_EN) {
2460 * we need to check the current set-up direction of
2461 * shared input pins since they can be switched via
2462 * "xxx as Output" mixer switch
2464 struct sigmatel_spec *spec = codec->spec;
2465 struct auto_pin_cfg *cfg = &spec->autocfg;
2466 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
2467 spec->line_switch) ||
2468 (nid == cfg->input_pins[AUTO_PIN_MIC] &&
2473 /* if setting pin direction bits, clear the current
2474 direction bits first */
2475 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
2476 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
2478 snd_hda_codec_write_cache(codec, nid, 0,
2479 AC_VERB_SET_PIN_WIDGET_CONTROL,
2483 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
2486 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2487 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2488 snd_hda_codec_write_cache(codec, nid, 0,
2489 AC_VERB_SET_PIN_WIDGET_CONTROL,
2493 static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid)
2497 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
2499 unsigned int pinctl;
2500 pinctl = snd_hda_codec_read(codec, nid, 0,
2501 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2502 if (pinctl & AC_PINCTL_IN_EN)
2503 return 0; /* mic- or line-input */
2505 return 1; /* HP-output */
2510 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
2512 struct sigmatel_spec *spec = codec->spec;
2513 struct auto_pin_cfg *cfg = &spec->autocfg;
2517 for (i = 0; i < cfg->hp_outs; i++) {
2518 presence = get_hp_pin_presence(codec, cfg->hp_pins[i]);
2524 /* disable lineouts, enable hp */
2525 for (i = 0; i < cfg->line_outs; i++)
2526 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
2528 for (i = 0; i < cfg->speaker_outs; i++)
2529 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
2532 /* enable lineouts, disable hp */
2533 for (i = 0; i < cfg->line_outs; i++)
2534 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
2536 for (i = 0; i < cfg->speaker_outs; i++)
2537 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
2542 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
2544 switch (res >> 26) {
2546 stac92xx_hp_detect(codec, res);
2551 #ifdef SND_HDA_NEEDS_RESUME
2552 static int stac92xx_resume(struct hda_codec *codec)
2554 struct sigmatel_spec *spec = codec->spec;
2556 stac92xx_set_config_regs(codec);
2557 snd_hda_sequence_write(codec, spec->init);
2558 if (spec->gpio_mute) {
2559 stac922x_gpio_mute(codec, 0, 0);
2560 stac922x_gpio_mute(codec, 1, 0);
2562 snd_hda_codec_resume_amp(codec);
2563 snd_hda_codec_resume_cache(codec);
2564 /* invoke unsolicited event to reset the HP state */
2565 if (spec->hp_detect)
2566 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2571 static struct hda_codec_ops stac92xx_patch_ops = {
2572 .build_controls = stac92xx_build_controls,
2573 .build_pcms = stac92xx_build_pcms,
2574 .init = stac92xx_init,
2575 .free = stac92xx_free,
2576 .unsol_event = stac92xx_unsol_event,
2577 #ifdef SND_HDA_NEEDS_RESUME
2578 .resume = stac92xx_resume,
2582 static int patch_stac9200(struct hda_codec *codec)
2584 struct sigmatel_spec *spec;
2587 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2592 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
2593 spec->pin_nids = stac9200_pin_nids;
2594 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
2597 if (spec->board_config < 0) {
2598 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
2599 err = stac92xx_save_bios_config_regs(codec);
2601 stac92xx_free(codec);
2604 spec->pin_configs = spec->bios_pin_configs;
2606 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
2607 stac92xx_set_config_regs(codec);
2610 spec->multiout.max_channels = 2;
2611 spec->multiout.num_dacs = 1;
2612 spec->multiout.dac_nids = stac9200_dac_nids;
2613 spec->adc_nids = stac9200_adc_nids;
2614 spec->mux_nids = stac9200_mux_nids;
2615 spec->num_muxes = 1;
2616 spec->num_dmics = 0;
2619 if (spec->board_config == STAC_9200_GATEWAY)
2620 spec->init = stac9200_eapd_init;
2622 spec->init = stac9200_core_init;
2623 spec->mixer = stac9200_mixer;
2625 err = stac9200_parse_auto_config(codec);
2627 stac92xx_free(codec);
2631 codec->patch_ops = stac92xx_patch_ops;
2636 static int patch_stac925x(struct hda_codec *codec)
2638 struct sigmatel_spec *spec;
2641 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2646 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
2647 spec->pin_nids = stac925x_pin_nids;
2648 spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
2652 if (spec->board_config < 0) {
2653 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
2654 "using BIOS defaults\n");
2655 err = stac92xx_save_bios_config_regs(codec);
2657 stac92xx_free(codec);
2660 spec->pin_configs = spec->bios_pin_configs;
2661 } else if (stac925x_brd_tbl[spec->board_config] != NULL){
2662 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
2663 stac92xx_set_config_regs(codec);
2666 spec->multiout.max_channels = 2;
2667 spec->multiout.num_dacs = 1;
2668 spec->multiout.dac_nids = stac925x_dac_nids;
2669 spec->adc_nids = stac925x_adc_nids;
2670 spec->mux_nids = stac925x_mux_nids;
2671 spec->num_muxes = 1;
2673 switch (codec->vendor_id) {
2674 case 0x83847632: /* STAC9202 */
2675 case 0x83847633: /* STAC9202D */
2676 case 0x83847636: /* STAC9251 */
2677 case 0x83847637: /* STAC9251D */
2678 spec->num_dmics = STAC925X_NUM_DMICS;
2679 spec->dmic_nids = stac925x_dmic_nids;
2682 spec->num_dmics = 0;
2686 spec->init = stac925x_core_init;
2687 spec->mixer = stac925x_mixer;
2689 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
2691 if (spec->board_config < 0) {
2692 printk(KERN_WARNING "hda_codec: No auto-config is "
2693 "available, default to model=ref\n");
2694 spec->board_config = STAC_925x_REF;
2700 stac92xx_free(codec);
2704 codec->patch_ops = stac92xx_patch_ops;
2709 static int patch_stac92hd71bxx(struct hda_codec *codec)
2711 struct sigmatel_spec *spec;
2714 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2719 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
2720 spec->pin_nids = stac92hd71bxx_pin_nids;
2721 spec->board_config = snd_hda_check_board_config(codec,
2722 STAC_92HD71BXX_MODELS,
2723 stac92hd71bxx_models,
2724 stac92hd71bxx_cfg_tbl);
2726 if (spec->board_config < 0) {
2727 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
2728 " STAC92HD71BXX, using BIOS defaults\n");
2729 err = stac92xx_save_bios_config_regs(codec);
2731 stac92xx_free(codec);
2734 spec->pin_configs = spec->bios_pin_configs;
2736 spec->pin_configs = stac92hd71bxx_brd_tbl[spec->board_config];
2737 stac92xx_set_config_regs(codec);
2740 spec->gpio_mask = spec->gpio_data = 0x00000001; /* GPIO0 High = EAPD */
2741 stac92xx_enable_gpio_mask(codec);
2743 spec->init = stac92hd71bxx_core_init;
2744 spec->mixer = stac92hd71bxx_mixer;
2746 spec->mux_nids = stac92hd71bxx_mux_nids;
2747 spec->adc_nids = stac92hd71bxx_adc_nids;
2748 spec->dmic_nids = stac92hd71bxx_dmic_nids;
2749 spec->dmux_nid = 0x1c;
2751 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
2752 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
2753 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
2755 spec->multiout.num_dacs = 2;
2756 spec->multiout.hp_nid = 0x11;
2757 spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
2759 err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
2761 if (spec->board_config < 0) {
2762 printk(KERN_WARNING "hda_codec: No auto-config is "
2763 "available, default to model=ref\n");
2764 spec->board_config = STAC_92HD71BXX_REF;
2771 stac92xx_free(codec);
2775 codec->patch_ops = stac92xx_patch_ops;
2780 static int patch_stac922x(struct hda_codec *codec)
2782 struct sigmatel_spec *spec;
2785 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2790 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
2791 spec->pin_nids = stac922x_pin_nids;
2792 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
2795 if (spec->board_config == STAC_INTEL_MAC_V3) {
2796 spec->gpio_mute = 1;
2797 /* Intel Macs have all same PCI SSID, so we need to check
2798 * codec SSID to distinguish the exact models
2800 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
2801 switch (codec->subsystem_id) {
2804 spec->board_config = STAC_INTEL_MAC_V1;
2808 spec->board_config = STAC_INTEL_MAC_V2;
2816 spec->board_config = STAC_INTEL_MAC_V3;
2820 spec->board_config = STAC_INTEL_MAC_V4;
2824 spec->board_config = STAC_INTEL_MAC_V5;
2830 if (spec->board_config < 0) {
2831 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
2832 "using BIOS defaults\n");
2833 err = stac92xx_save_bios_config_regs(codec);
2835 stac92xx_free(codec);
2838 spec->pin_configs = spec->bios_pin_configs;
2839 } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
2840 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
2841 stac92xx_set_config_regs(codec);
2844 spec->adc_nids = stac922x_adc_nids;
2845 spec->mux_nids = stac922x_mux_nids;
2846 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
2847 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
2848 spec->num_dmics = 0;
2850 spec->init = stac922x_core_init;
2851 spec->mixer = stac922x_mixer;
2853 spec->multiout.dac_nids = spec->dac_nids;
2855 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
2857 if (spec->board_config < 0) {
2858 printk(KERN_WARNING "hda_codec: No auto-config is "
2859 "available, default to model=ref\n");
2860 spec->board_config = STAC_D945_REF;
2866 stac92xx_free(codec);
2870 codec->patch_ops = stac92xx_patch_ops;
2872 /* Fix Mux capture level; max to 2 */
2873 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
2874 (0 << AC_AMPCAP_OFFSET_SHIFT) |
2875 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
2876 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2877 (0 << AC_AMPCAP_MUTE_SHIFT));
2882 static int patch_stac927x(struct hda_codec *codec)
2884 struct sigmatel_spec *spec;
2887 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2892 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
2893 spec->pin_nids = stac927x_pin_nids;
2894 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
2898 if (spec->board_config < 0) {
2899 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC927x, using BIOS defaults\n");
2900 err = stac92xx_save_bios_config_regs(codec);
2902 stac92xx_free(codec);
2905 spec->pin_configs = spec->bios_pin_configs;
2906 } else if (stac927x_brd_tbl[spec->board_config] != NULL) {
2907 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
2908 stac92xx_set_config_regs(codec);
2911 switch (spec->board_config) {
2913 spec->adc_nids = stac927x_adc_nids;
2914 spec->mux_nids = stac927x_mux_nids;
2915 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
2916 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
2917 spec->init = d965_core_init;
2918 spec->mixer = stac927x_mixer;
2921 spec->adc_nids = stac927x_adc_nids;
2922 spec->mux_nids = stac927x_mux_nids;
2923 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
2924 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
2925 spec->init = d965_core_init;
2926 spec->mixer = stac927x_mixer;
2929 spec->adc_nids = stac927x_adc_nids;
2930 spec->mux_nids = stac927x_mux_nids;
2931 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
2932 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
2933 spec->init = stac927x_core_init;
2934 spec->mixer = stac927x_mixer;
2937 switch (codec->subsystem_id) {
2938 case 0x10280242: /* STAC 9228 */
2942 spec->dmic_nids = stac927x_dmic_nids;
2943 spec->num_dmics = STAC927X_NUM_DMICS;
2944 spec->dmux_nid = 0x1b;
2947 stac92xx_set_config_reg(codec, 0x13, 0x90a60040);
2949 /* GPIO2 High = Enable EAPD */
2950 spec->gpio_mask = spec->gpio_data = 0x00000004;
2953 spec->num_dmics = 0;
2955 /* GPIO0 High = Enable EAPD */
2956 spec->gpio_mask = spec->gpio_data = 0x00000001;
2959 spec->multiout.dac_nids = spec->dac_nids;
2960 stac92xx_enable_gpio_mask(codec);
2962 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
2964 if (spec->board_config < 0) {
2965 printk(KERN_WARNING "hda_codec: No auto-config is "
2966 "available, default to model=ref\n");
2967 spec->board_config = STAC_D965_REF;
2973 stac92xx_free(codec);
2977 codec->patch_ops = stac92xx_patch_ops;
2982 static int patch_stac9205(struct hda_codec *codec)
2984 struct sigmatel_spec *spec;
2987 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2992 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
2993 spec->pin_nids = stac9205_pin_nids;
2994 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
2998 if (spec->board_config < 0) {
2999 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
3000 err = stac92xx_save_bios_config_regs(codec);
3002 stac92xx_free(codec);
3005 spec->pin_configs = spec->bios_pin_configs;
3007 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
3008 stac92xx_set_config_regs(codec);
3011 spec->adc_nids = stac9205_adc_nids;
3012 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
3013 spec->mux_nids = stac9205_mux_nids;
3014 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
3015 spec->dmic_nids = stac9205_dmic_nids;
3016 spec->num_dmics = STAC9205_NUM_DMICS;
3017 spec->dmux_nid = 0x1d;
3019 spec->init = stac9205_core_init;
3020 spec->mixer = stac9205_mixer;
3022 spec->multiout.dac_nids = spec->dac_nids;
3024 switch (spec->board_config){
3025 case STAC_9205_DELL_M43:
3026 /* Enable SPDIF in/out */
3027 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
3028 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
3030 spec->gpio_mask = 0x00000007; /* GPIO0-2 */
3031 /* GPIO0 High = EAPD, GPIO1 Low = DRM,
3032 * GPIO2 High = Headphone Mute
3034 spec->gpio_data = 0x00000005;
3037 /* GPIO0 High = EAPD */
3038 spec->gpio_mask = spec->gpio_data = 0x00000001;
3042 stac92xx_enable_gpio_mask(codec);
3043 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
3045 if (spec->board_config < 0) {
3046 printk(KERN_WARNING "hda_codec: No auto-config is "
3047 "available, default to model=ref\n");
3048 spec->board_config = STAC_9205_REF;
3054 stac92xx_free(codec);
3058 codec->patch_ops = stac92xx_patch_ops;
3067 /* static config for Sony VAIO FE550G and Sony VAIO AR */
3068 static hda_nid_t vaio_dacs[] = { 0x2 };
3069 #define VAIO_HP_DAC 0x5
3070 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
3071 static hda_nid_t vaio_mux_nids[] = { 0x15 };
3073 static struct hda_input_mux vaio_mux = {
3076 /* { "HP", 0x0 }, */
3077 { "Mic Jack", 0x1 },
3078 { "Internal Mic", 0x2 },
3083 static struct hda_verb vaio_init[] = {
3084 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3085 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
3086 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3087 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3088 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3089 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3090 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3091 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3092 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3093 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3094 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3095 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3099 static struct hda_verb vaio_ar_init[] = {
3100 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3101 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3102 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3103 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3104 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
3105 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3106 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3107 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3108 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3109 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
3110 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3111 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3112 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3116 /* bind volumes of both NID 0x02 and 0x05 */
3117 static struct hda_bind_ctls vaio_bind_master_vol = {
3118 .ops = &snd_hda_bind_vol,
3120 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3121 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3126 /* bind volumes of both NID 0x02 and 0x05 */
3127 static struct hda_bind_ctls vaio_bind_master_sw = {
3128 .ops = &snd_hda_bind_sw,
3130 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3131 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3136 static struct snd_kcontrol_new vaio_mixer[] = {
3137 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3138 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3139 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3140 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3141 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3143 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3144 .name = "Capture Source",
3146 .info = stac92xx_mux_enum_info,
3147 .get = stac92xx_mux_enum_get,
3148 .put = stac92xx_mux_enum_put,
3153 static struct snd_kcontrol_new vaio_ar_mixer[] = {
3154 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3155 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3156 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3157 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3158 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3159 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
3160 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
3162 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3163 .name = "Capture Source",
3165 .info = stac92xx_mux_enum_info,
3166 .get = stac92xx_mux_enum_get,
3167 .put = stac92xx_mux_enum_put,
3172 static struct hda_codec_ops stac9872_patch_ops = {
3173 .build_controls = stac92xx_build_controls,
3174 .build_pcms = stac92xx_build_pcms,
3175 .init = stac92xx_init,
3176 .free = stac92xx_free,
3177 #ifdef SND_HDA_NEEDS_RESUME
3178 .resume = stac92xx_resume,
3182 static int stac9872_vaio_init(struct hda_codec *codec)
3186 err = stac92xx_init(codec);
3189 if (codec->patch_ops.unsol_event)
3190 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3194 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
3196 if (get_hp_pin_presence(codec, 0x0a)) {
3197 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3198 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3200 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3201 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3205 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
3207 switch (res >> 26) {
3209 stac9872_vaio_hp_detect(codec, res);
3214 static struct hda_codec_ops stac9872_vaio_patch_ops = {
3215 .build_controls = stac92xx_build_controls,
3216 .build_pcms = stac92xx_build_pcms,
3217 .init = stac9872_vaio_init,
3218 .free = stac92xx_free,
3219 .unsol_event = stac9872_vaio_unsol_event,
3221 .resume = stac92xx_resume,
3225 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
3227 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
3229 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
3231 /* AR Series. id=0x83847664 and subsys=104D1300 */
3236 static const char *stac9872_models[STAC_9872_MODELS] = {
3237 [CXD9872RD_VAIO] = "vaio",
3238 [CXD9872AKD_VAIO] = "vaio-ar",
3241 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
3242 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
3243 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
3244 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
3245 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
3249 static int patch_stac9872(struct hda_codec *codec)
3251 struct sigmatel_spec *spec;
3254 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
3257 if (board_config < 0)
3258 /* unknown config, let generic-parser do its job... */
3259 return snd_hda_parse_generic_codec(codec);
3261 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3266 switch (board_config) {
3267 case CXD9872RD_VAIO:
3268 case STAC9872AK_VAIO:
3269 case STAC9872K_VAIO:
3270 spec->mixer = vaio_mixer;
3271 spec->init = vaio_init;
3272 spec->multiout.max_channels = 2;
3273 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3274 spec->multiout.dac_nids = vaio_dacs;
3275 spec->multiout.hp_nid = VAIO_HP_DAC;
3276 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3277 spec->adc_nids = vaio_adcs;
3278 spec->input_mux = &vaio_mux;
3279 spec->mux_nids = vaio_mux_nids;
3280 codec->patch_ops = stac9872_vaio_patch_ops;
3283 case CXD9872AKD_VAIO:
3284 spec->mixer = vaio_ar_mixer;
3285 spec->init = vaio_ar_init;
3286 spec->multiout.max_channels = 2;
3287 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3288 spec->multiout.dac_nids = vaio_dacs;
3289 spec->multiout.hp_nid = VAIO_HP_DAC;
3290 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3291 spec->adc_nids = vaio_adcs;
3292 spec->input_mux = &vaio_mux;
3293 spec->mux_nids = vaio_mux_nids;
3294 codec->patch_ops = stac9872_patch_ops;
3305 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
3306 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
3307 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
3308 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
3309 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
3310 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
3311 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
3312 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
3313 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
3314 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
3315 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
3316 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
3317 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
3318 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
3319 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
3320 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
3321 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
3322 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
3323 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
3324 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
3325 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
3326 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
3327 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
3328 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
3329 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
3330 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
3331 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
3332 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
3333 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
3334 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
3335 /* The following does not take into account .id=0x83847661 when subsys =
3336 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
3337 * currently not fully supported.
3339 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
3340 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
3341 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
3342 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
3343 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
3344 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
3345 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
3346 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
3347 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
3348 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
3349 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
3350 { .id = 0x111d76b0, .name = "92HD71BXX", .patch = patch_stac92hd71bxx },