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_input_mux *mono_mux;
135 unsigned int cur_mmux;
136 struct hda_multi_out multiout;
137 hda_nid_t dac_nids[5];
141 unsigned int num_adcs;
143 unsigned int num_muxes;
144 hda_nid_t *dmic_nids;
145 unsigned int num_dmics;
146 hda_nid_t *dmux_nids;
147 unsigned int num_dmuxes;
148 hda_nid_t dig_in_nid;
153 unsigned int num_pins;
154 unsigned int *pin_configs;
155 unsigned int *bios_pin_configs;
157 /* codec specific stuff */
158 struct hda_verb *init;
159 struct snd_kcontrol_new *mixer;
162 struct hda_input_mux *dinput_mux;
163 unsigned int cur_dmux[2];
164 struct hda_input_mux *input_mux;
165 unsigned int cur_mux[3];
168 unsigned int io_switch[2];
169 unsigned int clfe_swap;
170 unsigned int aloopback;
172 struct hda_pcm pcm_rec[2]; /* PCM information */
174 /* dynamic controls and input_mux */
175 struct auto_pin_cfg autocfg;
176 unsigned int num_kctl_alloc, num_kctl_used;
177 struct snd_kcontrol_new *kctl_alloc;
178 struct hda_input_mux private_dimux;
179 struct hda_input_mux private_imux;
180 struct hda_input_mux private_mono_mux;
183 unsigned int vmaster_tlv[4];
186 static hda_nid_t stac9200_adc_nids[1] = {
190 static hda_nid_t stac9200_mux_nids[1] = {
194 static hda_nid_t stac9200_dac_nids[1] = {
198 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
199 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
203 static hda_nid_t stac92hd73xx_adc_nids[2] = {
207 #define STAC92HD73XX_NUM_DMICS 2
208 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
212 #define STAC92HD73_DAC_COUNT 5
213 static hda_nid_t stac92hd73xx_dac_nids[STAC92HD73_DAC_COUNT] = {
214 0x15, 0x16, 0x17, 0x18, 0x19,
217 static hda_nid_t stac92hd73xx_mux_nids[4] = {
218 0x28, 0x29, 0x2a, 0x2b,
221 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
225 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
229 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
233 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
237 static hda_nid_t stac92hd71bxx_dmux_nids[1] = {
241 static hda_nid_t stac92hd71bxx_dac_nids[2] = {
245 #define STAC92HD71BXX_NUM_DMICS 2
246 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
250 static hda_nid_t stac925x_adc_nids[1] = {
254 static hda_nid_t stac925x_mux_nids[1] = {
258 static hda_nid_t stac925x_dac_nids[1] = {
262 #define STAC925X_NUM_DMICS 1
263 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
267 static hda_nid_t stac925x_dmux_nids[1] = {
271 static hda_nid_t stac922x_adc_nids[2] = {
275 static hda_nid_t stac922x_mux_nids[2] = {
279 static hda_nid_t stac927x_adc_nids[3] = {
283 static hda_nid_t stac927x_mux_nids[3] = {
287 static hda_nid_t stac927x_dmux_nids[1] = {
291 #define STAC927X_NUM_DMICS 2
292 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
296 static hda_nid_t stac9205_adc_nids[2] = {
300 static hda_nid_t stac9205_mux_nids[2] = {
304 static hda_nid_t stac9205_dmux_nids[1] = {
308 #define STAC9205_NUM_DMICS 2
309 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
313 static hda_nid_t stac9200_pin_nids[8] = {
314 0x08, 0x09, 0x0d, 0x0e,
315 0x0f, 0x10, 0x11, 0x12,
318 static hda_nid_t stac925x_pin_nids[8] = {
319 0x07, 0x08, 0x0a, 0x0b,
320 0x0c, 0x0d, 0x10, 0x11,
323 static hda_nid_t stac922x_pin_nids[10] = {
324 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
325 0x0f, 0x10, 0x11, 0x15, 0x1b,
328 static hda_nid_t stac92hd73xx_pin_nids[12] = {
329 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
330 0x0f, 0x10, 0x11, 0x12, 0x13,
334 static hda_nid_t stac92hd71bxx_pin_nids[10] = {
335 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
336 0x0f, 0x14, 0x18, 0x19, 0x1e,
339 static hda_nid_t stac927x_pin_nids[14] = {
340 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
341 0x0f, 0x10, 0x11, 0x12, 0x13,
342 0x14, 0x21, 0x22, 0x23,
345 static hda_nid_t stac9205_pin_nids[12] = {
346 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
347 0x0f, 0x14, 0x16, 0x17, 0x18,
351 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
352 struct snd_ctl_elem_info *uinfo)
354 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
355 struct sigmatel_spec *spec = codec->spec;
356 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
359 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
360 struct snd_ctl_elem_value *ucontrol)
362 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
363 struct sigmatel_spec *spec = codec->spec;
364 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
366 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
370 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
371 struct snd_ctl_elem_value *ucontrol)
373 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
374 struct sigmatel_spec *spec = codec->spec;
375 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
377 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
378 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
381 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
383 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
384 struct sigmatel_spec *spec = codec->spec;
385 return snd_hda_input_mux_info(spec->input_mux, uinfo);
388 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
390 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
391 struct sigmatel_spec *spec = codec->spec;
392 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
394 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
398 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
400 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
401 struct sigmatel_spec *spec = codec->spec;
402 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
404 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
405 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
408 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
409 struct snd_ctl_elem_info *uinfo)
411 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
412 struct sigmatel_spec *spec = codec->spec;
413 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
416 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
417 struct snd_ctl_elem_value *ucontrol)
419 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
420 struct sigmatel_spec *spec = codec->spec;
422 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
426 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
427 struct snd_ctl_elem_value *ucontrol)
429 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
430 struct sigmatel_spec *spec = codec->spec;
432 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
433 spec->mono_nid, &spec->cur_mmux);
436 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
438 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
439 struct snd_ctl_elem_value *ucontrol)
441 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
442 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
443 struct sigmatel_spec *spec = codec->spec;
445 ucontrol->value.integer.value[0] = !!(spec->aloopback &
446 (spec->aloopback_mask << idx));
450 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
451 struct snd_ctl_elem_value *ucontrol)
453 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
454 struct sigmatel_spec *spec = codec->spec;
455 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
456 unsigned int dac_mode;
457 unsigned int val, idx_val;
459 idx_val = spec->aloopback_mask << idx;
460 if (ucontrol->value.integer.value[0])
461 val = spec->aloopback | idx_val;
463 val = spec->aloopback & ~idx_val;
464 if (spec->aloopback == val)
467 spec->aloopback = val;
469 /* Only return the bits defined by the shift value of the
470 * first two bytes of the mask
472 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
473 kcontrol->private_value & 0xFFFF, 0x0);
474 dac_mode >>= spec->aloopback_shift;
476 if (spec->aloopback & idx_val) {
477 snd_hda_power_up(codec);
480 snd_hda_power_down(codec);
481 dac_mode &= ~idx_val;
484 snd_hda_codec_write_cache(codec, codec->afg, 0,
485 kcontrol->private_value >> 16, dac_mode);
490 static struct hda_verb stac9200_core_init[] = {
491 /* set dac0mux for dac converter */
492 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
496 static struct hda_verb stac9200_eapd_init[] = {
497 /* set dac0mux for dac converter */
498 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
499 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
503 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
504 /* set master volume and direct control */
505 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
506 /* setup audio connections */
507 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
508 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
509 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
510 /* setup adcs to point to mixer */
511 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
512 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
513 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
514 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
515 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
516 /* setup import muxs */
517 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
518 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
519 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
520 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
524 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
525 /* set master volume and direct control */
526 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
527 /* setup audio connections */
528 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
529 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
530 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
531 /* connect hp ports to dac3 */
532 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x03},
533 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x03},
534 /* setup adcs to point to mixer */
535 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
536 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
537 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
538 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
539 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
540 /* setup import muxs */
541 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
542 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
543 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
544 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
548 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
549 /* set master volume and direct control */
550 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
551 /* setup audio connections */
552 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
553 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01 },
554 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02 },
555 /* dac3 is connected to import3 mux */
556 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
557 /* connect hp ports to dac4 */
558 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x04},
559 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x04},
560 /* setup adcs to point to mixer */
561 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
562 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
563 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
564 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
565 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
566 /* setup import muxs */
567 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
568 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
569 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
570 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
574 static struct hda_verb stac92hd71bxx_core_init[] = {
575 /* set master volume and direct control */
576 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
577 /* connect headphone jack to dac1 */
578 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
579 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */
580 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
581 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
582 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
583 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
586 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
587 /* set master volume and direct control */
588 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
589 /* connect headphone jack to dac1 */
590 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
591 /* connect ports 0d and 0f to audio mixer */
592 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x2},
593 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
594 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */
595 /* unmute dac0 input in audio mixer */
596 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
597 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
598 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
599 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
600 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
604 static struct hda_verb stac925x_core_init[] = {
605 /* set dac0mux for dac converter */
606 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
610 static struct hda_verb stac922x_core_init[] = {
611 /* set master volume and direct control */
612 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
616 static struct hda_verb d965_core_init[] = {
617 /* set master volume and direct control */
618 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
619 /* unmute node 0x1b */
620 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
621 /* select node 0x03 as DAC */
622 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
626 static struct hda_verb stac927x_core_init[] = {
627 /* set master volume and direct control */
628 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
632 static struct hda_verb stac9205_core_init[] = {
633 /* set master volume and direct control */
634 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
638 #define STAC_MONO_MUX \
640 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
641 .name = "Mono Mux", \
643 .info = stac92xx_mono_mux_enum_info, \
644 .get = stac92xx_mono_mux_enum_get, \
645 .put = stac92xx_mono_mux_enum_put, \
648 #define STAC_INPUT_SOURCE(cnt) \
650 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
651 .name = "Input Source", \
653 .info = stac92xx_mux_enum_info, \
654 .get = stac92xx_mux_enum_get, \
655 .put = stac92xx_mux_enum_put, \
658 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
660 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
661 .name = "Analog Loopback", \
663 .info = stac92xx_aloopback_info, \
664 .get = stac92xx_aloopback_get, \
665 .put = stac92xx_aloopback_put, \
666 .private_value = verb_read | (verb_write << 16), \
669 static struct snd_kcontrol_new stac9200_mixer[] = {
670 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
671 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
672 STAC_INPUT_SOURCE(1),
673 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
674 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
675 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT),
679 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
680 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
682 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
683 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
685 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
686 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
688 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
689 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
691 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
692 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
694 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
695 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
697 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
698 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
700 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
701 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
705 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
706 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
708 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
709 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
711 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
712 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
714 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
715 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
717 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
718 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
720 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
721 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
723 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
724 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
726 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
727 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
731 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
732 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
734 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
735 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
737 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
738 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
740 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
741 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
743 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
744 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
746 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
747 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
749 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
750 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
752 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
753 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
757 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
758 STAC_INPUT_SOURCE(2),
761 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
762 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
763 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
765 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
766 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
767 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
769 HDA_CODEC_MUTE("Analog Loopback 1", 0x17, 0x3, HDA_INPUT),
770 HDA_CODEC_MUTE("Analog Loopback 2", 0x17, 0x4, HDA_INPUT),
772 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x14, 0x1, 0, HDA_INPUT),
776 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
777 STAC_INPUT_SOURCE(2),
778 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
781 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
782 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
783 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
785 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
786 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
787 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
789 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x14, 0x1, 0, HDA_INPUT),
793 static struct snd_kcontrol_new stac925x_mixer[] = {
794 STAC_INPUT_SOURCE(1),
795 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
796 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_OUTPUT),
797 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT),
801 static struct snd_kcontrol_new stac9205_mixer[] = {
802 STAC_INPUT_SOURCE(2),
803 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
805 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
806 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
807 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT),
809 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
810 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
811 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT),
816 /* This needs to be generated dynamically based on sequence */
817 static struct snd_kcontrol_new stac922x_mixer[] = {
818 STAC_INPUT_SOURCE(2),
819 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
820 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
821 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT),
823 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
824 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
825 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT),
830 static struct snd_kcontrol_new stac927x_mixer[] = {
831 STAC_INPUT_SOURCE(3),
832 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
834 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
835 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
836 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT),
838 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
839 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
840 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT),
842 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
843 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
844 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT),
848 static struct snd_kcontrol_new stac_dmux_mixer = {
849 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
850 .name = "Digital Input Source",
851 /* count set later */
852 .info = stac92xx_dmux_enum_info,
853 .get = stac92xx_dmux_enum_get,
854 .put = stac92xx_dmux_enum_put,
857 static const char *slave_vols[] = {
858 "Front Playback Volume",
859 "Surround Playback Volume",
860 "Center Playback Volume",
861 "LFE Playback Volume",
862 "Side Playback Volume",
863 "Headphone Playback Volume",
864 "Headphone Playback Volume",
865 "Speaker Playback Volume",
866 "External Speaker Playback Volume",
867 "Speaker2 Playback Volume",
871 static const char *slave_sws[] = {
872 "Front Playback Switch",
873 "Surround Playback Switch",
874 "Center Playback Switch",
875 "LFE Playback Switch",
876 "Side Playback Switch",
877 "Headphone Playback Switch",
878 "Headphone Playback Switch",
879 "Speaker Playback Switch",
880 "External Speaker Playback Switch",
881 "Speaker2 Playback Switch",
885 static int stac92xx_build_controls(struct hda_codec *codec)
887 struct sigmatel_spec *spec = codec->spec;
891 err = snd_hda_add_new_ctls(codec, spec->mixer);
895 for (i = 0; i < spec->num_mixers; i++) {
896 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
900 if (spec->num_dmuxes > 0) {
901 stac_dmux_mixer.count = spec->num_dmuxes;
902 err = snd_ctl_add(codec->bus->card,
903 snd_ctl_new1(&stac_dmux_mixer, codec));
908 if (spec->multiout.dig_out_nid) {
909 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
913 if (spec->dig_in_nid) {
914 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
919 /* if we have no master control, let's create it */
920 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
921 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
922 HDA_OUTPUT, spec->vmaster_tlv);
923 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
924 spec->vmaster_tlv, slave_vols);
928 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
929 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
938 static unsigned int ref9200_pin_configs[8] = {
939 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
940 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
944 STAC 9200 pin configs for
949 static unsigned int dell9200_d21_pin_configs[8] = {
950 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
951 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
955 STAC 9200 pin configs for
959 static unsigned int dell9200_d22_pin_configs[8] = {
960 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
961 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
965 STAC 9200 pin configs for
966 102801C4 (Dell Dimension E310)
973 static unsigned int dell9200_d23_pin_configs[8] = {
974 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
975 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
980 STAC 9200-32 pin configs for
981 102801B5 (Dell Inspiron 630m)
982 102801D8 (Dell Inspiron 640m)
984 static unsigned int dell9200_m21_pin_configs[8] = {
985 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
986 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
990 STAC 9200-32 pin configs for
991 102801C2 (Dell Latitude D620)
993 102801CC (Dell Latitude D820)
997 static unsigned int dell9200_m22_pin_configs[8] = {
998 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
999 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1003 STAC 9200-32 pin configs for
1004 102801CE (Dell XPS M1710)
1005 102801CF (Dell Precision M90)
1007 static unsigned int dell9200_m23_pin_configs[8] = {
1008 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1009 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1013 STAC 9200-32 pin configs for
1016 102801CB (Dell Latitude 120L)
1019 static unsigned int dell9200_m24_pin_configs[8] = {
1020 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1021 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1025 STAC 9200-32 pin configs for
1026 102801BD (Dell Inspiron E1505n)
1030 static unsigned int dell9200_m25_pin_configs[8] = {
1031 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1032 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1036 STAC 9200-32 pin configs for
1037 102801F5 (Dell Inspiron 1501)
1040 static unsigned int dell9200_m26_pin_configs[8] = {
1041 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1042 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1047 102801CD (Dell Inspiron E1705/9400)
1049 static unsigned int dell9200_m27_pin_configs[8] = {
1050 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1051 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1055 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1056 [STAC_REF] = ref9200_pin_configs,
1057 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1058 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1059 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1060 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1061 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1062 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1063 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1064 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1065 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1066 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1069 static const char *stac9200_models[STAC_9200_MODELS] = {
1071 [STAC_9200_DELL_D21] = "dell-d21",
1072 [STAC_9200_DELL_D22] = "dell-d22",
1073 [STAC_9200_DELL_D23] = "dell-d23",
1074 [STAC_9200_DELL_M21] = "dell-m21",
1075 [STAC_9200_DELL_M22] = "dell-m22",
1076 [STAC_9200_DELL_M23] = "dell-m23",
1077 [STAC_9200_DELL_M24] = "dell-m24",
1078 [STAC_9200_DELL_M25] = "dell-m25",
1079 [STAC_9200_DELL_M26] = "dell-m26",
1080 [STAC_9200_DELL_M27] = "dell-m27",
1081 [STAC_9200_GATEWAY] = "gateway",
1084 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1085 /* SigmaTel reference board */
1086 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1087 "DFI LanParty", STAC_REF),
1088 /* Dell laptops have BIOS problem */
1089 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1090 "unknown Dell", STAC_9200_DELL_D21),
1091 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1092 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1093 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1094 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1095 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1096 "unknown Dell", STAC_9200_DELL_D22),
1097 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1098 "unknown Dell", STAC_9200_DELL_D22),
1099 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1100 "Dell Latitude D620", STAC_9200_DELL_M22),
1101 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1102 "unknown Dell", STAC_9200_DELL_D23),
1103 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1104 "unknown Dell", STAC_9200_DELL_D23),
1105 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1106 "unknown Dell", STAC_9200_DELL_M22),
1107 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1108 "unknown Dell", STAC_9200_DELL_M24),
1109 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1110 "unknown Dell", STAC_9200_DELL_M24),
1111 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1112 "Dell Latitude 120L", STAC_9200_DELL_M24),
1113 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1114 "Dell Latitude D820", STAC_9200_DELL_M22),
1115 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1116 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1117 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1118 "Dell XPS M1710", STAC_9200_DELL_M23),
1119 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1120 "Dell Precision M90", STAC_9200_DELL_M23),
1121 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1122 "unknown Dell", STAC_9200_DELL_M22),
1123 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1124 "unknown Dell", STAC_9200_DELL_M22),
1125 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1126 "unknown Dell", STAC_9200_DELL_M22),
1127 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1128 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1129 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1130 "unknown Dell", STAC_9200_DELL_D23),
1131 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1132 "unknown Dell", STAC_9200_DELL_D23),
1133 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1134 "unknown Dell", STAC_9200_DELL_D21),
1135 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1136 "unknown Dell", STAC_9200_DELL_D23),
1137 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1138 "unknown Dell", STAC_9200_DELL_D21),
1139 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1140 "unknown Dell", STAC_9200_DELL_M25),
1141 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1142 "unknown Dell", STAC_9200_DELL_M25),
1143 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1144 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1145 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1146 "unknown Dell", STAC_9200_DELL_M26),
1148 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_REF),
1149 /* Gateway machines needs EAPD to be set on resume */
1150 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
1151 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
1153 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
1158 static unsigned int ref925x_pin_configs[8] = {
1159 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1160 0x90a70320, 0x02214210, 0x400003f1, 0x9033032e,
1163 static unsigned int stac925x_MA6_pin_configs[8] = {
1164 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1165 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
1168 static unsigned int stac925x_PA6_pin_configs[8] = {
1169 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1170 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
1173 static unsigned int stac925xM2_2_pin_configs[8] = {
1174 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
1175 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
1178 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1179 [STAC_REF] = ref925x_pin_configs,
1180 [STAC_M2_2] = stac925xM2_2_pin_configs,
1181 [STAC_MA6] = stac925x_MA6_pin_configs,
1182 [STAC_PA6] = stac925x_PA6_pin_configs,
1185 static const char *stac925x_models[STAC_925x_MODELS] = {
1187 [STAC_M2_2] = "m2-2",
1192 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1193 /* SigmaTel reference board */
1194 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1195 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1196 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
1197 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
1198 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
1199 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
1200 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
1204 static unsigned int ref92hd73xx_pin_configs[12] = {
1205 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1206 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1207 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1210 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1211 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1214 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1215 [STAC_92HD73XX_REF] = "ref",
1218 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1219 /* SigmaTel reference board */
1220 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1221 "DFI LanParty", STAC_92HD73XX_REF),
1225 static unsigned int ref92hd71bxx_pin_configs[10] = {
1226 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1227 0x0181302e, 0x01114010, 0x01019020, 0x90a000f0,
1228 0x90a000f0, 0x01452050,
1231 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1232 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1235 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1236 [STAC_92HD71BXX_REF] = "ref",
1239 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1240 /* SigmaTel reference board */
1241 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1242 "DFI LanParty", STAC_92HD71BXX_REF),
1246 static unsigned int ref922x_pin_configs[10] = {
1247 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1248 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1249 0x40000100, 0x40000100,
1253 STAC 922X pin configs for
1260 static unsigned int dell_922x_d81_pin_configs[10] = {
1261 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1262 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1263 0x01813122, 0x400001f2,
1267 STAC 922X pin configs for
1271 static unsigned int dell_922x_d82_pin_configs[10] = {
1272 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1273 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1274 0x01813122, 0x400001f1,
1278 STAC 922X pin configs for
1281 static unsigned int dell_922x_m81_pin_configs[10] = {
1282 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1283 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1284 0x40C003f1, 0x405003f0,
1288 STAC 9221 A1 pin configs for
1289 102801D7 (Dell XPS M1210)
1291 static unsigned int dell_922x_m82_pin_configs[10] = {
1292 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1293 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1294 0x508003f3, 0x405003f4,
1297 static unsigned int d945gtp3_pin_configs[10] = {
1298 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1299 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1300 0x02a19120, 0x40000100,
1303 static unsigned int d945gtp5_pin_configs[10] = {
1304 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1305 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1306 0x02a19320, 0x40000100,
1309 static unsigned int intel_mac_v1_pin_configs[10] = {
1310 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1311 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1312 0x400000fc, 0x400000fb,
1315 static unsigned int intel_mac_v2_pin_configs[10] = {
1316 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1317 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1318 0x400000fc, 0x400000fb,
1321 static unsigned int intel_mac_v3_pin_configs[10] = {
1322 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1323 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1324 0x400000fc, 0x400000fb,
1327 static unsigned int intel_mac_v4_pin_configs[10] = {
1328 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1329 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1330 0x400000fc, 0x400000fb,
1333 static unsigned int intel_mac_v5_pin_configs[10] = {
1334 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1335 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1336 0x400000fc, 0x400000fb,
1340 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1341 [STAC_D945_REF] = ref922x_pin_configs,
1342 [STAC_D945GTP3] = d945gtp3_pin_configs,
1343 [STAC_D945GTP5] = d945gtp5_pin_configs,
1344 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1345 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1346 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1347 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1348 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1349 /* for backward compatibility */
1350 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1351 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1352 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1353 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1354 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1355 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1356 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1357 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1358 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1359 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1362 static const char *stac922x_models[STAC_922X_MODELS] = {
1363 [STAC_D945_REF] = "ref",
1364 [STAC_D945GTP5] = "5stack",
1365 [STAC_D945GTP3] = "3stack",
1366 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1367 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1368 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1369 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1370 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1371 /* for backward compatibility */
1372 [STAC_MACMINI] = "macmini",
1373 [STAC_MACBOOK] = "macbook",
1374 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1375 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1376 [STAC_IMAC_INTEL] = "imac-intel",
1377 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1378 [STAC_922X_DELL_D81] = "dell-d81",
1379 [STAC_922X_DELL_D82] = "dell-d82",
1380 [STAC_922X_DELL_M81] = "dell-m81",
1381 [STAC_922X_DELL_M82] = "dell-m82",
1384 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1385 /* SigmaTel reference board */
1386 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1387 "DFI LanParty", STAC_D945_REF),
1388 /* Intel 945G based systems */
1389 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1390 "Intel D945G", STAC_D945GTP3),
1391 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1392 "Intel D945G", STAC_D945GTP3),
1393 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1394 "Intel D945G", STAC_D945GTP3),
1395 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1396 "Intel D945G", STAC_D945GTP3),
1397 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1398 "Intel D945G", STAC_D945GTP3),
1399 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1400 "Intel D945G", STAC_D945GTP3),
1401 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1402 "Intel D945G", STAC_D945GTP3),
1403 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1404 "Intel D945G", STAC_D945GTP3),
1405 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1406 "Intel D945G", STAC_D945GTP3),
1407 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1408 "Intel D945G", STAC_D945GTP3),
1409 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1410 "Intel D945G", STAC_D945GTP3),
1411 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1412 "Intel D945G", STAC_D945GTP3),
1413 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1414 "Intel D945G", STAC_D945GTP3),
1415 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1416 "Intel D945G", STAC_D945GTP3),
1417 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1418 "Intel D945G", STAC_D945GTP3),
1419 /* Intel D945G 5-stack systems */
1420 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1421 "Intel D945G", STAC_D945GTP5),
1422 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1423 "Intel D945G", STAC_D945GTP5),
1424 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1425 "Intel D945G", STAC_D945GTP5),
1426 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1427 "Intel D945G", STAC_D945GTP5),
1428 /* Intel 945P based systems */
1429 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1430 "Intel D945P", STAC_D945GTP3),
1431 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1432 "Intel D945P", STAC_D945GTP3),
1433 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1434 "Intel D945P", STAC_D945GTP3),
1435 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1436 "Intel D945P", STAC_D945GTP3),
1437 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1438 "Intel D945P", STAC_D945GTP3),
1439 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1440 "Intel D945P", STAC_D945GTP5),
1442 /* Apple Mac Mini (early 2006) */
1443 SND_PCI_QUIRK(0x8384, 0x7680,
1444 "Mac Mini", STAC_INTEL_MAC_V3),
1446 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1447 "unknown Dell", STAC_922X_DELL_D81),
1448 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1449 "unknown Dell", STAC_922X_DELL_D81),
1450 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1451 "unknown Dell", STAC_922X_DELL_D81),
1452 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1453 "unknown Dell", STAC_922X_DELL_D82),
1454 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1455 "unknown Dell", STAC_922X_DELL_M81),
1456 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1457 "unknown Dell", STAC_922X_DELL_D82),
1458 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1459 "unknown Dell", STAC_922X_DELL_D81),
1460 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1461 "unknown Dell", STAC_922X_DELL_D81),
1462 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1463 "Dell XPS M1210", STAC_922X_DELL_M82),
1467 static unsigned int ref927x_pin_configs[14] = {
1468 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1469 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1470 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1471 0x01c42190, 0x40000100,
1474 static unsigned int d965_3st_pin_configs[14] = {
1475 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
1476 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
1477 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1478 0x40000100, 0x40000100
1481 static unsigned int d965_5st_pin_configs[14] = {
1482 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1483 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
1484 0x40000100, 0x40000100, 0x40000100, 0x01442070,
1485 0x40000100, 0x40000100
1488 static unsigned int dell_3st_pin_configs[14] = {
1489 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
1490 0x01111212, 0x01116211, 0x01813050, 0x01112214,
1491 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
1492 0x40c003fc, 0x40000100
1495 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
1496 [STAC_D965_REF] = ref927x_pin_configs,
1497 [STAC_D965_3ST] = d965_3st_pin_configs,
1498 [STAC_D965_5ST] = d965_5st_pin_configs,
1499 [STAC_DELL_3ST] = dell_3st_pin_configs,
1500 [STAC_DELL_BIOS] = NULL,
1503 static const char *stac927x_models[STAC_927X_MODELS] = {
1504 [STAC_D965_REF] = "ref",
1505 [STAC_D965_3ST] = "3stack",
1506 [STAC_D965_5ST] = "5stack",
1507 [STAC_DELL_3ST] = "dell-3stack",
1508 [STAC_DELL_BIOS] = "dell-bios",
1511 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
1512 /* SigmaTel reference board */
1513 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1514 "DFI LanParty", STAC_D965_REF),
1515 /* Intel 946 based systems */
1516 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
1517 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
1518 /* 965 based 3 stack systems */
1519 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
1520 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
1521 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
1522 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
1523 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
1524 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
1525 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
1526 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
1527 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
1528 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
1529 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
1530 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
1531 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
1532 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
1533 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
1534 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
1535 /* Dell 3 stack systems */
1536 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
1537 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
1538 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
1539 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
1540 /* Dell 3 stack systems with verb table in BIOS */
1541 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
1542 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
1543 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell ", STAC_DELL_BIOS),
1544 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
1545 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
1546 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
1547 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
1548 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
1549 /* 965 based 5 stack systems */
1550 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
1551 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
1552 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
1553 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
1554 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
1555 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
1556 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
1557 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
1558 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
1562 static unsigned int ref9205_pin_configs[12] = {
1563 0x40000100, 0x40000100, 0x01016011, 0x01014010,
1564 0x01813122, 0x01a19021, 0x40000100, 0x40000100,
1565 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
1569 STAC 9205 pin configs for
1576 10280228 (Dell Vostro 1500)
1578 static unsigned int dell_9205_m42_pin_configs[12] = {
1579 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
1580 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
1581 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
1585 STAC 9205 pin configs for
1589 102801FF (Dell Precision M4300)
1594 static unsigned int dell_9205_m43_pin_configs[12] = {
1595 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
1596 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
1597 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
1600 static unsigned int dell_9205_m44_pin_configs[12] = {
1601 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
1602 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
1603 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
1606 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
1607 [STAC_9205_REF] = ref9205_pin_configs,
1608 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
1609 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
1610 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
1613 static const char *stac9205_models[STAC_9205_MODELS] = {
1614 [STAC_9205_REF] = "ref",
1615 [STAC_9205_DELL_M42] = "dell-m42",
1616 [STAC_9205_DELL_M43] = "dell-m43",
1617 [STAC_9205_DELL_M44] = "dell-m44",
1620 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
1621 /* SigmaTel reference board */
1622 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1623 "DFI LanParty", STAC_9205_REF),
1624 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1625 "unknown Dell", STAC_9205_DELL_M42),
1626 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1627 "unknown Dell", STAC_9205_DELL_M42),
1628 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
1629 "Dell Precision", STAC_9205_DELL_M43),
1630 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
1631 "Dell Precision", STAC_9205_DELL_M43),
1632 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
1633 "Dell Precision", STAC_9205_DELL_M43),
1634 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
1635 "Dell Precision", STAC_9205_DELL_M43),
1636 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
1637 "Dell Precision", STAC_9205_DELL_M43),
1638 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1639 "unknown Dell", STAC_9205_DELL_M42),
1640 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1641 "unknown Dell", STAC_9205_DELL_M42),
1642 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
1643 "Dell Precision", STAC_9205_DELL_M43),
1644 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
1645 "Dell Precision M4300", STAC_9205_DELL_M43),
1646 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
1647 "Dell Precision", STAC_9205_DELL_M43),
1648 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1649 "Dell Inspiron", STAC_9205_DELL_M44),
1650 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1651 "Dell Inspiron", STAC_9205_DELL_M44),
1652 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1653 "Dell Inspiron", STAC_9205_DELL_M44),
1654 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1655 "Dell Inspiron", STAC_9205_DELL_M44),
1656 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
1657 "unknown Dell", STAC_9205_DELL_M42),
1658 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
1659 "Dell Inspiron", STAC_9205_DELL_M44),
1660 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
1661 "Dell Vostro 1500", STAC_9205_DELL_M42),
1665 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
1668 struct sigmatel_spec *spec = codec->spec;
1670 if (! spec->bios_pin_configs) {
1671 spec->bios_pin_configs = kcalloc(spec->num_pins,
1672 sizeof(*spec->bios_pin_configs), GFP_KERNEL);
1673 if (! spec->bios_pin_configs)
1677 for (i = 0; i < spec->num_pins; i++) {
1678 hda_nid_t nid = spec->pin_nids[i];
1679 unsigned int pin_cfg;
1681 pin_cfg = snd_hda_codec_read(codec, nid, 0,
1682 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
1683 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
1685 spec->bios_pin_configs[i] = pin_cfg;
1691 static void stac92xx_set_config_reg(struct hda_codec *codec,
1692 hda_nid_t pin_nid, unsigned int pin_config)
1695 snd_hda_codec_write(codec, pin_nid, 0,
1696 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
1697 pin_config & 0x000000ff);
1698 snd_hda_codec_write(codec, pin_nid, 0,
1699 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
1700 (pin_config & 0x0000ff00) >> 8);
1701 snd_hda_codec_write(codec, pin_nid, 0,
1702 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
1703 (pin_config & 0x00ff0000) >> 16);
1704 snd_hda_codec_write(codec, pin_nid, 0,
1705 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
1707 i = snd_hda_codec_read(codec, pin_nid, 0,
1708 AC_VERB_GET_CONFIG_DEFAULT,
1710 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
1714 static void stac92xx_set_config_regs(struct hda_codec *codec)
1717 struct sigmatel_spec *spec = codec->spec;
1719 if (!spec->pin_configs)
1722 for (i = 0; i < spec->num_pins; i++)
1723 stac92xx_set_config_reg(codec, spec->pin_nids[i],
1724 spec->pin_configs[i]);
1728 * Analog playback callbacks
1730 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
1731 struct hda_codec *codec,
1732 struct snd_pcm_substream *substream)
1734 struct sigmatel_spec *spec = codec->spec;
1735 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
1738 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1739 struct hda_codec *codec,
1740 unsigned int stream_tag,
1741 unsigned int format,
1742 struct snd_pcm_substream *substream)
1744 struct sigmatel_spec *spec = codec->spec;
1745 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
1748 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1749 struct hda_codec *codec,
1750 struct snd_pcm_substream *substream)
1752 struct sigmatel_spec *spec = codec->spec;
1753 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1757 * Digital playback callbacks
1759 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1760 struct hda_codec *codec,
1761 struct snd_pcm_substream *substream)
1763 struct sigmatel_spec *spec = codec->spec;
1764 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1767 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1768 struct hda_codec *codec,
1769 struct snd_pcm_substream *substream)
1771 struct sigmatel_spec *spec = codec->spec;
1772 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1775 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1776 struct hda_codec *codec,
1777 unsigned int stream_tag,
1778 unsigned int format,
1779 struct snd_pcm_substream *substream)
1781 struct sigmatel_spec *spec = codec->spec;
1782 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1783 stream_tag, format, substream);
1788 * Analog capture callbacks
1790 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1791 struct hda_codec *codec,
1792 unsigned int stream_tag,
1793 unsigned int format,
1794 struct snd_pcm_substream *substream)
1796 struct sigmatel_spec *spec = codec->spec;
1798 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1799 stream_tag, 0, format);
1803 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1804 struct hda_codec *codec,
1805 struct snd_pcm_substream *substream)
1807 struct sigmatel_spec *spec = codec->spec;
1809 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
1813 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
1817 /* NID is set in stac92xx_build_pcms */
1819 .open = stac92xx_dig_playback_pcm_open,
1820 .close = stac92xx_dig_playback_pcm_close,
1821 .prepare = stac92xx_dig_playback_pcm_prepare
1825 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
1829 /* NID is set in stac92xx_build_pcms */
1832 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
1836 .nid = 0x02, /* NID to query formats and rates */
1838 .open = stac92xx_playback_pcm_open,
1839 .prepare = stac92xx_playback_pcm_prepare,
1840 .cleanup = stac92xx_playback_pcm_cleanup
1844 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
1848 .nid = 0x06, /* NID to query formats and rates */
1850 .open = stac92xx_playback_pcm_open,
1851 .prepare = stac92xx_playback_pcm_prepare,
1852 .cleanup = stac92xx_playback_pcm_cleanup
1856 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
1859 /* NID + .substreams is set in stac92xx_build_pcms */
1861 .prepare = stac92xx_capture_pcm_prepare,
1862 .cleanup = stac92xx_capture_pcm_cleanup
1866 static int stac92xx_build_pcms(struct hda_codec *codec)
1868 struct sigmatel_spec *spec = codec->spec;
1869 struct hda_pcm *info = spec->pcm_rec;
1871 codec->num_pcms = 1;
1872 codec->pcm_info = info;
1874 info->name = "STAC92xx Analog";
1875 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
1876 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
1877 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1878 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
1880 if (spec->alt_switch) {
1883 info->name = "STAC92xx Analog Alt";
1884 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
1887 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1890 info->name = "STAC92xx Digital";
1891 if (spec->multiout.dig_out_nid) {
1892 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
1893 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
1895 if (spec->dig_in_nid) {
1896 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
1897 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
1904 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
1906 unsigned int pincap = snd_hda_param_read(codec, nid,
1908 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
1909 if (pincap & AC_PINCAP_VREF_100)
1910 return AC_PINCTL_VREF_100;
1911 if (pincap & AC_PINCAP_VREF_80)
1912 return AC_PINCTL_VREF_80;
1913 if (pincap & AC_PINCAP_VREF_50)
1914 return AC_PINCTL_VREF_50;
1915 if (pincap & AC_PINCAP_VREF_GRD)
1916 return AC_PINCTL_VREF_GRD;
1920 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
1923 snd_hda_codec_write_cache(codec, nid, 0,
1924 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
1927 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
1929 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1931 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1932 struct sigmatel_spec *spec = codec->spec;
1933 int io_idx = kcontrol-> private_value & 0xff;
1935 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
1939 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1941 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1942 struct sigmatel_spec *spec = codec->spec;
1943 hda_nid_t nid = kcontrol->private_value >> 8;
1944 int io_idx = kcontrol-> private_value & 0xff;
1945 unsigned short val = !!ucontrol->value.integer.value[0];
1947 spec->io_switch[io_idx] = val;
1950 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
1952 unsigned int pinctl = AC_PINCTL_IN_EN;
1953 if (io_idx) /* set VREF for mic */
1954 pinctl |= stac92xx_get_vref(codec, nid);
1955 stac92xx_auto_set_pinctl(codec, nid, pinctl);
1958 /* check the auto-mute again: we need to mute/unmute the speaker
1959 * appropriately according to the pin direction
1961 if (spec->hp_detect)
1962 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
1967 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
1969 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
1970 struct snd_ctl_elem_value *ucontrol)
1972 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1973 struct sigmatel_spec *spec = codec->spec;
1975 ucontrol->value.integer.value[0] = spec->clfe_swap;
1979 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
1980 struct snd_ctl_elem_value *ucontrol)
1982 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1983 struct sigmatel_spec *spec = codec->spec;
1984 hda_nid_t nid = kcontrol->private_value & 0xff;
1985 unsigned int val = !!ucontrol->value.integer.value[0];
1987 if (spec->clfe_swap == val)
1990 spec->clfe_swap = val;
1992 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1993 spec->clfe_swap ? 0x4 : 0x0);
1998 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
1999 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2002 .info = stac92xx_io_switch_info, \
2003 .get = stac92xx_io_switch_get, \
2004 .put = stac92xx_io_switch_put, \
2005 .private_value = xpval, \
2008 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2009 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2012 .info = stac92xx_clfe_switch_info, \
2013 .get = stac92xx_clfe_switch_get, \
2014 .put = stac92xx_clfe_switch_put, \
2015 .private_value = xpval, \
2019 STAC_CTL_WIDGET_VOL,
2020 STAC_CTL_WIDGET_MUTE,
2021 STAC_CTL_WIDGET_IO_SWITCH,
2022 STAC_CTL_WIDGET_CLFE_SWITCH
2025 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2026 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2027 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2028 STAC_CODEC_IO_SWITCH(NULL, 0),
2029 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2032 /* add dynamic controls */
2033 static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val)
2035 struct snd_kcontrol_new *knew;
2037 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
2038 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
2040 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
2043 if (spec->kctl_alloc) {
2044 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
2045 kfree(spec->kctl_alloc);
2047 spec->kctl_alloc = knew;
2048 spec->num_kctl_alloc = num;
2051 knew = &spec->kctl_alloc[spec->num_kctl_used];
2052 *knew = stac92xx_control_templates[type];
2053 knew->name = kstrdup(name, GFP_KERNEL);
2056 knew->private_value = val;
2057 spec->num_kctl_used++;
2061 /* flag inputs as additional dynamic lineouts */
2062 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
2064 struct sigmatel_spec *spec = codec->spec;
2065 unsigned int wcaps, wtype;
2066 int i, num_dacs = 0;
2068 /* use the wcaps cache to count all DACs available for line-outs */
2069 for (i = 0; i < codec->num_nodes; i++) {
2070 wcaps = codec->wcaps[i];
2071 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2073 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
2077 snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
2079 switch (cfg->line_outs) {
2081 /* add line-in as side */
2082 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
2083 cfg->line_out_pins[cfg->line_outs] =
2084 cfg->input_pins[AUTO_PIN_LINE];
2085 spec->line_switch = 1;
2090 /* add line-in as clfe and mic as side */
2091 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
2092 cfg->line_out_pins[cfg->line_outs] =
2093 cfg->input_pins[AUTO_PIN_LINE];
2094 spec->line_switch = 1;
2097 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
2098 cfg->line_out_pins[cfg->line_outs] =
2099 cfg->input_pins[AUTO_PIN_MIC];
2100 spec->mic_switch = 1;
2105 /* add line-in as surr and mic as clfe */
2106 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
2107 cfg->line_out_pins[cfg->line_outs] =
2108 cfg->input_pins[AUTO_PIN_LINE];
2109 spec->line_switch = 1;
2112 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
2113 cfg->line_out_pins[cfg->line_outs] =
2114 cfg->input_pins[AUTO_PIN_MIC];
2115 spec->mic_switch = 1;
2125 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2129 for (i = 0; i < spec->multiout.num_dacs; i++) {
2130 if (spec->multiout.dac_nids[i] == nid)
2138 * Fill in the dac_nids table from the parsed pin configuration
2139 * This function only works when every pin in line_out_pins[]
2140 * contains atleast one DAC in its connection list. Some 92xx
2141 * codecs are not connected directly to a DAC, such as the 9200
2142 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2144 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
2145 struct auto_pin_cfg *cfg)
2147 struct sigmatel_spec *spec = codec->spec;
2148 int i, j, conn_len = 0;
2149 hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
2150 unsigned int wcaps, wtype;
2152 for (i = 0; i < cfg->line_outs; i++) {
2153 nid = cfg->line_out_pins[i];
2154 conn_len = snd_hda_get_connections(codec, nid, conn,
2155 HDA_MAX_CONNECTIONS);
2156 for (j = 0; j < conn_len; j++) {
2157 wcaps = snd_hda_param_read(codec, conn[j],
2158 AC_PAR_AUDIO_WIDGET_CAP);
2159 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2160 if (wtype != AC_WID_AUD_OUT ||
2161 (wcaps & AC_WCAP_DIGITAL))
2163 /* conn[j] is a DAC routed to this line-out */
2164 if (!is_in_dac_nids(spec, conn[j]))
2168 if (j == conn_len) {
2169 if (spec->multiout.num_dacs > 0) {
2170 /* we have already working output pins,
2171 * so let's drop the broken ones again
2173 cfg->line_outs = spec->multiout.num_dacs;
2176 /* error out, no available DAC found */
2178 "%s: No available DAC for pin 0x%x\n",
2183 spec->multiout.dac_nids[i] = conn[j];
2184 spec->multiout.num_dacs++;
2186 /* select this DAC in the pin's input mux */
2187 snd_hda_codec_write_cache(codec, nid, 0,
2188 AC_VERB_SET_CONNECT_SEL, j);
2193 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2194 spec->multiout.num_dacs,
2195 spec->multiout.dac_nids[0],
2196 spec->multiout.dac_nids[1],
2197 spec->multiout.dac_nids[2],
2198 spec->multiout.dac_nids[3],
2199 spec->multiout.dac_nids[4]);
2203 /* create volume control/switch for the given prefx type */
2204 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
2209 sprintf(name, "%s Playback Volume", pfx);
2210 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
2211 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2214 sprintf(name, "%s Playback Switch", pfx);
2215 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
2216 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2222 /* add playback controls from the parsed DAC table */
2223 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
2224 const struct auto_pin_cfg *cfg)
2226 static const char *chname[4] = {
2227 "Front", "Surround", NULL /*CLFE*/, "Side"
2232 struct sigmatel_spec *spec = codec->spec;
2233 unsigned int wid_caps;
2236 for (i = 0; i < cfg->line_outs; i++) {
2237 if (!spec->multiout.dac_nids[i])
2240 nid = spec->multiout.dac_nids[i];
2244 err = create_controls(spec, "Center", nid, 1);
2247 err = create_controls(spec, "LFE", nid, 2);
2251 wid_caps = get_wcaps(codec, nid);
2253 if (wid_caps & AC_WCAP_LR_SWAP) {
2254 err = stac92xx_add_control(spec,
2255 STAC_CTL_WIDGET_CLFE_SWITCH,
2256 "Swap Center/LFE Playback Switch", nid);
2263 err = create_controls(spec, chname[i], nid, 3);
2269 if (spec->line_switch)
2270 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Line In as Output Switch", cfg->input_pins[AUTO_PIN_LINE] << 8)) < 0)
2273 if (spec->mic_switch)
2274 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Mic as Output Switch", (cfg->input_pins[AUTO_PIN_MIC] << 8) | 1)) < 0)
2280 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2282 if (is_in_dac_nids(spec, nid))
2284 if (spec->multiout.hp_nid == nid)
2289 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
2291 if (!spec->multiout.hp_nid)
2292 spec->multiout.hp_nid = nid;
2293 else if (spec->multiout.num_dacs > 4) {
2294 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
2297 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
2298 spec->multiout.num_dacs++;
2303 /* add playback controls for Speaker and HP outputs */
2304 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
2305 struct auto_pin_cfg *cfg)
2307 struct sigmatel_spec *spec = codec->spec;
2309 int i, old_num_dacs, err;
2311 old_num_dacs = spec->multiout.num_dacs;
2312 for (i = 0; i < cfg->hp_outs; i++) {
2313 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
2314 if (wid_caps & AC_WCAP_UNSOL_CAP)
2315 spec->hp_detect = 1;
2316 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
2317 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2318 if (check_in_dac_nids(spec, nid))
2322 add_spec_dacs(spec, nid);
2324 for (i = 0; i < cfg->speaker_outs; i++) {
2325 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
2326 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2327 if (check_in_dac_nids(spec, nid))
2331 add_spec_dacs(spec, nid);
2333 for (i = 0; i < cfg->line_outs; i++) {
2334 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
2335 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2336 if (check_in_dac_nids(spec, nid))
2340 add_spec_dacs(spec, nid);
2342 for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
2343 static const char *pfxs[] = {
2344 "Speaker", "External Speaker", "Speaker2",
2346 err = create_controls(spec, pfxs[i - old_num_dacs],
2347 spec->multiout.dac_nids[i], 3);
2351 if (spec->multiout.hp_nid) {
2353 if (old_num_dacs == spec->multiout.num_dacs)
2357 err = create_controls(spec, pfx, spec->multiout.hp_nid, 3);
2365 /* labels for mono mux outputs */
2366 static const char *stac92xx_mono_labels[3] = {
2367 "DAC0", "DAC1", "Mixer"
2370 /* create mono mux for mono out on capable codecs */
2371 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
2373 struct sigmatel_spec *spec = codec->spec;
2374 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
2376 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
2378 num_cons = snd_hda_get_connections(codec,
2381 HDA_MAX_NUM_INPUTS);
2382 if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
2385 for (i = 0; i < num_cons; i++) {
2386 mono_mux->items[mono_mux->num_items].label =
2387 stac92xx_mono_labels[i];
2388 mono_mux->items[mono_mux->num_items].index = i;
2389 mono_mux->num_items++;
2394 /* labels for dmic mux inputs */
2395 static const char *stac92xx_dmic_labels[5] = {
2396 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
2397 "Digital Mic 3", "Digital Mic 4"
2400 /* create playback/capture controls for input pins on dmic capable codecs */
2401 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
2402 const struct auto_pin_cfg *cfg)
2404 struct sigmatel_spec *spec = codec->spec;
2405 struct hda_input_mux *dimux = &spec->private_dimux;
2406 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2410 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
2411 dimux->items[dimux->num_items].index = 0;
2414 for (i = 0; i < spec->num_dmics; i++) {
2419 unsigned int def_conf;
2421 def_conf = snd_hda_codec_read(codec,
2424 AC_VERB_GET_CONFIG_DEFAULT,
2426 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
2429 nid = spec->dmic_nids[i];
2430 num_cons = snd_hda_get_connections(codec,
2433 HDA_MAX_NUM_INPUTS);
2434 for (j = 0; j < num_cons; j++)
2435 if (con_lst[j] == nid) {
2441 wcaps = get_wcaps(codec, nid);
2443 if (wcaps & AC_WCAP_OUT_AMP) {
2444 sprintf(name, "%s Capture Volume",
2445 stac92xx_dmic_labels[dimux->num_items]);
2447 err = stac92xx_add_control(spec,
2448 STAC_CTL_WIDGET_VOL,
2450 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
2455 dimux->items[dimux->num_items].label =
2456 stac92xx_dmic_labels[dimux->num_items];
2457 dimux->items[dimux->num_items].index = index;
2464 /* create playback/capture controls for input pins */
2465 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
2467 struct sigmatel_spec *spec = codec->spec;
2468 struct hda_input_mux *imux = &spec->private_imux;
2469 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2472 for (i = 0; i < AUTO_PIN_LAST; i++) {
2475 if (!cfg->input_pins[i])
2478 for (j = 0; j < spec->num_muxes; j++) {
2480 num_cons = snd_hda_get_connections(codec,
2483 HDA_MAX_NUM_INPUTS);
2484 for (k = 0; k < num_cons; k++)
2485 if (con_lst[k] == cfg->input_pins[i]) {
2492 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2493 imux->items[imux->num_items].index = index;
2497 if (imux->num_items) {
2499 * Set the current input for the muxes.
2500 * The STAC9221 has two input muxes with identical source
2501 * NID lists. Hopefully this won't get confused.
2503 for (i = 0; i < spec->num_muxes; i++) {
2504 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
2505 AC_VERB_SET_CONNECT_SEL,
2506 imux->items[0].index);
2513 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
2515 struct sigmatel_spec *spec = codec->spec;
2518 for (i = 0; i < spec->autocfg.line_outs; i++) {
2519 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2520 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2524 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
2526 struct sigmatel_spec *spec = codec->spec;
2529 for (i = 0; i < spec->autocfg.hp_outs; i++) {
2531 pin = spec->autocfg.hp_pins[i];
2532 if (pin) /* connect to front */
2533 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
2535 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
2537 pin = spec->autocfg.speaker_pins[i];
2538 if (pin) /* connect to front */
2539 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
2543 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
2545 struct sigmatel_spec *spec = codec->spec;
2547 int hp_speaker_swap = 0;
2549 if ((err = snd_hda_parse_pin_def_config(codec,
2551 spec->dmic_nids)) < 0)
2553 if (! spec->autocfg.line_outs)
2554 return 0; /* can't find valid pin config */
2556 /* If we have no real line-out pin and multiple hp-outs, HPs should
2557 * be set up as multi-channel outputs.
2559 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
2560 spec->autocfg.hp_outs > 1) {
2561 /* Copy hp_outs to line_outs, backup line_outs in
2562 * speaker_outs so that the following routines can handle
2563 * HP pins as primary outputs.
2565 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
2566 sizeof(spec->autocfg.line_out_pins));
2567 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
2568 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
2569 sizeof(spec->autocfg.hp_pins));
2570 spec->autocfg.line_outs = spec->autocfg.hp_outs;
2571 hp_speaker_swap = 1;
2574 if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
2576 if (spec->multiout.num_dacs == 0)
2577 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2580 err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
2585 if (hp_speaker_swap == 1) {
2586 /* Restore the hp_outs and line_outs */
2587 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
2588 sizeof(spec->autocfg.line_out_pins));
2589 spec->autocfg.hp_outs = spec->autocfg.line_outs;
2590 memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins,
2591 sizeof(spec->autocfg.speaker_pins));
2592 spec->autocfg.line_outs = spec->autocfg.speaker_outs;
2593 memset(spec->autocfg.speaker_pins, 0,
2594 sizeof(spec->autocfg.speaker_pins));
2595 spec->autocfg.speaker_outs = 0;
2598 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
2603 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
2608 if (spec->mono_nid > 0) {
2609 err = stac92xx_auto_create_mono_output_ctls(codec);
2614 if (spec->num_dmics > 0)
2615 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
2616 &spec->autocfg)) < 0)
2619 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2620 if (spec->multiout.max_channels > 2)
2621 spec->surr_switch = 1;
2623 if (spec->autocfg.dig_out_pin)
2624 spec->multiout.dig_out_nid = dig_out;
2625 if (spec->autocfg.dig_in_pin)
2626 spec->dig_in_nid = dig_in;
2628 if (spec->kctl_alloc)
2629 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2631 spec->input_mux = &spec->private_imux;
2632 if (!spec->dinput_mux)
2633 spec->dinput_mux = &spec->private_dimux;
2634 spec->mono_mux = &spec->private_mono_mux;
2639 /* add playback controls for HP output */
2640 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
2641 struct auto_pin_cfg *cfg)
2643 struct sigmatel_spec *spec = codec->spec;
2644 hda_nid_t pin = cfg->hp_pins[0];
2645 unsigned int wid_caps;
2650 wid_caps = get_wcaps(codec, pin);
2651 if (wid_caps & AC_WCAP_UNSOL_CAP)
2652 spec->hp_detect = 1;
2657 /* add playback controls for LFE output */
2658 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
2659 struct auto_pin_cfg *cfg)
2661 struct sigmatel_spec *spec = codec->spec;
2663 hda_nid_t lfe_pin = 0x0;
2667 * search speaker outs and line outs for a mono speaker pin
2668 * with an amp. If one is found, add LFE controls
2671 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
2672 hda_nid_t pin = spec->autocfg.speaker_pins[i];
2673 unsigned long wcaps = get_wcaps(codec, pin);
2674 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2675 if (wcaps == AC_WCAP_OUT_AMP)
2676 /* found a mono speaker with an amp, must be lfe */
2680 /* if speaker_outs is 0, then speakers may be in line_outs */
2681 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
2682 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
2683 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2685 cfg = snd_hda_codec_read(codec, pin, 0,
2686 AC_VERB_GET_CONFIG_DEFAULT,
2688 if (get_defcfg_device(cfg) == AC_JACK_SPEAKER) {
2689 unsigned long wcaps = get_wcaps(codec, pin);
2690 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2691 if (wcaps == AC_WCAP_OUT_AMP)
2692 /* found a mono speaker with an amp,
2700 err = create_controls(spec, "LFE", lfe_pin, 1);
2708 static int stac9200_parse_auto_config(struct hda_codec *codec)
2710 struct sigmatel_spec *spec = codec->spec;
2713 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2716 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
2719 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
2722 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
2725 if (spec->autocfg.dig_out_pin)
2726 spec->multiout.dig_out_nid = 0x05;
2727 if (spec->autocfg.dig_in_pin)
2728 spec->dig_in_nid = 0x04;
2730 if (spec->kctl_alloc)
2731 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2733 spec->input_mux = &spec->private_imux;
2734 spec->dinput_mux = &spec->private_dimux;
2740 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
2741 * funky external mute control using GPIO pins.
2744 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
2747 unsigned int gpiostate, gpiomask, gpiodir;
2749 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
2750 AC_VERB_GET_GPIO_DATA, 0);
2751 gpiostate = (gpiostate & ~mask) | (data & mask);
2753 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
2754 AC_VERB_GET_GPIO_MASK, 0);
2757 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
2758 AC_VERB_GET_GPIO_DIRECTION, 0);
2761 /* Configure GPIOx as CMOS */
2762 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
2764 snd_hda_codec_write(codec, codec->afg, 0,
2765 AC_VERB_SET_GPIO_MASK, gpiomask);
2766 snd_hda_codec_read(codec, codec->afg, 0,
2767 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
2771 snd_hda_codec_read(codec, codec->afg, 0,
2772 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
2775 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
2778 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
2779 snd_hda_codec_write_cache(codec, nid, 0,
2780 AC_VERB_SET_UNSOLICITED_ENABLE,
2781 (AC_USRSP_EN | event));
2784 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
2787 for (i = 0; i < cfg->hp_outs; i++)
2788 if (cfg->hp_pins[i] == nid)
2789 return 1; /* nid is a HP-Out */
2791 return 0; /* nid is not a HP-Out */
2794 static int stac92xx_init(struct hda_codec *codec)
2796 struct sigmatel_spec *spec = codec->spec;
2797 struct auto_pin_cfg *cfg = &spec->autocfg;
2800 snd_hda_sequence_write(codec, spec->init);
2803 if (spec->hp_detect) {
2804 /* Enable unsolicited responses on the HP widget */
2805 for (i = 0; i < cfg->hp_outs; i++)
2806 enable_pin_detect(codec, cfg->hp_pins[i],
2808 /* force to enable the first line-out; the others are set up
2811 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
2813 stac92xx_auto_init_hp_out(codec);
2814 /* fake event to set up pins */
2815 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2817 stac92xx_auto_init_multi_out(codec);
2818 stac92xx_auto_init_hp_out(codec);
2820 for (i = 0; i < AUTO_PIN_LAST; i++) {
2821 hda_nid_t nid = cfg->input_pins[i];
2823 unsigned int pinctl = AC_PINCTL_IN_EN;
2824 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
2825 pinctl |= stac92xx_get_vref(codec, nid);
2826 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2829 for (i = 0; i < spec->num_dmics; i++)
2830 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
2832 for (i = 0; i < spec->num_pwrs; i++) {
2833 int event = is_nid_hp_pin(cfg, spec->pwr_nids[i])
2834 ? STAC_HP_EVENT : STAC_PWR_EVENT;
2835 int pinctl = snd_hda_codec_read(codec, spec->pwr_nids[i],
2836 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2837 /* outputs are only ports capable of power management
2838 * any attempts on powering down a input port cause the
2839 * referenced VREF to act quirky.
2841 if (pinctl & AC_PINCTL_IN_EN)
2843 enable_pin_detect(codec, spec->pwr_nids[i], event | i);
2844 codec->patch_ops.unsol_event(codec, (event | i) << 26);
2847 if (cfg->dig_out_pin)
2848 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
2850 if (cfg->dig_in_pin)
2851 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
2854 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_data);
2859 static void stac92xx_free(struct hda_codec *codec)
2861 struct sigmatel_spec *spec = codec->spec;
2867 if (spec->kctl_alloc) {
2868 for (i = 0; i < spec->num_kctl_used; i++)
2869 kfree(spec->kctl_alloc[i].name);
2870 kfree(spec->kctl_alloc);
2873 if (spec->bios_pin_configs)
2874 kfree(spec->bios_pin_configs);
2879 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
2882 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2883 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2885 if (pin_ctl & AC_PINCTL_IN_EN) {
2887 * we need to check the current set-up direction of
2888 * shared input pins since they can be switched via
2889 * "xxx as Output" mixer switch
2891 struct sigmatel_spec *spec = codec->spec;
2892 struct auto_pin_cfg *cfg = &spec->autocfg;
2893 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
2894 spec->line_switch) ||
2895 (nid == cfg->input_pins[AUTO_PIN_MIC] &&
2900 /* if setting pin direction bits, clear the current
2901 direction bits first */
2902 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
2903 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
2905 snd_hda_codec_write_cache(codec, nid, 0,
2906 AC_VERB_SET_PIN_WIDGET_CONTROL,
2910 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
2913 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2914 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2915 snd_hda_codec_write_cache(codec, nid, 0,
2916 AC_VERB_SET_PIN_WIDGET_CONTROL,
2920 static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid)
2924 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
2926 unsigned int pinctl;
2927 pinctl = snd_hda_codec_read(codec, nid, 0,
2928 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2929 if (pinctl & AC_PINCTL_IN_EN)
2930 return 0; /* mic- or line-input */
2932 return 1; /* HP-output */
2937 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
2939 struct sigmatel_spec *spec = codec->spec;
2940 struct auto_pin_cfg *cfg = &spec->autocfg;
2944 for (i = 0; i < cfg->hp_outs; i++) {
2945 presence = get_hp_pin_presence(codec, cfg->hp_pins[i]);
2951 /* disable lineouts, enable hp */
2952 for (i = 0; i < cfg->line_outs; i++)
2953 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
2955 for (i = 0; i < cfg->speaker_outs; i++)
2956 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
2959 /* enable lineouts, disable hp */
2960 for (i = 0; i < cfg->line_outs; i++)
2961 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
2963 for (i = 0; i < cfg->speaker_outs; i++)
2964 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
2969 static void stac92xx_pin_sense(struct hda_codec *codec, int idx)
2971 struct sigmatel_spec *spec = codec->spec;
2972 hda_nid_t nid = spec->pwr_nids[idx];
2974 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0)
2976 presence = get_hp_pin_presence(codec, nid);
2984 /* power down unused output ports */
2985 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
2988 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
2990 struct sigmatel_spec *spec = codec->spec;
2991 int idx = res >> 26 & 0x0f;
2993 switch ((res >> 26) & 0x30) {
2995 stac92xx_hp_detect(codec, res);
2997 case STAC_PWR_EVENT:
2998 if (spec->num_pwrs > 0)
2999 stac92xx_pin_sense(codec, idx);
3003 #ifdef SND_HDA_NEEDS_RESUME
3004 static int stac92xx_resume(struct hda_codec *codec)
3006 struct sigmatel_spec *spec = codec->spec;
3008 stac92xx_set_config_regs(codec);
3009 snd_hda_sequence_write(codec, spec->init);
3010 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_data);
3011 snd_hda_codec_resume_amp(codec);
3012 snd_hda_codec_resume_cache(codec);
3013 /* invoke unsolicited event to reset the HP state */
3014 if (spec->hp_detect)
3015 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3020 static struct hda_codec_ops stac92xx_patch_ops = {
3021 .build_controls = stac92xx_build_controls,
3022 .build_pcms = stac92xx_build_pcms,
3023 .init = stac92xx_init,
3024 .free = stac92xx_free,
3025 .unsol_event = stac92xx_unsol_event,
3026 #ifdef SND_HDA_NEEDS_RESUME
3027 .resume = stac92xx_resume,
3031 static int patch_stac9200(struct hda_codec *codec)
3033 struct sigmatel_spec *spec;
3036 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3041 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
3042 spec->pin_nids = stac9200_pin_nids;
3043 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
3046 if (spec->board_config < 0) {
3047 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
3048 err = stac92xx_save_bios_config_regs(codec);
3050 stac92xx_free(codec);
3053 spec->pin_configs = spec->bios_pin_configs;
3055 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
3056 stac92xx_set_config_regs(codec);
3059 spec->multiout.max_channels = 2;
3060 spec->multiout.num_dacs = 1;
3061 spec->multiout.dac_nids = stac9200_dac_nids;
3062 spec->adc_nids = stac9200_adc_nids;
3063 spec->mux_nids = stac9200_mux_nids;
3064 spec->num_muxes = 1;
3065 spec->num_dmics = 0;
3069 if (spec->board_config == STAC_9200_GATEWAY)
3070 spec->init = stac9200_eapd_init;
3072 spec->init = stac9200_core_init;
3073 spec->mixer = stac9200_mixer;
3075 err = stac9200_parse_auto_config(codec);
3077 stac92xx_free(codec);
3081 codec->patch_ops = stac92xx_patch_ops;
3086 static int patch_stac925x(struct hda_codec *codec)
3088 struct sigmatel_spec *spec;
3091 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3096 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
3097 spec->pin_nids = stac925x_pin_nids;
3098 spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
3102 if (spec->board_config < 0) {
3103 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
3104 "using BIOS defaults\n");
3105 err = stac92xx_save_bios_config_regs(codec);
3107 stac92xx_free(codec);
3110 spec->pin_configs = spec->bios_pin_configs;
3111 } else if (stac925x_brd_tbl[spec->board_config] != NULL){
3112 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
3113 stac92xx_set_config_regs(codec);
3116 spec->multiout.max_channels = 2;
3117 spec->multiout.num_dacs = 1;
3118 spec->multiout.dac_nids = stac925x_dac_nids;
3119 spec->adc_nids = stac925x_adc_nids;
3120 spec->mux_nids = stac925x_mux_nids;
3121 spec->num_muxes = 1;
3124 switch (codec->vendor_id) {
3125 case 0x83847632: /* STAC9202 */
3126 case 0x83847633: /* STAC9202D */
3127 case 0x83847636: /* STAC9251 */
3128 case 0x83847637: /* STAC9251D */
3129 spec->num_dmics = STAC925X_NUM_DMICS;
3130 spec->dmic_nids = stac925x_dmic_nids;
3131 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
3132 spec->dmux_nids = stac925x_dmux_nids;
3135 spec->num_dmics = 0;
3139 spec->init = stac925x_core_init;
3140 spec->mixer = stac925x_mixer;
3142 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
3144 if (spec->board_config < 0) {
3145 printk(KERN_WARNING "hda_codec: No auto-config is "
3146 "available, default to model=ref\n");
3147 spec->board_config = STAC_925x_REF;
3153 stac92xx_free(codec);
3157 codec->patch_ops = stac92xx_patch_ops;
3162 static struct hda_input_mux stac92hd73xx_dmux = {
3165 { "Analog Inputs", 0x0b },
3167 { "Digital Mic 1", 0x09 },
3168 { "Digital Mic 2", 0x0a },
3172 static int patch_stac92hd73xx(struct hda_codec *codec)
3174 struct sigmatel_spec *spec;
3175 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
3178 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3183 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
3184 spec->pin_nids = stac92hd73xx_pin_nids;
3185 spec->board_config = snd_hda_check_board_config(codec,
3186 STAC_92HD73XX_MODELS,
3187 stac92hd73xx_models,
3188 stac92hd73xx_cfg_tbl);
3190 if (spec->board_config < 0) {
3191 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3192 " STAC92HD73XX, using BIOS defaults\n");
3193 err = stac92xx_save_bios_config_regs(codec);
3195 stac92xx_free(codec);
3198 spec->pin_configs = spec->bios_pin_configs;
3200 spec->pin_configs = stac92hd73xx_brd_tbl[spec->board_config];
3201 stac92xx_set_config_regs(codec);
3204 spec->multiout.num_dacs = snd_hda_get_connections(codec, 0x0a,
3205 conn, STAC92HD73_DAC_COUNT + 2) - 1;
3207 if (spec->multiout.num_dacs < 0) {
3208 printk(KERN_WARNING "hda_codec: Could not determine "
3209 "number of channels defaulting to DAC count\n");
3210 spec->multiout.num_dacs = STAC92HD73_DAC_COUNT;
3213 switch (spec->multiout.num_dacs) {
3214 case 0x3: /* 6 Channel */
3215 spec->mixer = stac92hd73xx_6ch_mixer;
3216 spec->init = stac92hd73xx_6ch_core_init;
3218 case 0x4: /* 8 Channel */
3219 spec->multiout.hp_nid = 0x18;
3220 spec->mixer = stac92hd73xx_8ch_mixer;
3221 spec->init = stac92hd73xx_8ch_core_init;
3223 case 0x5: /* 10 Channel */
3224 spec->multiout.hp_nid = 0x19;
3225 spec->mixer = stac92hd73xx_10ch_mixer;
3226 spec->init = stac92hd73xx_10ch_core_init;
3229 spec->multiout.dac_nids = stac92hd73xx_dac_nids;
3230 spec->aloopback_mask = 0x01;
3231 spec->aloopback_shift = 8;
3233 spec->mux_nids = stac92hd73xx_mux_nids;
3234 spec->adc_nids = stac92hd73xx_adc_nids;
3235 spec->dmic_nids = stac92hd73xx_dmic_nids;
3236 spec->dmux_nids = stac92hd73xx_dmux_nids;
3238 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
3239 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
3240 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
3241 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
3242 spec->dinput_mux = &stac92hd73xx_dmux;
3243 /* GPIO0 High = Enable EAPD */
3244 spec->gpio_mask = spec->gpio_data = 0x000001;
3246 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
3247 spec->pwr_nids = stac92hd73xx_pwr_nids;
3249 err = stac92xx_parse_auto_config(codec, 0x22, 0x24);
3252 if (spec->board_config < 0) {
3253 printk(KERN_WARNING "hda_codec: No auto-config is "
3254 "available, default to model=ref\n");
3255 spec->board_config = STAC_92HD73XX_REF;
3262 stac92xx_free(codec);
3266 codec->patch_ops = stac92xx_patch_ops;
3271 static int patch_stac92hd71bxx(struct hda_codec *codec)
3273 struct sigmatel_spec *spec;
3276 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3281 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
3282 spec->pin_nids = stac92hd71bxx_pin_nids;
3283 spec->board_config = snd_hda_check_board_config(codec,
3284 STAC_92HD71BXX_MODELS,
3285 stac92hd71bxx_models,
3286 stac92hd71bxx_cfg_tbl);
3288 if (spec->board_config < 0) {
3289 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3290 " STAC92HD71BXX, using BIOS defaults\n");
3291 err = stac92xx_save_bios_config_regs(codec);
3293 stac92xx_free(codec);
3296 spec->pin_configs = spec->bios_pin_configs;
3298 spec->pin_configs = stac92hd71bxx_brd_tbl[spec->board_config];
3299 stac92xx_set_config_regs(codec);
3302 switch (codec->vendor_id) {
3303 case 0x111d76b6: /* 4 Port without Analog Mixer */
3305 case 0x111d76b4: /* 6 Port without Analog Mixer */
3307 spec->mixer = stac92hd71bxx_mixer;
3308 spec->init = stac92hd71bxx_core_init;
3311 spec->mixer = stac92hd71bxx_analog_mixer;
3312 spec->init = stac92hd71bxx_analog_core_init;
3315 spec->aloopback_mask = 0x20;
3316 spec->aloopback_shift = 0;
3318 spec->gpio_mask = spec->gpio_data = 0x00000001; /* GPIO0 High = EAPD */
3320 spec->mono_nid = 0x15;
3321 spec->mux_nids = stac92hd71bxx_mux_nids;
3322 spec->adc_nids = stac92hd71bxx_adc_nids;
3323 spec->dmic_nids = stac92hd71bxx_dmic_nids;
3324 spec->dmux_nids = stac92hd71bxx_dmux_nids;
3326 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
3327 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
3328 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
3329 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
3331 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
3332 spec->pwr_nids = stac92hd71bxx_pwr_nids;
3334 spec->multiout.num_dacs = 2;
3335 spec->multiout.hp_nid = 0x11;
3336 spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
3338 err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
3340 if (spec->board_config < 0) {
3341 printk(KERN_WARNING "hda_codec: No auto-config is "
3342 "available, default to model=ref\n");
3343 spec->board_config = STAC_92HD71BXX_REF;
3350 stac92xx_free(codec);
3354 codec->patch_ops = stac92xx_patch_ops;
3359 static int patch_stac922x(struct hda_codec *codec)
3361 struct sigmatel_spec *spec;
3364 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3369 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
3370 spec->pin_nids = stac922x_pin_nids;
3371 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
3374 if (spec->board_config == STAC_INTEL_MAC_V3) {
3375 spec->gpio_mask = spec->gpio_data = 0x03;
3376 /* Intel Macs have all same PCI SSID, so we need to check
3377 * codec SSID to distinguish the exact models
3379 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
3380 switch (codec->subsystem_id) {
3383 spec->board_config = STAC_INTEL_MAC_V1;
3387 spec->board_config = STAC_INTEL_MAC_V2;
3395 spec->board_config = STAC_INTEL_MAC_V3;
3399 spec->board_config = STAC_INTEL_MAC_V4;
3403 spec->board_config = STAC_INTEL_MAC_V5;
3409 if (spec->board_config < 0) {
3410 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
3411 "using BIOS defaults\n");
3412 err = stac92xx_save_bios_config_regs(codec);
3414 stac92xx_free(codec);
3417 spec->pin_configs = spec->bios_pin_configs;
3418 } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
3419 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
3420 stac92xx_set_config_regs(codec);
3423 spec->adc_nids = stac922x_adc_nids;
3424 spec->mux_nids = stac922x_mux_nids;
3425 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
3426 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
3427 spec->num_dmics = 0;
3430 spec->init = stac922x_core_init;
3431 spec->mixer = stac922x_mixer;
3433 spec->multiout.dac_nids = spec->dac_nids;
3435 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
3437 if (spec->board_config < 0) {
3438 printk(KERN_WARNING "hda_codec: No auto-config is "
3439 "available, default to model=ref\n");
3440 spec->board_config = STAC_D945_REF;
3446 stac92xx_free(codec);
3450 codec->patch_ops = stac92xx_patch_ops;
3452 /* Fix Mux capture level; max to 2 */
3453 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
3454 (0 << AC_AMPCAP_OFFSET_SHIFT) |
3455 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3456 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3457 (0 << AC_AMPCAP_MUTE_SHIFT));
3462 static int patch_stac927x(struct hda_codec *codec)
3464 struct sigmatel_spec *spec;
3467 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3472 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
3473 spec->pin_nids = stac927x_pin_nids;
3474 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
3478 if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
3479 if (spec->board_config < 0)
3480 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3481 "STAC927x, using BIOS defaults\n");
3482 err = stac92xx_save_bios_config_regs(codec);
3484 stac92xx_free(codec);
3487 spec->pin_configs = spec->bios_pin_configs;
3489 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
3490 stac92xx_set_config_regs(codec);
3493 spec->adc_nids = stac927x_adc_nids;
3494 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
3495 spec->mux_nids = stac927x_mux_nids;
3496 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
3497 spec->multiout.dac_nids = spec->dac_nids;
3499 switch (spec->board_config) {
3502 /* GPIO0 High = Enable EAPD */
3503 spec->gpio_mask = spec->gpio_data = 0x00000001;
3504 spec->num_dmics = 0;
3506 spec->init = d965_core_init;
3507 spec->mixer = stac927x_mixer;
3509 case STAC_DELL_BIOS:
3510 /* correct the front output jack as a hp out */
3511 stac92xx_set_config_reg(codec, 0x0f, 0x02270110);
3512 /* correct the front input jack as a mic */
3513 stac92xx_set_config_reg(codec, 0x0e, 0x02a79130);
3516 /* GPIO2 High = Enable EAPD */
3517 spec->gpio_mask = spec->gpio_data = 0x00000004;
3518 spec->dmic_nids = stac927x_dmic_nids;
3519 spec->num_dmics = STAC927X_NUM_DMICS;
3521 spec->init = d965_core_init;
3522 spec->mixer = stac927x_mixer;
3523 spec->dmux_nids = stac927x_dmux_nids;
3524 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
3527 /* GPIO0 High = Enable EAPD */
3528 spec->gpio_mask = spec->gpio_data = 0x00000001;
3529 spec->num_dmics = 0;
3531 spec->init = stac927x_core_init;
3532 spec->mixer = stac927x_mixer;
3536 spec->aloopback_mask = 0x40;
3537 spec->aloopback_shift = 0;
3539 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
3541 if (spec->board_config < 0) {
3542 printk(KERN_WARNING "hda_codec: No auto-config is "
3543 "available, default to model=ref\n");
3544 spec->board_config = STAC_D965_REF;
3550 stac92xx_free(codec);
3554 codec->patch_ops = stac92xx_patch_ops;
3558 * The STAC927x seem to require fairly long delays for certain
3559 * command sequences. With too short delays (even if the answer
3560 * is set to RIRB properly), it results in the silence output
3561 * on some hardwares like Dell.
3563 * The below flag enables the longer delay (see get_response
3566 codec->bus->needs_damn_long_delay = 1;
3571 static int patch_stac9205(struct hda_codec *codec)
3573 struct sigmatel_spec *spec;
3576 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3581 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
3582 spec->pin_nids = stac9205_pin_nids;
3583 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
3587 if (spec->board_config < 0) {
3588 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
3589 err = stac92xx_save_bios_config_regs(codec);
3591 stac92xx_free(codec);
3594 spec->pin_configs = spec->bios_pin_configs;
3596 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
3597 stac92xx_set_config_regs(codec);
3600 spec->adc_nids = stac9205_adc_nids;
3601 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
3602 spec->mux_nids = stac9205_mux_nids;
3603 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
3604 spec->dmic_nids = stac9205_dmic_nids;
3605 spec->num_dmics = STAC9205_NUM_DMICS;
3606 spec->dmux_nids = stac9205_dmux_nids;
3607 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
3610 spec->init = stac9205_core_init;
3611 spec->mixer = stac9205_mixer;
3613 spec->aloopback_mask = 0x40;
3614 spec->aloopback_shift = 0;
3615 spec->multiout.dac_nids = spec->dac_nids;
3617 switch (spec->board_config){
3618 case STAC_9205_DELL_M43:
3619 /* Enable SPDIF in/out */
3620 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
3621 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
3623 spec->gpio_mask = 0x00000007; /* GPIO0-2 */
3624 /* GPIO0 High = EAPD, GPIO1 Low = DRM,
3625 * GPIO2 High = Headphone Mute
3627 spec->gpio_data = 0x00000005;
3630 /* GPIO0 High = EAPD */
3631 spec->gpio_mask = spec->gpio_data = 0x00000001;
3635 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
3637 if (spec->board_config < 0) {
3638 printk(KERN_WARNING "hda_codec: No auto-config is "
3639 "available, default to model=ref\n");
3640 spec->board_config = STAC_9205_REF;
3646 stac92xx_free(codec);
3650 codec->patch_ops = stac92xx_patch_ops;
3659 /* static config for Sony VAIO FE550G and Sony VAIO AR */
3660 static hda_nid_t vaio_dacs[] = { 0x2 };
3661 #define VAIO_HP_DAC 0x5
3662 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
3663 static hda_nid_t vaio_mux_nids[] = { 0x15 };
3665 static struct hda_input_mux vaio_mux = {
3668 /* { "HP", 0x0 }, */
3669 { "Mic Jack", 0x1 },
3670 { "Internal Mic", 0x2 },
3675 static struct hda_verb vaio_init[] = {
3676 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3677 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
3678 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3679 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3680 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3681 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3682 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3683 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3684 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3685 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3686 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3687 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3691 static struct hda_verb vaio_ar_init[] = {
3692 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3693 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3694 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3695 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3696 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
3697 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3698 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3699 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3700 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3701 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
3702 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3703 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3704 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3708 /* bind volumes of both NID 0x02 and 0x05 */
3709 static struct hda_bind_ctls vaio_bind_master_vol = {
3710 .ops = &snd_hda_bind_vol,
3712 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3713 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3718 /* bind volumes of both NID 0x02 and 0x05 */
3719 static struct hda_bind_ctls vaio_bind_master_sw = {
3720 .ops = &snd_hda_bind_sw,
3722 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3723 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3728 static struct snd_kcontrol_new vaio_mixer[] = {
3729 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3730 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3731 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3732 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3733 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3735 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3736 .name = "Capture Source",
3738 .info = stac92xx_mux_enum_info,
3739 .get = stac92xx_mux_enum_get,
3740 .put = stac92xx_mux_enum_put,
3745 static struct snd_kcontrol_new vaio_ar_mixer[] = {
3746 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3747 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3748 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3749 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3750 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3751 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
3752 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
3754 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3755 .name = "Capture Source",
3757 .info = stac92xx_mux_enum_info,
3758 .get = stac92xx_mux_enum_get,
3759 .put = stac92xx_mux_enum_put,
3764 static struct hda_codec_ops stac9872_patch_ops = {
3765 .build_controls = stac92xx_build_controls,
3766 .build_pcms = stac92xx_build_pcms,
3767 .init = stac92xx_init,
3768 .free = stac92xx_free,
3769 #ifdef SND_HDA_NEEDS_RESUME
3770 .resume = stac92xx_resume,
3774 static int stac9872_vaio_init(struct hda_codec *codec)
3778 err = stac92xx_init(codec);
3781 if (codec->patch_ops.unsol_event)
3782 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3786 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
3788 if (get_hp_pin_presence(codec, 0x0a)) {
3789 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3790 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3792 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3793 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3797 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
3799 switch (res >> 26) {
3801 stac9872_vaio_hp_detect(codec, res);
3806 static struct hda_codec_ops stac9872_vaio_patch_ops = {
3807 .build_controls = stac92xx_build_controls,
3808 .build_pcms = stac92xx_build_pcms,
3809 .init = stac9872_vaio_init,
3810 .free = stac92xx_free,
3811 .unsol_event = stac9872_vaio_unsol_event,
3813 .resume = stac92xx_resume,
3817 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
3819 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
3821 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
3823 /* AR Series. id=0x83847664 and subsys=104D1300 */
3828 static const char *stac9872_models[STAC_9872_MODELS] = {
3829 [CXD9872RD_VAIO] = "vaio",
3830 [CXD9872AKD_VAIO] = "vaio-ar",
3833 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
3834 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
3835 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
3836 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
3837 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
3841 static int patch_stac9872(struct hda_codec *codec)
3843 struct sigmatel_spec *spec;
3846 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
3849 if (board_config < 0)
3850 /* unknown config, let generic-parser do its job... */
3851 return snd_hda_parse_generic_codec(codec);
3853 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3858 switch (board_config) {
3859 case CXD9872RD_VAIO:
3860 case STAC9872AK_VAIO:
3861 case STAC9872K_VAIO:
3862 spec->mixer = vaio_mixer;
3863 spec->init = vaio_init;
3864 spec->multiout.max_channels = 2;
3865 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3866 spec->multiout.dac_nids = vaio_dacs;
3867 spec->multiout.hp_nid = VAIO_HP_DAC;
3868 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3869 spec->adc_nids = vaio_adcs;
3871 spec->input_mux = &vaio_mux;
3872 spec->mux_nids = vaio_mux_nids;
3873 codec->patch_ops = stac9872_vaio_patch_ops;
3876 case CXD9872AKD_VAIO:
3877 spec->mixer = vaio_ar_mixer;
3878 spec->init = vaio_ar_init;
3879 spec->multiout.max_channels = 2;
3880 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3881 spec->multiout.dac_nids = vaio_dacs;
3882 spec->multiout.hp_nid = VAIO_HP_DAC;
3883 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3885 spec->adc_nids = vaio_adcs;
3886 spec->input_mux = &vaio_mux;
3887 spec->mux_nids = vaio_mux_nids;
3888 codec->patch_ops = stac9872_patch_ops;
3899 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
3900 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
3901 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
3902 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
3903 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
3904 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
3905 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
3906 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
3907 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
3908 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
3909 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
3910 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
3911 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
3912 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
3913 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
3914 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
3915 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
3916 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
3917 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
3918 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
3919 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
3920 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
3921 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
3922 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
3923 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
3924 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
3925 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
3926 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
3927 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
3928 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
3929 /* The following does not take into account .id=0x83847661 when subsys =
3930 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
3931 * currently not fully supported.
3933 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
3934 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
3935 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
3936 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
3937 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
3938 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
3939 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
3940 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
3941 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
3942 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
3943 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
3944 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
3945 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
3946 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
3947 { .id = 0x111d7608, .name = "92HD71BXX", .patch = patch_stac92hd71bxx },
3948 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
3949 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
3950 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
3951 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
3952 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
3953 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
3954 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
3955 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },