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 hda_nid_t dig_in_nid;
146 unsigned int num_pins;
147 unsigned int *pin_configs;
148 unsigned int *bios_pin_configs;
150 /* codec specific stuff */
151 struct hda_verb *init;
152 struct snd_kcontrol_new *mixer;
155 struct hda_input_mux *dinput_mux;
156 unsigned int cur_dmux[2];
157 struct hda_input_mux *input_mux;
158 unsigned int cur_mux[3];
161 unsigned int io_switch[2];
162 unsigned int clfe_swap;
163 unsigned int aloopback;
165 struct hda_pcm pcm_rec[2]; /* PCM information */
167 /* dynamic controls and input_mux */
168 struct auto_pin_cfg autocfg;
169 unsigned int num_kctl_alloc, num_kctl_used;
170 struct snd_kcontrol_new *kctl_alloc;
171 struct hda_input_mux private_dimux;
172 struct hda_input_mux private_imux;
175 static hda_nid_t stac9200_adc_nids[1] = {
179 static hda_nid_t stac9200_mux_nids[1] = {
183 static hda_nid_t stac9200_dac_nids[1] = {
187 static hda_nid_t stac92hd73xx_adc_nids[2] = {
191 #define STAC92HD73XX_NUM_DMICS 2
192 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
196 #define STAC92HD73_DAC_COUNT 5
197 static hda_nid_t stac92hd73xx_dac_nids[STAC92HD73_DAC_COUNT] = {
198 0x15, 0x16, 0x17, 0x18, 0x19,
201 static hda_nid_t stac92hd73xx_mux_nids[4] = {
202 0x28, 0x29, 0x2a, 0x2b,
205 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
209 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
213 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
217 static hda_nid_t stac92hd71bxx_dmux_nids[1] = {
221 static hda_nid_t stac92hd71bxx_dac_nids[2] = {
225 #define STAC92HD71BXX_NUM_DMICS 2
226 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
230 static hda_nid_t stac925x_adc_nids[1] = {
234 static hda_nid_t stac925x_mux_nids[1] = {
238 static hda_nid_t stac925x_dac_nids[1] = {
242 #define STAC925X_NUM_DMICS 1
243 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
247 static hda_nid_t stac922x_adc_nids[2] = {
251 static hda_nid_t stac922x_mux_nids[2] = {
255 static hda_nid_t stac927x_adc_nids[3] = {
259 static hda_nid_t stac927x_mux_nids[3] = {
263 static hda_nid_t stac927x_dmux_nids[1] = {
267 #define STAC927X_NUM_DMICS 2
268 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
272 static hda_nid_t stac9205_adc_nids[2] = {
276 static hda_nid_t stac9205_mux_nids[2] = {
280 static hda_nid_t stac9205_dmux_nids[1] = {
284 #define STAC9205_NUM_DMICS 2
285 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
289 static hda_nid_t stac9200_pin_nids[8] = {
290 0x08, 0x09, 0x0d, 0x0e,
291 0x0f, 0x10, 0x11, 0x12,
294 static hda_nid_t stac925x_pin_nids[8] = {
295 0x07, 0x08, 0x0a, 0x0b,
296 0x0c, 0x0d, 0x10, 0x11,
299 static hda_nid_t stac922x_pin_nids[10] = {
300 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
301 0x0f, 0x10, 0x11, 0x15, 0x1b,
304 static hda_nid_t stac92hd73xx_pin_nids[12] = {
305 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
306 0x0f, 0x10, 0x11, 0x12, 0x13,
310 static hda_nid_t stac92hd71bxx_pin_nids[10] = {
311 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
312 0x0f, 0x14, 0x18, 0x19, 0x1e,
315 static hda_nid_t stac927x_pin_nids[14] = {
316 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
317 0x0f, 0x10, 0x11, 0x12, 0x13,
318 0x14, 0x21, 0x22, 0x23,
321 static hda_nid_t stac9205_pin_nids[12] = {
322 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
323 0x0f, 0x14, 0x16, 0x17, 0x18,
327 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
328 struct snd_ctl_elem_info *uinfo)
330 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
331 struct sigmatel_spec *spec = codec->spec;
332 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
335 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
336 struct snd_ctl_elem_value *ucontrol)
338 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
339 struct sigmatel_spec *spec = codec->spec;
340 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
342 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
346 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
347 struct snd_ctl_elem_value *ucontrol)
349 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
350 struct sigmatel_spec *spec = codec->spec;
351 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
353 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
354 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
357 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
359 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
360 struct sigmatel_spec *spec = codec->spec;
361 return snd_hda_input_mux_info(spec->input_mux, uinfo);
364 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
366 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
367 struct sigmatel_spec *spec = codec->spec;
368 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
370 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
374 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
376 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
377 struct sigmatel_spec *spec = codec->spec;
378 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
380 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
381 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
384 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
386 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
387 struct snd_ctl_elem_value *ucontrol)
389 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
390 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
391 struct sigmatel_spec *spec = codec->spec;
393 ucontrol->value.integer.value[0] = !!(spec->aloopback &
394 (spec->aloopback_mask << idx));
398 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
399 struct snd_ctl_elem_value *ucontrol)
401 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
402 struct sigmatel_spec *spec = codec->spec;
403 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
404 unsigned int dac_mode;
405 unsigned int val, idx_val;
407 idx_val = spec->aloopback_mask << idx;
408 if (ucontrol->value.integer.value[0])
409 val = spec->aloopback | idx_val;
411 val = spec->aloopback & ~idx_val;
412 if (spec->aloopback == val)
415 spec->aloopback = val;
417 /* Only return the bits defined by the shift value of the
418 * first two bytes of the mask
420 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
421 kcontrol->private_value & 0xFFFF, 0x0);
422 dac_mode >>= spec->aloopback_shift;
424 if (spec->aloopback & idx_val) {
425 snd_hda_power_up(codec);
428 snd_hda_power_down(codec);
429 dac_mode &= ~idx_val;
432 snd_hda_codec_write_cache(codec, codec->afg, 0,
433 kcontrol->private_value >> 16, dac_mode);
438 static struct hda_verb stac9200_core_init[] = {
439 /* set dac0mux for dac converter */
440 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
444 static struct hda_verb stac9200_eapd_init[] = {
445 /* set dac0mux for dac converter */
446 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
447 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
451 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
452 /* set master volume and direct control */
453 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
454 /* setup audio connections */
455 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
456 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
457 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
458 /* setup adcs to point to mixer */
459 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
460 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
461 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Front Mic */
462 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Mic */
463 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Line In */
464 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
465 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
466 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
467 /* setup import muxs */
468 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
469 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
470 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
471 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
475 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
476 /* set master volume and direct control */
477 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
478 /* setup audio connections */
479 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
480 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
481 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
482 /* connect hp ports to dac3 */
483 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x03},
484 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x03},
485 /* setup adcs to point to mixer */
486 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
487 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
488 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Front Mic */
489 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Mic */
490 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Line In */
491 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
492 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
493 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
494 /* setup import muxs */
495 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
496 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
497 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
498 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
502 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
503 /* set master volume and direct control */
504 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
505 /* setup audio connections */
506 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
507 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01 },
508 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02 },
509 /* dac3 is connected to import3 mux */
510 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
511 /* connect hp ports to dac4 */
512 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x04},
513 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x04},
514 /* setup adcs to point to mixer */
515 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
516 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
517 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Front Mic */
518 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Mic */
519 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Line In */
520 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
521 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
522 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
523 /* setup import muxs */
524 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
525 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
526 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
527 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
531 static struct hda_verb stac92hd71bxx_core_init[] = {
532 /* set master volume and direct control */
533 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
534 /* connect headphone jack to dac1 */
535 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
536 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */
537 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
538 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
539 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
540 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
541 /* unmute mono out node */
542 { 0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
545 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
546 /* set master volume and direct control */
547 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
548 /* connect headphone jack to dac1 */
549 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
550 /* connect ports 0d and 0f to audio mixer */
551 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x2},
552 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
553 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
554 /* unmute dac0 input in audio mixer */
555 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
556 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
557 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
558 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
559 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
560 /* unmute mono out node */
561 { 0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
565 static struct hda_verb stac925x_core_init[] = {
566 /* set dac0mux for dac converter */
567 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
571 static struct hda_verb stac922x_core_init[] = {
572 /* set master volume and direct control */
573 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
577 static struct hda_verb d965_core_init[] = {
578 /* set master volume and direct control */
579 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
580 /* unmute node 0x1b */
581 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
582 /* select node 0x03 as DAC */
583 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
587 static struct hda_verb stac927x_core_init[] = {
588 /* set master volume and direct control */
589 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
593 static struct hda_verb stac9205_core_init[] = {
594 /* set master volume and direct control */
595 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
599 #define STAC_DIGITAL_INPUT_SOURCE(cnt) \
601 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
602 .name = "Digital Input Source", \
604 .info = stac92xx_dmux_enum_info, \
605 .get = stac92xx_dmux_enum_get, \
606 .put = stac92xx_dmux_enum_put,\
609 #define STAC_INPUT_SOURCE(cnt) \
611 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
612 .name = "Input Source", \
614 .info = stac92xx_mux_enum_info, \
615 .get = stac92xx_mux_enum_get, \
616 .put = stac92xx_mux_enum_put, \
619 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
621 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
622 .name = "Analog Loopback", \
624 .info = stac92xx_aloopback_info, \
625 .get = stac92xx_aloopback_get, \
626 .put = stac92xx_aloopback_put, \
627 .private_value = verb_read | (verb_write << 16), \
630 static struct snd_kcontrol_new stac9200_mixer[] = {
631 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
632 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
633 STAC_INPUT_SOURCE(1),
634 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
635 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
636 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT),
640 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
641 STAC_DIGITAL_INPUT_SOURCE(2),
642 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
644 /* hardware gain controls */
645 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x13, 0x0, HDA_INPUT),
646 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x14, 0x0, HDA_INPUT),
648 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
649 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
651 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
652 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
654 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
655 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
657 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
658 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
660 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
661 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
663 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
664 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
666 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
667 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
671 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
672 STAC_DIGITAL_INPUT_SOURCE(2),
673 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
675 /* hardware gain controls */
676 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x13, 0x0, HDA_INPUT),
677 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x14, 0x0, HDA_INPUT),
679 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
680 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
682 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
683 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
685 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
686 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
688 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
689 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
691 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
692 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
694 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
695 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
697 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
698 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
702 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
703 STAC_DIGITAL_INPUT_SOURCE(2),
704 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
706 /* hardware gain controls */
707 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x13, 0x0, HDA_INPUT),
708 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x14, 0x0, HDA_INPUT),
710 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
711 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
713 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
714 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
716 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
717 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
719 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
720 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
722 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
723 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
725 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
726 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
728 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
729 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
733 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
734 STAC_DIGITAL_INPUT_SOURCE(1),
735 STAC_INPUT_SOURCE(2),
737 /* hardware gain controls */
738 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x18, 0x0, HDA_OUTPUT),
739 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x19, 0x0, HDA_OUTPUT),
741 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
742 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
743 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
745 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
746 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
747 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
749 HDA_CODEC_MUTE("Analog Loopback 1", 0x17, 0x3, HDA_INPUT),
750 HDA_CODEC_MUTE("Analog Loopback 2", 0x17, 0x4, HDA_INPUT),
754 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
755 STAC_DIGITAL_INPUT_SOURCE(1),
756 STAC_INPUT_SOURCE(2),
757 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
759 /* hardware gain controls */
760 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x18, 0x0, HDA_OUTPUT),
761 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x19, 0x0, HDA_OUTPUT),
763 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
764 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
765 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
767 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
768 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
769 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
773 static struct snd_kcontrol_new stac925x_mixer[] = {
774 STAC_INPUT_SOURCE(1),
775 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
776 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_OUTPUT),
777 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT),
781 static struct snd_kcontrol_new stac9205_mixer[] = {
782 STAC_DIGITAL_INPUT_SOURCE(1),
783 STAC_INPUT_SOURCE(2),
784 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
786 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
787 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
788 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT),
790 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
791 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
792 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT),
797 /* This needs to be generated dynamically based on sequence */
798 static struct snd_kcontrol_new stac922x_mixer[] = {
799 STAC_INPUT_SOURCE(2),
800 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
801 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
802 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT),
804 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
805 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
806 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT),
811 static struct snd_kcontrol_new stac927x_mixer[] = {
812 STAC_DIGITAL_INPUT_SOURCE(1),
813 STAC_INPUT_SOURCE(3),
814 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
816 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
817 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
818 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT),
820 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
821 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
822 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT),
824 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
825 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
826 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT),
830 static int stac92xx_build_controls(struct hda_codec *codec)
832 struct sigmatel_spec *spec = codec->spec;
836 err = snd_hda_add_new_ctls(codec, spec->mixer);
840 for (i = 0; i < spec->num_mixers; i++) {
841 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
846 if (spec->multiout.dig_out_nid) {
847 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
851 if (spec->dig_in_nid) {
852 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
859 static unsigned int ref9200_pin_configs[8] = {
860 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
861 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
865 STAC 9200 pin configs for
870 static unsigned int dell9200_d21_pin_configs[8] = {
871 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
872 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
876 STAC 9200 pin configs for
880 static unsigned int dell9200_d22_pin_configs[8] = {
881 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
882 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
886 STAC 9200 pin configs for
887 102801C4 (Dell Dimension E310)
894 static unsigned int dell9200_d23_pin_configs[8] = {
895 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
896 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
901 STAC 9200-32 pin configs for
902 102801B5 (Dell Inspiron 630m)
903 102801D8 (Dell Inspiron 640m)
905 static unsigned int dell9200_m21_pin_configs[8] = {
906 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
907 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
911 STAC 9200-32 pin configs for
912 102801C2 (Dell Latitude D620)
914 102801CC (Dell Latitude D820)
918 static unsigned int dell9200_m22_pin_configs[8] = {
919 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
920 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
924 STAC 9200-32 pin configs for
925 102801CE (Dell XPS M1710)
926 102801CF (Dell Precision M90)
928 static unsigned int dell9200_m23_pin_configs[8] = {
929 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
930 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
934 STAC 9200-32 pin configs for
937 102801CB (Dell Latitude 120L)
940 static unsigned int dell9200_m24_pin_configs[8] = {
941 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
942 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
946 STAC 9200-32 pin configs for
947 102801BD (Dell Inspiron E1505n)
951 static unsigned int dell9200_m25_pin_configs[8] = {
952 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
953 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
957 STAC 9200-32 pin configs for
958 102801F5 (Dell Inspiron 1501)
961 static unsigned int dell9200_m26_pin_configs[8] = {
962 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
963 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
968 102801CD (Dell Inspiron E1705/9400)
970 static unsigned int dell9200_m27_pin_configs[8] = {
971 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
972 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
976 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
977 [STAC_REF] = ref9200_pin_configs,
978 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
979 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
980 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
981 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
982 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
983 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
984 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
985 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
986 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
987 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
990 static const char *stac9200_models[STAC_9200_MODELS] = {
992 [STAC_9200_DELL_D21] = "dell-d21",
993 [STAC_9200_DELL_D22] = "dell-d22",
994 [STAC_9200_DELL_D23] = "dell-d23",
995 [STAC_9200_DELL_M21] = "dell-m21",
996 [STAC_9200_DELL_M22] = "dell-m22",
997 [STAC_9200_DELL_M23] = "dell-m23",
998 [STAC_9200_DELL_M24] = "dell-m24",
999 [STAC_9200_DELL_M25] = "dell-m25",
1000 [STAC_9200_DELL_M26] = "dell-m26",
1001 [STAC_9200_DELL_M27] = "dell-m27",
1002 [STAC_9200_GATEWAY] = "gateway",
1005 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1006 /* SigmaTel reference board */
1007 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1008 "DFI LanParty", STAC_REF),
1009 /* Dell laptops have BIOS problem */
1010 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1011 "unknown Dell", STAC_9200_DELL_D21),
1012 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1013 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1014 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1015 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1016 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1017 "unknown Dell", STAC_9200_DELL_D22),
1018 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1019 "unknown Dell", STAC_9200_DELL_D22),
1020 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1021 "Dell Latitude D620", STAC_9200_DELL_M22),
1022 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1023 "unknown Dell", STAC_9200_DELL_D23),
1024 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1025 "unknown Dell", STAC_9200_DELL_D23),
1026 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1027 "unknown Dell", STAC_9200_DELL_M22),
1028 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1029 "unknown Dell", STAC_9200_DELL_M24),
1030 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1031 "unknown Dell", STAC_9200_DELL_M24),
1032 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1033 "Dell Latitude 120L", STAC_9200_DELL_M24),
1034 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1035 "Dell Latitude D820", STAC_9200_DELL_M22),
1036 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1037 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1038 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1039 "Dell XPS M1710", STAC_9200_DELL_M23),
1040 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1041 "Dell Precision M90", STAC_9200_DELL_M23),
1042 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1043 "unknown Dell", STAC_9200_DELL_M22),
1044 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1045 "unknown Dell", STAC_9200_DELL_M22),
1046 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1047 "unknown Dell", STAC_9200_DELL_M22),
1048 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1049 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1050 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1051 "unknown Dell", STAC_9200_DELL_D23),
1052 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1053 "unknown Dell", STAC_9200_DELL_D23),
1054 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1055 "unknown Dell", STAC_9200_DELL_D21),
1056 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1057 "unknown Dell", STAC_9200_DELL_D23),
1058 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1059 "unknown Dell", STAC_9200_DELL_D21),
1060 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1061 "unknown Dell", STAC_9200_DELL_M25),
1062 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1063 "unknown Dell", STAC_9200_DELL_M25),
1064 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1065 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1066 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1067 "unknown Dell", STAC_9200_DELL_M26),
1069 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_REF),
1070 /* Gateway machines needs EAPD to be set on resume */
1071 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
1072 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
1074 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
1079 static unsigned int ref925x_pin_configs[8] = {
1080 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1081 0x90a70320, 0x02214210, 0x400003f1, 0x9033032e,
1084 static unsigned int stac925x_MA6_pin_configs[8] = {
1085 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1086 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
1089 static unsigned int stac925x_PA6_pin_configs[8] = {
1090 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1091 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
1094 static unsigned int stac925xM2_2_pin_configs[8] = {
1095 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
1096 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
1099 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1100 [STAC_REF] = ref925x_pin_configs,
1101 [STAC_M2_2] = stac925xM2_2_pin_configs,
1102 [STAC_MA6] = stac925x_MA6_pin_configs,
1103 [STAC_PA6] = stac925x_PA6_pin_configs,
1106 static const char *stac925x_models[STAC_925x_MODELS] = {
1108 [STAC_M2_2] = "m2-2",
1113 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1114 /* SigmaTel reference board */
1115 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1116 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1117 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
1118 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
1119 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
1120 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
1121 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
1125 static unsigned int ref92hd73xx_pin_configs[12] = {
1126 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1127 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1128 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1131 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1132 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1135 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1136 [STAC_92HD73XX_REF] = "ref",
1139 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1140 /* SigmaTel reference board */
1141 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1142 "DFI LanParty", STAC_92HD73XX_REF),
1146 static unsigned int ref92hd71bxx_pin_configs[10] = {
1147 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1148 0x0181302e, 0x01114010, 0x01a19020, 0x90a000f0,
1149 0x90a000f0, 0x01452050,
1152 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1153 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1156 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1157 [STAC_92HD71BXX_REF] = "ref",
1160 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1161 /* SigmaTel reference board */
1162 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1163 "DFI LanParty", STAC_92HD71BXX_REF),
1167 static unsigned int ref922x_pin_configs[10] = {
1168 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1169 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1170 0x40000100, 0x40000100,
1174 STAC 922X pin configs for
1181 static unsigned int dell_922x_d81_pin_configs[10] = {
1182 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1183 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1184 0x01813122, 0x400001f2,
1188 STAC 922X pin configs for
1192 static unsigned int dell_922x_d82_pin_configs[10] = {
1193 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1194 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1195 0x01813122, 0x400001f1,
1199 STAC 922X pin configs for
1202 static unsigned int dell_922x_m81_pin_configs[10] = {
1203 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1204 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1205 0x40C003f1, 0x405003f0,
1209 STAC 9221 A1 pin configs for
1210 102801D7 (Dell XPS M1210)
1212 static unsigned int dell_922x_m82_pin_configs[10] = {
1213 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1214 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1215 0x508003f3, 0x405003f4,
1218 static unsigned int d945gtp3_pin_configs[10] = {
1219 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1220 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1221 0x02a19120, 0x40000100,
1224 static unsigned int d945gtp5_pin_configs[10] = {
1225 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1226 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1227 0x02a19320, 0x40000100,
1230 static unsigned int intel_mac_v1_pin_configs[10] = {
1231 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1232 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1233 0x400000fc, 0x400000fb,
1236 static unsigned int intel_mac_v2_pin_configs[10] = {
1237 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1238 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1239 0x400000fc, 0x400000fb,
1242 static unsigned int intel_mac_v3_pin_configs[10] = {
1243 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1244 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1245 0x400000fc, 0x400000fb,
1248 static unsigned int intel_mac_v4_pin_configs[10] = {
1249 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1250 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1251 0x400000fc, 0x400000fb,
1254 static unsigned int intel_mac_v5_pin_configs[10] = {
1255 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1256 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1257 0x400000fc, 0x400000fb,
1261 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1262 [STAC_D945_REF] = ref922x_pin_configs,
1263 [STAC_D945GTP3] = d945gtp3_pin_configs,
1264 [STAC_D945GTP5] = d945gtp5_pin_configs,
1265 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1266 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1267 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1268 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1269 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1270 /* for backward compatibility */
1271 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1272 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1273 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1274 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1275 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1276 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1277 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1278 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1279 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1280 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1283 static const char *stac922x_models[STAC_922X_MODELS] = {
1284 [STAC_D945_REF] = "ref",
1285 [STAC_D945GTP5] = "5stack",
1286 [STAC_D945GTP3] = "3stack",
1287 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1288 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1289 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1290 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1291 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1292 /* for backward compatibility */
1293 [STAC_MACMINI] = "macmini",
1294 [STAC_MACBOOK] = "macbook",
1295 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1296 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1297 [STAC_IMAC_INTEL] = "imac-intel",
1298 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1299 [STAC_922X_DELL_D81] = "dell-d81",
1300 [STAC_922X_DELL_D82] = "dell-d82",
1301 [STAC_922X_DELL_M81] = "dell-m81",
1302 [STAC_922X_DELL_M82] = "dell-m82",
1305 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1306 /* SigmaTel reference board */
1307 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1308 "DFI LanParty", STAC_D945_REF),
1309 /* Intel 945G based systems */
1310 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1311 "Intel D945G", STAC_D945GTP3),
1312 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1313 "Intel D945G", STAC_D945GTP3),
1314 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1315 "Intel D945G", STAC_D945GTP3),
1316 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1317 "Intel D945G", STAC_D945GTP3),
1318 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1319 "Intel D945G", STAC_D945GTP3),
1320 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1321 "Intel D945G", STAC_D945GTP3),
1322 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1323 "Intel D945G", STAC_D945GTP3),
1324 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1325 "Intel D945G", STAC_D945GTP3),
1326 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1327 "Intel D945G", STAC_D945GTP3),
1328 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1329 "Intel D945G", STAC_D945GTP3),
1330 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1331 "Intel D945G", STAC_D945GTP3),
1332 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1333 "Intel D945G", STAC_D945GTP3),
1334 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1335 "Intel D945G", STAC_D945GTP3),
1336 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1337 "Intel D945G", STAC_D945GTP3),
1338 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1339 "Intel D945G", STAC_D945GTP3),
1340 /* Intel D945G 5-stack systems */
1341 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1342 "Intel D945G", STAC_D945GTP5),
1343 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1344 "Intel D945G", STAC_D945GTP5),
1345 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1346 "Intel D945G", STAC_D945GTP5),
1347 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1348 "Intel D945G", STAC_D945GTP5),
1349 /* Intel 945P based systems */
1350 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1351 "Intel D945P", STAC_D945GTP3),
1352 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1353 "Intel D945P", STAC_D945GTP3),
1354 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1355 "Intel D945P", STAC_D945GTP3),
1356 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1357 "Intel D945P", STAC_D945GTP3),
1358 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1359 "Intel D945P", STAC_D945GTP3),
1360 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1361 "Intel D945P", STAC_D945GTP5),
1363 /* Apple Mac Mini (early 2006) */
1364 SND_PCI_QUIRK(0x8384, 0x7680,
1365 "Mac Mini", STAC_INTEL_MAC_V3),
1367 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1368 "unknown Dell", STAC_922X_DELL_D81),
1369 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1370 "unknown Dell", STAC_922X_DELL_D81),
1371 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1372 "unknown Dell", STAC_922X_DELL_D81),
1373 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1374 "unknown Dell", STAC_922X_DELL_D82),
1375 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1376 "unknown Dell", STAC_922X_DELL_M81),
1377 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1378 "unknown Dell", STAC_922X_DELL_D82),
1379 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1380 "unknown Dell", STAC_922X_DELL_D81),
1381 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1382 "unknown Dell", STAC_922X_DELL_D81),
1383 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1384 "Dell XPS M1210", STAC_922X_DELL_M82),
1388 static unsigned int ref927x_pin_configs[14] = {
1389 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1390 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1391 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1392 0x01c42190, 0x40000100,
1395 static unsigned int d965_3st_pin_configs[14] = {
1396 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
1397 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
1398 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1399 0x40000100, 0x40000100
1402 static unsigned int d965_5st_pin_configs[14] = {
1403 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1404 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
1405 0x40000100, 0x40000100, 0x40000100, 0x01442070,
1406 0x40000100, 0x40000100
1409 static unsigned int dell_3st_pin_configs[14] = {
1410 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
1411 0x01111212, 0x01116211, 0x01813050, 0x01112214,
1412 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
1413 0x40c003fc, 0x40000100
1416 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
1417 [STAC_D965_REF] = ref927x_pin_configs,
1418 [STAC_D965_3ST] = d965_3st_pin_configs,
1419 [STAC_D965_5ST] = d965_5st_pin_configs,
1420 [STAC_DELL_3ST] = dell_3st_pin_configs,
1421 [STAC_DELL_BIOS] = NULL,
1424 static const char *stac927x_models[STAC_927X_MODELS] = {
1425 [STAC_D965_REF] = "ref",
1426 [STAC_D965_3ST] = "3stack",
1427 [STAC_D965_5ST] = "5stack",
1428 [STAC_DELL_3ST] = "dell-3stack",
1429 [STAC_DELL_BIOS] = "dell-bios",
1432 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
1433 /* SigmaTel reference board */
1434 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1435 "DFI LanParty", STAC_D965_REF),
1436 /* Intel 946 based systems */
1437 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
1438 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
1439 /* 965 based 3 stack systems */
1440 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
1441 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
1442 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
1443 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
1444 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
1445 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
1446 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
1447 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
1448 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
1449 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
1450 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
1451 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
1452 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
1453 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
1454 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
1455 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
1456 /* Dell 3 stack systems */
1457 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_3ST),
1458 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
1459 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
1460 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
1461 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
1462 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_3ST),
1463 /* Dell 3 stack systems with verb table in BIOS */
1464 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell ", STAC_DELL_BIOS),
1465 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
1466 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
1467 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
1468 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
1469 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
1470 /* 965 based 5 stack systems */
1471 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
1472 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
1473 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
1474 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
1475 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
1476 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
1477 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
1478 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
1479 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
1483 static unsigned int ref9205_pin_configs[12] = {
1484 0x40000100, 0x40000100, 0x01016011, 0x01014010,
1485 0x01813122, 0x01a19021, 0x40000100, 0x40000100,
1486 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
1490 STAC 9205 pin configs for
1498 static unsigned int dell_9205_m42_pin_configs[12] = {
1499 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
1500 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
1501 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
1505 STAC 9205 pin configs for
1509 102801FF (Dell Precision M4300)
1514 static unsigned int dell_9205_m43_pin_configs[12] = {
1515 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
1516 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
1517 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
1520 static unsigned int dell_9205_m44_pin_configs[12] = {
1521 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
1522 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
1523 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
1526 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
1527 [STAC_9205_REF] = ref9205_pin_configs,
1528 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
1529 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
1530 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
1533 static const char *stac9205_models[STAC_9205_MODELS] = {
1534 [STAC_9205_REF] = "ref",
1535 [STAC_9205_DELL_M42] = "dell-m42",
1536 [STAC_9205_DELL_M43] = "dell-m43",
1537 [STAC_9205_DELL_M44] = "dell-m44",
1540 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
1541 /* SigmaTel reference board */
1542 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1543 "DFI LanParty", STAC_9205_REF),
1544 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1545 "unknown Dell", STAC_9205_DELL_M42),
1546 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1547 "unknown Dell", STAC_9205_DELL_M42),
1548 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
1549 "Dell Precision", STAC_9205_DELL_M43),
1550 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
1551 "Dell Precision", STAC_9205_DELL_M43),
1552 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
1553 "Dell Precision", STAC_9205_DELL_M43),
1554 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
1555 "Dell Precision", STAC_9205_DELL_M43),
1556 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
1557 "Dell Precision", STAC_9205_DELL_M43),
1558 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1559 "unknown Dell", STAC_9205_DELL_M42),
1560 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1561 "unknown Dell", STAC_9205_DELL_M42),
1562 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
1563 "Dell Precision", STAC_9205_DELL_M43),
1564 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
1565 "Dell Precision M4300", STAC_9205_DELL_M43),
1566 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
1567 "Dell Precision", STAC_9205_DELL_M43),
1568 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1569 "Dell Inspiron", STAC_9205_DELL_M44),
1570 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1571 "Dell Inspiron", STAC_9205_DELL_M44),
1572 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1573 "Dell Inspiron", STAC_9205_DELL_M44),
1574 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1575 "Dell Inspiron", STAC_9205_DELL_M44),
1576 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
1577 "unknown Dell", STAC_9205_DELL_M42),
1578 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
1579 "Dell Inspiron", STAC_9205_DELL_M44),
1583 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
1586 struct sigmatel_spec *spec = codec->spec;
1588 if (! spec->bios_pin_configs) {
1589 spec->bios_pin_configs = kcalloc(spec->num_pins,
1590 sizeof(*spec->bios_pin_configs), GFP_KERNEL);
1591 if (! spec->bios_pin_configs)
1595 for (i = 0; i < spec->num_pins; i++) {
1596 hda_nid_t nid = spec->pin_nids[i];
1597 unsigned int pin_cfg;
1599 pin_cfg = snd_hda_codec_read(codec, nid, 0,
1600 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
1601 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
1603 spec->bios_pin_configs[i] = pin_cfg;
1609 static void stac92xx_set_config_reg(struct hda_codec *codec,
1610 hda_nid_t pin_nid, unsigned int pin_config)
1613 snd_hda_codec_write(codec, pin_nid, 0,
1614 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
1615 pin_config & 0x000000ff);
1616 snd_hda_codec_write(codec, pin_nid, 0,
1617 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
1618 (pin_config & 0x0000ff00) >> 8);
1619 snd_hda_codec_write(codec, pin_nid, 0,
1620 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
1621 (pin_config & 0x00ff0000) >> 16);
1622 snd_hda_codec_write(codec, pin_nid, 0,
1623 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
1625 i = snd_hda_codec_read(codec, pin_nid, 0,
1626 AC_VERB_GET_CONFIG_DEFAULT,
1628 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
1632 static void stac92xx_set_config_regs(struct hda_codec *codec)
1635 struct sigmatel_spec *spec = codec->spec;
1637 if (!spec->pin_configs)
1640 for (i = 0; i < spec->num_pins; i++)
1641 stac92xx_set_config_reg(codec, spec->pin_nids[i],
1642 spec->pin_configs[i]);
1645 static void stac92xx_enable_gpio_mask(struct hda_codec *codec)
1647 struct sigmatel_spec *spec = codec->spec;
1648 /* Configure GPIOx as output */
1649 snd_hda_codec_write_cache(codec, codec->afg, 0,
1650 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_mask);
1651 /* Configure GPIOx as CMOS */
1652 snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7e7, 0x00000000);
1654 snd_hda_codec_write_cache(codec, codec->afg, 0,
1655 AC_VERB_SET_GPIO_DATA, spec->gpio_data);
1657 snd_hda_codec_write_cache(codec, codec->afg, 0,
1658 AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
1662 * Analog playback callbacks
1664 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
1665 struct hda_codec *codec,
1666 struct snd_pcm_substream *substream)
1668 struct sigmatel_spec *spec = codec->spec;
1669 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
1672 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1673 struct hda_codec *codec,
1674 unsigned int stream_tag,
1675 unsigned int format,
1676 struct snd_pcm_substream *substream)
1678 struct sigmatel_spec *spec = codec->spec;
1679 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
1682 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1683 struct hda_codec *codec,
1684 struct snd_pcm_substream *substream)
1686 struct sigmatel_spec *spec = codec->spec;
1687 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1691 * Digital playback callbacks
1693 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1694 struct hda_codec *codec,
1695 struct snd_pcm_substream *substream)
1697 struct sigmatel_spec *spec = codec->spec;
1698 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1701 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1702 struct hda_codec *codec,
1703 struct snd_pcm_substream *substream)
1705 struct sigmatel_spec *spec = codec->spec;
1706 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1709 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1710 struct hda_codec *codec,
1711 unsigned int stream_tag,
1712 unsigned int format,
1713 struct snd_pcm_substream *substream)
1715 struct sigmatel_spec *spec = codec->spec;
1716 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1717 stream_tag, format, substream);
1722 * Analog capture callbacks
1724 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1725 struct hda_codec *codec,
1726 unsigned int stream_tag,
1727 unsigned int format,
1728 struct snd_pcm_substream *substream)
1730 struct sigmatel_spec *spec = codec->spec;
1732 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1733 stream_tag, 0, format);
1737 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1738 struct hda_codec *codec,
1739 struct snd_pcm_substream *substream)
1741 struct sigmatel_spec *spec = codec->spec;
1743 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
1747 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
1751 /* NID is set in stac92xx_build_pcms */
1753 .open = stac92xx_dig_playback_pcm_open,
1754 .close = stac92xx_dig_playback_pcm_close,
1755 .prepare = stac92xx_dig_playback_pcm_prepare
1759 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
1763 /* NID is set in stac92xx_build_pcms */
1766 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
1770 .nid = 0x02, /* NID to query formats and rates */
1772 .open = stac92xx_playback_pcm_open,
1773 .prepare = stac92xx_playback_pcm_prepare,
1774 .cleanup = stac92xx_playback_pcm_cleanup
1778 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
1782 .nid = 0x06, /* NID to query formats and rates */
1784 .open = stac92xx_playback_pcm_open,
1785 .prepare = stac92xx_playback_pcm_prepare,
1786 .cleanup = stac92xx_playback_pcm_cleanup
1790 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
1793 /* NID + .substreams is set in stac92xx_build_pcms */
1795 .prepare = stac92xx_capture_pcm_prepare,
1796 .cleanup = stac92xx_capture_pcm_cleanup
1800 static int stac92xx_build_pcms(struct hda_codec *codec)
1802 struct sigmatel_spec *spec = codec->spec;
1803 struct hda_pcm *info = spec->pcm_rec;
1805 codec->num_pcms = 1;
1806 codec->pcm_info = info;
1808 info->name = "STAC92xx Analog";
1809 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
1810 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
1811 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1812 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
1814 if (spec->alt_switch) {
1817 info->name = "STAC92xx Analog Alt";
1818 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
1821 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1824 info->name = "STAC92xx Digital";
1825 if (spec->multiout.dig_out_nid) {
1826 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
1827 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
1829 if (spec->dig_in_nid) {
1830 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
1831 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
1838 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
1840 unsigned int pincap = snd_hda_param_read(codec, nid,
1842 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
1843 if (pincap & AC_PINCAP_VREF_100)
1844 return AC_PINCTL_VREF_100;
1845 if (pincap & AC_PINCAP_VREF_80)
1846 return AC_PINCTL_VREF_80;
1847 if (pincap & AC_PINCAP_VREF_50)
1848 return AC_PINCTL_VREF_50;
1849 if (pincap & AC_PINCAP_VREF_GRD)
1850 return AC_PINCTL_VREF_GRD;
1854 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
1857 snd_hda_codec_write_cache(codec, nid, 0,
1858 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
1861 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
1863 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1865 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1866 struct sigmatel_spec *spec = codec->spec;
1867 int io_idx = kcontrol-> private_value & 0xff;
1869 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
1873 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1875 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1876 struct sigmatel_spec *spec = codec->spec;
1877 hda_nid_t nid = kcontrol->private_value >> 8;
1878 int io_idx = kcontrol-> private_value & 0xff;
1879 unsigned short val = !!ucontrol->value.integer.value[0];
1881 spec->io_switch[io_idx] = val;
1884 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
1886 unsigned int pinctl = AC_PINCTL_IN_EN;
1887 if (io_idx) /* set VREF for mic */
1888 pinctl |= stac92xx_get_vref(codec, nid);
1889 stac92xx_auto_set_pinctl(codec, nid, pinctl);
1892 /* check the auto-mute again: we need to mute/unmute the speaker
1893 * appropriately according to the pin direction
1895 if (spec->hp_detect)
1896 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
1901 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
1903 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
1904 struct snd_ctl_elem_value *ucontrol)
1906 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1907 struct sigmatel_spec *spec = codec->spec;
1909 ucontrol->value.integer.value[0] = spec->clfe_swap;
1913 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
1914 struct snd_ctl_elem_value *ucontrol)
1916 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1917 struct sigmatel_spec *spec = codec->spec;
1918 hda_nid_t nid = kcontrol->private_value & 0xff;
1919 unsigned int val = !!ucontrol->value.integer.value[0];
1921 if (spec->clfe_swap == val)
1924 spec->clfe_swap = val;
1926 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1927 spec->clfe_swap ? 0x4 : 0x0);
1932 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
1933 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1936 .info = stac92xx_io_switch_info, \
1937 .get = stac92xx_io_switch_get, \
1938 .put = stac92xx_io_switch_put, \
1939 .private_value = xpval, \
1942 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
1943 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1946 .info = stac92xx_clfe_switch_info, \
1947 .get = stac92xx_clfe_switch_get, \
1948 .put = stac92xx_clfe_switch_put, \
1949 .private_value = xpval, \
1953 STAC_CTL_WIDGET_VOL,
1954 STAC_CTL_WIDGET_MUTE,
1955 STAC_CTL_WIDGET_IO_SWITCH,
1956 STAC_CTL_WIDGET_CLFE_SWITCH
1959 static struct snd_kcontrol_new stac92xx_control_templates[] = {
1960 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
1961 HDA_CODEC_MUTE(NULL, 0, 0, 0),
1962 STAC_CODEC_IO_SWITCH(NULL, 0),
1963 STAC_CODEC_CLFE_SWITCH(NULL, 0),
1966 /* add dynamic controls */
1967 static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val)
1969 struct snd_kcontrol_new *knew;
1971 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
1972 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
1974 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
1977 if (spec->kctl_alloc) {
1978 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
1979 kfree(spec->kctl_alloc);
1981 spec->kctl_alloc = knew;
1982 spec->num_kctl_alloc = num;
1985 knew = &spec->kctl_alloc[spec->num_kctl_used];
1986 *knew = stac92xx_control_templates[type];
1987 knew->name = kstrdup(name, GFP_KERNEL);
1990 knew->private_value = val;
1991 spec->num_kctl_used++;
1995 /* flag inputs as additional dynamic lineouts */
1996 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
1998 struct sigmatel_spec *spec = codec->spec;
1999 unsigned int wcaps, wtype;
2000 int i, num_dacs = 0;
2002 /* use the wcaps cache to count all DACs available for line-outs */
2003 for (i = 0; i < codec->num_nodes; i++) {
2004 wcaps = codec->wcaps[i];
2005 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2007 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
2011 snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
2013 switch (cfg->line_outs) {
2015 /* add line-in as side */
2016 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
2017 cfg->line_out_pins[cfg->line_outs] =
2018 cfg->input_pins[AUTO_PIN_LINE];
2019 spec->line_switch = 1;
2024 /* add line-in as clfe and mic as side */
2025 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
2026 cfg->line_out_pins[cfg->line_outs] =
2027 cfg->input_pins[AUTO_PIN_LINE];
2028 spec->line_switch = 1;
2031 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
2032 cfg->line_out_pins[cfg->line_outs] =
2033 cfg->input_pins[AUTO_PIN_MIC];
2034 spec->mic_switch = 1;
2039 /* add line-in as surr and mic as clfe */
2040 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
2041 cfg->line_out_pins[cfg->line_outs] =
2042 cfg->input_pins[AUTO_PIN_LINE];
2043 spec->line_switch = 1;
2046 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
2047 cfg->line_out_pins[cfg->line_outs] =
2048 cfg->input_pins[AUTO_PIN_MIC];
2049 spec->mic_switch = 1;
2059 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2063 for (i = 0; i < spec->multiout.num_dacs; i++) {
2064 if (spec->multiout.dac_nids[i] == nid)
2072 * Fill in the dac_nids table from the parsed pin configuration
2073 * This function only works when every pin in line_out_pins[]
2074 * contains atleast one DAC in its connection list. Some 92xx
2075 * codecs are not connected directly to a DAC, such as the 9200
2076 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2078 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
2079 struct auto_pin_cfg *cfg)
2081 struct sigmatel_spec *spec = codec->spec;
2082 int i, j, conn_len = 0;
2083 hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
2084 unsigned int wcaps, wtype;
2086 for (i = 0; i < cfg->line_outs; i++) {
2087 nid = cfg->line_out_pins[i];
2088 conn_len = snd_hda_get_connections(codec, nid, conn,
2089 HDA_MAX_CONNECTIONS);
2090 for (j = 0; j < conn_len; j++) {
2091 wcaps = snd_hda_param_read(codec, conn[j],
2092 AC_PAR_AUDIO_WIDGET_CAP);
2093 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2094 if (wtype != AC_WID_AUD_OUT ||
2095 (wcaps & AC_WCAP_DIGITAL))
2097 /* conn[j] is a DAC routed to this line-out */
2098 if (!is_in_dac_nids(spec, conn[j]))
2102 if (j == conn_len) {
2103 if (spec->multiout.num_dacs > 0) {
2104 /* we have already working output pins,
2105 * so let's drop the broken ones again
2107 cfg->line_outs = spec->multiout.num_dacs;
2110 /* error out, no available DAC found */
2112 "%s: No available DAC for pin 0x%x\n",
2117 spec->multiout.dac_nids[i] = conn[j];
2118 spec->multiout.num_dacs++;
2120 /* select this DAC in the pin's input mux */
2121 snd_hda_codec_write_cache(codec, nid, 0,
2122 AC_VERB_SET_CONNECT_SEL, j);
2127 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2128 spec->multiout.num_dacs,
2129 spec->multiout.dac_nids[0],
2130 spec->multiout.dac_nids[1],
2131 spec->multiout.dac_nids[2],
2132 spec->multiout.dac_nids[3],
2133 spec->multiout.dac_nids[4]);
2137 /* create volume control/switch for the given prefx type */
2138 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
2143 sprintf(name, "%s Playback Volume", pfx);
2144 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
2145 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2148 sprintf(name, "%s Playback Switch", pfx);
2149 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
2150 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2156 /* add playback controls from the parsed DAC table */
2157 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
2158 const struct auto_pin_cfg *cfg)
2160 static const char *chname[4] = {
2161 "Front", "Surround", NULL /*CLFE*/, "Side"
2166 struct sigmatel_spec *spec = codec->spec;
2167 unsigned int wid_caps;
2170 for (i = 0; i < cfg->line_outs; i++) {
2171 if (!spec->multiout.dac_nids[i])
2174 nid = spec->multiout.dac_nids[i];
2178 err = create_controls(spec, "Center", nid, 1);
2181 err = create_controls(spec, "LFE", nid, 2);
2185 wid_caps = get_wcaps(codec, nid);
2187 if (wid_caps & AC_WCAP_LR_SWAP) {
2188 err = stac92xx_add_control(spec,
2189 STAC_CTL_WIDGET_CLFE_SWITCH,
2190 "Swap Center/LFE Playback Switch", nid);
2197 err = create_controls(spec, chname[i], nid, 3);
2203 if (spec->line_switch)
2204 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Line In as Output Switch", cfg->input_pins[AUTO_PIN_LINE] << 8)) < 0)
2207 if (spec->mic_switch)
2208 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Mic as Output Switch", (cfg->input_pins[AUTO_PIN_MIC] << 8) | 1)) < 0)
2214 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2216 if (is_in_dac_nids(spec, nid))
2218 if (spec->multiout.hp_nid == nid)
2223 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
2225 if (!spec->multiout.hp_nid)
2226 spec->multiout.hp_nid = nid;
2227 else if (spec->multiout.num_dacs > 4) {
2228 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
2231 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
2232 spec->multiout.num_dacs++;
2237 /* add playback controls for Speaker and HP outputs */
2238 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
2239 struct auto_pin_cfg *cfg)
2241 struct sigmatel_spec *spec = codec->spec;
2243 int i, old_num_dacs, err;
2245 old_num_dacs = spec->multiout.num_dacs;
2246 for (i = 0; i < cfg->hp_outs; i++) {
2247 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
2248 if (wid_caps & AC_WCAP_UNSOL_CAP)
2249 spec->hp_detect = 1;
2250 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
2251 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2252 if (check_in_dac_nids(spec, nid))
2256 add_spec_dacs(spec, nid);
2258 for (i = 0; i < cfg->speaker_outs; i++) {
2259 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
2260 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2261 if (check_in_dac_nids(spec, nid))
2265 add_spec_dacs(spec, nid);
2267 for (i = 0; i < cfg->line_outs; i++) {
2268 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
2269 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2270 if (check_in_dac_nids(spec, nid))
2274 add_spec_dacs(spec, nid);
2276 for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
2277 static const char *pfxs[] = {
2278 "Speaker", "External Speaker", "Speaker2",
2280 err = create_controls(spec, pfxs[i - old_num_dacs],
2281 spec->multiout.dac_nids[i], 3);
2285 if (spec->multiout.hp_nid) {
2287 if (old_num_dacs == spec->multiout.num_dacs)
2291 err = create_controls(spec, pfx, spec->multiout.hp_nid, 3);
2299 /* labels for dmic mux inputs */
2300 static const char *stac92xx_dmic_labels[5] = {
2301 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
2302 "Digital Mic 3", "Digital Mic 4"
2305 /* create playback/capture controls for input pins on dmic capable codecs */
2306 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
2307 const struct auto_pin_cfg *cfg)
2309 struct sigmatel_spec *spec = codec->spec;
2310 struct hda_input_mux *dimux = &spec->private_dimux;
2311 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2314 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
2315 dimux->items[dimux->num_items].index = 0;
2318 for (i = 0; i < spec->num_dmics; i++) {
2321 unsigned int def_conf;
2323 def_conf = snd_hda_codec_read(codec,
2326 AC_VERB_GET_CONFIG_DEFAULT,
2328 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
2331 num_cons = snd_hda_get_connections(codec,
2334 HDA_MAX_NUM_INPUTS);
2335 for (j = 0; j < num_cons; j++)
2336 if (con_lst[j] == spec->dmic_nids[i]) {
2342 dimux->items[dimux->num_items].label =
2343 stac92xx_dmic_labels[dimux->num_items];
2344 dimux->items[dimux->num_items].index = index;
2351 /* create playback/capture controls for input pins */
2352 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
2354 struct sigmatel_spec *spec = codec->spec;
2355 struct hda_input_mux *imux = &spec->private_imux;
2356 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2359 for (i = 0; i < AUTO_PIN_LAST; i++) {
2362 if (!cfg->input_pins[i])
2365 for (j = 0; j < spec->num_muxes; j++) {
2367 num_cons = snd_hda_get_connections(codec,
2370 HDA_MAX_NUM_INPUTS);
2371 for (k = 0; k < num_cons; k++)
2372 if (con_lst[k] == cfg->input_pins[i]) {
2379 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2380 imux->items[imux->num_items].index = index;
2384 if (imux->num_items) {
2386 * Set the current input for the muxes.
2387 * The STAC9221 has two input muxes with identical source
2388 * NID lists. Hopefully this won't get confused.
2390 for (i = 0; i < spec->num_muxes; i++) {
2391 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
2392 AC_VERB_SET_CONNECT_SEL,
2393 imux->items[0].index);
2400 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
2402 struct sigmatel_spec *spec = codec->spec;
2405 for (i = 0; i < spec->autocfg.line_outs; i++) {
2406 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2407 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2411 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
2413 struct sigmatel_spec *spec = codec->spec;
2416 for (i = 0; i < spec->autocfg.hp_outs; i++) {
2418 pin = spec->autocfg.hp_pins[i];
2419 if (pin) /* connect to front */
2420 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
2422 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
2424 pin = spec->autocfg.speaker_pins[i];
2425 if (pin) /* connect to front */
2426 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
2430 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
2432 struct sigmatel_spec *spec = codec->spec;
2434 int hp_speaker_swap = 0;
2436 if ((err = snd_hda_parse_pin_def_config(codec,
2438 spec->dmic_nids)) < 0)
2440 if (! spec->autocfg.line_outs)
2441 return 0; /* can't find valid pin config */
2443 /* If we have no real line-out pin and multiple hp-outs, HPs should
2444 * be set up as multi-channel outputs.
2446 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
2447 spec->autocfg.hp_outs > 1) {
2448 /* Copy hp_outs to line_outs, backup line_outs in
2449 * speaker_outs so that the following routines can handle
2450 * HP pins as primary outputs.
2452 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
2453 sizeof(spec->autocfg.line_out_pins));
2454 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
2455 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
2456 sizeof(spec->autocfg.hp_pins));
2457 spec->autocfg.line_outs = spec->autocfg.hp_outs;
2458 hp_speaker_swap = 1;
2461 if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
2463 if (spec->multiout.num_dacs == 0)
2464 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2467 err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
2472 if (hp_speaker_swap == 1) {
2473 /* Restore the hp_outs and line_outs */
2474 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
2475 sizeof(spec->autocfg.line_out_pins));
2476 spec->autocfg.hp_outs = spec->autocfg.line_outs;
2477 memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins,
2478 sizeof(spec->autocfg.speaker_pins));
2479 spec->autocfg.line_outs = spec->autocfg.speaker_outs;
2480 memset(spec->autocfg.speaker_pins, 0,
2481 sizeof(spec->autocfg.speaker_pins));
2482 spec->autocfg.speaker_outs = 0;
2485 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
2490 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
2495 if (spec->num_dmics > 0)
2496 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
2497 &spec->autocfg)) < 0)
2500 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2501 if (spec->multiout.max_channels > 2)
2502 spec->surr_switch = 1;
2504 if (spec->autocfg.dig_out_pin)
2505 spec->multiout.dig_out_nid = dig_out;
2506 if (spec->autocfg.dig_in_pin)
2507 spec->dig_in_nid = dig_in;
2509 if (spec->kctl_alloc)
2510 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2512 spec->input_mux = &spec->private_imux;
2513 if (!spec->dinput_mux)
2514 spec->dinput_mux = &spec->private_dimux;
2519 /* add playback controls for HP output */
2520 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
2521 struct auto_pin_cfg *cfg)
2523 struct sigmatel_spec *spec = codec->spec;
2524 hda_nid_t pin = cfg->hp_pins[0];
2525 unsigned int wid_caps;
2530 wid_caps = get_wcaps(codec, pin);
2531 if (wid_caps & AC_WCAP_UNSOL_CAP)
2532 spec->hp_detect = 1;
2537 /* add playback controls for LFE output */
2538 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
2539 struct auto_pin_cfg *cfg)
2541 struct sigmatel_spec *spec = codec->spec;
2543 hda_nid_t lfe_pin = 0x0;
2547 * search speaker outs and line outs for a mono speaker pin
2548 * with an amp. If one is found, add LFE controls
2551 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
2552 hda_nid_t pin = spec->autocfg.speaker_pins[i];
2553 unsigned long wcaps = get_wcaps(codec, pin);
2554 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2555 if (wcaps == AC_WCAP_OUT_AMP)
2556 /* found a mono speaker with an amp, must be lfe */
2560 /* if speaker_outs is 0, then speakers may be in line_outs */
2561 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
2562 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
2563 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2565 cfg = snd_hda_codec_read(codec, pin, 0,
2566 AC_VERB_GET_CONFIG_DEFAULT,
2568 if (get_defcfg_device(cfg) == AC_JACK_SPEAKER) {
2569 unsigned long wcaps = get_wcaps(codec, pin);
2570 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2571 if (wcaps == AC_WCAP_OUT_AMP)
2572 /* found a mono speaker with an amp,
2580 err = create_controls(spec, "LFE", lfe_pin, 1);
2588 static int stac9200_parse_auto_config(struct hda_codec *codec)
2590 struct sigmatel_spec *spec = codec->spec;
2593 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2596 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
2599 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
2602 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
2605 if (spec->autocfg.dig_out_pin)
2606 spec->multiout.dig_out_nid = 0x05;
2607 if (spec->autocfg.dig_in_pin)
2608 spec->dig_in_nid = 0x04;
2610 if (spec->kctl_alloc)
2611 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2613 spec->input_mux = &spec->private_imux;
2614 spec->dinput_mux = &spec->private_dimux;
2620 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
2621 * funky external mute control using GPIO pins.
2624 static void stac922x_gpio_mute(struct hda_codec *codec, int pin, int muted)
2626 unsigned int gpiostate, gpiomask, gpiodir;
2628 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
2629 AC_VERB_GET_GPIO_DATA, 0);
2632 gpiostate |= (1 << pin);
2634 gpiostate &= ~(1 << pin);
2636 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
2637 AC_VERB_GET_GPIO_MASK, 0);
2638 gpiomask |= (1 << pin);
2640 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
2641 AC_VERB_GET_GPIO_DIRECTION, 0);
2642 gpiodir |= (1 << pin);
2644 /* AppleHDA seems to do this -- WTF is this verb?? */
2645 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
2647 snd_hda_codec_write(codec, codec->afg, 0,
2648 AC_VERB_SET_GPIO_MASK, gpiomask);
2649 snd_hda_codec_write(codec, codec->afg, 0,
2650 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
2654 snd_hda_codec_write(codec, codec->afg, 0,
2655 AC_VERB_SET_GPIO_DATA, gpiostate);
2658 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
2661 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
2662 snd_hda_codec_write_cache(codec, nid, 0,
2663 AC_VERB_SET_UNSOLICITED_ENABLE,
2664 (AC_USRSP_EN | event));
2667 static int stac92xx_init(struct hda_codec *codec)
2669 struct sigmatel_spec *spec = codec->spec;
2670 struct auto_pin_cfg *cfg = &spec->autocfg;
2673 snd_hda_sequence_write(codec, spec->init);
2676 if (spec->hp_detect) {
2677 /* Enable unsolicited responses on the HP widget */
2678 for (i = 0; i < cfg->hp_outs; i++)
2679 enable_pin_detect(codec, cfg->hp_pins[i],
2681 /* force to enable the first line-out; the others are set up
2684 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
2686 stac92xx_auto_init_hp_out(codec);
2687 /* fake event to set up pins */
2688 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2690 stac92xx_auto_init_multi_out(codec);
2691 stac92xx_auto_init_hp_out(codec);
2693 for (i = 0; i < AUTO_PIN_LAST; i++) {
2694 hda_nid_t nid = cfg->input_pins[i];
2696 unsigned int pinctl = AC_PINCTL_IN_EN;
2697 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
2698 pinctl |= stac92xx_get_vref(codec, nid);
2699 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2702 if (spec->num_dmics > 0)
2703 for (i = 0; i < spec->num_dmics; i++)
2704 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
2707 if (cfg->dig_out_pin)
2708 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
2710 if (cfg->dig_in_pin)
2711 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
2714 if (spec->gpio_mute) {
2715 stac922x_gpio_mute(codec, 0, 0);
2716 stac922x_gpio_mute(codec, 1, 0);
2722 static void stac92xx_free(struct hda_codec *codec)
2724 struct sigmatel_spec *spec = codec->spec;
2730 if (spec->kctl_alloc) {
2731 for (i = 0; i < spec->num_kctl_used; i++)
2732 kfree(spec->kctl_alloc[i].name);
2733 kfree(spec->kctl_alloc);
2736 if (spec->bios_pin_configs)
2737 kfree(spec->bios_pin_configs);
2742 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
2745 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2746 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2748 if (pin_ctl & AC_PINCTL_IN_EN) {
2750 * we need to check the current set-up direction of
2751 * shared input pins since they can be switched via
2752 * "xxx as Output" mixer switch
2754 struct sigmatel_spec *spec = codec->spec;
2755 struct auto_pin_cfg *cfg = &spec->autocfg;
2756 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
2757 spec->line_switch) ||
2758 (nid == cfg->input_pins[AUTO_PIN_MIC] &&
2763 /* if setting pin direction bits, clear the current
2764 direction bits first */
2765 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
2766 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
2768 snd_hda_codec_write_cache(codec, nid, 0,
2769 AC_VERB_SET_PIN_WIDGET_CONTROL,
2773 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
2776 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2777 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2778 snd_hda_codec_write_cache(codec, nid, 0,
2779 AC_VERB_SET_PIN_WIDGET_CONTROL,
2783 static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid)
2787 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
2789 unsigned int pinctl;
2790 pinctl = snd_hda_codec_read(codec, nid, 0,
2791 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2792 if (pinctl & AC_PINCTL_IN_EN)
2793 return 0; /* mic- or line-input */
2795 return 1; /* HP-output */
2800 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
2802 struct sigmatel_spec *spec = codec->spec;
2803 struct auto_pin_cfg *cfg = &spec->autocfg;
2807 for (i = 0; i < cfg->hp_outs; i++) {
2808 presence = get_hp_pin_presence(codec, cfg->hp_pins[i]);
2814 /* disable lineouts, enable hp */
2815 for (i = 0; i < cfg->line_outs; i++)
2816 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
2818 for (i = 0; i < cfg->speaker_outs; i++)
2819 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
2822 /* enable lineouts, disable hp */
2823 for (i = 0; i < cfg->line_outs; i++)
2824 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
2826 for (i = 0; i < cfg->speaker_outs; i++)
2827 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
2832 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
2834 switch (res >> 26) {
2836 stac92xx_hp_detect(codec, res);
2841 #ifdef SND_HDA_NEEDS_RESUME
2842 static int stac92xx_resume(struct hda_codec *codec)
2844 struct sigmatel_spec *spec = codec->spec;
2846 stac92xx_set_config_regs(codec);
2847 snd_hda_sequence_write(codec, spec->init);
2848 if (spec->gpio_mute) {
2849 stac922x_gpio_mute(codec, 0, 0);
2850 stac922x_gpio_mute(codec, 1, 0);
2852 snd_hda_codec_resume_amp(codec);
2853 snd_hda_codec_resume_cache(codec);
2854 /* invoke unsolicited event to reset the HP state */
2855 if (spec->hp_detect)
2856 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2861 static struct hda_codec_ops stac92xx_patch_ops = {
2862 .build_controls = stac92xx_build_controls,
2863 .build_pcms = stac92xx_build_pcms,
2864 .init = stac92xx_init,
2865 .free = stac92xx_free,
2866 .unsol_event = stac92xx_unsol_event,
2867 #ifdef SND_HDA_NEEDS_RESUME
2868 .resume = stac92xx_resume,
2872 static int patch_stac9200(struct hda_codec *codec)
2874 struct sigmatel_spec *spec;
2877 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2882 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
2883 spec->pin_nids = stac9200_pin_nids;
2884 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
2887 if (spec->board_config < 0) {
2888 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
2889 err = stac92xx_save_bios_config_regs(codec);
2891 stac92xx_free(codec);
2894 spec->pin_configs = spec->bios_pin_configs;
2896 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
2897 stac92xx_set_config_regs(codec);
2900 spec->multiout.max_channels = 2;
2901 spec->multiout.num_dacs = 1;
2902 spec->multiout.dac_nids = stac9200_dac_nids;
2903 spec->adc_nids = stac9200_adc_nids;
2904 spec->mux_nids = stac9200_mux_nids;
2905 spec->num_muxes = 1;
2906 spec->num_dmics = 0;
2909 if (spec->board_config == STAC_9200_GATEWAY)
2910 spec->init = stac9200_eapd_init;
2912 spec->init = stac9200_core_init;
2913 spec->mixer = stac9200_mixer;
2915 err = stac9200_parse_auto_config(codec);
2917 stac92xx_free(codec);
2921 codec->patch_ops = stac92xx_patch_ops;
2926 static int patch_stac925x(struct hda_codec *codec)
2928 struct sigmatel_spec *spec;
2931 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2936 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
2937 spec->pin_nids = stac925x_pin_nids;
2938 spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
2942 if (spec->board_config < 0) {
2943 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
2944 "using BIOS defaults\n");
2945 err = stac92xx_save_bios_config_regs(codec);
2947 stac92xx_free(codec);
2950 spec->pin_configs = spec->bios_pin_configs;
2951 } else if (stac925x_brd_tbl[spec->board_config] != NULL){
2952 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
2953 stac92xx_set_config_regs(codec);
2956 spec->multiout.max_channels = 2;
2957 spec->multiout.num_dacs = 1;
2958 spec->multiout.dac_nids = stac925x_dac_nids;
2959 spec->adc_nids = stac925x_adc_nids;
2960 spec->mux_nids = stac925x_mux_nids;
2961 spec->num_muxes = 1;
2963 switch (codec->vendor_id) {
2964 case 0x83847632: /* STAC9202 */
2965 case 0x83847633: /* STAC9202D */
2966 case 0x83847636: /* STAC9251 */
2967 case 0x83847637: /* STAC9251D */
2968 spec->num_dmics = STAC925X_NUM_DMICS;
2969 spec->dmic_nids = stac925x_dmic_nids;
2972 spec->num_dmics = 0;
2976 spec->init = stac925x_core_init;
2977 spec->mixer = stac925x_mixer;
2979 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
2981 if (spec->board_config < 0) {
2982 printk(KERN_WARNING "hda_codec: No auto-config is "
2983 "available, default to model=ref\n");
2984 spec->board_config = STAC_925x_REF;
2990 stac92xx_free(codec);
2994 codec->patch_ops = stac92xx_patch_ops;
2999 static struct hda_input_mux stac92hd73xx_dmux = {
3002 { "Analog Inputs", 0x0b },
3004 { "Digital Mic 1", 0x09 },
3005 { "Digital Mic 2", 0x0a },
3009 static int patch_stac92hd73xx(struct hda_codec *codec)
3011 struct sigmatel_spec *spec;
3012 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
3015 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3020 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
3021 spec->pin_nids = stac92hd73xx_pin_nids;
3022 spec->board_config = snd_hda_check_board_config(codec,
3023 STAC_92HD73XX_MODELS,
3024 stac92hd73xx_models,
3025 stac92hd73xx_cfg_tbl);
3027 if (spec->board_config < 0) {
3028 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3029 " STAC92HD73XX, using BIOS defaults\n");
3030 err = stac92xx_save_bios_config_regs(codec);
3032 stac92xx_free(codec);
3035 spec->pin_configs = spec->bios_pin_configs;
3037 spec->pin_configs = stac92hd73xx_brd_tbl[spec->board_config];
3038 stac92xx_set_config_regs(codec);
3041 spec->multiout.num_dacs = snd_hda_get_connections(codec, 0x0a,
3042 conn, STAC92HD73_DAC_COUNT + 2) - 1;
3044 if (spec->multiout.num_dacs < 0) {
3045 printk(KERN_WARNING "hda_codec: Could not determine "
3046 "number of channels defaulting to DAC count\n");
3047 spec->multiout.num_dacs = STAC92HD73_DAC_COUNT;
3050 switch (spec->multiout.num_dacs) {
3051 case 0x3: /* 6 Channel */
3052 spec->mixer = stac92hd73xx_6ch_mixer;
3053 spec->init = stac92hd73xx_6ch_core_init;
3055 case 0x4: /* 8 Channel */
3056 spec->multiout.hp_nid = 0x18;
3057 spec->mixer = stac92hd73xx_8ch_mixer;
3058 spec->init = stac92hd73xx_8ch_core_init;
3060 case 0x5: /* 10 Channel */
3061 spec->multiout.hp_nid = 0x19;
3062 spec->mixer = stac92hd73xx_10ch_mixer;
3063 spec->init = stac92hd73xx_10ch_core_init;
3066 spec->multiout.dac_nids = stac92hd73xx_dac_nids;
3067 spec->aloopback_mask = 0x01;
3068 spec->aloopback_shift = 8;
3070 spec->mux_nids = stac92hd73xx_mux_nids;
3071 spec->adc_nids = stac92hd73xx_adc_nids;
3072 spec->dmic_nids = stac92hd73xx_dmic_nids;
3073 spec->dmux_nids = stac92hd73xx_dmux_nids;
3075 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
3076 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
3077 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
3078 spec->dinput_mux = &stac92hd73xx_dmux;
3079 /* GPIO0 High = Enable EAPD */
3080 spec->gpio_mask = spec->gpio_data = 0x000001;
3081 stac92xx_enable_gpio_mask(codec);
3083 err = stac92xx_parse_auto_config(codec, 0x22, 0x24);
3086 if (spec->board_config < 0) {
3087 printk(KERN_WARNING "hda_codec: No auto-config is "
3088 "available, default to model=ref\n");
3089 spec->board_config = STAC_92HD73XX_REF;
3096 stac92xx_free(codec);
3100 codec->patch_ops = stac92xx_patch_ops;
3105 static int patch_stac92hd71bxx(struct hda_codec *codec)
3107 struct sigmatel_spec *spec;
3110 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3115 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
3116 spec->pin_nids = stac92hd71bxx_pin_nids;
3117 spec->board_config = snd_hda_check_board_config(codec,
3118 STAC_92HD71BXX_MODELS,
3119 stac92hd71bxx_models,
3120 stac92hd71bxx_cfg_tbl);
3122 if (spec->board_config < 0) {
3123 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3124 " STAC92HD71BXX, using BIOS defaults\n");
3125 err = stac92xx_save_bios_config_regs(codec);
3127 stac92xx_free(codec);
3130 spec->pin_configs = spec->bios_pin_configs;
3132 spec->pin_configs = stac92hd71bxx_brd_tbl[spec->board_config];
3133 stac92xx_set_config_regs(codec);
3136 switch (codec->vendor_id) {
3137 case 0x111d76b6: /* 4 Port without Analog Mixer */
3139 case 0x111d76b4: /* 6 Port without Analog Mixer */
3141 spec->mixer = stac92hd71bxx_mixer;
3142 spec->init = stac92hd71bxx_core_init;
3145 spec->mixer = stac92hd71bxx_analog_mixer;
3146 spec->init = stac92hd71bxx_analog_core_init;
3149 spec->aloopback_mask = 0x20;
3150 spec->aloopback_shift = 0;
3152 spec->gpio_mask = spec->gpio_data = 0x00000001; /* GPIO0 High = EAPD */
3153 stac92xx_enable_gpio_mask(codec);
3155 spec->mux_nids = stac92hd71bxx_mux_nids;
3156 spec->adc_nids = stac92hd71bxx_adc_nids;
3157 spec->dmic_nids = stac92hd71bxx_dmic_nids;
3158 spec->dmux_nids = stac92hd71bxx_dmux_nids;
3160 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
3161 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
3162 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
3164 spec->multiout.num_dacs = 2;
3165 spec->multiout.hp_nid = 0x11;
3166 spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
3168 err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
3170 if (spec->board_config < 0) {
3171 printk(KERN_WARNING "hda_codec: No auto-config is "
3172 "available, default to model=ref\n");
3173 spec->board_config = STAC_92HD71BXX_REF;
3180 stac92xx_free(codec);
3184 codec->patch_ops = stac92xx_patch_ops;
3189 static int patch_stac922x(struct hda_codec *codec)
3191 struct sigmatel_spec *spec;
3194 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3199 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
3200 spec->pin_nids = stac922x_pin_nids;
3201 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
3204 if (spec->board_config == STAC_INTEL_MAC_V3) {
3205 spec->gpio_mute = 1;
3206 /* Intel Macs have all same PCI SSID, so we need to check
3207 * codec SSID to distinguish the exact models
3209 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
3210 switch (codec->subsystem_id) {
3213 spec->board_config = STAC_INTEL_MAC_V1;
3217 spec->board_config = STAC_INTEL_MAC_V2;
3225 spec->board_config = STAC_INTEL_MAC_V3;
3229 spec->board_config = STAC_INTEL_MAC_V4;
3233 spec->board_config = STAC_INTEL_MAC_V5;
3239 if (spec->board_config < 0) {
3240 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
3241 "using BIOS defaults\n");
3242 err = stac92xx_save_bios_config_regs(codec);
3244 stac92xx_free(codec);
3247 spec->pin_configs = spec->bios_pin_configs;
3248 } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
3249 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
3250 stac92xx_set_config_regs(codec);
3253 spec->adc_nids = stac922x_adc_nids;
3254 spec->mux_nids = stac922x_mux_nids;
3255 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
3256 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
3257 spec->num_dmics = 0;
3259 spec->init = stac922x_core_init;
3260 spec->mixer = stac922x_mixer;
3262 spec->multiout.dac_nids = spec->dac_nids;
3264 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
3266 if (spec->board_config < 0) {
3267 printk(KERN_WARNING "hda_codec: No auto-config is "
3268 "available, default to model=ref\n");
3269 spec->board_config = STAC_D945_REF;
3275 stac92xx_free(codec);
3279 codec->patch_ops = stac92xx_patch_ops;
3281 /* Fix Mux capture level; max to 2 */
3282 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
3283 (0 << AC_AMPCAP_OFFSET_SHIFT) |
3284 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3285 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3286 (0 << AC_AMPCAP_MUTE_SHIFT));
3291 static int patch_stac927x(struct hda_codec *codec)
3293 struct sigmatel_spec *spec;
3296 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3301 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
3302 spec->pin_nids = stac927x_pin_nids;
3303 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
3307 if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
3308 if (spec->board_config < 0)
3309 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3310 "STAC927x, using BIOS defaults\n");
3311 err = stac92xx_save_bios_config_regs(codec);
3313 stac92xx_free(codec);
3316 spec->pin_configs = spec->bios_pin_configs;
3318 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
3319 stac92xx_set_config_regs(codec);
3322 spec->adc_nids = stac927x_adc_nids;
3323 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
3324 spec->mux_nids = stac927x_mux_nids;
3325 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
3326 spec->multiout.dac_nids = spec->dac_nids;
3328 switch (spec->board_config) {
3331 /* GPIO0 High = Enable EAPD */
3332 spec->gpio_mask = spec->gpio_data = 0x00000001;
3333 spec->num_dmics = 0;
3335 spec->init = d965_core_init;
3336 spec->mixer = stac927x_mixer;
3338 case STAC_DELL_BIOS:
3340 /* GPIO2 High = Enable EAPD */
3341 spec->gpio_mask = spec->gpio_data = 0x00000004;
3342 spec->dmic_nids = stac927x_dmic_nids;
3343 spec->num_dmics = STAC927X_NUM_DMICS;
3345 spec->init = d965_core_init;
3346 spec->mixer = stac927x_mixer;
3347 spec->dmux_nids = stac927x_dmux_nids;
3350 /* GPIO0 High = Enable EAPD */
3351 spec->gpio_mask = spec->gpio_data = 0x00000001;
3352 spec->num_dmics = 0;
3354 spec->init = stac927x_core_init;
3355 spec->mixer = stac927x_mixer;
3358 spec->aloopback_mask = 0x40;
3359 spec->aloopback_shift = 0;
3361 stac92xx_enable_gpio_mask(codec);
3362 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
3364 if (spec->board_config < 0) {
3365 printk(KERN_WARNING "hda_codec: No auto-config is "
3366 "available, default to model=ref\n");
3367 spec->board_config = STAC_D965_REF;
3373 stac92xx_free(codec);
3377 codec->patch_ops = stac92xx_patch_ops;
3382 static int patch_stac9205(struct hda_codec *codec)
3384 struct sigmatel_spec *spec;
3387 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3392 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
3393 spec->pin_nids = stac9205_pin_nids;
3394 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
3398 if (spec->board_config < 0) {
3399 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
3400 err = stac92xx_save_bios_config_regs(codec);
3402 stac92xx_free(codec);
3405 spec->pin_configs = spec->bios_pin_configs;
3407 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
3408 stac92xx_set_config_regs(codec);
3411 spec->adc_nids = stac9205_adc_nids;
3412 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
3413 spec->mux_nids = stac9205_mux_nids;
3414 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
3415 spec->dmic_nids = stac9205_dmic_nids;
3416 spec->num_dmics = STAC9205_NUM_DMICS;
3417 spec->dmux_nids = stac9205_dmux_nids;
3419 spec->init = stac9205_core_init;
3420 spec->mixer = stac9205_mixer;
3422 spec->aloopback_mask = 0x40;
3423 spec->aloopback_shift = 0;
3424 spec->multiout.dac_nids = spec->dac_nids;
3426 switch (spec->board_config){
3427 case STAC_9205_DELL_M43:
3428 /* Enable SPDIF in/out */
3429 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
3430 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
3432 spec->gpio_mask = 0x00000007; /* GPIO0-2 */
3433 /* GPIO0 High = EAPD, GPIO1 Low = DRM,
3434 * GPIO2 High = Headphone Mute
3436 spec->gpio_data = 0x00000005;
3439 /* GPIO0 High = EAPD */
3440 spec->gpio_mask = spec->gpio_data = 0x00000001;
3444 stac92xx_enable_gpio_mask(codec);
3445 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
3447 if (spec->board_config < 0) {
3448 printk(KERN_WARNING "hda_codec: No auto-config is "
3449 "available, default to model=ref\n");
3450 spec->board_config = STAC_9205_REF;
3456 stac92xx_free(codec);
3460 codec->patch_ops = stac92xx_patch_ops;
3469 /* static config for Sony VAIO FE550G and Sony VAIO AR */
3470 static hda_nid_t vaio_dacs[] = { 0x2 };
3471 #define VAIO_HP_DAC 0x5
3472 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
3473 static hda_nid_t vaio_mux_nids[] = { 0x15 };
3475 static struct hda_input_mux vaio_mux = {
3478 /* { "HP", 0x0 }, */
3479 { "Mic Jack", 0x1 },
3480 { "Internal Mic", 0x2 },
3485 static struct hda_verb vaio_init[] = {
3486 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3487 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
3488 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3489 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3490 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3491 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3492 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3493 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3494 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3495 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3496 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3497 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3501 static struct hda_verb vaio_ar_init[] = {
3502 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3503 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3504 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3505 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3506 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
3507 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3508 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3509 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3510 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3511 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
3512 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3513 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3514 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3518 /* bind volumes of both NID 0x02 and 0x05 */
3519 static struct hda_bind_ctls vaio_bind_master_vol = {
3520 .ops = &snd_hda_bind_vol,
3522 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3523 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3528 /* bind volumes of both NID 0x02 and 0x05 */
3529 static struct hda_bind_ctls vaio_bind_master_sw = {
3530 .ops = &snd_hda_bind_sw,
3532 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3533 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3538 static struct snd_kcontrol_new vaio_mixer[] = {
3539 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3540 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3541 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3542 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3543 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3545 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3546 .name = "Capture Source",
3548 .info = stac92xx_mux_enum_info,
3549 .get = stac92xx_mux_enum_get,
3550 .put = stac92xx_mux_enum_put,
3555 static struct snd_kcontrol_new vaio_ar_mixer[] = {
3556 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3557 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3558 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3559 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3560 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3561 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
3562 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
3564 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3565 .name = "Capture Source",
3567 .info = stac92xx_mux_enum_info,
3568 .get = stac92xx_mux_enum_get,
3569 .put = stac92xx_mux_enum_put,
3574 static struct hda_codec_ops stac9872_patch_ops = {
3575 .build_controls = stac92xx_build_controls,
3576 .build_pcms = stac92xx_build_pcms,
3577 .init = stac92xx_init,
3578 .free = stac92xx_free,
3579 #ifdef SND_HDA_NEEDS_RESUME
3580 .resume = stac92xx_resume,
3584 static int stac9872_vaio_init(struct hda_codec *codec)
3588 err = stac92xx_init(codec);
3591 if (codec->patch_ops.unsol_event)
3592 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3596 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
3598 if (get_hp_pin_presence(codec, 0x0a)) {
3599 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3600 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3602 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3603 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3607 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
3609 switch (res >> 26) {
3611 stac9872_vaio_hp_detect(codec, res);
3616 static struct hda_codec_ops stac9872_vaio_patch_ops = {
3617 .build_controls = stac92xx_build_controls,
3618 .build_pcms = stac92xx_build_pcms,
3619 .init = stac9872_vaio_init,
3620 .free = stac92xx_free,
3621 .unsol_event = stac9872_vaio_unsol_event,
3623 .resume = stac92xx_resume,
3627 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
3629 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
3631 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
3633 /* AR Series. id=0x83847664 and subsys=104D1300 */
3638 static const char *stac9872_models[STAC_9872_MODELS] = {
3639 [CXD9872RD_VAIO] = "vaio",
3640 [CXD9872AKD_VAIO] = "vaio-ar",
3643 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
3644 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
3645 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
3646 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
3647 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
3651 static int patch_stac9872(struct hda_codec *codec)
3653 struct sigmatel_spec *spec;
3656 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
3659 if (board_config < 0)
3660 /* unknown config, let generic-parser do its job... */
3661 return snd_hda_parse_generic_codec(codec);
3663 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3668 switch (board_config) {
3669 case CXD9872RD_VAIO:
3670 case STAC9872AK_VAIO:
3671 case STAC9872K_VAIO:
3672 spec->mixer = vaio_mixer;
3673 spec->init = vaio_init;
3674 spec->multiout.max_channels = 2;
3675 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3676 spec->multiout.dac_nids = vaio_dacs;
3677 spec->multiout.hp_nid = VAIO_HP_DAC;
3678 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3679 spec->adc_nids = vaio_adcs;
3680 spec->input_mux = &vaio_mux;
3681 spec->mux_nids = vaio_mux_nids;
3682 codec->patch_ops = stac9872_vaio_patch_ops;
3685 case CXD9872AKD_VAIO:
3686 spec->mixer = vaio_ar_mixer;
3687 spec->init = vaio_ar_init;
3688 spec->multiout.max_channels = 2;
3689 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3690 spec->multiout.dac_nids = vaio_dacs;
3691 spec->multiout.hp_nid = VAIO_HP_DAC;
3692 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3693 spec->adc_nids = vaio_adcs;
3694 spec->input_mux = &vaio_mux;
3695 spec->mux_nids = vaio_mux_nids;
3696 codec->patch_ops = stac9872_patch_ops;
3707 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
3708 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
3709 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
3710 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
3711 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
3712 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
3713 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
3714 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
3715 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
3716 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
3717 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
3718 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
3719 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
3720 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
3721 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
3722 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
3723 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
3724 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
3725 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
3726 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
3727 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
3728 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
3729 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
3730 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
3731 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
3732 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
3733 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
3734 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
3735 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
3736 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
3737 /* The following does not take into account .id=0x83847661 when subsys =
3738 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
3739 * currently not fully supported.
3741 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
3742 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
3743 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
3744 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
3745 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
3746 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
3747 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
3748 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
3749 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
3750 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
3751 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
3752 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
3753 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
3754 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
3755 { .id = 0x111d7608, .name = "92HD71BXX", .patch = patch_stac92hd71bxx },
3756 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
3757 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
3758 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
3759 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
3760 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
3761 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
3762 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
3763 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },