2 * Universal Interface for Intel High Definition Audio Codec
4 * HD audio interface patch for SigmaTel STAC92xx
6 * Copyright (c) 2005 Embedded Alley Solutions, Inc.
7 * Matt Porter <mporter@embeddedalley.com>
9 * Based on patch_cmedia.c and patch_realtek.c
10 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
12 * This driver is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This driver is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include <linux/init.h>
28 #include <linux/delay.h>
29 #include <linux/slab.h>
30 #include <linux/pci.h>
31 #include <sound/core.h>
32 #include <sound/asoundef.h>
33 #include "hda_codec.h"
34 #include "hda_local.h"
36 #define NUM_CONTROL_ALLOC 32
37 #define STAC_PWR_EVENT 0x20
38 #define STAC_HP_EVENT 0x30
91 /* for backward compatibility */
114 struct sigmatel_spec {
115 struct snd_kcontrol_new *mixers[4];
116 unsigned int num_mixers;
119 unsigned int surr_switch: 1;
120 unsigned int line_switch: 1;
121 unsigned int mic_switch: 1;
122 unsigned int alt_switch: 1;
123 unsigned int hp_detect: 1;
125 unsigned int gpio_mask, gpio_data;
126 unsigned char aloopback_mask;
127 unsigned char aloopback_shift;
129 /* power management */
130 unsigned int num_pwrs;
134 struct hda_multi_out multiout;
135 hda_nid_t dac_nids[5];
139 unsigned int num_adcs;
141 unsigned int num_muxes;
142 hda_nid_t *dmic_nids;
143 unsigned int num_dmics;
144 hda_nid_t *dmux_nids;
145 unsigned int num_dmuxes;
146 hda_nid_t dig_in_nid;
150 unsigned int num_pins;
151 unsigned int *pin_configs;
152 unsigned int *bios_pin_configs;
154 /* codec specific stuff */
155 struct hda_verb *init;
156 struct snd_kcontrol_new *mixer;
159 struct hda_input_mux *dinput_mux;
160 unsigned int cur_dmux[2];
161 struct hda_input_mux *input_mux;
162 unsigned int cur_mux[3];
165 unsigned int io_switch[2];
166 unsigned int clfe_swap;
167 unsigned int aloopback;
169 struct hda_pcm pcm_rec[2]; /* PCM information */
171 /* dynamic controls and input_mux */
172 struct auto_pin_cfg autocfg;
173 unsigned int num_kctl_alloc, num_kctl_used;
174 struct snd_kcontrol_new *kctl_alloc;
175 struct hda_input_mux private_dimux;
176 struct hda_input_mux private_imux;
179 unsigned int vmaster_tlv[4];
182 static hda_nid_t stac9200_adc_nids[1] = {
186 static hda_nid_t stac9200_mux_nids[1] = {
190 static hda_nid_t stac9200_dac_nids[1] = {
194 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
195 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
199 static hda_nid_t stac92hd73xx_adc_nids[2] = {
203 #define STAC92HD73XX_NUM_DMICS 2
204 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
208 #define STAC92HD73_DAC_COUNT 5
209 static hda_nid_t stac92hd73xx_dac_nids[STAC92HD73_DAC_COUNT] = {
210 0x15, 0x16, 0x17, 0x18, 0x19,
213 static hda_nid_t stac92hd73xx_mux_nids[4] = {
214 0x28, 0x29, 0x2a, 0x2b,
217 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
221 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
225 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
229 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
233 static hda_nid_t stac92hd71bxx_dmux_nids[1] = {
237 static hda_nid_t stac92hd71bxx_dac_nids[2] = {
241 #define STAC92HD71BXX_NUM_DMICS 2
242 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
246 static hda_nid_t stac925x_adc_nids[1] = {
250 static hda_nid_t stac925x_mux_nids[1] = {
254 static hda_nid_t stac925x_dac_nids[1] = {
258 #define STAC925X_NUM_DMICS 1
259 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
263 static hda_nid_t stac925x_dmux_nids[1] = {
267 static hda_nid_t stac922x_adc_nids[2] = {
271 static hda_nid_t stac922x_mux_nids[2] = {
275 static hda_nid_t stac927x_adc_nids[3] = {
279 static hda_nid_t stac927x_mux_nids[3] = {
283 static hda_nid_t stac927x_dmux_nids[1] = {
287 #define STAC927X_NUM_DMICS 2
288 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
292 static hda_nid_t stac9205_adc_nids[2] = {
296 static hda_nid_t stac9205_mux_nids[2] = {
300 static hda_nid_t stac9205_dmux_nids[1] = {
304 #define STAC9205_NUM_DMICS 2
305 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
309 static hda_nid_t stac9200_pin_nids[8] = {
310 0x08, 0x09, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12,
314 static hda_nid_t stac925x_pin_nids[8] = {
315 0x07, 0x08, 0x0a, 0x0b,
316 0x0c, 0x0d, 0x10, 0x11,
319 static hda_nid_t stac922x_pin_nids[10] = {
320 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
321 0x0f, 0x10, 0x11, 0x15, 0x1b,
324 static hda_nid_t stac92hd73xx_pin_nids[12] = {
325 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
326 0x0f, 0x10, 0x11, 0x12, 0x13,
330 static hda_nid_t stac92hd71bxx_pin_nids[10] = {
331 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
332 0x0f, 0x14, 0x18, 0x19, 0x1e,
335 static hda_nid_t stac927x_pin_nids[14] = {
336 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
337 0x0f, 0x10, 0x11, 0x12, 0x13,
338 0x14, 0x21, 0x22, 0x23,
341 static hda_nid_t stac9205_pin_nids[12] = {
342 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
343 0x0f, 0x14, 0x16, 0x17, 0x18,
347 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
348 struct snd_ctl_elem_info *uinfo)
350 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
351 struct sigmatel_spec *spec = codec->spec;
352 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
355 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
356 struct snd_ctl_elem_value *ucontrol)
358 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
359 struct sigmatel_spec *spec = codec->spec;
360 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
362 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
366 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
367 struct snd_ctl_elem_value *ucontrol)
369 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
370 struct sigmatel_spec *spec = codec->spec;
371 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
373 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
374 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
377 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
379 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
380 struct sigmatel_spec *spec = codec->spec;
381 return snd_hda_input_mux_info(spec->input_mux, uinfo);
384 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
386 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
387 struct sigmatel_spec *spec = codec->spec;
388 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
390 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
394 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
396 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
397 struct sigmatel_spec *spec = codec->spec;
398 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
400 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
401 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
404 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
406 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
407 struct snd_ctl_elem_value *ucontrol)
409 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
410 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
411 struct sigmatel_spec *spec = codec->spec;
413 ucontrol->value.integer.value[0] = !!(spec->aloopback &
414 (spec->aloopback_mask << idx));
418 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
419 struct snd_ctl_elem_value *ucontrol)
421 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
422 struct sigmatel_spec *spec = codec->spec;
423 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
424 unsigned int dac_mode;
425 unsigned int val, idx_val;
427 idx_val = spec->aloopback_mask << idx;
428 if (ucontrol->value.integer.value[0])
429 val = spec->aloopback | idx_val;
431 val = spec->aloopback & ~idx_val;
432 if (spec->aloopback == val)
435 spec->aloopback = val;
437 /* Only return the bits defined by the shift value of the
438 * first two bytes of the mask
440 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
441 kcontrol->private_value & 0xFFFF, 0x0);
442 dac_mode >>= spec->aloopback_shift;
444 if (spec->aloopback & idx_val) {
445 snd_hda_power_up(codec);
448 snd_hda_power_down(codec);
449 dac_mode &= ~idx_val;
452 snd_hda_codec_write_cache(codec, codec->afg, 0,
453 kcontrol->private_value >> 16, dac_mode);
458 static struct hda_verb stac9200_core_init[] = {
459 /* set dac0mux for dac converter */
460 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
464 static struct hda_verb stac9200_eapd_init[] = {
465 /* set dac0mux for dac converter */
466 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
467 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
471 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
472 /* set master volume and direct control */
473 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
474 /* setup audio connections */
475 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
476 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
477 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
478 /* setup adcs to point to mixer */
479 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
480 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
481 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
482 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
483 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
484 /* setup import muxs */
485 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
486 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
487 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
488 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
492 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
493 /* set master volume and direct control */
494 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
495 /* setup audio connections */
496 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
497 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
498 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
499 /* connect hp ports to dac3 */
500 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x03},
501 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x03},
502 /* setup adcs to point to mixer */
503 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
504 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
505 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
506 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
507 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
508 /* setup import muxs */
509 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
510 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
511 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
512 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
516 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
517 /* set master volume and direct control */
518 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
519 /* setup audio connections */
520 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
521 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01 },
522 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02 },
523 /* dac3 is connected to import3 mux */
524 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
525 /* connect hp ports to dac4 */
526 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x04},
527 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x04},
528 /* setup adcs to point to mixer */
529 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
530 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
531 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
532 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
533 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
534 /* setup import muxs */
535 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
536 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
537 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
538 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
542 static struct hda_verb stac92hd71bxx_core_init[] = {
543 /* set master volume and direct control */
544 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
545 /* connect headphone jack to dac1 */
546 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
547 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */
548 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
549 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
550 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
551 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
554 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
555 /* set master volume and direct control */
556 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
557 /* connect headphone jack to dac1 */
558 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
559 /* connect ports 0d and 0f to audio mixer */
560 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x2},
561 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
562 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */
563 /* unmute dac0 input in audio mixer */
564 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
565 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
566 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
567 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
568 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
572 static struct hda_verb stac925x_core_init[] = {
573 /* set dac0mux for dac converter */
574 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
578 static struct hda_verb stac922x_core_init[] = {
579 /* set master volume and direct control */
580 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
584 static struct hda_verb d965_core_init[] = {
585 /* set master volume and direct control */
586 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
587 /* unmute node 0x1b */
588 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
589 /* select node 0x03 as DAC */
590 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
594 static struct hda_verb stac927x_core_init[] = {
595 /* set master volume and direct control */
596 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
600 static struct hda_verb stac9205_core_init[] = {
601 /* set master volume and direct control */
602 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
606 #define STAC_INPUT_SOURCE(cnt) \
608 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
609 .name = "Input Source", \
611 .info = stac92xx_mux_enum_info, \
612 .get = stac92xx_mux_enum_get, \
613 .put = stac92xx_mux_enum_put, \
616 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
618 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
619 .name = "Analog Loopback", \
621 .info = stac92xx_aloopback_info, \
622 .get = stac92xx_aloopback_get, \
623 .put = stac92xx_aloopback_put, \
624 .private_value = verb_read | (verb_write << 16), \
627 static struct snd_kcontrol_new stac9200_mixer[] = {
628 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
629 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
630 STAC_INPUT_SOURCE(1),
631 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
632 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
633 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT),
637 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
638 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
640 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
641 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
643 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
644 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
646 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
647 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
649 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
650 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
652 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
653 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
655 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
656 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
658 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
659 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
663 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
664 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
666 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
667 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
669 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
670 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
672 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
673 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
675 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
676 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
678 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
679 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
681 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
682 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
684 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
685 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
689 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
690 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
692 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
693 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
695 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
696 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
698 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
699 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
701 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
702 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
704 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
705 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
707 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
708 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
710 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
711 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
715 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
716 STAC_INPUT_SOURCE(2),
718 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
719 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
720 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
722 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
723 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
724 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
726 HDA_CODEC_MUTE("Analog Loopback 1", 0x17, 0x3, HDA_INPUT),
727 HDA_CODEC_MUTE("Analog Loopback 2", 0x17, 0x4, HDA_INPUT),
729 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x14, 0x1, 0, HDA_INPUT),
733 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
734 STAC_INPUT_SOURCE(2),
735 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
737 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
738 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
739 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
741 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
742 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
743 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
745 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x14, 0x1, 0, HDA_INPUT),
749 static struct snd_kcontrol_new stac925x_mixer[] = {
750 STAC_INPUT_SOURCE(1),
751 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
752 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_OUTPUT),
753 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT),
757 static struct snd_kcontrol_new stac9205_mixer[] = {
758 STAC_INPUT_SOURCE(2),
759 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
761 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
762 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
763 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT),
765 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
766 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
767 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT),
772 /* This needs to be generated dynamically based on sequence */
773 static struct snd_kcontrol_new stac922x_mixer[] = {
774 STAC_INPUT_SOURCE(2),
775 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
776 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
777 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT),
779 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
780 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
781 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT),
786 static struct snd_kcontrol_new stac927x_mixer[] = {
787 STAC_INPUT_SOURCE(3),
788 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
790 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
791 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
792 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT),
794 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
795 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
796 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT),
798 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
799 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
800 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT),
804 static struct snd_kcontrol_new stac_dmux_mixer = {
805 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
806 .name = "Digital Input Source",
807 /* count set later */
808 .info = stac92xx_dmux_enum_info,
809 .get = stac92xx_dmux_enum_get,
810 .put = stac92xx_dmux_enum_put,
813 static const char *slave_vols[] = {
814 "Front Playback Volume",
815 "Surround Playback Volume",
816 "Center Playback Volume",
817 "LFE Playback Volume",
818 "Side Playback Volume",
819 "Headphone Playback Volume",
820 "Headphone Playback Volume",
821 "Speaker Playback Volume",
822 "External Speaker Playback Volume",
823 "Speaker2 Playback Volume",
827 static const char *slave_sws[] = {
828 "Front Playback Switch",
829 "Surround Playback Switch",
830 "Center Playback Switch",
831 "LFE Playback Switch",
832 "Side Playback Switch",
833 "Headphone Playback Switch",
834 "Headphone Playback Switch",
835 "Speaker Playback Switch",
836 "External Speaker Playback Switch",
837 "Speaker2 Playback Switch",
841 static int stac92xx_build_controls(struct hda_codec *codec)
843 struct sigmatel_spec *spec = codec->spec;
847 err = snd_hda_add_new_ctls(codec, spec->mixer);
851 for (i = 0; i < spec->num_mixers; i++) {
852 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
856 if (spec->num_dmuxes > 0) {
857 stac_dmux_mixer.count = spec->num_dmuxes;
858 err = snd_ctl_add(codec->bus->card,
859 snd_ctl_new1(&stac_dmux_mixer, codec));
864 if (spec->multiout.dig_out_nid) {
865 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
869 if (spec->dig_in_nid) {
870 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
875 /* if we have no master control, let's create it */
876 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
877 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
878 HDA_OUTPUT, spec->vmaster_tlv);
879 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
880 spec->vmaster_tlv, slave_vols);
884 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
885 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
894 static unsigned int ref9200_pin_configs[8] = {
895 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
896 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
900 STAC 9200 pin configs for
905 static unsigned int dell9200_d21_pin_configs[8] = {
906 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
907 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
911 STAC 9200 pin configs for
915 static unsigned int dell9200_d22_pin_configs[8] = {
916 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
917 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
921 STAC 9200 pin configs for
922 102801C4 (Dell Dimension E310)
929 static unsigned int dell9200_d23_pin_configs[8] = {
930 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
931 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
936 STAC 9200-32 pin configs for
937 102801B5 (Dell Inspiron 630m)
938 102801D8 (Dell Inspiron 640m)
940 static unsigned int dell9200_m21_pin_configs[8] = {
941 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
942 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
946 STAC 9200-32 pin configs for
947 102801C2 (Dell Latitude D620)
949 102801CC (Dell Latitude D820)
953 static unsigned int dell9200_m22_pin_configs[8] = {
954 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
955 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
959 STAC 9200-32 pin configs for
960 102801CE (Dell XPS M1710)
961 102801CF (Dell Precision M90)
963 static unsigned int dell9200_m23_pin_configs[8] = {
964 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
965 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
969 STAC 9200-32 pin configs for
972 102801CB (Dell Latitude 120L)
975 static unsigned int dell9200_m24_pin_configs[8] = {
976 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
977 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
981 STAC 9200-32 pin configs for
982 102801BD (Dell Inspiron E1505n)
986 static unsigned int dell9200_m25_pin_configs[8] = {
987 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
988 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
992 STAC 9200-32 pin configs for
993 102801F5 (Dell Inspiron 1501)
996 static unsigned int dell9200_m26_pin_configs[8] = {
997 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
998 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1003 102801CD (Dell Inspiron E1705/9400)
1005 static unsigned int dell9200_m27_pin_configs[8] = {
1006 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1007 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1011 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1012 [STAC_REF] = ref9200_pin_configs,
1013 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1014 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1015 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1016 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1017 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1018 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1019 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1020 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1021 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1022 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1025 static const char *stac9200_models[STAC_9200_MODELS] = {
1027 [STAC_9200_DELL_D21] = "dell-d21",
1028 [STAC_9200_DELL_D22] = "dell-d22",
1029 [STAC_9200_DELL_D23] = "dell-d23",
1030 [STAC_9200_DELL_M21] = "dell-m21",
1031 [STAC_9200_DELL_M22] = "dell-m22",
1032 [STAC_9200_DELL_M23] = "dell-m23",
1033 [STAC_9200_DELL_M24] = "dell-m24",
1034 [STAC_9200_DELL_M25] = "dell-m25",
1035 [STAC_9200_DELL_M26] = "dell-m26",
1036 [STAC_9200_DELL_M27] = "dell-m27",
1037 [STAC_9200_GATEWAY] = "gateway",
1040 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1041 /* SigmaTel reference board */
1042 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1043 "DFI LanParty", STAC_REF),
1044 /* Dell laptops have BIOS problem */
1045 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1046 "unknown Dell", STAC_9200_DELL_D21),
1047 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1048 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1049 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1050 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1051 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1052 "unknown Dell", STAC_9200_DELL_D22),
1053 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1054 "unknown Dell", STAC_9200_DELL_D22),
1055 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1056 "Dell Latitude D620", STAC_9200_DELL_M22),
1057 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1058 "unknown Dell", STAC_9200_DELL_D23),
1059 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1060 "unknown Dell", STAC_9200_DELL_D23),
1061 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1062 "unknown Dell", STAC_9200_DELL_M22),
1063 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1064 "unknown Dell", STAC_9200_DELL_M24),
1065 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1066 "unknown Dell", STAC_9200_DELL_M24),
1067 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1068 "Dell Latitude 120L", STAC_9200_DELL_M24),
1069 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1070 "Dell Latitude D820", STAC_9200_DELL_M22),
1071 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1072 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1073 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1074 "Dell XPS M1710", STAC_9200_DELL_M23),
1075 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1076 "Dell Precision M90", STAC_9200_DELL_M23),
1077 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1078 "unknown Dell", STAC_9200_DELL_M22),
1079 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1080 "unknown Dell", STAC_9200_DELL_M22),
1081 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1082 "unknown Dell", STAC_9200_DELL_M22),
1083 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1084 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1085 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1086 "unknown Dell", STAC_9200_DELL_D23),
1087 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1088 "unknown Dell", STAC_9200_DELL_D23),
1089 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1090 "unknown Dell", STAC_9200_DELL_D21),
1091 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1092 "unknown Dell", STAC_9200_DELL_D23),
1093 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1094 "unknown Dell", STAC_9200_DELL_D21),
1095 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1096 "unknown Dell", STAC_9200_DELL_M25),
1097 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1098 "unknown Dell", STAC_9200_DELL_M25),
1099 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1100 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1101 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1102 "unknown Dell", STAC_9200_DELL_M26),
1104 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_REF),
1105 /* Gateway machines needs EAPD to be set on resume */
1106 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
1107 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
1109 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
1114 static unsigned int ref925x_pin_configs[8] = {
1115 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1116 0x90a70320, 0x02214210, 0x400003f1, 0x9033032e,
1119 static unsigned int stac925x_MA6_pin_configs[8] = {
1120 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1121 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
1124 static unsigned int stac925x_PA6_pin_configs[8] = {
1125 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1126 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
1129 static unsigned int stac925xM2_2_pin_configs[8] = {
1130 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
1131 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
1134 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1135 [STAC_REF] = ref925x_pin_configs,
1136 [STAC_M2_2] = stac925xM2_2_pin_configs,
1137 [STAC_MA6] = stac925x_MA6_pin_configs,
1138 [STAC_PA6] = stac925x_PA6_pin_configs,
1141 static const char *stac925x_models[STAC_925x_MODELS] = {
1143 [STAC_M2_2] = "m2-2",
1148 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1149 /* SigmaTel reference board */
1150 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1151 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1152 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
1153 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
1154 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
1155 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
1156 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
1160 static unsigned int ref92hd73xx_pin_configs[12] = {
1161 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1162 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1163 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1166 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1167 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1170 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1171 [STAC_92HD73XX_REF] = "ref",
1174 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1175 /* SigmaTel reference board */
1176 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1177 "DFI LanParty", STAC_92HD73XX_REF),
1181 static unsigned int ref92hd71bxx_pin_configs[10] = {
1182 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1183 0x0181302e, 0x01114010, 0x01a19020, 0x90a000f0,
1184 0x90a000f0, 0x01452050,
1187 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1188 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1191 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1192 [STAC_92HD71BXX_REF] = "ref",
1195 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1196 /* SigmaTel reference board */
1197 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1198 "DFI LanParty", STAC_92HD71BXX_REF),
1202 static unsigned int ref922x_pin_configs[10] = {
1203 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1204 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1205 0x40000100, 0x40000100,
1209 STAC 922X pin configs for
1216 static unsigned int dell_922x_d81_pin_configs[10] = {
1217 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1218 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1219 0x01813122, 0x400001f2,
1223 STAC 922X pin configs for
1227 static unsigned int dell_922x_d82_pin_configs[10] = {
1228 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1229 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1230 0x01813122, 0x400001f1,
1234 STAC 922X pin configs for
1237 static unsigned int dell_922x_m81_pin_configs[10] = {
1238 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1239 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1240 0x40C003f1, 0x405003f0,
1244 STAC 9221 A1 pin configs for
1245 102801D7 (Dell XPS M1210)
1247 static unsigned int dell_922x_m82_pin_configs[10] = {
1248 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1249 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1250 0x508003f3, 0x405003f4,
1253 static unsigned int d945gtp3_pin_configs[10] = {
1254 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1255 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1256 0x02a19120, 0x40000100,
1259 static unsigned int d945gtp5_pin_configs[10] = {
1260 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1261 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1262 0x02a19320, 0x40000100,
1265 static unsigned int intel_mac_v1_pin_configs[10] = {
1266 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1267 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1268 0x400000fc, 0x400000fb,
1271 static unsigned int intel_mac_v2_pin_configs[10] = {
1272 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1273 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1274 0x400000fc, 0x400000fb,
1277 static unsigned int intel_mac_v3_pin_configs[10] = {
1278 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1279 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1280 0x400000fc, 0x400000fb,
1283 static unsigned int intel_mac_v4_pin_configs[10] = {
1284 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1285 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1286 0x400000fc, 0x400000fb,
1289 static unsigned int intel_mac_v5_pin_configs[10] = {
1290 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1291 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1292 0x400000fc, 0x400000fb,
1296 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1297 [STAC_D945_REF] = ref922x_pin_configs,
1298 [STAC_D945GTP3] = d945gtp3_pin_configs,
1299 [STAC_D945GTP5] = d945gtp5_pin_configs,
1300 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1301 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1302 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1303 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1304 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1305 /* for backward compatibility */
1306 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1307 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1308 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1309 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1310 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1311 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1312 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1313 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1314 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1315 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1318 static const char *stac922x_models[STAC_922X_MODELS] = {
1319 [STAC_D945_REF] = "ref",
1320 [STAC_D945GTP5] = "5stack",
1321 [STAC_D945GTP3] = "3stack",
1322 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1323 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1324 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1325 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1326 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1327 /* for backward compatibility */
1328 [STAC_MACMINI] = "macmini",
1329 [STAC_MACBOOK] = "macbook",
1330 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1331 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1332 [STAC_IMAC_INTEL] = "imac-intel",
1333 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1334 [STAC_922X_DELL_D81] = "dell-d81",
1335 [STAC_922X_DELL_D82] = "dell-d82",
1336 [STAC_922X_DELL_M81] = "dell-m81",
1337 [STAC_922X_DELL_M82] = "dell-m82",
1340 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1341 /* SigmaTel reference board */
1342 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1343 "DFI LanParty", STAC_D945_REF),
1344 /* Intel 945G based systems */
1345 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1346 "Intel D945G", STAC_D945GTP3),
1347 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1348 "Intel D945G", STAC_D945GTP3),
1349 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1350 "Intel D945G", STAC_D945GTP3),
1351 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1352 "Intel D945G", STAC_D945GTP3),
1353 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1354 "Intel D945G", STAC_D945GTP3),
1355 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1356 "Intel D945G", STAC_D945GTP3),
1357 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1358 "Intel D945G", STAC_D945GTP3),
1359 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1360 "Intel D945G", STAC_D945GTP3),
1361 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1362 "Intel D945G", STAC_D945GTP3),
1363 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1364 "Intel D945G", STAC_D945GTP3),
1365 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1366 "Intel D945G", STAC_D945GTP3),
1367 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1368 "Intel D945G", STAC_D945GTP3),
1369 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1370 "Intel D945G", STAC_D945GTP3),
1371 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1372 "Intel D945G", STAC_D945GTP3),
1373 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1374 "Intel D945G", STAC_D945GTP3),
1375 /* Intel D945G 5-stack systems */
1376 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1377 "Intel D945G", STAC_D945GTP5),
1378 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1379 "Intel D945G", STAC_D945GTP5),
1380 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1381 "Intel D945G", STAC_D945GTP5),
1382 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1383 "Intel D945G", STAC_D945GTP5),
1384 /* Intel 945P based systems */
1385 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1386 "Intel D945P", STAC_D945GTP3),
1387 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1388 "Intel D945P", STAC_D945GTP3),
1389 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1390 "Intel D945P", STAC_D945GTP3),
1391 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1392 "Intel D945P", STAC_D945GTP3),
1393 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1394 "Intel D945P", STAC_D945GTP3),
1395 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1396 "Intel D945P", STAC_D945GTP5),
1398 /* Apple Mac Mini (early 2006) */
1399 SND_PCI_QUIRK(0x8384, 0x7680,
1400 "Mac Mini", STAC_INTEL_MAC_V3),
1402 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1403 "unknown Dell", STAC_922X_DELL_D81),
1404 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1405 "unknown Dell", STAC_922X_DELL_D81),
1406 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1407 "unknown Dell", STAC_922X_DELL_D81),
1408 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1409 "unknown Dell", STAC_922X_DELL_D82),
1410 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1411 "unknown Dell", STAC_922X_DELL_M81),
1412 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1413 "unknown Dell", STAC_922X_DELL_D82),
1414 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1415 "unknown Dell", STAC_922X_DELL_D81),
1416 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1417 "unknown Dell", STAC_922X_DELL_D81),
1418 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1419 "Dell XPS M1210", STAC_922X_DELL_M82),
1423 static unsigned int ref927x_pin_configs[14] = {
1424 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1425 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1426 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1427 0x01c42190, 0x40000100,
1430 static unsigned int d965_3st_pin_configs[14] = {
1431 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
1432 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
1433 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1434 0x40000100, 0x40000100
1437 static unsigned int d965_5st_pin_configs[14] = {
1438 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1439 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
1440 0x40000100, 0x40000100, 0x40000100, 0x01442070,
1441 0x40000100, 0x40000100
1444 static unsigned int dell_3st_pin_configs[14] = {
1445 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
1446 0x01111212, 0x01116211, 0x01813050, 0x01112214,
1447 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
1448 0x40c003fc, 0x40000100
1451 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
1452 [STAC_D965_REF] = ref927x_pin_configs,
1453 [STAC_D965_3ST] = d965_3st_pin_configs,
1454 [STAC_D965_5ST] = d965_5st_pin_configs,
1455 [STAC_DELL_3ST] = dell_3st_pin_configs,
1456 [STAC_DELL_BIOS] = NULL,
1459 static const char *stac927x_models[STAC_927X_MODELS] = {
1460 [STAC_D965_REF] = "ref",
1461 [STAC_D965_3ST] = "3stack",
1462 [STAC_D965_5ST] = "5stack",
1463 [STAC_DELL_3ST] = "dell-3stack",
1464 [STAC_DELL_BIOS] = "dell-bios",
1467 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
1468 /* SigmaTel reference board */
1469 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1470 "DFI LanParty", STAC_D965_REF),
1471 /* Intel 946 based systems */
1472 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
1473 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
1474 /* 965 based 3 stack systems */
1475 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
1476 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
1477 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
1478 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
1479 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
1480 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
1481 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
1482 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
1483 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
1484 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
1485 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
1486 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
1487 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
1488 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
1489 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
1490 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
1491 /* Dell 3 stack systems */
1492 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
1493 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
1494 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
1495 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
1496 /* Dell 3 stack systems with verb table in BIOS */
1497 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
1498 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
1499 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell ", STAC_DELL_BIOS),
1500 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
1501 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
1502 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
1503 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
1504 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
1505 /* 965 based 5 stack systems */
1506 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
1507 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
1508 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
1509 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
1510 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
1511 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
1512 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
1513 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
1514 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
1518 static unsigned int ref9205_pin_configs[12] = {
1519 0x40000100, 0x40000100, 0x01016011, 0x01014010,
1520 0x01813122, 0x01a19021, 0x40000100, 0x40000100,
1521 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
1525 STAC 9205 pin configs for
1532 10280228 (Dell Vostro 1500)
1534 static unsigned int dell_9205_m42_pin_configs[12] = {
1535 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
1536 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
1537 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
1541 STAC 9205 pin configs for
1545 102801FF (Dell Precision M4300)
1550 static unsigned int dell_9205_m43_pin_configs[12] = {
1551 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
1552 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
1553 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
1556 static unsigned int dell_9205_m44_pin_configs[12] = {
1557 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
1558 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
1559 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
1562 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
1563 [STAC_9205_REF] = ref9205_pin_configs,
1564 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
1565 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
1566 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
1569 static const char *stac9205_models[STAC_9205_MODELS] = {
1570 [STAC_9205_REF] = "ref",
1571 [STAC_9205_DELL_M42] = "dell-m42",
1572 [STAC_9205_DELL_M43] = "dell-m43",
1573 [STAC_9205_DELL_M44] = "dell-m44",
1576 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
1577 /* SigmaTel reference board */
1578 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1579 "DFI LanParty", STAC_9205_REF),
1580 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1581 "unknown Dell", STAC_9205_DELL_M42),
1582 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1583 "unknown Dell", STAC_9205_DELL_M42),
1584 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
1585 "Dell Precision", STAC_9205_DELL_M43),
1586 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
1587 "Dell Precision", STAC_9205_DELL_M43),
1588 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
1589 "Dell Precision", STAC_9205_DELL_M43),
1590 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
1591 "Dell Precision", STAC_9205_DELL_M43),
1592 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
1593 "Dell Precision", STAC_9205_DELL_M43),
1594 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1595 "unknown Dell", STAC_9205_DELL_M42),
1596 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1597 "unknown Dell", STAC_9205_DELL_M42),
1598 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
1599 "Dell Precision", STAC_9205_DELL_M43),
1600 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
1601 "Dell Precision M4300", STAC_9205_DELL_M43),
1602 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
1603 "Dell Precision", STAC_9205_DELL_M43),
1604 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1605 "Dell Inspiron", STAC_9205_DELL_M44),
1606 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1607 "Dell Inspiron", STAC_9205_DELL_M44),
1608 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1609 "Dell Inspiron", STAC_9205_DELL_M44),
1610 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1611 "Dell Inspiron", STAC_9205_DELL_M44),
1612 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
1613 "unknown Dell", STAC_9205_DELL_M42),
1614 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
1615 "Dell Inspiron", STAC_9205_DELL_M44),
1616 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
1617 "Dell Vostro 1500", STAC_9205_DELL_M42),
1621 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
1624 struct sigmatel_spec *spec = codec->spec;
1626 if (! spec->bios_pin_configs) {
1627 spec->bios_pin_configs = kcalloc(spec->num_pins,
1628 sizeof(*spec->bios_pin_configs), GFP_KERNEL);
1629 if (! spec->bios_pin_configs)
1633 for (i = 0; i < spec->num_pins; i++) {
1634 hda_nid_t nid = spec->pin_nids[i];
1635 unsigned int pin_cfg;
1637 pin_cfg = snd_hda_codec_read(codec, nid, 0,
1638 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
1639 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
1641 spec->bios_pin_configs[i] = pin_cfg;
1647 static void stac92xx_set_config_reg(struct hda_codec *codec,
1648 hda_nid_t pin_nid, unsigned int pin_config)
1651 snd_hda_codec_write(codec, pin_nid, 0,
1652 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
1653 pin_config & 0x000000ff);
1654 snd_hda_codec_write(codec, pin_nid, 0,
1655 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
1656 (pin_config & 0x0000ff00) >> 8);
1657 snd_hda_codec_write(codec, pin_nid, 0,
1658 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
1659 (pin_config & 0x00ff0000) >> 16);
1660 snd_hda_codec_write(codec, pin_nid, 0,
1661 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
1663 i = snd_hda_codec_read(codec, pin_nid, 0,
1664 AC_VERB_GET_CONFIG_DEFAULT,
1666 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
1670 static void stac92xx_set_config_regs(struct hda_codec *codec)
1673 struct sigmatel_spec *spec = codec->spec;
1675 if (!spec->pin_configs)
1678 for (i = 0; i < spec->num_pins; i++)
1679 stac92xx_set_config_reg(codec, spec->pin_nids[i],
1680 spec->pin_configs[i]);
1684 * Analog playback callbacks
1686 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
1687 struct hda_codec *codec,
1688 struct snd_pcm_substream *substream)
1690 struct sigmatel_spec *spec = codec->spec;
1691 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
1694 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1695 struct hda_codec *codec,
1696 unsigned int stream_tag,
1697 unsigned int format,
1698 struct snd_pcm_substream *substream)
1700 struct sigmatel_spec *spec = codec->spec;
1701 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
1704 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1705 struct hda_codec *codec,
1706 struct snd_pcm_substream *substream)
1708 struct sigmatel_spec *spec = codec->spec;
1709 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1713 * Digital playback callbacks
1715 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1716 struct hda_codec *codec,
1717 struct snd_pcm_substream *substream)
1719 struct sigmatel_spec *spec = codec->spec;
1720 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1723 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1724 struct hda_codec *codec,
1725 struct snd_pcm_substream *substream)
1727 struct sigmatel_spec *spec = codec->spec;
1728 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1731 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1732 struct hda_codec *codec,
1733 unsigned int stream_tag,
1734 unsigned int format,
1735 struct snd_pcm_substream *substream)
1737 struct sigmatel_spec *spec = codec->spec;
1738 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1739 stream_tag, format, substream);
1744 * Analog capture callbacks
1746 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1747 struct hda_codec *codec,
1748 unsigned int stream_tag,
1749 unsigned int format,
1750 struct snd_pcm_substream *substream)
1752 struct sigmatel_spec *spec = codec->spec;
1754 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1755 stream_tag, 0, format);
1759 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1760 struct hda_codec *codec,
1761 struct snd_pcm_substream *substream)
1763 struct sigmatel_spec *spec = codec->spec;
1765 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
1769 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
1773 /* NID is set in stac92xx_build_pcms */
1775 .open = stac92xx_dig_playback_pcm_open,
1776 .close = stac92xx_dig_playback_pcm_close,
1777 .prepare = stac92xx_dig_playback_pcm_prepare
1781 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
1785 /* NID is set in stac92xx_build_pcms */
1788 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
1792 .nid = 0x02, /* NID to query formats and rates */
1794 .open = stac92xx_playback_pcm_open,
1795 .prepare = stac92xx_playback_pcm_prepare,
1796 .cleanup = stac92xx_playback_pcm_cleanup
1800 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
1804 .nid = 0x06, /* NID to query formats and rates */
1806 .open = stac92xx_playback_pcm_open,
1807 .prepare = stac92xx_playback_pcm_prepare,
1808 .cleanup = stac92xx_playback_pcm_cleanup
1812 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
1815 /* NID + .substreams is set in stac92xx_build_pcms */
1817 .prepare = stac92xx_capture_pcm_prepare,
1818 .cleanup = stac92xx_capture_pcm_cleanup
1822 static int stac92xx_build_pcms(struct hda_codec *codec)
1824 struct sigmatel_spec *spec = codec->spec;
1825 struct hda_pcm *info = spec->pcm_rec;
1827 codec->num_pcms = 1;
1828 codec->pcm_info = info;
1830 info->name = "STAC92xx Analog";
1831 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
1832 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
1833 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1834 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
1836 if (spec->alt_switch) {
1839 info->name = "STAC92xx Analog Alt";
1840 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
1843 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1846 info->name = "STAC92xx Digital";
1847 if (spec->multiout.dig_out_nid) {
1848 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
1849 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
1851 if (spec->dig_in_nid) {
1852 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
1853 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
1860 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
1862 unsigned int pincap = snd_hda_param_read(codec, nid,
1864 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
1865 if (pincap & AC_PINCAP_VREF_100)
1866 return AC_PINCTL_VREF_100;
1867 if (pincap & AC_PINCAP_VREF_80)
1868 return AC_PINCTL_VREF_80;
1869 if (pincap & AC_PINCAP_VREF_50)
1870 return AC_PINCTL_VREF_50;
1871 if (pincap & AC_PINCAP_VREF_GRD)
1872 return AC_PINCTL_VREF_GRD;
1876 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
1879 snd_hda_codec_write_cache(codec, nid, 0,
1880 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
1883 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
1885 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1887 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1888 struct sigmatel_spec *spec = codec->spec;
1889 int io_idx = kcontrol-> private_value & 0xff;
1891 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
1895 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1897 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1898 struct sigmatel_spec *spec = codec->spec;
1899 hda_nid_t nid = kcontrol->private_value >> 8;
1900 int io_idx = kcontrol-> private_value & 0xff;
1901 unsigned short val = !!ucontrol->value.integer.value[0];
1903 spec->io_switch[io_idx] = val;
1906 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
1908 unsigned int pinctl = AC_PINCTL_IN_EN;
1909 if (io_idx) /* set VREF for mic */
1910 pinctl |= stac92xx_get_vref(codec, nid);
1911 stac92xx_auto_set_pinctl(codec, nid, pinctl);
1914 /* check the auto-mute again: we need to mute/unmute the speaker
1915 * appropriately according to the pin direction
1917 if (spec->hp_detect)
1918 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
1923 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
1925 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
1926 struct snd_ctl_elem_value *ucontrol)
1928 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1929 struct sigmatel_spec *spec = codec->spec;
1931 ucontrol->value.integer.value[0] = spec->clfe_swap;
1935 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
1936 struct snd_ctl_elem_value *ucontrol)
1938 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1939 struct sigmatel_spec *spec = codec->spec;
1940 hda_nid_t nid = kcontrol->private_value & 0xff;
1941 unsigned int val = !!ucontrol->value.integer.value[0];
1943 if (spec->clfe_swap == val)
1946 spec->clfe_swap = val;
1948 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1949 spec->clfe_swap ? 0x4 : 0x0);
1954 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
1955 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1958 .info = stac92xx_io_switch_info, \
1959 .get = stac92xx_io_switch_get, \
1960 .put = stac92xx_io_switch_put, \
1961 .private_value = xpval, \
1964 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
1965 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1968 .info = stac92xx_clfe_switch_info, \
1969 .get = stac92xx_clfe_switch_get, \
1970 .put = stac92xx_clfe_switch_put, \
1971 .private_value = xpval, \
1975 STAC_CTL_WIDGET_VOL,
1976 STAC_CTL_WIDGET_MUTE,
1977 STAC_CTL_WIDGET_IO_SWITCH,
1978 STAC_CTL_WIDGET_CLFE_SWITCH
1981 static struct snd_kcontrol_new stac92xx_control_templates[] = {
1982 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
1983 HDA_CODEC_MUTE(NULL, 0, 0, 0),
1984 STAC_CODEC_IO_SWITCH(NULL, 0),
1985 STAC_CODEC_CLFE_SWITCH(NULL, 0),
1988 /* add dynamic controls */
1989 static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val)
1991 struct snd_kcontrol_new *knew;
1993 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
1994 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
1996 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
1999 if (spec->kctl_alloc) {
2000 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
2001 kfree(spec->kctl_alloc);
2003 spec->kctl_alloc = knew;
2004 spec->num_kctl_alloc = num;
2007 knew = &spec->kctl_alloc[spec->num_kctl_used];
2008 *knew = stac92xx_control_templates[type];
2009 knew->name = kstrdup(name, GFP_KERNEL);
2012 knew->private_value = val;
2013 spec->num_kctl_used++;
2017 /* flag inputs as additional dynamic lineouts */
2018 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
2020 struct sigmatel_spec *spec = codec->spec;
2021 unsigned int wcaps, wtype;
2022 int i, num_dacs = 0;
2024 /* use the wcaps cache to count all DACs available for line-outs */
2025 for (i = 0; i < codec->num_nodes; i++) {
2026 wcaps = codec->wcaps[i];
2027 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2029 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
2033 snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
2035 switch (cfg->line_outs) {
2037 /* add line-in as side */
2038 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
2039 cfg->line_out_pins[cfg->line_outs] =
2040 cfg->input_pins[AUTO_PIN_LINE];
2041 spec->line_switch = 1;
2046 /* add line-in as clfe and mic as side */
2047 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
2048 cfg->line_out_pins[cfg->line_outs] =
2049 cfg->input_pins[AUTO_PIN_LINE];
2050 spec->line_switch = 1;
2053 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
2054 cfg->line_out_pins[cfg->line_outs] =
2055 cfg->input_pins[AUTO_PIN_MIC];
2056 spec->mic_switch = 1;
2061 /* add line-in as surr and mic as clfe */
2062 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
2063 cfg->line_out_pins[cfg->line_outs] =
2064 cfg->input_pins[AUTO_PIN_LINE];
2065 spec->line_switch = 1;
2068 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
2069 cfg->line_out_pins[cfg->line_outs] =
2070 cfg->input_pins[AUTO_PIN_MIC];
2071 spec->mic_switch = 1;
2081 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2085 for (i = 0; i < spec->multiout.num_dacs; i++) {
2086 if (spec->multiout.dac_nids[i] == nid)
2094 * Fill in the dac_nids table from the parsed pin configuration
2095 * This function only works when every pin in line_out_pins[]
2096 * contains atleast one DAC in its connection list. Some 92xx
2097 * codecs are not connected directly to a DAC, such as the 9200
2098 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2100 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
2101 struct auto_pin_cfg *cfg)
2103 struct sigmatel_spec *spec = codec->spec;
2104 int i, j, conn_len = 0;
2105 hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
2106 unsigned int wcaps, wtype;
2108 for (i = 0; i < cfg->line_outs; i++) {
2109 nid = cfg->line_out_pins[i];
2110 conn_len = snd_hda_get_connections(codec, nid, conn,
2111 HDA_MAX_CONNECTIONS);
2112 for (j = 0; j < conn_len; j++) {
2113 wcaps = snd_hda_param_read(codec, conn[j],
2114 AC_PAR_AUDIO_WIDGET_CAP);
2115 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2116 if (wtype != AC_WID_AUD_OUT ||
2117 (wcaps & AC_WCAP_DIGITAL))
2119 /* conn[j] is a DAC routed to this line-out */
2120 if (!is_in_dac_nids(spec, conn[j]))
2124 if (j == conn_len) {
2125 if (spec->multiout.num_dacs > 0) {
2126 /* we have already working output pins,
2127 * so let's drop the broken ones again
2129 cfg->line_outs = spec->multiout.num_dacs;
2132 /* error out, no available DAC found */
2134 "%s: No available DAC for pin 0x%x\n",
2139 spec->multiout.dac_nids[i] = conn[j];
2140 spec->multiout.num_dacs++;
2142 /* select this DAC in the pin's input mux */
2143 snd_hda_codec_write_cache(codec, nid, 0,
2144 AC_VERB_SET_CONNECT_SEL, j);
2149 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2150 spec->multiout.num_dacs,
2151 spec->multiout.dac_nids[0],
2152 spec->multiout.dac_nids[1],
2153 spec->multiout.dac_nids[2],
2154 spec->multiout.dac_nids[3],
2155 spec->multiout.dac_nids[4]);
2159 /* create volume control/switch for the given prefx type */
2160 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
2165 sprintf(name, "%s Playback Volume", pfx);
2166 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
2167 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2170 sprintf(name, "%s Playback Switch", pfx);
2171 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
2172 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2178 /* add playback controls from the parsed DAC table */
2179 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
2180 const struct auto_pin_cfg *cfg)
2182 static const char *chname[4] = {
2183 "Front", "Surround", NULL /*CLFE*/, "Side"
2188 struct sigmatel_spec *spec = codec->spec;
2189 unsigned int wid_caps;
2192 for (i = 0; i < cfg->line_outs; i++) {
2193 if (!spec->multiout.dac_nids[i])
2196 nid = spec->multiout.dac_nids[i];
2200 err = create_controls(spec, "Center", nid, 1);
2203 err = create_controls(spec, "LFE", nid, 2);
2207 wid_caps = get_wcaps(codec, nid);
2209 if (wid_caps & AC_WCAP_LR_SWAP) {
2210 err = stac92xx_add_control(spec,
2211 STAC_CTL_WIDGET_CLFE_SWITCH,
2212 "Swap Center/LFE Playback Switch", nid);
2219 err = create_controls(spec, chname[i], nid, 3);
2225 if (spec->line_switch)
2226 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Line In as Output Switch", cfg->input_pins[AUTO_PIN_LINE] << 8)) < 0)
2229 if (spec->mic_switch)
2230 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Mic as Output Switch", (cfg->input_pins[AUTO_PIN_MIC] << 8) | 1)) < 0)
2236 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2238 if (is_in_dac_nids(spec, nid))
2240 if (spec->multiout.hp_nid == nid)
2245 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
2247 if (!spec->multiout.hp_nid)
2248 spec->multiout.hp_nid = nid;
2249 else if (spec->multiout.num_dacs > 4) {
2250 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
2253 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
2254 spec->multiout.num_dacs++;
2259 /* add playback controls for Speaker and HP outputs */
2260 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
2261 struct auto_pin_cfg *cfg)
2263 struct sigmatel_spec *spec = codec->spec;
2265 int i, old_num_dacs, err;
2267 old_num_dacs = spec->multiout.num_dacs;
2268 for (i = 0; i < cfg->hp_outs; i++) {
2269 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
2270 if (wid_caps & AC_WCAP_UNSOL_CAP)
2271 spec->hp_detect = 1;
2272 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
2273 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2274 if (check_in_dac_nids(spec, nid))
2278 add_spec_dacs(spec, nid);
2280 for (i = 0; i < cfg->speaker_outs; i++) {
2281 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
2282 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2283 if (check_in_dac_nids(spec, nid))
2287 add_spec_dacs(spec, nid);
2289 for (i = 0; i < cfg->line_outs; i++) {
2290 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
2291 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2292 if (check_in_dac_nids(spec, nid))
2296 add_spec_dacs(spec, nid);
2298 for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
2299 static const char *pfxs[] = {
2300 "Speaker", "External Speaker", "Speaker2",
2302 err = create_controls(spec, pfxs[i - old_num_dacs],
2303 spec->multiout.dac_nids[i], 3);
2307 if (spec->multiout.hp_nid) {
2309 if (old_num_dacs == spec->multiout.num_dacs)
2313 err = create_controls(spec, pfx, spec->multiout.hp_nid, 3);
2321 /* labels for dmic mux inputs */
2322 static const char *stac92xx_dmic_labels[5] = {
2323 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
2324 "Digital Mic 3", "Digital Mic 4"
2327 /* create playback/capture controls for input pins on dmic capable codecs */
2328 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
2329 const struct auto_pin_cfg *cfg)
2331 struct sigmatel_spec *spec = codec->spec;
2332 struct hda_input_mux *dimux = &spec->private_dimux;
2333 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2337 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
2338 dimux->items[dimux->num_items].index = 0;
2341 for (i = 0; i < spec->num_dmics; i++) {
2346 unsigned int def_conf;
2348 def_conf = snd_hda_codec_read(codec,
2351 AC_VERB_GET_CONFIG_DEFAULT,
2353 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
2356 nid = spec->dmic_nids[i];
2357 num_cons = snd_hda_get_connections(codec,
2360 HDA_MAX_NUM_INPUTS);
2361 for (j = 0; j < num_cons; j++)
2362 if (con_lst[j] == nid) {
2368 wcaps = get_wcaps(codec, nid);
2370 if (wcaps & AC_WCAP_OUT_AMP) {
2371 sprintf(name, "%s Capture Volume",
2372 stac92xx_dmic_labels[dimux->num_items]);
2374 err = stac92xx_add_control(spec,
2375 STAC_CTL_WIDGET_VOL,
2377 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
2382 dimux->items[dimux->num_items].label =
2383 stac92xx_dmic_labels[dimux->num_items];
2384 dimux->items[dimux->num_items].index = index;
2391 /* create playback/capture controls for input pins */
2392 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
2394 struct sigmatel_spec *spec = codec->spec;
2395 struct hda_input_mux *imux = &spec->private_imux;
2396 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2399 for (i = 0; i < AUTO_PIN_LAST; i++) {
2402 if (!cfg->input_pins[i])
2405 for (j = 0; j < spec->num_muxes; j++) {
2407 num_cons = snd_hda_get_connections(codec,
2410 HDA_MAX_NUM_INPUTS);
2411 for (k = 0; k < num_cons; k++)
2412 if (con_lst[k] == cfg->input_pins[i]) {
2419 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2420 imux->items[imux->num_items].index = index;
2424 if (imux->num_items) {
2426 * Set the current input for the muxes.
2427 * The STAC9221 has two input muxes with identical source
2428 * NID lists. Hopefully this won't get confused.
2430 for (i = 0; i < spec->num_muxes; i++) {
2431 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
2432 AC_VERB_SET_CONNECT_SEL,
2433 imux->items[0].index);
2440 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
2442 struct sigmatel_spec *spec = codec->spec;
2445 for (i = 0; i < spec->autocfg.line_outs; i++) {
2446 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2447 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2451 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
2453 struct sigmatel_spec *spec = codec->spec;
2456 for (i = 0; i < spec->autocfg.hp_outs; i++) {
2458 pin = spec->autocfg.hp_pins[i];
2459 if (pin) /* connect to front */
2460 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
2462 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
2464 pin = spec->autocfg.speaker_pins[i];
2465 if (pin) /* connect to front */
2466 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
2470 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
2472 struct sigmatel_spec *spec = codec->spec;
2474 int hp_speaker_swap = 0;
2476 if ((err = snd_hda_parse_pin_def_config(codec,
2478 spec->dmic_nids)) < 0)
2480 if (! spec->autocfg.line_outs)
2481 return 0; /* can't find valid pin config */
2483 /* If we have no real line-out pin and multiple hp-outs, HPs should
2484 * be set up as multi-channel outputs.
2486 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
2487 spec->autocfg.hp_outs > 1) {
2488 /* Copy hp_outs to line_outs, backup line_outs in
2489 * speaker_outs so that the following routines can handle
2490 * HP pins as primary outputs.
2492 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
2493 sizeof(spec->autocfg.line_out_pins));
2494 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
2495 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
2496 sizeof(spec->autocfg.hp_pins));
2497 spec->autocfg.line_outs = spec->autocfg.hp_outs;
2498 hp_speaker_swap = 1;
2501 if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
2503 if (spec->multiout.num_dacs == 0)
2504 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2507 err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
2512 if (hp_speaker_swap == 1) {
2513 /* Restore the hp_outs and line_outs */
2514 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
2515 sizeof(spec->autocfg.line_out_pins));
2516 spec->autocfg.hp_outs = spec->autocfg.line_outs;
2517 memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins,
2518 sizeof(spec->autocfg.speaker_pins));
2519 spec->autocfg.line_outs = spec->autocfg.speaker_outs;
2520 memset(spec->autocfg.speaker_pins, 0,
2521 sizeof(spec->autocfg.speaker_pins));
2522 spec->autocfg.speaker_outs = 0;
2525 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
2530 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
2535 if (spec->num_dmics > 0)
2536 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
2537 &spec->autocfg)) < 0)
2540 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2541 if (spec->multiout.max_channels > 2)
2542 spec->surr_switch = 1;
2544 if (spec->autocfg.dig_out_pin)
2545 spec->multiout.dig_out_nid = dig_out;
2546 if (spec->autocfg.dig_in_pin)
2547 spec->dig_in_nid = dig_in;
2549 if (spec->kctl_alloc)
2550 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2552 spec->input_mux = &spec->private_imux;
2553 if (!spec->dinput_mux)
2554 spec->dinput_mux = &spec->private_dimux;
2559 /* add playback controls for HP output */
2560 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
2561 struct auto_pin_cfg *cfg)
2563 struct sigmatel_spec *spec = codec->spec;
2564 hda_nid_t pin = cfg->hp_pins[0];
2565 unsigned int wid_caps;
2570 wid_caps = get_wcaps(codec, pin);
2571 if (wid_caps & AC_WCAP_UNSOL_CAP)
2572 spec->hp_detect = 1;
2577 /* add playback controls for LFE output */
2578 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
2579 struct auto_pin_cfg *cfg)
2581 struct sigmatel_spec *spec = codec->spec;
2583 hda_nid_t lfe_pin = 0x0;
2587 * search speaker outs and line outs for a mono speaker pin
2588 * with an amp. If one is found, add LFE controls
2591 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
2592 hda_nid_t pin = spec->autocfg.speaker_pins[i];
2593 unsigned long wcaps = get_wcaps(codec, pin);
2594 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2595 if (wcaps == AC_WCAP_OUT_AMP)
2596 /* found a mono speaker with an amp, must be lfe */
2600 /* if speaker_outs is 0, then speakers may be in line_outs */
2601 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
2602 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
2603 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2605 cfg = snd_hda_codec_read(codec, pin, 0,
2606 AC_VERB_GET_CONFIG_DEFAULT,
2608 if (get_defcfg_device(cfg) == AC_JACK_SPEAKER) {
2609 unsigned long wcaps = get_wcaps(codec, pin);
2610 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2611 if (wcaps == AC_WCAP_OUT_AMP)
2612 /* found a mono speaker with an amp,
2620 err = create_controls(spec, "LFE", lfe_pin, 1);
2628 static int stac9200_parse_auto_config(struct hda_codec *codec)
2630 struct sigmatel_spec *spec = codec->spec;
2633 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2636 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
2639 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
2642 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
2645 if (spec->autocfg.dig_out_pin)
2646 spec->multiout.dig_out_nid = 0x05;
2647 if (spec->autocfg.dig_in_pin)
2648 spec->dig_in_nid = 0x04;
2650 if (spec->kctl_alloc)
2651 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2653 spec->input_mux = &spec->private_imux;
2654 spec->dinput_mux = &spec->private_dimux;
2660 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
2661 * funky external mute control using GPIO pins.
2664 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
2667 unsigned int gpiostate, gpiomask, gpiodir;
2669 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
2670 AC_VERB_GET_GPIO_DATA, 0);
2671 gpiostate = (gpiostate & ~mask) | (data & mask);
2673 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
2674 AC_VERB_GET_GPIO_MASK, 0);
2677 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
2678 AC_VERB_GET_GPIO_DIRECTION, 0);
2681 /* Configure GPIOx as CMOS */
2682 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
2684 snd_hda_codec_write(codec, codec->afg, 0,
2685 AC_VERB_SET_GPIO_MASK, gpiomask);
2686 snd_hda_codec_read(codec, codec->afg, 0,
2687 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
2691 snd_hda_codec_read(codec, codec->afg, 0,
2692 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
2695 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
2698 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
2699 snd_hda_codec_write_cache(codec, nid, 0,
2700 AC_VERB_SET_UNSOLICITED_ENABLE,
2701 (AC_USRSP_EN | event));
2704 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
2707 for (i = 0; i < cfg->hp_outs; i++)
2708 if (cfg->hp_pins[i] == nid)
2709 return 1; /* nid is a HP-Out */
2711 return 0; /* nid is not a HP-Out */
2714 static int stac92xx_init(struct hda_codec *codec)
2716 struct sigmatel_spec *spec = codec->spec;
2717 struct auto_pin_cfg *cfg = &spec->autocfg;
2720 snd_hda_sequence_write(codec, spec->init);
2723 if (spec->hp_detect) {
2724 /* Enable unsolicited responses on the HP widget */
2725 for (i = 0; i < cfg->hp_outs; i++)
2726 enable_pin_detect(codec, cfg->hp_pins[i],
2728 /* force to enable the first line-out; the others are set up
2731 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
2733 stac92xx_auto_init_hp_out(codec);
2734 /* fake event to set up pins */
2735 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2737 stac92xx_auto_init_multi_out(codec);
2738 stac92xx_auto_init_hp_out(codec);
2740 for (i = 0; i < AUTO_PIN_LAST; i++) {
2741 hda_nid_t nid = cfg->input_pins[i];
2743 unsigned int pinctl = AC_PINCTL_IN_EN;
2744 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
2745 pinctl |= stac92xx_get_vref(codec, nid);
2746 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2749 for (i = 0; i < spec->num_dmics; i++)
2750 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
2752 for (i = 0; i < spec->num_pwrs; i++) {
2753 int event = is_nid_hp_pin(cfg, spec->pwr_nids[i])
2754 ? STAC_HP_EVENT : STAC_PWR_EVENT;
2755 int pinctl = snd_hda_codec_read(codec, spec->pwr_nids[i],
2756 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2757 /* outputs are only ports capable of power management
2758 * any attempts on powering down a input port cause the
2759 * referenced VREF to act quirky.
2761 if (pinctl & AC_PINCTL_IN_EN)
2763 enable_pin_detect(codec, spec->pwr_nids[i], event | i);
2764 codec->patch_ops.unsol_event(codec, (event | i) << 26);
2767 if (cfg->dig_out_pin)
2768 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
2770 if (cfg->dig_in_pin)
2771 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
2774 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_data);
2779 static void stac92xx_free(struct hda_codec *codec)
2781 struct sigmatel_spec *spec = codec->spec;
2787 if (spec->kctl_alloc) {
2788 for (i = 0; i < spec->num_kctl_used; i++)
2789 kfree(spec->kctl_alloc[i].name);
2790 kfree(spec->kctl_alloc);
2793 if (spec->bios_pin_configs)
2794 kfree(spec->bios_pin_configs);
2799 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
2802 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2803 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2805 if (pin_ctl & AC_PINCTL_IN_EN) {
2807 * we need to check the current set-up direction of
2808 * shared input pins since they can be switched via
2809 * "xxx as Output" mixer switch
2811 struct sigmatel_spec *spec = codec->spec;
2812 struct auto_pin_cfg *cfg = &spec->autocfg;
2813 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
2814 spec->line_switch) ||
2815 (nid == cfg->input_pins[AUTO_PIN_MIC] &&
2820 /* if setting pin direction bits, clear the current
2821 direction bits first */
2822 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
2823 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
2825 snd_hda_codec_write_cache(codec, nid, 0,
2826 AC_VERB_SET_PIN_WIDGET_CONTROL,
2830 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
2833 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2834 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2835 snd_hda_codec_write_cache(codec, nid, 0,
2836 AC_VERB_SET_PIN_WIDGET_CONTROL,
2840 static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid)
2844 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
2846 unsigned int pinctl;
2847 pinctl = snd_hda_codec_read(codec, nid, 0,
2848 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2849 if (pinctl & AC_PINCTL_IN_EN)
2850 return 0; /* mic- or line-input */
2852 return 1; /* HP-output */
2857 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
2859 struct sigmatel_spec *spec = codec->spec;
2860 struct auto_pin_cfg *cfg = &spec->autocfg;
2864 for (i = 0; i < cfg->hp_outs; i++) {
2865 presence = get_hp_pin_presence(codec, cfg->hp_pins[i]);
2871 /* disable lineouts, enable hp */
2872 for (i = 0; i < cfg->line_outs; i++)
2873 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
2875 for (i = 0; i < cfg->speaker_outs; i++)
2876 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
2879 /* enable lineouts, disable hp */
2880 for (i = 0; i < cfg->line_outs; i++)
2881 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
2883 for (i = 0; i < cfg->speaker_outs; i++)
2884 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
2889 static void stac92xx_pin_sense(struct hda_codec *codec, int idx)
2891 struct sigmatel_spec *spec = codec->spec;
2892 hda_nid_t nid = spec->pwr_nids[idx];
2894 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0)
2896 presence = get_hp_pin_presence(codec, nid);
2904 /* power down unused output ports */
2905 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
2908 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
2910 struct sigmatel_spec *spec = codec->spec;
2911 int idx = res >> 26 & 0x0f;
2913 switch ((res >> 26) & 0x30) {
2915 stac92xx_hp_detect(codec, res);
2917 case STAC_PWR_EVENT:
2918 if (spec->num_pwrs > 0)
2919 stac92xx_pin_sense(codec, idx);
2923 #ifdef SND_HDA_NEEDS_RESUME
2924 static int stac92xx_resume(struct hda_codec *codec)
2926 struct sigmatel_spec *spec = codec->spec;
2928 stac92xx_set_config_regs(codec);
2929 snd_hda_sequence_write(codec, spec->init);
2930 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_data);
2931 snd_hda_codec_resume_amp(codec);
2932 snd_hda_codec_resume_cache(codec);
2933 /* invoke unsolicited event to reset the HP state */
2934 if (spec->hp_detect)
2935 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2940 static struct hda_codec_ops stac92xx_patch_ops = {
2941 .build_controls = stac92xx_build_controls,
2942 .build_pcms = stac92xx_build_pcms,
2943 .init = stac92xx_init,
2944 .free = stac92xx_free,
2945 .unsol_event = stac92xx_unsol_event,
2946 #ifdef SND_HDA_NEEDS_RESUME
2947 .resume = stac92xx_resume,
2951 static int patch_stac9200(struct hda_codec *codec)
2953 struct sigmatel_spec *spec;
2956 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2961 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
2962 spec->pin_nids = stac9200_pin_nids;
2963 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
2966 if (spec->board_config < 0) {
2967 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
2968 err = stac92xx_save_bios_config_regs(codec);
2970 stac92xx_free(codec);
2973 spec->pin_configs = spec->bios_pin_configs;
2975 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
2976 stac92xx_set_config_regs(codec);
2979 spec->multiout.max_channels = 2;
2980 spec->multiout.num_dacs = 1;
2981 spec->multiout.dac_nids = stac9200_dac_nids;
2982 spec->adc_nids = stac9200_adc_nids;
2983 spec->mux_nids = stac9200_mux_nids;
2984 spec->num_muxes = 1;
2985 spec->num_dmics = 0;
2989 if (spec->board_config == STAC_9200_GATEWAY)
2990 spec->init = stac9200_eapd_init;
2992 spec->init = stac9200_core_init;
2993 spec->mixer = stac9200_mixer;
2995 err = stac9200_parse_auto_config(codec);
2997 stac92xx_free(codec);
3001 codec->patch_ops = stac92xx_patch_ops;
3006 static int patch_stac925x(struct hda_codec *codec)
3008 struct sigmatel_spec *spec;
3011 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3016 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
3017 spec->pin_nids = stac925x_pin_nids;
3018 spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
3022 if (spec->board_config < 0) {
3023 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
3024 "using BIOS defaults\n");
3025 err = stac92xx_save_bios_config_regs(codec);
3027 stac92xx_free(codec);
3030 spec->pin_configs = spec->bios_pin_configs;
3031 } else if (stac925x_brd_tbl[spec->board_config] != NULL){
3032 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
3033 stac92xx_set_config_regs(codec);
3036 spec->multiout.max_channels = 2;
3037 spec->multiout.num_dacs = 1;
3038 spec->multiout.dac_nids = stac925x_dac_nids;
3039 spec->adc_nids = stac925x_adc_nids;
3040 spec->mux_nids = stac925x_mux_nids;
3041 spec->num_muxes = 1;
3044 switch (codec->vendor_id) {
3045 case 0x83847632: /* STAC9202 */
3046 case 0x83847633: /* STAC9202D */
3047 case 0x83847636: /* STAC9251 */
3048 case 0x83847637: /* STAC9251D */
3049 spec->num_dmics = STAC925X_NUM_DMICS;
3050 spec->dmic_nids = stac925x_dmic_nids;
3051 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
3052 spec->dmux_nids = stac925x_dmux_nids;
3055 spec->num_dmics = 0;
3059 spec->init = stac925x_core_init;
3060 spec->mixer = stac925x_mixer;
3062 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
3064 if (spec->board_config < 0) {
3065 printk(KERN_WARNING "hda_codec: No auto-config is "
3066 "available, default to model=ref\n");
3067 spec->board_config = STAC_925x_REF;
3073 stac92xx_free(codec);
3077 codec->patch_ops = stac92xx_patch_ops;
3082 static struct hda_input_mux stac92hd73xx_dmux = {
3085 { "Analog Inputs", 0x0b },
3087 { "Digital Mic 1", 0x09 },
3088 { "Digital Mic 2", 0x0a },
3092 static int patch_stac92hd73xx(struct hda_codec *codec)
3094 struct sigmatel_spec *spec;
3095 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
3098 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3103 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
3104 spec->pin_nids = stac92hd73xx_pin_nids;
3105 spec->board_config = snd_hda_check_board_config(codec,
3106 STAC_92HD73XX_MODELS,
3107 stac92hd73xx_models,
3108 stac92hd73xx_cfg_tbl);
3110 if (spec->board_config < 0) {
3111 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3112 " STAC92HD73XX, using BIOS defaults\n");
3113 err = stac92xx_save_bios_config_regs(codec);
3115 stac92xx_free(codec);
3118 spec->pin_configs = spec->bios_pin_configs;
3120 spec->pin_configs = stac92hd73xx_brd_tbl[spec->board_config];
3121 stac92xx_set_config_regs(codec);
3124 spec->multiout.num_dacs = snd_hda_get_connections(codec, 0x0a,
3125 conn, STAC92HD73_DAC_COUNT + 2) - 1;
3127 if (spec->multiout.num_dacs < 0) {
3128 printk(KERN_WARNING "hda_codec: Could not determine "
3129 "number of channels defaulting to DAC count\n");
3130 spec->multiout.num_dacs = STAC92HD73_DAC_COUNT;
3133 switch (spec->multiout.num_dacs) {
3134 case 0x3: /* 6 Channel */
3135 spec->mixer = stac92hd73xx_6ch_mixer;
3136 spec->init = stac92hd73xx_6ch_core_init;
3138 case 0x4: /* 8 Channel */
3139 spec->multiout.hp_nid = 0x18;
3140 spec->mixer = stac92hd73xx_8ch_mixer;
3141 spec->init = stac92hd73xx_8ch_core_init;
3143 case 0x5: /* 10 Channel */
3144 spec->multiout.hp_nid = 0x19;
3145 spec->mixer = stac92hd73xx_10ch_mixer;
3146 spec->init = stac92hd73xx_10ch_core_init;
3149 spec->multiout.dac_nids = stac92hd73xx_dac_nids;
3150 spec->aloopback_mask = 0x01;
3151 spec->aloopback_shift = 8;
3153 spec->mux_nids = stac92hd73xx_mux_nids;
3154 spec->adc_nids = stac92hd73xx_adc_nids;
3155 spec->dmic_nids = stac92hd73xx_dmic_nids;
3156 spec->dmux_nids = stac92hd73xx_dmux_nids;
3158 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
3159 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
3160 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
3161 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
3162 spec->dinput_mux = &stac92hd73xx_dmux;
3163 /* GPIO0 High = Enable EAPD */
3164 spec->gpio_mask = spec->gpio_data = 0x000001;
3166 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
3167 spec->pwr_nids = stac92hd73xx_pwr_nids;
3169 err = stac92xx_parse_auto_config(codec, 0x22, 0x24);
3172 if (spec->board_config < 0) {
3173 printk(KERN_WARNING "hda_codec: No auto-config is "
3174 "available, default to model=ref\n");
3175 spec->board_config = STAC_92HD73XX_REF;
3182 stac92xx_free(codec);
3186 codec->patch_ops = stac92xx_patch_ops;
3191 static int patch_stac92hd71bxx(struct hda_codec *codec)
3193 struct sigmatel_spec *spec;
3196 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3201 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
3202 spec->pin_nids = stac92hd71bxx_pin_nids;
3203 spec->board_config = snd_hda_check_board_config(codec,
3204 STAC_92HD71BXX_MODELS,
3205 stac92hd71bxx_models,
3206 stac92hd71bxx_cfg_tbl);
3208 if (spec->board_config < 0) {
3209 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3210 " STAC92HD71BXX, using BIOS defaults\n");
3211 err = stac92xx_save_bios_config_regs(codec);
3213 stac92xx_free(codec);
3216 spec->pin_configs = spec->bios_pin_configs;
3218 spec->pin_configs = stac92hd71bxx_brd_tbl[spec->board_config];
3219 stac92xx_set_config_regs(codec);
3222 switch (codec->vendor_id) {
3223 case 0x111d76b6: /* 4 Port without Analog Mixer */
3225 case 0x111d76b4: /* 6 Port without Analog Mixer */
3227 spec->mixer = stac92hd71bxx_mixer;
3228 spec->init = stac92hd71bxx_core_init;
3231 spec->mixer = stac92hd71bxx_analog_mixer;
3232 spec->init = stac92hd71bxx_analog_core_init;
3235 spec->aloopback_mask = 0x20;
3236 spec->aloopback_shift = 0;
3238 spec->gpio_mask = spec->gpio_data = 0x00000001; /* GPIO0 High = EAPD */
3240 spec->mux_nids = stac92hd71bxx_mux_nids;
3241 spec->adc_nids = stac92hd71bxx_adc_nids;
3242 spec->dmic_nids = stac92hd71bxx_dmic_nids;
3243 spec->dmux_nids = stac92hd71bxx_dmux_nids;
3245 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
3246 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
3247 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
3248 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
3250 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
3251 spec->pwr_nids = stac92hd71bxx_pwr_nids;
3253 spec->multiout.num_dacs = 2;
3254 spec->multiout.hp_nid = 0x11;
3255 spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
3257 err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
3259 if (spec->board_config < 0) {
3260 printk(KERN_WARNING "hda_codec: No auto-config is "
3261 "available, default to model=ref\n");
3262 spec->board_config = STAC_92HD71BXX_REF;
3269 stac92xx_free(codec);
3273 codec->patch_ops = stac92xx_patch_ops;
3278 static int patch_stac922x(struct hda_codec *codec)
3280 struct sigmatel_spec *spec;
3283 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3288 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
3289 spec->pin_nids = stac922x_pin_nids;
3290 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
3293 if (spec->board_config == STAC_INTEL_MAC_V3) {
3294 spec->gpio_mask = spec->gpio_data = 0x03;
3295 /* Intel Macs have all same PCI SSID, so we need to check
3296 * codec SSID to distinguish the exact models
3298 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
3299 switch (codec->subsystem_id) {
3302 spec->board_config = STAC_INTEL_MAC_V1;
3306 spec->board_config = STAC_INTEL_MAC_V2;
3314 spec->board_config = STAC_INTEL_MAC_V3;
3318 spec->board_config = STAC_INTEL_MAC_V4;
3322 spec->board_config = STAC_INTEL_MAC_V5;
3328 if (spec->board_config < 0) {
3329 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
3330 "using BIOS defaults\n");
3331 err = stac92xx_save_bios_config_regs(codec);
3333 stac92xx_free(codec);
3336 spec->pin_configs = spec->bios_pin_configs;
3337 } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
3338 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
3339 stac92xx_set_config_regs(codec);
3342 spec->adc_nids = stac922x_adc_nids;
3343 spec->mux_nids = stac922x_mux_nids;
3344 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
3345 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
3346 spec->num_dmics = 0;
3349 spec->init = stac922x_core_init;
3350 spec->mixer = stac922x_mixer;
3352 spec->multiout.dac_nids = spec->dac_nids;
3354 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
3356 if (spec->board_config < 0) {
3357 printk(KERN_WARNING "hda_codec: No auto-config is "
3358 "available, default to model=ref\n");
3359 spec->board_config = STAC_D945_REF;
3365 stac92xx_free(codec);
3369 codec->patch_ops = stac92xx_patch_ops;
3371 /* Fix Mux capture level; max to 2 */
3372 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
3373 (0 << AC_AMPCAP_OFFSET_SHIFT) |
3374 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3375 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3376 (0 << AC_AMPCAP_MUTE_SHIFT));
3381 static int patch_stac927x(struct hda_codec *codec)
3383 struct sigmatel_spec *spec;
3386 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3391 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
3392 spec->pin_nids = stac927x_pin_nids;
3393 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
3397 if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
3398 if (spec->board_config < 0)
3399 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3400 "STAC927x, using BIOS defaults\n");
3401 err = stac92xx_save_bios_config_regs(codec);
3403 stac92xx_free(codec);
3406 spec->pin_configs = spec->bios_pin_configs;
3408 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
3409 stac92xx_set_config_regs(codec);
3412 spec->adc_nids = stac927x_adc_nids;
3413 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
3414 spec->mux_nids = stac927x_mux_nids;
3415 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
3416 spec->multiout.dac_nids = spec->dac_nids;
3418 switch (spec->board_config) {
3421 /* GPIO0 High = Enable EAPD */
3422 spec->gpio_mask = spec->gpio_data = 0x00000001;
3423 spec->num_dmics = 0;
3425 spec->init = d965_core_init;
3426 spec->mixer = stac927x_mixer;
3428 case STAC_DELL_BIOS:
3429 /* correct the front output jack as a hp out */
3430 stac92xx_set_config_reg(codec, 0x0f, 0x02270110);
3431 /* correct the front input jack as a mic */
3432 stac92xx_set_config_reg(codec, 0x0e, 0x02a79130);
3435 /* GPIO2 High = Enable EAPD */
3436 spec->gpio_mask = spec->gpio_data = 0x00000004;
3437 spec->dmic_nids = stac927x_dmic_nids;
3438 spec->num_dmics = STAC927X_NUM_DMICS;
3440 spec->init = d965_core_init;
3441 spec->mixer = stac927x_mixer;
3442 spec->dmux_nids = stac927x_dmux_nids;
3443 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
3446 /* GPIO0 High = Enable EAPD */
3447 spec->gpio_mask = spec->gpio_data = 0x00000001;
3448 spec->num_dmics = 0;
3450 spec->init = stac927x_core_init;
3451 spec->mixer = stac927x_mixer;
3455 spec->aloopback_mask = 0x40;
3456 spec->aloopback_shift = 0;
3458 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
3460 if (spec->board_config < 0) {
3461 printk(KERN_WARNING "hda_codec: No auto-config is "
3462 "available, default to model=ref\n");
3463 spec->board_config = STAC_D965_REF;
3469 stac92xx_free(codec);
3473 codec->patch_ops = stac92xx_patch_ops;
3478 static int patch_stac9205(struct hda_codec *codec)
3480 struct sigmatel_spec *spec;
3483 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3488 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
3489 spec->pin_nids = stac9205_pin_nids;
3490 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
3494 if (spec->board_config < 0) {
3495 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
3496 err = stac92xx_save_bios_config_regs(codec);
3498 stac92xx_free(codec);
3501 spec->pin_configs = spec->bios_pin_configs;
3503 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
3504 stac92xx_set_config_regs(codec);
3507 spec->adc_nids = stac9205_adc_nids;
3508 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
3509 spec->mux_nids = stac9205_mux_nids;
3510 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
3511 spec->dmic_nids = stac9205_dmic_nids;
3512 spec->num_dmics = STAC9205_NUM_DMICS;
3513 spec->dmux_nids = stac9205_dmux_nids;
3514 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
3517 spec->init = stac9205_core_init;
3518 spec->mixer = stac9205_mixer;
3520 spec->aloopback_mask = 0x40;
3521 spec->aloopback_shift = 0;
3522 spec->multiout.dac_nids = spec->dac_nids;
3524 switch (spec->board_config){
3525 case STAC_9205_DELL_M43:
3526 /* Enable SPDIF in/out */
3527 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
3528 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
3530 spec->gpio_mask = 0x00000007; /* GPIO0-2 */
3531 /* GPIO0 High = EAPD, GPIO1 Low = DRM,
3532 * GPIO2 High = Headphone Mute
3534 spec->gpio_data = 0x00000005;
3537 /* GPIO0 High = EAPD */
3538 spec->gpio_mask = spec->gpio_data = 0x00000001;
3542 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
3544 if (spec->board_config < 0) {
3545 printk(KERN_WARNING "hda_codec: No auto-config is "
3546 "available, default to model=ref\n");
3547 spec->board_config = STAC_9205_REF;
3553 stac92xx_free(codec);
3557 codec->patch_ops = stac92xx_patch_ops;
3566 /* static config for Sony VAIO FE550G and Sony VAIO AR */
3567 static hda_nid_t vaio_dacs[] = { 0x2 };
3568 #define VAIO_HP_DAC 0x5
3569 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
3570 static hda_nid_t vaio_mux_nids[] = { 0x15 };
3572 static struct hda_input_mux vaio_mux = {
3575 /* { "HP", 0x0 }, */
3576 { "Mic Jack", 0x1 },
3577 { "Internal Mic", 0x2 },
3582 static struct hda_verb vaio_init[] = {
3583 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3584 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
3585 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3586 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3587 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3588 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3589 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3590 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3591 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3592 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3593 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3594 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3598 static struct hda_verb vaio_ar_init[] = {
3599 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3600 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3601 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3602 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3603 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
3604 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3605 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3606 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3607 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3608 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
3609 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3610 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3611 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3615 /* bind volumes of both NID 0x02 and 0x05 */
3616 static struct hda_bind_ctls vaio_bind_master_vol = {
3617 .ops = &snd_hda_bind_vol,
3619 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3620 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3625 /* bind volumes of both NID 0x02 and 0x05 */
3626 static struct hda_bind_ctls vaio_bind_master_sw = {
3627 .ops = &snd_hda_bind_sw,
3629 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3630 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3635 static struct snd_kcontrol_new vaio_mixer[] = {
3636 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3637 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3638 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3639 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3640 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3642 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3643 .name = "Capture Source",
3645 .info = stac92xx_mux_enum_info,
3646 .get = stac92xx_mux_enum_get,
3647 .put = stac92xx_mux_enum_put,
3652 static struct snd_kcontrol_new vaio_ar_mixer[] = {
3653 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3654 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3655 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3656 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3657 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3658 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
3659 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
3661 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3662 .name = "Capture Source",
3664 .info = stac92xx_mux_enum_info,
3665 .get = stac92xx_mux_enum_get,
3666 .put = stac92xx_mux_enum_put,
3671 static struct hda_codec_ops stac9872_patch_ops = {
3672 .build_controls = stac92xx_build_controls,
3673 .build_pcms = stac92xx_build_pcms,
3674 .init = stac92xx_init,
3675 .free = stac92xx_free,
3676 #ifdef SND_HDA_NEEDS_RESUME
3677 .resume = stac92xx_resume,
3681 static int stac9872_vaio_init(struct hda_codec *codec)
3685 err = stac92xx_init(codec);
3688 if (codec->patch_ops.unsol_event)
3689 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3693 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
3695 if (get_hp_pin_presence(codec, 0x0a)) {
3696 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3697 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3699 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3700 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3704 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
3706 switch (res >> 26) {
3708 stac9872_vaio_hp_detect(codec, res);
3713 static struct hda_codec_ops stac9872_vaio_patch_ops = {
3714 .build_controls = stac92xx_build_controls,
3715 .build_pcms = stac92xx_build_pcms,
3716 .init = stac9872_vaio_init,
3717 .free = stac92xx_free,
3718 .unsol_event = stac9872_vaio_unsol_event,
3720 .resume = stac92xx_resume,
3724 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
3726 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
3728 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
3730 /* AR Series. id=0x83847664 and subsys=104D1300 */
3735 static const char *stac9872_models[STAC_9872_MODELS] = {
3736 [CXD9872RD_VAIO] = "vaio",
3737 [CXD9872AKD_VAIO] = "vaio-ar",
3740 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
3741 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
3742 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
3743 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
3744 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
3748 static int patch_stac9872(struct hda_codec *codec)
3750 struct sigmatel_spec *spec;
3753 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
3756 if (board_config < 0)
3757 /* unknown config, let generic-parser do its job... */
3758 return snd_hda_parse_generic_codec(codec);
3760 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3765 switch (board_config) {
3766 case CXD9872RD_VAIO:
3767 case STAC9872AK_VAIO:
3768 case STAC9872K_VAIO:
3769 spec->mixer = vaio_mixer;
3770 spec->init = vaio_init;
3771 spec->multiout.max_channels = 2;
3772 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3773 spec->multiout.dac_nids = vaio_dacs;
3774 spec->multiout.hp_nid = VAIO_HP_DAC;
3775 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3776 spec->adc_nids = vaio_adcs;
3778 spec->input_mux = &vaio_mux;
3779 spec->mux_nids = vaio_mux_nids;
3780 codec->patch_ops = stac9872_vaio_patch_ops;
3783 case CXD9872AKD_VAIO:
3784 spec->mixer = vaio_ar_mixer;
3785 spec->init = vaio_ar_init;
3786 spec->multiout.max_channels = 2;
3787 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3788 spec->multiout.dac_nids = vaio_dacs;
3789 spec->multiout.hp_nid = VAIO_HP_DAC;
3790 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3792 spec->adc_nids = vaio_adcs;
3793 spec->input_mux = &vaio_mux;
3794 spec->mux_nids = vaio_mux_nids;
3795 codec->patch_ops = stac9872_patch_ops;
3806 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
3807 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
3808 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
3809 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
3810 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
3811 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
3812 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
3813 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
3814 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
3815 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
3816 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
3817 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
3818 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
3819 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
3820 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
3821 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
3822 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
3823 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
3824 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
3825 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
3826 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
3827 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
3828 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
3829 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
3830 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
3831 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
3832 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
3833 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
3834 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
3835 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
3836 /* The following does not take into account .id=0x83847661 when subsys =
3837 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
3838 * currently not fully supported.
3840 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
3841 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
3842 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
3843 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
3844 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
3845 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
3846 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
3847 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
3848 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
3849 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
3850 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
3851 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
3852 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
3853 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
3854 { .id = 0x111d7608, .name = "92HD71BXX", .patch = patch_stac92hd71bxx },
3855 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
3856 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
3857 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
3858 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
3859 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
3860 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
3861 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
3862 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },