2 * Universal Interface for Intel High Definition Audio Codec
4 * HD audio interface patch for SigmaTel STAC92xx
6 * Copyright (c) 2005 Embedded Alley Solutions, Inc.
7 * Matt Porter <mporter@embeddedalley.com>
9 * Based on patch_cmedia.c and patch_realtek.c
10 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
12 * This driver is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This driver is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include <sound/driver.h>
28 #include <linux/init.h>
29 #include <linux/delay.h>
30 #include <linux/slab.h>
31 #include <linux/pci.h>
32 #include <sound/core.h>
33 #include <sound/asoundef.h>
34 #include "hda_codec.h"
35 #include "hda_local.h"
37 #define NUM_CONTROL_ALLOC 32
38 #define STAC_HP_EVENT 0x37
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;
124 unsigned int gpio_mute: 1;
126 unsigned int gpio_mask, gpio_data;
127 unsigned char aloopback_mask;
128 unsigned char aloopback_shift;
131 struct hda_multi_out multiout;
132 hda_nid_t dac_nids[5];
136 unsigned int num_adcs;
138 unsigned int num_muxes;
139 hda_nid_t *dmic_nids;
140 unsigned int num_dmics;
141 hda_nid_t *dmux_nids;
142 unsigned int num_dmuxes;
143 hda_nid_t dig_in_nid;
147 unsigned int num_pins;
148 unsigned int *pin_configs;
149 unsigned int *bios_pin_configs;
151 /* codec specific stuff */
152 struct hda_verb *init;
153 struct snd_kcontrol_new *mixer;
156 struct hda_input_mux *dinput_mux;
157 unsigned int cur_dmux[2];
158 struct hda_input_mux *input_mux;
159 unsigned int cur_mux[3];
162 unsigned int io_switch[2];
163 unsigned int clfe_swap;
164 unsigned int aloopback;
166 struct hda_pcm pcm_rec[2]; /* PCM information */
168 /* dynamic controls and input_mux */
169 struct auto_pin_cfg autocfg;
170 unsigned int num_kctl_alloc, num_kctl_used;
171 struct snd_kcontrol_new *kctl_alloc;
172 struct hda_input_mux private_dimux;
173 struct hda_input_mux private_imux;
176 static hda_nid_t stac9200_adc_nids[1] = {
180 static hda_nid_t stac9200_mux_nids[1] = {
184 static hda_nid_t stac9200_dac_nids[1] = {
188 static hda_nid_t stac92hd73xx_adc_nids[2] = {
192 #define STAC92HD73XX_NUM_DMICS 2
193 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
197 #define STAC92HD73_DAC_COUNT 5
198 static hda_nid_t stac92hd73xx_dac_nids[STAC92HD73_DAC_COUNT] = {
199 0x15, 0x16, 0x17, 0x18, 0x19,
202 static hda_nid_t stac92hd73xx_mux_nids[4] = {
203 0x28, 0x29, 0x2a, 0x2b,
206 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
210 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
214 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
218 static hda_nid_t stac92hd71bxx_dmux_nids[1] = {
222 static hda_nid_t stac92hd71bxx_dac_nids[2] = {
226 #define STAC92HD71BXX_NUM_DMICS 2
227 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
231 static hda_nid_t stac925x_adc_nids[1] = {
235 static hda_nid_t stac925x_mux_nids[1] = {
239 static hda_nid_t stac925x_dac_nids[1] = {
243 #define STAC925X_NUM_DMICS 1
244 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
248 static hda_nid_t stac925x_dmux_nids[1] = {
252 static hda_nid_t stac922x_adc_nids[2] = {
256 static hda_nid_t stac922x_mux_nids[2] = {
260 static hda_nid_t stac927x_adc_nids[3] = {
264 static hda_nid_t stac927x_mux_nids[3] = {
268 static hda_nid_t stac927x_dmux_nids[1] = {
272 #define STAC927X_NUM_DMICS 2
273 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
277 static hda_nid_t stac9205_adc_nids[2] = {
281 static hda_nid_t stac9205_mux_nids[2] = {
285 static hda_nid_t stac9205_dmux_nids[1] = {
289 #define STAC9205_NUM_DMICS 2
290 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
294 static hda_nid_t stac9200_pin_nids[8] = {
295 0x08, 0x09, 0x0d, 0x0e,
296 0x0f, 0x10, 0x11, 0x12,
299 static hda_nid_t stac925x_pin_nids[8] = {
300 0x07, 0x08, 0x0a, 0x0b,
301 0x0c, 0x0d, 0x10, 0x11,
304 static hda_nid_t stac922x_pin_nids[10] = {
305 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
306 0x0f, 0x10, 0x11, 0x15, 0x1b,
309 static hda_nid_t stac92hd73xx_pin_nids[12] = {
310 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12, 0x13,
315 static hda_nid_t stac92hd71bxx_pin_nids[10] = {
316 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
317 0x0f, 0x14, 0x18, 0x19, 0x1e,
320 static hda_nid_t stac927x_pin_nids[14] = {
321 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
322 0x0f, 0x10, 0x11, 0x12, 0x13,
323 0x14, 0x21, 0x22, 0x23,
326 static hda_nid_t stac9205_pin_nids[12] = {
327 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
328 0x0f, 0x14, 0x16, 0x17, 0x18,
332 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
333 struct snd_ctl_elem_info *uinfo)
335 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
336 struct sigmatel_spec *spec = codec->spec;
337 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
340 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
341 struct snd_ctl_elem_value *ucontrol)
343 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
344 struct sigmatel_spec *spec = codec->spec;
345 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
347 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
351 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
352 struct snd_ctl_elem_value *ucontrol)
354 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
355 struct sigmatel_spec *spec = codec->spec;
356 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
358 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
359 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
362 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
364 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
365 struct sigmatel_spec *spec = codec->spec;
366 return snd_hda_input_mux_info(spec->input_mux, uinfo);
369 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
371 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
372 struct sigmatel_spec *spec = codec->spec;
373 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
375 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
379 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
381 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
382 struct sigmatel_spec *spec = codec->spec;
383 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
385 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
386 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
389 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
391 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
392 struct snd_ctl_elem_value *ucontrol)
394 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
395 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
396 struct sigmatel_spec *spec = codec->spec;
398 ucontrol->value.integer.value[0] = !!(spec->aloopback &
399 (spec->aloopback_mask << idx));
403 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
404 struct snd_ctl_elem_value *ucontrol)
406 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
407 struct sigmatel_spec *spec = codec->spec;
408 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
409 unsigned int dac_mode;
410 unsigned int val, idx_val;
412 idx_val = spec->aloopback_mask << idx;
413 if (ucontrol->value.integer.value[0])
414 val = spec->aloopback | idx_val;
416 val = spec->aloopback & ~idx_val;
417 if (spec->aloopback == val)
420 spec->aloopback = val;
422 /* Only return the bits defined by the shift value of the
423 * first two bytes of the mask
425 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
426 kcontrol->private_value & 0xFFFF, 0x0);
427 dac_mode >>= spec->aloopback_shift;
429 if (spec->aloopback & idx_val) {
430 snd_hda_power_up(codec);
433 snd_hda_power_down(codec);
434 dac_mode &= ~idx_val;
437 snd_hda_codec_write_cache(codec, codec->afg, 0,
438 kcontrol->private_value >> 16, dac_mode);
443 static struct hda_verb stac9200_core_init[] = {
444 /* set dac0mux for dac converter */
445 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
449 static struct hda_verb stac9200_eapd_init[] = {
450 /* set dac0mux for dac converter */
451 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
452 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
456 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
457 /* set master volume and direct control */
458 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
459 /* setup audio connections */
460 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
461 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
462 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
463 /* setup adcs to point to mixer */
464 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
465 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
466 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Front Mic */
467 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Mic */
468 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Line In */
469 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
470 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
471 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
472 /* setup import muxs */
473 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
474 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
475 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
476 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
480 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
481 /* set master volume and direct control */
482 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
483 /* setup audio connections */
484 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
485 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
486 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
487 /* connect hp ports to dac3 */
488 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x03},
489 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x03},
490 /* setup adcs to point to mixer */
491 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
492 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
493 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Front Mic */
494 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Mic */
495 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Line In */
496 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
497 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
498 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
499 /* setup import muxs */
500 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
501 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
502 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
503 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
507 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
508 /* set master volume and direct control */
509 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
510 /* setup audio connections */
511 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
512 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01 },
513 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02 },
514 /* dac3 is connected to import3 mux */
515 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
516 /* connect hp ports to dac4 */
517 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x04},
518 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x04},
519 /* setup adcs to point to mixer */
520 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
521 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
522 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Front Mic */
523 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Mic */
524 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Line In */
525 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
526 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
527 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
528 /* setup import muxs */
529 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
530 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
531 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
532 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
536 static struct hda_verb stac92hd71bxx_core_init[] = {
537 /* set master volume and direct control */
538 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
539 /* connect headphone jack to dac1 */
540 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
541 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */
542 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
543 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
544 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
545 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
546 /* unmute mono out node */
547 { 0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
550 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
551 /* set master volume and direct control */
552 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
553 /* connect headphone jack to dac1 */
554 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
555 /* connect ports 0d and 0f to audio mixer */
556 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x2},
557 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
558 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
559 /* unmute dac0 input in audio mixer */
560 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
561 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
562 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
563 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
564 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
565 /* unmute mono out node */
566 { 0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
570 static struct hda_verb stac925x_core_init[] = {
571 /* set dac0mux for dac converter */
572 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
576 static struct hda_verb stac922x_core_init[] = {
577 /* set master volume and direct control */
578 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
582 static struct hda_verb d965_core_init[] = {
583 /* set master volume and direct control */
584 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
585 /* unmute node 0x1b */
586 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
587 /* select node 0x03 as DAC */
588 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
592 static struct hda_verb stac927x_core_init[] = {
593 /* set master volume and direct control */
594 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
598 static struct hda_verb stac9205_core_init[] = {
599 /* set master volume and direct control */
600 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
604 #define STAC_INPUT_SOURCE(cnt) \
606 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
607 .name = "Input Source", \
609 .info = stac92xx_mux_enum_info, \
610 .get = stac92xx_mux_enum_get, \
611 .put = stac92xx_mux_enum_put, \
614 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
616 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
617 .name = "Analog Loopback", \
619 .info = stac92xx_aloopback_info, \
620 .get = stac92xx_aloopback_get, \
621 .put = stac92xx_aloopback_put, \
622 .private_value = verb_read | (verb_write << 16), \
625 static struct snd_kcontrol_new stac9200_mixer[] = {
626 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
627 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
628 STAC_INPUT_SOURCE(1),
629 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
630 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
631 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT),
635 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
636 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
638 /* hardware gain controls */
639 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x13, 0x0, HDA_INPUT),
640 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x14, 0x0, HDA_INPUT),
642 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
643 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
645 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
646 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
648 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
649 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
651 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
652 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
654 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
655 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
657 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
658 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
660 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
661 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
665 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
666 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
668 /* hardware gain controls */
669 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x13, 0x0, HDA_INPUT),
670 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x14, 0x0, HDA_INPUT),
672 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
673 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
675 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
676 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
678 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
679 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
681 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
682 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
684 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
685 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
687 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
688 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
690 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
691 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
695 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
696 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
698 /* hardware gain controls */
699 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x13, 0x0, HDA_INPUT),
700 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x14, 0x0, HDA_INPUT),
702 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
703 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
705 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
706 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
708 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
709 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
711 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
712 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
714 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
715 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
717 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
718 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
720 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
721 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
725 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
726 STAC_INPUT_SOURCE(2),
728 /* hardware gain controls */
729 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x18, 0x0, HDA_OUTPUT),
730 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x19, 0x0, HDA_OUTPUT),
732 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
733 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
734 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
736 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
737 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
738 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
740 HDA_CODEC_MUTE("Analog Loopback 1", 0x17, 0x3, HDA_INPUT),
741 HDA_CODEC_MUTE("Analog Loopback 2", 0x17, 0x4, HDA_INPUT),
745 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
746 STAC_INPUT_SOURCE(2),
747 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
749 /* hardware gain controls */
750 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x18, 0x0, HDA_OUTPUT),
751 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x19, 0x0, HDA_OUTPUT),
753 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
754 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
755 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
757 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
758 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
759 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
763 static struct snd_kcontrol_new stac925x_mixer[] = {
764 STAC_INPUT_SOURCE(1),
765 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
766 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_OUTPUT),
767 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT),
771 static struct snd_kcontrol_new stac9205_mixer[] = {
772 STAC_INPUT_SOURCE(2),
773 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
775 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
776 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
777 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT),
779 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
780 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
781 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT),
786 /* This needs to be generated dynamically based on sequence */
787 static struct snd_kcontrol_new stac922x_mixer[] = {
788 STAC_INPUT_SOURCE(2),
789 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
790 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
791 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT),
793 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
794 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
795 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT),
800 static struct snd_kcontrol_new stac927x_mixer[] = {
801 STAC_INPUT_SOURCE(3),
802 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
804 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
805 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
806 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT),
808 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
809 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
810 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT),
812 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
813 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
814 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT),
818 static struct snd_kcontrol_new stac_dmux_mixer = {
819 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
820 .name = "Digital Input Source",
821 /* count set later */
822 .info = stac92xx_dmux_enum_info,
823 .get = stac92xx_dmux_enum_get,
824 .put = stac92xx_dmux_enum_put,
827 static int stac92xx_build_controls(struct hda_codec *codec)
829 struct sigmatel_spec *spec = codec->spec;
833 err = snd_hda_add_new_ctls(codec, spec->mixer);
837 for (i = 0; i < spec->num_mixers; i++) {
838 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
842 if (spec->num_dmuxes > 0) {
843 stac_dmux_mixer.count = spec->num_dmuxes;
844 err = snd_ctl_add(codec->bus->card,
845 snd_ctl_new1(&stac_dmux_mixer, codec));
850 if (spec->multiout.dig_out_nid) {
851 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
855 if (spec->dig_in_nid) {
856 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
863 static unsigned int ref9200_pin_configs[8] = {
864 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
865 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
869 STAC 9200 pin configs for
874 static unsigned int dell9200_d21_pin_configs[8] = {
875 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
876 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
880 STAC 9200 pin configs for
884 static unsigned int dell9200_d22_pin_configs[8] = {
885 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
886 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
890 STAC 9200 pin configs for
891 102801C4 (Dell Dimension E310)
898 static unsigned int dell9200_d23_pin_configs[8] = {
899 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
900 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
905 STAC 9200-32 pin configs for
906 102801B5 (Dell Inspiron 630m)
907 102801D8 (Dell Inspiron 640m)
909 static unsigned int dell9200_m21_pin_configs[8] = {
910 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
911 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
915 STAC 9200-32 pin configs for
916 102801C2 (Dell Latitude D620)
918 102801CC (Dell Latitude D820)
922 static unsigned int dell9200_m22_pin_configs[8] = {
923 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
924 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
928 STAC 9200-32 pin configs for
929 102801CE (Dell XPS M1710)
930 102801CF (Dell Precision M90)
932 static unsigned int dell9200_m23_pin_configs[8] = {
933 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
934 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
938 STAC 9200-32 pin configs for
941 102801CB (Dell Latitude 120L)
944 static unsigned int dell9200_m24_pin_configs[8] = {
945 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
946 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
950 STAC 9200-32 pin configs for
951 102801BD (Dell Inspiron E1505n)
955 static unsigned int dell9200_m25_pin_configs[8] = {
956 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
957 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
961 STAC 9200-32 pin configs for
962 102801F5 (Dell Inspiron 1501)
965 static unsigned int dell9200_m26_pin_configs[8] = {
966 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
967 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
972 102801CD (Dell Inspiron E1705/9400)
974 static unsigned int dell9200_m27_pin_configs[8] = {
975 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
976 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
980 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
981 [STAC_REF] = ref9200_pin_configs,
982 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
983 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
984 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
985 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
986 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
987 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
988 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
989 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
990 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
991 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
994 static const char *stac9200_models[STAC_9200_MODELS] = {
996 [STAC_9200_DELL_D21] = "dell-d21",
997 [STAC_9200_DELL_D22] = "dell-d22",
998 [STAC_9200_DELL_D23] = "dell-d23",
999 [STAC_9200_DELL_M21] = "dell-m21",
1000 [STAC_9200_DELL_M22] = "dell-m22",
1001 [STAC_9200_DELL_M23] = "dell-m23",
1002 [STAC_9200_DELL_M24] = "dell-m24",
1003 [STAC_9200_DELL_M25] = "dell-m25",
1004 [STAC_9200_DELL_M26] = "dell-m26",
1005 [STAC_9200_DELL_M27] = "dell-m27",
1006 [STAC_9200_GATEWAY] = "gateway",
1009 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1010 /* SigmaTel reference board */
1011 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1012 "DFI LanParty", STAC_REF),
1013 /* Dell laptops have BIOS problem */
1014 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1015 "unknown Dell", STAC_9200_DELL_D21),
1016 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1017 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1018 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1019 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1020 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1021 "unknown Dell", STAC_9200_DELL_D22),
1022 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1023 "unknown Dell", STAC_9200_DELL_D22),
1024 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1025 "Dell Latitude D620", STAC_9200_DELL_M22),
1026 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1027 "unknown Dell", STAC_9200_DELL_D23),
1028 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1029 "unknown Dell", STAC_9200_DELL_D23),
1030 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1031 "unknown Dell", STAC_9200_DELL_M22),
1032 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1033 "unknown Dell", STAC_9200_DELL_M24),
1034 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1035 "unknown Dell", STAC_9200_DELL_M24),
1036 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1037 "Dell Latitude 120L", STAC_9200_DELL_M24),
1038 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1039 "Dell Latitude D820", STAC_9200_DELL_M22),
1040 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1041 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1042 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1043 "Dell XPS M1710", STAC_9200_DELL_M23),
1044 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1045 "Dell Precision M90", STAC_9200_DELL_M23),
1046 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1047 "unknown Dell", STAC_9200_DELL_M22),
1048 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1049 "unknown Dell", STAC_9200_DELL_M22),
1050 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1051 "unknown Dell", STAC_9200_DELL_M22),
1052 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1053 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1054 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1055 "unknown Dell", STAC_9200_DELL_D23),
1056 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1057 "unknown Dell", STAC_9200_DELL_D23),
1058 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1059 "unknown Dell", STAC_9200_DELL_D21),
1060 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1061 "unknown Dell", STAC_9200_DELL_D23),
1062 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1063 "unknown Dell", STAC_9200_DELL_D21),
1064 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1065 "unknown Dell", STAC_9200_DELL_M25),
1066 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1067 "unknown Dell", STAC_9200_DELL_M25),
1068 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1069 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1070 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1071 "unknown Dell", STAC_9200_DELL_M26),
1073 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_REF),
1074 /* Gateway machines needs EAPD to be set on resume */
1075 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
1076 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
1078 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
1083 static unsigned int ref925x_pin_configs[8] = {
1084 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1085 0x90a70320, 0x02214210, 0x400003f1, 0x9033032e,
1088 static unsigned int stac925x_MA6_pin_configs[8] = {
1089 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1090 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
1093 static unsigned int stac925x_PA6_pin_configs[8] = {
1094 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1095 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
1098 static unsigned int stac925xM2_2_pin_configs[8] = {
1099 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
1100 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
1103 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1104 [STAC_REF] = ref925x_pin_configs,
1105 [STAC_M2_2] = stac925xM2_2_pin_configs,
1106 [STAC_MA6] = stac925x_MA6_pin_configs,
1107 [STAC_PA6] = stac925x_PA6_pin_configs,
1110 static const char *stac925x_models[STAC_925x_MODELS] = {
1112 [STAC_M2_2] = "m2-2",
1117 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1118 /* SigmaTel reference board */
1119 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1120 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1121 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
1122 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
1123 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
1124 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
1125 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
1129 static unsigned int ref92hd73xx_pin_configs[12] = {
1130 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1131 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1132 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1135 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1136 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1139 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1140 [STAC_92HD73XX_REF] = "ref",
1143 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1144 /* SigmaTel reference board */
1145 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1146 "DFI LanParty", STAC_92HD73XX_REF),
1150 static unsigned int ref92hd71bxx_pin_configs[10] = {
1151 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1152 0x0181302e, 0x01114010, 0x01a19020, 0x90a000f0,
1153 0x90a000f0, 0x01452050,
1156 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1157 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1160 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1161 [STAC_92HD71BXX_REF] = "ref",
1164 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1165 /* SigmaTel reference board */
1166 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1167 "DFI LanParty", STAC_92HD71BXX_REF),
1171 static unsigned int ref922x_pin_configs[10] = {
1172 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1173 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1174 0x40000100, 0x40000100,
1178 STAC 922X pin configs for
1185 static unsigned int dell_922x_d81_pin_configs[10] = {
1186 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1187 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1188 0x01813122, 0x400001f2,
1192 STAC 922X pin configs for
1196 static unsigned int dell_922x_d82_pin_configs[10] = {
1197 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1198 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1199 0x01813122, 0x400001f1,
1203 STAC 922X pin configs for
1206 static unsigned int dell_922x_m81_pin_configs[10] = {
1207 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1208 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1209 0x40C003f1, 0x405003f0,
1213 STAC 9221 A1 pin configs for
1214 102801D7 (Dell XPS M1210)
1216 static unsigned int dell_922x_m82_pin_configs[10] = {
1217 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1218 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1219 0x508003f3, 0x405003f4,
1222 static unsigned int d945gtp3_pin_configs[10] = {
1223 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1224 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1225 0x02a19120, 0x40000100,
1228 static unsigned int d945gtp5_pin_configs[10] = {
1229 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1230 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1231 0x02a19320, 0x40000100,
1234 static unsigned int intel_mac_v1_pin_configs[10] = {
1235 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1236 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1237 0x400000fc, 0x400000fb,
1240 static unsigned int intel_mac_v2_pin_configs[10] = {
1241 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1242 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1243 0x400000fc, 0x400000fb,
1246 static unsigned int intel_mac_v3_pin_configs[10] = {
1247 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1248 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1249 0x400000fc, 0x400000fb,
1252 static unsigned int intel_mac_v4_pin_configs[10] = {
1253 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1254 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1255 0x400000fc, 0x400000fb,
1258 static unsigned int intel_mac_v5_pin_configs[10] = {
1259 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1260 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1261 0x400000fc, 0x400000fb,
1265 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1266 [STAC_D945_REF] = ref922x_pin_configs,
1267 [STAC_D945GTP3] = d945gtp3_pin_configs,
1268 [STAC_D945GTP5] = d945gtp5_pin_configs,
1269 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1270 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1271 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1272 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1273 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1274 /* for backward compatibility */
1275 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1276 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1277 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1278 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1279 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1280 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1281 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1282 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1283 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1284 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1287 static const char *stac922x_models[STAC_922X_MODELS] = {
1288 [STAC_D945_REF] = "ref",
1289 [STAC_D945GTP5] = "5stack",
1290 [STAC_D945GTP3] = "3stack",
1291 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1292 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1293 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1294 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1295 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1296 /* for backward compatibility */
1297 [STAC_MACMINI] = "macmini",
1298 [STAC_MACBOOK] = "macbook",
1299 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1300 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1301 [STAC_IMAC_INTEL] = "imac-intel",
1302 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1303 [STAC_922X_DELL_D81] = "dell-d81",
1304 [STAC_922X_DELL_D82] = "dell-d82",
1305 [STAC_922X_DELL_M81] = "dell-m81",
1306 [STAC_922X_DELL_M82] = "dell-m82",
1309 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1310 /* SigmaTel reference board */
1311 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1312 "DFI LanParty", STAC_D945_REF),
1313 /* Intel 945G based systems */
1314 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1315 "Intel D945G", STAC_D945GTP3),
1316 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1317 "Intel D945G", STAC_D945GTP3),
1318 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1319 "Intel D945G", STAC_D945GTP3),
1320 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1321 "Intel D945G", STAC_D945GTP3),
1322 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1323 "Intel D945G", STAC_D945GTP3),
1324 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1325 "Intel D945G", STAC_D945GTP3),
1326 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1327 "Intel D945G", STAC_D945GTP3),
1328 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1329 "Intel D945G", STAC_D945GTP3),
1330 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1331 "Intel D945G", STAC_D945GTP3),
1332 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1333 "Intel D945G", STAC_D945GTP3),
1334 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1335 "Intel D945G", STAC_D945GTP3),
1336 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1337 "Intel D945G", STAC_D945GTP3),
1338 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1339 "Intel D945G", STAC_D945GTP3),
1340 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1341 "Intel D945G", STAC_D945GTP3),
1342 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1343 "Intel D945G", STAC_D945GTP3),
1344 /* Intel D945G 5-stack systems */
1345 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1346 "Intel D945G", STAC_D945GTP5),
1347 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1348 "Intel D945G", STAC_D945GTP5),
1349 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1350 "Intel D945G", STAC_D945GTP5),
1351 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1352 "Intel D945G", STAC_D945GTP5),
1353 /* Intel 945P based systems */
1354 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1355 "Intel D945P", STAC_D945GTP3),
1356 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1357 "Intel D945P", STAC_D945GTP3),
1358 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1359 "Intel D945P", STAC_D945GTP3),
1360 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1361 "Intel D945P", STAC_D945GTP3),
1362 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1363 "Intel D945P", STAC_D945GTP3),
1364 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1365 "Intel D945P", STAC_D945GTP5),
1367 /* Apple Mac Mini (early 2006) */
1368 SND_PCI_QUIRK(0x8384, 0x7680,
1369 "Mac Mini", STAC_INTEL_MAC_V3),
1371 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1372 "unknown Dell", STAC_922X_DELL_D81),
1373 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1374 "unknown Dell", STAC_922X_DELL_D81),
1375 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1376 "unknown Dell", STAC_922X_DELL_D81),
1377 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1378 "unknown Dell", STAC_922X_DELL_D82),
1379 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1380 "unknown Dell", STAC_922X_DELL_M81),
1381 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1382 "unknown Dell", STAC_922X_DELL_D82),
1383 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1384 "unknown Dell", STAC_922X_DELL_D81),
1385 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1386 "unknown Dell", STAC_922X_DELL_D81),
1387 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1388 "Dell XPS M1210", STAC_922X_DELL_M82),
1392 static unsigned int ref927x_pin_configs[14] = {
1393 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1394 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1395 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1396 0x01c42190, 0x40000100,
1399 static unsigned int d965_3st_pin_configs[14] = {
1400 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
1401 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
1402 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1403 0x40000100, 0x40000100
1406 static unsigned int d965_5st_pin_configs[14] = {
1407 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1408 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
1409 0x40000100, 0x40000100, 0x40000100, 0x01442070,
1410 0x40000100, 0x40000100
1413 static unsigned int dell_3st_pin_configs[14] = {
1414 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
1415 0x01111212, 0x01116211, 0x01813050, 0x01112214,
1416 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
1417 0x40c003fc, 0x40000100
1420 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
1421 [STAC_D965_REF] = ref927x_pin_configs,
1422 [STAC_D965_3ST] = d965_3st_pin_configs,
1423 [STAC_D965_5ST] = d965_5st_pin_configs,
1424 [STAC_DELL_3ST] = dell_3st_pin_configs,
1425 [STAC_DELL_BIOS] = NULL,
1428 static const char *stac927x_models[STAC_927X_MODELS] = {
1429 [STAC_D965_REF] = "ref",
1430 [STAC_D965_3ST] = "3stack",
1431 [STAC_D965_5ST] = "5stack",
1432 [STAC_DELL_3ST] = "dell-3stack",
1433 [STAC_DELL_BIOS] = "dell-bios",
1436 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
1437 /* SigmaTel reference board */
1438 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1439 "DFI LanParty", STAC_D965_REF),
1440 /* Intel 946 based systems */
1441 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
1442 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
1443 /* 965 based 3 stack systems */
1444 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
1445 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
1446 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
1447 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
1448 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
1449 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
1450 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
1451 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
1452 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
1453 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
1454 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
1455 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
1456 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
1457 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
1458 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
1459 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
1460 /* Dell 3 stack systems */
1461 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_3ST),
1462 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
1463 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
1464 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
1465 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
1466 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_3ST),
1467 /* Dell 3 stack systems with verb table in BIOS */
1468 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell ", STAC_DELL_BIOS),
1469 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
1470 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
1471 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
1472 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
1473 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
1474 /* 965 based 5 stack systems */
1475 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
1476 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
1477 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
1478 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
1479 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
1480 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
1481 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
1482 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
1483 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
1487 static unsigned int ref9205_pin_configs[12] = {
1488 0x40000100, 0x40000100, 0x01016011, 0x01014010,
1489 0x01813122, 0x01a19021, 0x40000100, 0x40000100,
1490 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
1494 STAC 9205 pin configs for
1502 static unsigned int dell_9205_m42_pin_configs[12] = {
1503 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
1504 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
1505 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
1509 STAC 9205 pin configs for
1513 102801FF (Dell Precision M4300)
1518 static unsigned int dell_9205_m43_pin_configs[12] = {
1519 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
1520 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
1521 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
1524 static unsigned int dell_9205_m44_pin_configs[12] = {
1525 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
1526 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
1527 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
1530 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
1531 [STAC_9205_REF] = ref9205_pin_configs,
1532 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
1533 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
1534 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
1537 static const char *stac9205_models[STAC_9205_MODELS] = {
1538 [STAC_9205_REF] = "ref",
1539 [STAC_9205_DELL_M42] = "dell-m42",
1540 [STAC_9205_DELL_M43] = "dell-m43",
1541 [STAC_9205_DELL_M44] = "dell-m44",
1544 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
1545 /* SigmaTel reference board */
1546 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1547 "DFI LanParty", STAC_9205_REF),
1548 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1549 "unknown Dell", STAC_9205_DELL_M42),
1550 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1551 "unknown Dell", STAC_9205_DELL_M42),
1552 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
1553 "Dell Precision", STAC_9205_DELL_M43),
1554 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
1555 "Dell Precision", STAC_9205_DELL_M43),
1556 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
1557 "Dell Precision", STAC_9205_DELL_M43),
1558 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
1559 "Dell Precision", STAC_9205_DELL_M43),
1560 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
1561 "Dell Precision", STAC_9205_DELL_M43),
1562 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1563 "unknown Dell", STAC_9205_DELL_M42),
1564 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1565 "unknown Dell", STAC_9205_DELL_M42),
1566 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
1567 "Dell Precision", STAC_9205_DELL_M43),
1568 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
1569 "Dell Precision M4300", STAC_9205_DELL_M43),
1570 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
1571 "Dell Precision", STAC_9205_DELL_M43),
1572 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1573 "Dell Inspiron", STAC_9205_DELL_M44),
1574 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1575 "Dell Inspiron", STAC_9205_DELL_M44),
1576 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1577 "Dell Inspiron", STAC_9205_DELL_M44),
1578 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1579 "Dell Inspiron", STAC_9205_DELL_M44),
1580 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
1581 "unknown Dell", STAC_9205_DELL_M42),
1582 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
1583 "Dell Inspiron", STAC_9205_DELL_M44),
1587 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
1590 struct sigmatel_spec *spec = codec->spec;
1592 if (! spec->bios_pin_configs) {
1593 spec->bios_pin_configs = kcalloc(spec->num_pins,
1594 sizeof(*spec->bios_pin_configs), GFP_KERNEL);
1595 if (! spec->bios_pin_configs)
1599 for (i = 0; i < spec->num_pins; i++) {
1600 hda_nid_t nid = spec->pin_nids[i];
1601 unsigned int pin_cfg;
1603 pin_cfg = snd_hda_codec_read(codec, nid, 0,
1604 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
1605 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
1607 spec->bios_pin_configs[i] = pin_cfg;
1613 static void stac92xx_set_config_reg(struct hda_codec *codec,
1614 hda_nid_t pin_nid, unsigned int pin_config)
1617 snd_hda_codec_write(codec, pin_nid, 0,
1618 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
1619 pin_config & 0x000000ff);
1620 snd_hda_codec_write(codec, pin_nid, 0,
1621 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
1622 (pin_config & 0x0000ff00) >> 8);
1623 snd_hda_codec_write(codec, pin_nid, 0,
1624 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
1625 (pin_config & 0x00ff0000) >> 16);
1626 snd_hda_codec_write(codec, pin_nid, 0,
1627 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
1629 i = snd_hda_codec_read(codec, pin_nid, 0,
1630 AC_VERB_GET_CONFIG_DEFAULT,
1632 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
1636 static void stac92xx_set_config_regs(struct hda_codec *codec)
1639 struct sigmatel_spec *spec = codec->spec;
1641 if (!spec->pin_configs)
1644 for (i = 0; i < spec->num_pins; i++)
1645 stac92xx_set_config_reg(codec, spec->pin_nids[i],
1646 spec->pin_configs[i]);
1649 static void stac92xx_enable_gpio_mask(struct hda_codec *codec)
1651 struct sigmatel_spec *spec = codec->spec;
1652 /* Configure GPIOx as output */
1653 snd_hda_codec_write_cache(codec, codec->afg, 0,
1654 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_mask);
1655 /* Configure GPIOx as CMOS */
1656 snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7e7, 0x00000000);
1658 snd_hda_codec_write_cache(codec, codec->afg, 0,
1659 AC_VERB_SET_GPIO_DATA, spec->gpio_data);
1661 snd_hda_codec_write_cache(codec, codec->afg, 0,
1662 AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
1666 * Analog playback callbacks
1668 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
1669 struct hda_codec *codec,
1670 struct snd_pcm_substream *substream)
1672 struct sigmatel_spec *spec = codec->spec;
1673 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
1676 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1677 struct hda_codec *codec,
1678 unsigned int stream_tag,
1679 unsigned int format,
1680 struct snd_pcm_substream *substream)
1682 struct sigmatel_spec *spec = codec->spec;
1683 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
1686 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1687 struct hda_codec *codec,
1688 struct snd_pcm_substream *substream)
1690 struct sigmatel_spec *spec = codec->spec;
1691 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1695 * Digital playback callbacks
1697 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1698 struct hda_codec *codec,
1699 struct snd_pcm_substream *substream)
1701 struct sigmatel_spec *spec = codec->spec;
1702 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1705 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1706 struct hda_codec *codec,
1707 struct snd_pcm_substream *substream)
1709 struct sigmatel_spec *spec = codec->spec;
1710 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1713 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1714 struct hda_codec *codec,
1715 unsigned int stream_tag,
1716 unsigned int format,
1717 struct snd_pcm_substream *substream)
1719 struct sigmatel_spec *spec = codec->spec;
1720 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1721 stream_tag, format, substream);
1726 * Analog capture callbacks
1728 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1729 struct hda_codec *codec,
1730 unsigned int stream_tag,
1731 unsigned int format,
1732 struct snd_pcm_substream *substream)
1734 struct sigmatel_spec *spec = codec->spec;
1736 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1737 stream_tag, 0, format);
1741 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1742 struct hda_codec *codec,
1743 struct snd_pcm_substream *substream)
1745 struct sigmatel_spec *spec = codec->spec;
1747 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
1751 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
1755 /* NID is set in stac92xx_build_pcms */
1757 .open = stac92xx_dig_playback_pcm_open,
1758 .close = stac92xx_dig_playback_pcm_close,
1759 .prepare = stac92xx_dig_playback_pcm_prepare
1763 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
1767 /* NID is set in stac92xx_build_pcms */
1770 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
1774 .nid = 0x02, /* NID to query formats and rates */
1776 .open = stac92xx_playback_pcm_open,
1777 .prepare = stac92xx_playback_pcm_prepare,
1778 .cleanup = stac92xx_playback_pcm_cleanup
1782 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
1786 .nid = 0x06, /* NID to query formats and rates */
1788 .open = stac92xx_playback_pcm_open,
1789 .prepare = stac92xx_playback_pcm_prepare,
1790 .cleanup = stac92xx_playback_pcm_cleanup
1794 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
1797 /* NID + .substreams is set in stac92xx_build_pcms */
1799 .prepare = stac92xx_capture_pcm_prepare,
1800 .cleanup = stac92xx_capture_pcm_cleanup
1804 static int stac92xx_build_pcms(struct hda_codec *codec)
1806 struct sigmatel_spec *spec = codec->spec;
1807 struct hda_pcm *info = spec->pcm_rec;
1809 codec->num_pcms = 1;
1810 codec->pcm_info = info;
1812 info->name = "STAC92xx Analog";
1813 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
1814 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
1815 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1816 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
1818 if (spec->alt_switch) {
1821 info->name = "STAC92xx Analog Alt";
1822 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
1825 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1828 info->name = "STAC92xx Digital";
1829 if (spec->multiout.dig_out_nid) {
1830 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
1831 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
1833 if (spec->dig_in_nid) {
1834 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
1835 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
1842 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
1844 unsigned int pincap = snd_hda_param_read(codec, nid,
1846 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
1847 if (pincap & AC_PINCAP_VREF_100)
1848 return AC_PINCTL_VREF_100;
1849 if (pincap & AC_PINCAP_VREF_80)
1850 return AC_PINCTL_VREF_80;
1851 if (pincap & AC_PINCAP_VREF_50)
1852 return AC_PINCTL_VREF_50;
1853 if (pincap & AC_PINCAP_VREF_GRD)
1854 return AC_PINCTL_VREF_GRD;
1858 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
1861 snd_hda_codec_write_cache(codec, nid, 0,
1862 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
1865 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
1867 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1869 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1870 struct sigmatel_spec *spec = codec->spec;
1871 int io_idx = kcontrol-> private_value & 0xff;
1873 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
1877 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1879 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1880 struct sigmatel_spec *spec = codec->spec;
1881 hda_nid_t nid = kcontrol->private_value >> 8;
1882 int io_idx = kcontrol-> private_value & 0xff;
1883 unsigned short val = !!ucontrol->value.integer.value[0];
1885 spec->io_switch[io_idx] = val;
1888 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
1890 unsigned int pinctl = AC_PINCTL_IN_EN;
1891 if (io_idx) /* set VREF for mic */
1892 pinctl |= stac92xx_get_vref(codec, nid);
1893 stac92xx_auto_set_pinctl(codec, nid, pinctl);
1896 /* check the auto-mute again: we need to mute/unmute the speaker
1897 * appropriately according to the pin direction
1899 if (spec->hp_detect)
1900 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
1905 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
1907 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
1908 struct snd_ctl_elem_value *ucontrol)
1910 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1911 struct sigmatel_spec *spec = codec->spec;
1913 ucontrol->value.integer.value[0] = spec->clfe_swap;
1917 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
1918 struct snd_ctl_elem_value *ucontrol)
1920 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1921 struct sigmatel_spec *spec = codec->spec;
1922 hda_nid_t nid = kcontrol->private_value & 0xff;
1923 unsigned int val = !!ucontrol->value.integer.value[0];
1925 if (spec->clfe_swap == val)
1928 spec->clfe_swap = val;
1930 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1931 spec->clfe_swap ? 0x4 : 0x0);
1936 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
1937 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1940 .info = stac92xx_io_switch_info, \
1941 .get = stac92xx_io_switch_get, \
1942 .put = stac92xx_io_switch_put, \
1943 .private_value = xpval, \
1946 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
1947 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1950 .info = stac92xx_clfe_switch_info, \
1951 .get = stac92xx_clfe_switch_get, \
1952 .put = stac92xx_clfe_switch_put, \
1953 .private_value = xpval, \
1957 STAC_CTL_WIDGET_VOL,
1958 STAC_CTL_WIDGET_MUTE,
1959 STAC_CTL_WIDGET_IO_SWITCH,
1960 STAC_CTL_WIDGET_CLFE_SWITCH
1963 static struct snd_kcontrol_new stac92xx_control_templates[] = {
1964 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
1965 HDA_CODEC_MUTE(NULL, 0, 0, 0),
1966 STAC_CODEC_IO_SWITCH(NULL, 0),
1967 STAC_CODEC_CLFE_SWITCH(NULL, 0),
1970 /* add dynamic controls */
1971 static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val)
1973 struct snd_kcontrol_new *knew;
1975 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
1976 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
1978 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
1981 if (spec->kctl_alloc) {
1982 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
1983 kfree(spec->kctl_alloc);
1985 spec->kctl_alloc = knew;
1986 spec->num_kctl_alloc = num;
1989 knew = &spec->kctl_alloc[spec->num_kctl_used];
1990 *knew = stac92xx_control_templates[type];
1991 knew->name = kstrdup(name, GFP_KERNEL);
1994 knew->private_value = val;
1995 spec->num_kctl_used++;
1999 /* flag inputs as additional dynamic lineouts */
2000 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
2002 struct sigmatel_spec *spec = codec->spec;
2003 unsigned int wcaps, wtype;
2004 int i, num_dacs = 0;
2006 /* use the wcaps cache to count all DACs available for line-outs */
2007 for (i = 0; i < codec->num_nodes; i++) {
2008 wcaps = codec->wcaps[i];
2009 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2011 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
2015 snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
2017 switch (cfg->line_outs) {
2019 /* add line-in as side */
2020 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
2021 cfg->line_out_pins[cfg->line_outs] =
2022 cfg->input_pins[AUTO_PIN_LINE];
2023 spec->line_switch = 1;
2028 /* add line-in as clfe and mic as side */
2029 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
2030 cfg->line_out_pins[cfg->line_outs] =
2031 cfg->input_pins[AUTO_PIN_LINE];
2032 spec->line_switch = 1;
2035 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
2036 cfg->line_out_pins[cfg->line_outs] =
2037 cfg->input_pins[AUTO_PIN_MIC];
2038 spec->mic_switch = 1;
2043 /* add line-in as surr and mic as clfe */
2044 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
2045 cfg->line_out_pins[cfg->line_outs] =
2046 cfg->input_pins[AUTO_PIN_LINE];
2047 spec->line_switch = 1;
2050 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
2051 cfg->line_out_pins[cfg->line_outs] =
2052 cfg->input_pins[AUTO_PIN_MIC];
2053 spec->mic_switch = 1;
2063 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2067 for (i = 0; i < spec->multiout.num_dacs; i++) {
2068 if (spec->multiout.dac_nids[i] == nid)
2076 * Fill in the dac_nids table from the parsed pin configuration
2077 * This function only works when every pin in line_out_pins[]
2078 * contains atleast one DAC in its connection list. Some 92xx
2079 * codecs are not connected directly to a DAC, such as the 9200
2080 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2082 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
2083 struct auto_pin_cfg *cfg)
2085 struct sigmatel_spec *spec = codec->spec;
2086 int i, j, conn_len = 0;
2087 hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
2088 unsigned int wcaps, wtype;
2090 for (i = 0; i < cfg->line_outs; i++) {
2091 nid = cfg->line_out_pins[i];
2092 conn_len = snd_hda_get_connections(codec, nid, conn,
2093 HDA_MAX_CONNECTIONS);
2094 for (j = 0; j < conn_len; j++) {
2095 wcaps = snd_hda_param_read(codec, conn[j],
2096 AC_PAR_AUDIO_WIDGET_CAP);
2097 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2098 if (wtype != AC_WID_AUD_OUT ||
2099 (wcaps & AC_WCAP_DIGITAL))
2101 /* conn[j] is a DAC routed to this line-out */
2102 if (!is_in_dac_nids(spec, conn[j]))
2106 if (j == conn_len) {
2107 if (spec->multiout.num_dacs > 0) {
2108 /* we have already working output pins,
2109 * so let's drop the broken ones again
2111 cfg->line_outs = spec->multiout.num_dacs;
2114 /* error out, no available DAC found */
2116 "%s: No available DAC for pin 0x%x\n",
2121 spec->multiout.dac_nids[i] = conn[j];
2122 spec->multiout.num_dacs++;
2124 /* select this DAC in the pin's input mux */
2125 snd_hda_codec_write_cache(codec, nid, 0,
2126 AC_VERB_SET_CONNECT_SEL, j);
2131 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2132 spec->multiout.num_dacs,
2133 spec->multiout.dac_nids[0],
2134 spec->multiout.dac_nids[1],
2135 spec->multiout.dac_nids[2],
2136 spec->multiout.dac_nids[3],
2137 spec->multiout.dac_nids[4]);
2141 /* create volume control/switch for the given prefx type */
2142 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
2147 sprintf(name, "%s Playback Volume", pfx);
2148 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
2149 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2152 sprintf(name, "%s Playback Switch", pfx);
2153 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
2154 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2160 /* add playback controls from the parsed DAC table */
2161 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
2162 const struct auto_pin_cfg *cfg)
2164 static const char *chname[4] = {
2165 "Front", "Surround", NULL /*CLFE*/, "Side"
2170 struct sigmatel_spec *spec = codec->spec;
2171 unsigned int wid_caps;
2174 for (i = 0; i < cfg->line_outs; i++) {
2175 if (!spec->multiout.dac_nids[i])
2178 nid = spec->multiout.dac_nids[i];
2182 err = create_controls(spec, "Center", nid, 1);
2185 err = create_controls(spec, "LFE", nid, 2);
2189 wid_caps = get_wcaps(codec, nid);
2191 if (wid_caps & AC_WCAP_LR_SWAP) {
2192 err = stac92xx_add_control(spec,
2193 STAC_CTL_WIDGET_CLFE_SWITCH,
2194 "Swap Center/LFE Playback Switch", nid);
2201 err = create_controls(spec, chname[i], nid, 3);
2207 if (spec->line_switch)
2208 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Line In as Output Switch", cfg->input_pins[AUTO_PIN_LINE] << 8)) < 0)
2211 if (spec->mic_switch)
2212 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Mic as Output Switch", (cfg->input_pins[AUTO_PIN_MIC] << 8) | 1)) < 0)
2218 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2220 if (is_in_dac_nids(spec, nid))
2222 if (spec->multiout.hp_nid == nid)
2227 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
2229 if (!spec->multiout.hp_nid)
2230 spec->multiout.hp_nid = nid;
2231 else if (spec->multiout.num_dacs > 4) {
2232 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
2235 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
2236 spec->multiout.num_dacs++;
2241 /* add playback controls for Speaker and HP outputs */
2242 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
2243 struct auto_pin_cfg *cfg)
2245 struct sigmatel_spec *spec = codec->spec;
2247 int i, old_num_dacs, err;
2249 old_num_dacs = spec->multiout.num_dacs;
2250 for (i = 0; i < cfg->hp_outs; i++) {
2251 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
2252 if (wid_caps & AC_WCAP_UNSOL_CAP)
2253 spec->hp_detect = 1;
2254 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
2255 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2256 if (check_in_dac_nids(spec, nid))
2260 add_spec_dacs(spec, nid);
2262 for (i = 0; i < cfg->speaker_outs; i++) {
2263 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
2264 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2265 if (check_in_dac_nids(spec, nid))
2269 add_spec_dacs(spec, nid);
2271 for (i = 0; i < cfg->line_outs; i++) {
2272 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
2273 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2274 if (check_in_dac_nids(spec, nid))
2278 add_spec_dacs(spec, nid);
2280 for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
2281 static const char *pfxs[] = {
2282 "Speaker", "External Speaker", "Speaker2",
2284 err = create_controls(spec, pfxs[i - old_num_dacs],
2285 spec->multiout.dac_nids[i], 3);
2289 if (spec->multiout.hp_nid) {
2291 if (old_num_dacs == spec->multiout.num_dacs)
2295 err = create_controls(spec, pfx, spec->multiout.hp_nid, 3);
2303 /* labels for dmic mux inputs */
2304 static const char *stac92xx_dmic_labels[5] = {
2305 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
2306 "Digital Mic 3", "Digital Mic 4"
2309 /* create playback/capture controls for input pins on dmic capable codecs */
2310 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
2311 const struct auto_pin_cfg *cfg)
2313 struct sigmatel_spec *spec = codec->spec;
2314 struct hda_input_mux *dimux = &spec->private_dimux;
2315 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2318 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
2319 dimux->items[dimux->num_items].index = 0;
2322 for (i = 0; i < spec->num_dmics; i++) {
2325 unsigned int def_conf;
2327 def_conf = snd_hda_codec_read(codec,
2330 AC_VERB_GET_CONFIG_DEFAULT,
2332 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
2335 num_cons = snd_hda_get_connections(codec,
2338 HDA_MAX_NUM_INPUTS);
2339 for (j = 0; j < num_cons; j++)
2340 if (con_lst[j] == spec->dmic_nids[i]) {
2346 dimux->items[dimux->num_items].label =
2347 stac92xx_dmic_labels[dimux->num_items];
2348 dimux->items[dimux->num_items].index = index;
2355 /* create playback/capture controls for input pins */
2356 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
2358 struct sigmatel_spec *spec = codec->spec;
2359 struct hda_input_mux *imux = &spec->private_imux;
2360 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2363 for (i = 0; i < AUTO_PIN_LAST; i++) {
2366 if (!cfg->input_pins[i])
2369 for (j = 0; j < spec->num_muxes; j++) {
2371 num_cons = snd_hda_get_connections(codec,
2374 HDA_MAX_NUM_INPUTS);
2375 for (k = 0; k < num_cons; k++)
2376 if (con_lst[k] == cfg->input_pins[i]) {
2383 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2384 imux->items[imux->num_items].index = index;
2388 if (imux->num_items) {
2390 * Set the current input for the muxes.
2391 * The STAC9221 has two input muxes with identical source
2392 * NID lists. Hopefully this won't get confused.
2394 for (i = 0; i < spec->num_muxes; i++) {
2395 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
2396 AC_VERB_SET_CONNECT_SEL,
2397 imux->items[0].index);
2404 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
2406 struct sigmatel_spec *spec = codec->spec;
2409 for (i = 0; i < spec->autocfg.line_outs; i++) {
2410 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2411 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2415 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
2417 struct sigmatel_spec *spec = codec->spec;
2420 for (i = 0; i < spec->autocfg.hp_outs; i++) {
2422 pin = spec->autocfg.hp_pins[i];
2423 if (pin) /* connect to front */
2424 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
2426 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
2428 pin = spec->autocfg.speaker_pins[i];
2429 if (pin) /* connect to front */
2430 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
2434 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
2436 struct sigmatel_spec *spec = codec->spec;
2438 int hp_speaker_swap = 0;
2440 if ((err = snd_hda_parse_pin_def_config(codec,
2442 spec->dmic_nids)) < 0)
2444 if (! spec->autocfg.line_outs)
2445 return 0; /* can't find valid pin config */
2447 /* If we have no real line-out pin and multiple hp-outs, HPs should
2448 * be set up as multi-channel outputs.
2450 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
2451 spec->autocfg.hp_outs > 1) {
2452 /* Copy hp_outs to line_outs, backup line_outs in
2453 * speaker_outs so that the following routines can handle
2454 * HP pins as primary outputs.
2456 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
2457 sizeof(spec->autocfg.line_out_pins));
2458 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
2459 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
2460 sizeof(spec->autocfg.hp_pins));
2461 spec->autocfg.line_outs = spec->autocfg.hp_outs;
2462 hp_speaker_swap = 1;
2465 if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
2467 if (spec->multiout.num_dacs == 0)
2468 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2471 err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
2476 if (hp_speaker_swap == 1) {
2477 /* Restore the hp_outs and line_outs */
2478 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
2479 sizeof(spec->autocfg.line_out_pins));
2480 spec->autocfg.hp_outs = spec->autocfg.line_outs;
2481 memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins,
2482 sizeof(spec->autocfg.speaker_pins));
2483 spec->autocfg.line_outs = spec->autocfg.speaker_outs;
2484 memset(spec->autocfg.speaker_pins, 0,
2485 sizeof(spec->autocfg.speaker_pins));
2486 spec->autocfg.speaker_outs = 0;
2489 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
2494 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
2499 if (spec->num_dmics > 0)
2500 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
2501 &spec->autocfg)) < 0)
2504 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2505 if (spec->multiout.max_channels > 2)
2506 spec->surr_switch = 1;
2508 if (spec->autocfg.dig_out_pin)
2509 spec->multiout.dig_out_nid = dig_out;
2510 if (spec->autocfg.dig_in_pin)
2511 spec->dig_in_nid = dig_in;
2513 if (spec->kctl_alloc)
2514 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2516 spec->input_mux = &spec->private_imux;
2517 if (!spec->dinput_mux)
2518 spec->dinput_mux = &spec->private_dimux;
2523 /* add playback controls for HP output */
2524 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
2525 struct auto_pin_cfg *cfg)
2527 struct sigmatel_spec *spec = codec->spec;
2528 hda_nid_t pin = cfg->hp_pins[0];
2529 unsigned int wid_caps;
2534 wid_caps = get_wcaps(codec, pin);
2535 if (wid_caps & AC_WCAP_UNSOL_CAP)
2536 spec->hp_detect = 1;
2541 /* add playback controls for LFE output */
2542 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
2543 struct auto_pin_cfg *cfg)
2545 struct sigmatel_spec *spec = codec->spec;
2547 hda_nid_t lfe_pin = 0x0;
2551 * search speaker outs and line outs for a mono speaker pin
2552 * with an amp. If one is found, add LFE controls
2555 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
2556 hda_nid_t pin = spec->autocfg.speaker_pins[i];
2557 unsigned long wcaps = get_wcaps(codec, pin);
2558 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2559 if (wcaps == AC_WCAP_OUT_AMP)
2560 /* found a mono speaker with an amp, must be lfe */
2564 /* if speaker_outs is 0, then speakers may be in line_outs */
2565 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
2566 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
2567 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2569 cfg = snd_hda_codec_read(codec, pin, 0,
2570 AC_VERB_GET_CONFIG_DEFAULT,
2572 if (get_defcfg_device(cfg) == AC_JACK_SPEAKER) {
2573 unsigned long wcaps = get_wcaps(codec, pin);
2574 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2575 if (wcaps == AC_WCAP_OUT_AMP)
2576 /* found a mono speaker with an amp,
2584 err = create_controls(spec, "LFE", lfe_pin, 1);
2592 static int stac9200_parse_auto_config(struct hda_codec *codec)
2594 struct sigmatel_spec *spec = codec->spec;
2597 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2600 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
2603 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
2606 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
2609 if (spec->autocfg.dig_out_pin)
2610 spec->multiout.dig_out_nid = 0x05;
2611 if (spec->autocfg.dig_in_pin)
2612 spec->dig_in_nid = 0x04;
2614 if (spec->kctl_alloc)
2615 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2617 spec->input_mux = &spec->private_imux;
2618 spec->dinput_mux = &spec->private_dimux;
2624 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
2625 * funky external mute control using GPIO pins.
2628 static void stac922x_gpio_mute(struct hda_codec *codec, int pin, int muted)
2630 unsigned int gpiostate, gpiomask, gpiodir;
2632 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
2633 AC_VERB_GET_GPIO_DATA, 0);
2636 gpiostate |= (1 << pin);
2638 gpiostate &= ~(1 << pin);
2640 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
2641 AC_VERB_GET_GPIO_MASK, 0);
2642 gpiomask |= (1 << pin);
2644 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
2645 AC_VERB_GET_GPIO_DIRECTION, 0);
2646 gpiodir |= (1 << pin);
2648 /* AppleHDA seems to do this -- WTF is this verb?? */
2649 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
2651 snd_hda_codec_write(codec, codec->afg, 0,
2652 AC_VERB_SET_GPIO_MASK, gpiomask);
2653 snd_hda_codec_write(codec, codec->afg, 0,
2654 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
2658 snd_hda_codec_write(codec, codec->afg, 0,
2659 AC_VERB_SET_GPIO_DATA, gpiostate);
2662 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
2665 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
2666 snd_hda_codec_write_cache(codec, nid, 0,
2667 AC_VERB_SET_UNSOLICITED_ENABLE,
2668 (AC_USRSP_EN | event));
2671 static int stac92xx_init(struct hda_codec *codec)
2673 struct sigmatel_spec *spec = codec->spec;
2674 struct auto_pin_cfg *cfg = &spec->autocfg;
2677 snd_hda_sequence_write(codec, spec->init);
2680 if (spec->hp_detect) {
2681 /* Enable unsolicited responses on the HP widget */
2682 for (i = 0; i < cfg->hp_outs; i++)
2683 enable_pin_detect(codec, cfg->hp_pins[i],
2685 /* force to enable the first line-out; the others are set up
2688 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
2690 stac92xx_auto_init_hp_out(codec);
2691 /* fake event to set up pins */
2692 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2694 stac92xx_auto_init_multi_out(codec);
2695 stac92xx_auto_init_hp_out(codec);
2697 for (i = 0; i < AUTO_PIN_LAST; i++) {
2698 hda_nid_t nid = cfg->input_pins[i];
2700 unsigned int pinctl = AC_PINCTL_IN_EN;
2701 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
2702 pinctl |= stac92xx_get_vref(codec, nid);
2703 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2706 if (spec->num_dmics > 0)
2707 for (i = 0; i < spec->num_dmics; i++)
2708 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
2711 if (cfg->dig_out_pin)
2712 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
2714 if (cfg->dig_in_pin)
2715 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
2718 if (spec->gpio_mute) {
2719 stac922x_gpio_mute(codec, 0, 0);
2720 stac922x_gpio_mute(codec, 1, 0);
2726 static void stac92xx_free(struct hda_codec *codec)
2728 struct sigmatel_spec *spec = codec->spec;
2734 if (spec->kctl_alloc) {
2735 for (i = 0; i < spec->num_kctl_used; i++)
2736 kfree(spec->kctl_alloc[i].name);
2737 kfree(spec->kctl_alloc);
2740 if (spec->bios_pin_configs)
2741 kfree(spec->bios_pin_configs);
2746 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
2749 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2750 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2752 if (pin_ctl & AC_PINCTL_IN_EN) {
2754 * we need to check the current set-up direction of
2755 * shared input pins since they can be switched via
2756 * "xxx as Output" mixer switch
2758 struct sigmatel_spec *spec = codec->spec;
2759 struct auto_pin_cfg *cfg = &spec->autocfg;
2760 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
2761 spec->line_switch) ||
2762 (nid == cfg->input_pins[AUTO_PIN_MIC] &&
2767 /* if setting pin direction bits, clear the current
2768 direction bits first */
2769 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
2770 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
2772 snd_hda_codec_write_cache(codec, nid, 0,
2773 AC_VERB_SET_PIN_WIDGET_CONTROL,
2777 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
2780 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2781 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2782 snd_hda_codec_write_cache(codec, nid, 0,
2783 AC_VERB_SET_PIN_WIDGET_CONTROL,
2787 static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid)
2791 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
2793 unsigned int pinctl;
2794 pinctl = snd_hda_codec_read(codec, nid, 0,
2795 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2796 if (pinctl & AC_PINCTL_IN_EN)
2797 return 0; /* mic- or line-input */
2799 return 1; /* HP-output */
2804 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
2806 struct sigmatel_spec *spec = codec->spec;
2807 struct auto_pin_cfg *cfg = &spec->autocfg;
2811 for (i = 0; i < cfg->hp_outs; i++) {
2812 presence = get_hp_pin_presence(codec, cfg->hp_pins[i]);
2818 /* disable lineouts, enable hp */
2819 for (i = 0; i < cfg->line_outs; i++)
2820 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
2822 for (i = 0; i < cfg->speaker_outs; i++)
2823 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
2826 /* enable lineouts, disable hp */
2827 for (i = 0; i < cfg->line_outs; i++)
2828 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
2830 for (i = 0; i < cfg->speaker_outs; i++)
2831 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
2836 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
2838 switch (res >> 26) {
2840 stac92xx_hp_detect(codec, res);
2845 #ifdef SND_HDA_NEEDS_RESUME
2846 static int stac92xx_resume(struct hda_codec *codec)
2848 struct sigmatel_spec *spec = codec->spec;
2850 stac92xx_set_config_regs(codec);
2851 snd_hda_sequence_write(codec, spec->init);
2852 if (spec->gpio_mute) {
2853 stac922x_gpio_mute(codec, 0, 0);
2854 stac922x_gpio_mute(codec, 1, 0);
2856 snd_hda_codec_resume_amp(codec);
2857 snd_hda_codec_resume_cache(codec);
2858 /* invoke unsolicited event to reset the HP state */
2859 if (spec->hp_detect)
2860 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2865 static struct hda_codec_ops stac92xx_patch_ops = {
2866 .build_controls = stac92xx_build_controls,
2867 .build_pcms = stac92xx_build_pcms,
2868 .init = stac92xx_init,
2869 .free = stac92xx_free,
2870 .unsol_event = stac92xx_unsol_event,
2871 #ifdef SND_HDA_NEEDS_RESUME
2872 .resume = stac92xx_resume,
2876 static int patch_stac9200(struct hda_codec *codec)
2878 struct sigmatel_spec *spec;
2881 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2886 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
2887 spec->pin_nids = stac9200_pin_nids;
2888 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
2891 if (spec->board_config < 0) {
2892 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
2893 err = stac92xx_save_bios_config_regs(codec);
2895 stac92xx_free(codec);
2898 spec->pin_configs = spec->bios_pin_configs;
2900 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
2901 stac92xx_set_config_regs(codec);
2904 spec->multiout.max_channels = 2;
2905 spec->multiout.num_dacs = 1;
2906 spec->multiout.dac_nids = stac9200_dac_nids;
2907 spec->adc_nids = stac9200_adc_nids;
2908 spec->mux_nids = stac9200_mux_nids;
2909 spec->num_muxes = 1;
2910 spec->num_dmics = 0;
2913 if (spec->board_config == STAC_9200_GATEWAY)
2914 spec->init = stac9200_eapd_init;
2916 spec->init = stac9200_core_init;
2917 spec->mixer = stac9200_mixer;
2919 err = stac9200_parse_auto_config(codec);
2921 stac92xx_free(codec);
2925 codec->patch_ops = stac92xx_patch_ops;
2930 static int patch_stac925x(struct hda_codec *codec)
2932 struct sigmatel_spec *spec;
2935 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2940 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
2941 spec->pin_nids = stac925x_pin_nids;
2942 spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
2946 if (spec->board_config < 0) {
2947 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
2948 "using BIOS defaults\n");
2949 err = stac92xx_save_bios_config_regs(codec);
2951 stac92xx_free(codec);
2954 spec->pin_configs = spec->bios_pin_configs;
2955 } else if (stac925x_brd_tbl[spec->board_config] != NULL){
2956 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
2957 stac92xx_set_config_regs(codec);
2960 spec->multiout.max_channels = 2;
2961 spec->multiout.num_dacs = 1;
2962 spec->multiout.dac_nids = stac925x_dac_nids;
2963 spec->adc_nids = stac925x_adc_nids;
2964 spec->mux_nids = stac925x_mux_nids;
2965 spec->num_muxes = 1;
2967 switch (codec->vendor_id) {
2968 case 0x83847632: /* STAC9202 */
2969 case 0x83847633: /* STAC9202D */
2970 case 0x83847636: /* STAC9251 */
2971 case 0x83847637: /* STAC9251D */
2972 spec->num_dmics = STAC925X_NUM_DMICS;
2973 spec->dmic_nids = stac925x_dmic_nids;
2974 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
2975 spec->dmux_nids = stac925x_dmux_nids;
2978 spec->num_dmics = 0;
2982 spec->init = stac925x_core_init;
2983 spec->mixer = stac925x_mixer;
2985 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
2987 if (spec->board_config < 0) {
2988 printk(KERN_WARNING "hda_codec: No auto-config is "
2989 "available, default to model=ref\n");
2990 spec->board_config = STAC_925x_REF;
2996 stac92xx_free(codec);
3000 codec->patch_ops = stac92xx_patch_ops;
3005 static struct hda_input_mux stac92hd73xx_dmux = {
3008 { "Analog Inputs", 0x0b },
3010 { "Digital Mic 1", 0x09 },
3011 { "Digital Mic 2", 0x0a },
3015 static int patch_stac92hd73xx(struct hda_codec *codec)
3017 struct sigmatel_spec *spec;
3018 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
3021 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3026 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
3027 spec->pin_nids = stac92hd73xx_pin_nids;
3028 spec->board_config = snd_hda_check_board_config(codec,
3029 STAC_92HD73XX_MODELS,
3030 stac92hd73xx_models,
3031 stac92hd73xx_cfg_tbl);
3033 if (spec->board_config < 0) {
3034 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3035 " STAC92HD73XX, using BIOS defaults\n");
3036 err = stac92xx_save_bios_config_regs(codec);
3038 stac92xx_free(codec);
3041 spec->pin_configs = spec->bios_pin_configs;
3043 spec->pin_configs = stac92hd73xx_brd_tbl[spec->board_config];
3044 stac92xx_set_config_regs(codec);
3047 spec->multiout.num_dacs = snd_hda_get_connections(codec, 0x0a,
3048 conn, STAC92HD73_DAC_COUNT + 2) - 1;
3050 if (spec->multiout.num_dacs < 0) {
3051 printk(KERN_WARNING "hda_codec: Could not determine "
3052 "number of channels defaulting to DAC count\n");
3053 spec->multiout.num_dacs = STAC92HD73_DAC_COUNT;
3056 switch (spec->multiout.num_dacs) {
3057 case 0x3: /* 6 Channel */
3058 spec->mixer = stac92hd73xx_6ch_mixer;
3059 spec->init = stac92hd73xx_6ch_core_init;
3061 case 0x4: /* 8 Channel */
3062 spec->multiout.hp_nid = 0x18;
3063 spec->mixer = stac92hd73xx_8ch_mixer;
3064 spec->init = stac92hd73xx_8ch_core_init;
3066 case 0x5: /* 10 Channel */
3067 spec->multiout.hp_nid = 0x19;
3068 spec->mixer = stac92hd73xx_10ch_mixer;
3069 spec->init = stac92hd73xx_10ch_core_init;
3072 spec->multiout.dac_nids = stac92hd73xx_dac_nids;
3073 spec->aloopback_mask = 0x01;
3074 spec->aloopback_shift = 8;
3076 spec->mux_nids = stac92hd73xx_mux_nids;
3077 spec->adc_nids = stac92hd73xx_adc_nids;
3078 spec->dmic_nids = stac92hd73xx_dmic_nids;
3079 spec->dmux_nids = stac92hd73xx_dmux_nids;
3081 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
3082 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
3083 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
3084 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
3085 spec->dinput_mux = &stac92hd73xx_dmux;
3086 /* GPIO0 High = Enable EAPD */
3087 spec->gpio_mask = spec->gpio_data = 0x000001;
3088 stac92xx_enable_gpio_mask(codec);
3090 err = stac92xx_parse_auto_config(codec, 0x22, 0x24);
3093 if (spec->board_config < 0) {
3094 printk(KERN_WARNING "hda_codec: No auto-config is "
3095 "available, default to model=ref\n");
3096 spec->board_config = STAC_92HD73XX_REF;
3103 stac92xx_free(codec);
3107 codec->patch_ops = stac92xx_patch_ops;
3112 static int patch_stac92hd71bxx(struct hda_codec *codec)
3114 struct sigmatel_spec *spec;
3117 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3122 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
3123 spec->pin_nids = stac92hd71bxx_pin_nids;
3124 spec->board_config = snd_hda_check_board_config(codec,
3125 STAC_92HD71BXX_MODELS,
3126 stac92hd71bxx_models,
3127 stac92hd71bxx_cfg_tbl);
3129 if (spec->board_config < 0) {
3130 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3131 " STAC92HD71BXX, using BIOS defaults\n");
3132 err = stac92xx_save_bios_config_regs(codec);
3134 stac92xx_free(codec);
3137 spec->pin_configs = spec->bios_pin_configs;
3139 spec->pin_configs = stac92hd71bxx_brd_tbl[spec->board_config];
3140 stac92xx_set_config_regs(codec);
3143 switch (codec->vendor_id) {
3144 case 0x111d76b6: /* 4 Port without Analog Mixer */
3146 case 0x111d76b4: /* 6 Port without Analog Mixer */
3148 spec->mixer = stac92hd71bxx_mixer;
3149 spec->init = stac92hd71bxx_core_init;
3152 spec->mixer = stac92hd71bxx_analog_mixer;
3153 spec->init = stac92hd71bxx_analog_core_init;
3156 spec->aloopback_mask = 0x20;
3157 spec->aloopback_shift = 0;
3159 spec->gpio_mask = spec->gpio_data = 0x00000001; /* GPIO0 High = EAPD */
3160 stac92xx_enable_gpio_mask(codec);
3162 spec->mux_nids = stac92hd71bxx_mux_nids;
3163 spec->adc_nids = stac92hd71bxx_adc_nids;
3164 spec->dmic_nids = stac92hd71bxx_dmic_nids;
3165 spec->dmux_nids = stac92hd71bxx_dmux_nids;
3167 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
3168 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
3169 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
3170 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
3172 spec->multiout.num_dacs = 2;
3173 spec->multiout.hp_nid = 0x11;
3174 spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
3176 err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
3178 if (spec->board_config < 0) {
3179 printk(KERN_WARNING "hda_codec: No auto-config is "
3180 "available, default to model=ref\n");
3181 spec->board_config = STAC_92HD71BXX_REF;
3188 stac92xx_free(codec);
3192 codec->patch_ops = stac92xx_patch_ops;
3197 static int patch_stac922x(struct hda_codec *codec)
3199 struct sigmatel_spec *spec;
3202 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3207 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
3208 spec->pin_nids = stac922x_pin_nids;
3209 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
3212 if (spec->board_config == STAC_INTEL_MAC_V3) {
3213 spec->gpio_mute = 1;
3214 /* Intel Macs have all same PCI SSID, so we need to check
3215 * codec SSID to distinguish the exact models
3217 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
3218 switch (codec->subsystem_id) {
3221 spec->board_config = STAC_INTEL_MAC_V1;
3225 spec->board_config = STAC_INTEL_MAC_V2;
3233 spec->board_config = STAC_INTEL_MAC_V3;
3237 spec->board_config = STAC_INTEL_MAC_V4;
3241 spec->board_config = STAC_INTEL_MAC_V5;
3247 if (spec->board_config < 0) {
3248 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
3249 "using BIOS defaults\n");
3250 err = stac92xx_save_bios_config_regs(codec);
3252 stac92xx_free(codec);
3255 spec->pin_configs = spec->bios_pin_configs;
3256 } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
3257 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
3258 stac92xx_set_config_regs(codec);
3261 spec->adc_nids = stac922x_adc_nids;
3262 spec->mux_nids = stac922x_mux_nids;
3263 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
3264 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
3265 spec->num_dmics = 0;
3267 spec->init = stac922x_core_init;
3268 spec->mixer = stac922x_mixer;
3270 spec->multiout.dac_nids = spec->dac_nids;
3272 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
3274 if (spec->board_config < 0) {
3275 printk(KERN_WARNING "hda_codec: No auto-config is "
3276 "available, default to model=ref\n");
3277 spec->board_config = STAC_D945_REF;
3283 stac92xx_free(codec);
3287 codec->patch_ops = stac92xx_patch_ops;
3289 /* Fix Mux capture level; max to 2 */
3290 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
3291 (0 << AC_AMPCAP_OFFSET_SHIFT) |
3292 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3293 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3294 (0 << AC_AMPCAP_MUTE_SHIFT));
3299 static int patch_stac927x(struct hda_codec *codec)
3301 struct sigmatel_spec *spec;
3304 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3309 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
3310 spec->pin_nids = stac927x_pin_nids;
3311 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
3315 if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
3316 if (spec->board_config < 0)
3317 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3318 "STAC927x, using BIOS defaults\n");
3319 err = stac92xx_save_bios_config_regs(codec);
3321 stac92xx_free(codec);
3324 spec->pin_configs = spec->bios_pin_configs;
3326 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
3327 stac92xx_set_config_regs(codec);
3330 spec->adc_nids = stac927x_adc_nids;
3331 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
3332 spec->mux_nids = stac927x_mux_nids;
3333 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
3334 spec->multiout.dac_nids = spec->dac_nids;
3336 switch (spec->board_config) {
3339 /* GPIO0 High = Enable EAPD */
3340 spec->gpio_mask = spec->gpio_data = 0x00000001;
3341 spec->num_dmics = 0;
3343 spec->init = d965_core_init;
3344 spec->mixer = stac927x_mixer;
3346 case STAC_DELL_BIOS:
3348 /* GPIO2 High = Enable EAPD */
3349 spec->gpio_mask = spec->gpio_data = 0x00000004;
3350 spec->dmic_nids = stac927x_dmic_nids;
3351 spec->num_dmics = STAC927X_NUM_DMICS;
3353 spec->init = d965_core_init;
3354 spec->mixer = stac927x_mixer;
3355 spec->dmux_nids = stac927x_dmux_nids;
3356 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
3359 /* GPIO0 High = Enable EAPD */
3360 spec->gpio_mask = spec->gpio_data = 0x00000001;
3361 spec->num_dmics = 0;
3363 spec->init = stac927x_core_init;
3364 spec->mixer = stac927x_mixer;
3367 spec->aloopback_mask = 0x40;
3368 spec->aloopback_shift = 0;
3370 stac92xx_enable_gpio_mask(codec);
3371 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
3373 if (spec->board_config < 0) {
3374 printk(KERN_WARNING "hda_codec: No auto-config is "
3375 "available, default to model=ref\n");
3376 spec->board_config = STAC_D965_REF;
3382 stac92xx_free(codec);
3386 codec->patch_ops = stac92xx_patch_ops;
3391 static int patch_stac9205(struct hda_codec *codec)
3393 struct sigmatel_spec *spec;
3396 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3401 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
3402 spec->pin_nids = stac9205_pin_nids;
3403 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
3407 if (spec->board_config < 0) {
3408 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
3409 err = stac92xx_save_bios_config_regs(codec);
3411 stac92xx_free(codec);
3414 spec->pin_configs = spec->bios_pin_configs;
3416 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
3417 stac92xx_set_config_regs(codec);
3420 spec->adc_nids = stac9205_adc_nids;
3421 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
3422 spec->mux_nids = stac9205_mux_nids;
3423 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
3424 spec->dmic_nids = stac9205_dmic_nids;
3425 spec->num_dmics = STAC9205_NUM_DMICS;
3426 spec->dmux_nids = stac9205_dmux_nids;
3427 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
3429 spec->init = stac9205_core_init;
3430 spec->mixer = stac9205_mixer;
3432 spec->aloopback_mask = 0x40;
3433 spec->aloopback_shift = 0;
3434 spec->multiout.dac_nids = spec->dac_nids;
3436 switch (spec->board_config){
3437 case STAC_9205_DELL_M43:
3438 /* Enable SPDIF in/out */
3439 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
3440 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
3442 spec->gpio_mask = 0x00000007; /* GPIO0-2 */
3443 /* GPIO0 High = EAPD, GPIO1 Low = DRM,
3444 * GPIO2 High = Headphone Mute
3446 spec->gpio_data = 0x00000005;
3449 /* GPIO0 High = EAPD */
3450 spec->gpio_mask = spec->gpio_data = 0x00000001;
3454 stac92xx_enable_gpio_mask(codec);
3455 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
3457 if (spec->board_config < 0) {
3458 printk(KERN_WARNING "hda_codec: No auto-config is "
3459 "available, default to model=ref\n");
3460 spec->board_config = STAC_9205_REF;
3466 stac92xx_free(codec);
3470 codec->patch_ops = stac92xx_patch_ops;
3479 /* static config for Sony VAIO FE550G and Sony VAIO AR */
3480 static hda_nid_t vaio_dacs[] = { 0x2 };
3481 #define VAIO_HP_DAC 0x5
3482 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
3483 static hda_nid_t vaio_mux_nids[] = { 0x15 };
3485 static struct hda_input_mux vaio_mux = {
3488 /* { "HP", 0x0 }, */
3489 { "Mic Jack", 0x1 },
3490 { "Internal Mic", 0x2 },
3495 static struct hda_verb vaio_init[] = {
3496 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3497 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
3498 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3499 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3500 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3501 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3502 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3503 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3504 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3505 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3506 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3507 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3511 static struct hda_verb vaio_ar_init[] = {
3512 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3513 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3514 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3515 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3516 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
3517 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3518 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3519 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3520 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3521 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
3522 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3523 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3524 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3528 /* bind volumes of both NID 0x02 and 0x05 */
3529 static struct hda_bind_ctls vaio_bind_master_vol = {
3530 .ops = &snd_hda_bind_vol,
3532 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3533 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3538 /* bind volumes of both NID 0x02 and 0x05 */
3539 static struct hda_bind_ctls vaio_bind_master_sw = {
3540 .ops = &snd_hda_bind_sw,
3542 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3543 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3548 static struct snd_kcontrol_new vaio_mixer[] = {
3549 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3550 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3551 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3552 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3553 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3555 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3556 .name = "Capture Source",
3558 .info = stac92xx_mux_enum_info,
3559 .get = stac92xx_mux_enum_get,
3560 .put = stac92xx_mux_enum_put,
3565 static struct snd_kcontrol_new vaio_ar_mixer[] = {
3566 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3567 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3568 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3569 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3570 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3571 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
3572 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
3574 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3575 .name = "Capture Source",
3577 .info = stac92xx_mux_enum_info,
3578 .get = stac92xx_mux_enum_get,
3579 .put = stac92xx_mux_enum_put,
3584 static struct hda_codec_ops stac9872_patch_ops = {
3585 .build_controls = stac92xx_build_controls,
3586 .build_pcms = stac92xx_build_pcms,
3587 .init = stac92xx_init,
3588 .free = stac92xx_free,
3589 #ifdef SND_HDA_NEEDS_RESUME
3590 .resume = stac92xx_resume,
3594 static int stac9872_vaio_init(struct hda_codec *codec)
3598 err = stac92xx_init(codec);
3601 if (codec->patch_ops.unsol_event)
3602 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3606 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
3608 if (get_hp_pin_presence(codec, 0x0a)) {
3609 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3610 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3612 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3613 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3617 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
3619 switch (res >> 26) {
3621 stac9872_vaio_hp_detect(codec, res);
3626 static struct hda_codec_ops stac9872_vaio_patch_ops = {
3627 .build_controls = stac92xx_build_controls,
3628 .build_pcms = stac92xx_build_pcms,
3629 .init = stac9872_vaio_init,
3630 .free = stac92xx_free,
3631 .unsol_event = stac9872_vaio_unsol_event,
3633 .resume = stac92xx_resume,
3637 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
3639 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
3641 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
3643 /* AR Series. id=0x83847664 and subsys=104D1300 */
3648 static const char *stac9872_models[STAC_9872_MODELS] = {
3649 [CXD9872RD_VAIO] = "vaio",
3650 [CXD9872AKD_VAIO] = "vaio-ar",
3653 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
3654 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
3655 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
3656 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
3657 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
3661 static int patch_stac9872(struct hda_codec *codec)
3663 struct sigmatel_spec *spec;
3666 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
3669 if (board_config < 0)
3670 /* unknown config, let generic-parser do its job... */
3671 return snd_hda_parse_generic_codec(codec);
3673 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3678 switch (board_config) {
3679 case CXD9872RD_VAIO:
3680 case STAC9872AK_VAIO:
3681 case STAC9872K_VAIO:
3682 spec->mixer = vaio_mixer;
3683 spec->init = vaio_init;
3684 spec->multiout.max_channels = 2;
3685 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3686 spec->multiout.dac_nids = vaio_dacs;
3687 spec->multiout.hp_nid = VAIO_HP_DAC;
3688 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3689 spec->adc_nids = vaio_adcs;
3690 spec->input_mux = &vaio_mux;
3691 spec->mux_nids = vaio_mux_nids;
3692 codec->patch_ops = stac9872_vaio_patch_ops;
3695 case CXD9872AKD_VAIO:
3696 spec->mixer = vaio_ar_mixer;
3697 spec->init = vaio_ar_init;
3698 spec->multiout.max_channels = 2;
3699 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3700 spec->multiout.dac_nids = vaio_dacs;
3701 spec->multiout.hp_nid = VAIO_HP_DAC;
3702 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3703 spec->adc_nids = vaio_adcs;
3704 spec->input_mux = &vaio_mux;
3705 spec->mux_nids = vaio_mux_nids;
3706 codec->patch_ops = stac9872_patch_ops;
3717 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
3718 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
3719 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
3720 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
3721 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
3722 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
3723 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
3724 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
3725 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
3726 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
3727 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
3728 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
3729 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
3730 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
3731 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
3732 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
3733 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
3734 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
3735 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
3736 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
3737 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
3738 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
3739 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
3740 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
3741 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
3742 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
3743 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
3744 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
3745 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
3746 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
3747 /* The following does not take into account .id=0x83847661 when subsys =
3748 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
3749 * currently not fully supported.
3751 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
3752 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
3753 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
3754 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
3755 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
3756 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
3757 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
3758 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
3759 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
3760 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
3761 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
3762 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
3763 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
3764 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
3765 { .id = 0x111d7608, .name = "92HD71BXX", .patch = patch_stac92hd71bxx },
3766 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
3767 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
3768 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
3769 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
3770 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
3771 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
3772 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
3773 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },