2 * Universal Interface for Intel High Definition Audio Codec
4 * HD audio interface patch for SigmaTel STAC92xx
6 * Copyright (c) 2005 Embedded Alley Solutions, Inc.
7 * Matt Porter <mporter@embeddedalley.com>
9 * Based on patch_cmedia.c and patch_realtek.c
10 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
12 * This driver is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This driver is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include <sound/driver.h>
28 #include <linux/init.h>
29 #include <linux/delay.h>
30 #include <linux/slab.h>
31 #include <linux/pci.h>
32 #include <sound/core.h>
33 #include <sound/asoundef.h>
34 #include "hda_codec.h"
35 #include "hda_local.h"
37 #define NUM_CONTROL_ALLOC 32
38 #define STAC_HP_EVENT 0x37
91 /* for backward compatibility */
114 struct sigmatel_spec {
115 struct snd_kcontrol_new *mixers[4];
116 unsigned int num_mixers;
119 unsigned int surr_switch: 1;
120 unsigned int line_switch: 1;
121 unsigned int mic_switch: 1;
122 unsigned int alt_switch: 1;
123 unsigned int hp_detect: 1;
124 unsigned int gpio_mute: 1;
126 unsigned int gpio_mask, gpio_data;
127 unsigned char aloopback_mask;
128 unsigned char aloopback_shift;
131 struct hda_multi_out multiout;
132 hda_nid_t dac_nids[5];
136 unsigned int num_adcs;
138 unsigned int num_muxes;
139 hda_nid_t *dmic_nids;
140 unsigned int num_dmics;
141 hda_nid_t *dmux_nids;
142 unsigned int num_dmuxes;
143 hda_nid_t dig_in_nid;
147 unsigned int num_pins;
148 unsigned int *pin_configs;
149 unsigned int *bios_pin_configs;
151 /* codec specific stuff */
152 struct hda_verb *init;
153 struct snd_kcontrol_new *mixer;
156 struct hda_input_mux *dinput_mux;
157 unsigned int cur_dmux[2];
158 struct hda_input_mux *input_mux;
159 unsigned int cur_mux[3];
162 unsigned int io_switch[2];
163 unsigned int clfe_swap;
164 unsigned int aloopback;
166 struct hda_pcm pcm_rec[2]; /* PCM information */
168 /* dynamic controls and input_mux */
169 struct auto_pin_cfg autocfg;
170 unsigned int num_kctl_alloc, num_kctl_used;
171 struct snd_kcontrol_new *kctl_alloc;
172 struct hda_input_mux private_dimux;
173 struct hda_input_mux private_imux;
176 static hda_nid_t stac9200_adc_nids[1] = {
180 static hda_nid_t stac9200_mux_nids[1] = {
184 static hda_nid_t stac9200_dac_nids[1] = {
188 static hda_nid_t stac92hd73xx_adc_nids[2] = {
192 #define STAC92HD73XX_NUM_DMICS 2
193 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
197 #define STAC92HD73_DAC_COUNT 5
198 static hda_nid_t stac92hd73xx_dac_nids[STAC92HD73_DAC_COUNT] = {
199 0x15, 0x16, 0x17, 0x18, 0x19,
202 static hda_nid_t stac92hd73xx_mux_nids[4] = {
203 0x28, 0x29, 0x2a, 0x2b,
206 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
210 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
214 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
218 static hda_nid_t stac92hd71bxx_dmux_nids[1] = {
222 static hda_nid_t stac92hd71bxx_dac_nids[2] = {
226 #define STAC92HD71BXX_NUM_DMICS 2
227 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
231 static hda_nid_t stac925x_adc_nids[1] = {
235 static hda_nid_t stac925x_mux_nids[1] = {
239 static hda_nid_t stac925x_dac_nids[1] = {
243 #define STAC925X_NUM_DMICS 1
244 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
248 static hda_nid_t stac925x_dmux_nids[1] = {
252 static hda_nid_t stac922x_adc_nids[2] = {
256 static hda_nid_t stac922x_mux_nids[2] = {
260 static hda_nid_t stac927x_adc_nids[3] = {
264 static hda_nid_t stac927x_mux_nids[3] = {
268 static hda_nid_t stac927x_dmux_nids[1] = {
272 #define STAC927X_NUM_DMICS 2
273 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
277 static hda_nid_t stac9205_adc_nids[2] = {
281 static hda_nid_t stac9205_mux_nids[2] = {
285 static hda_nid_t stac9205_dmux_nids[1] = {
289 #define STAC9205_NUM_DMICS 2
290 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
294 static hda_nid_t stac9200_pin_nids[8] = {
295 0x08, 0x09, 0x0d, 0x0e,
296 0x0f, 0x10, 0x11, 0x12,
299 static hda_nid_t stac925x_pin_nids[8] = {
300 0x07, 0x08, 0x0a, 0x0b,
301 0x0c, 0x0d, 0x10, 0x11,
304 static hda_nid_t stac922x_pin_nids[10] = {
305 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
306 0x0f, 0x10, 0x11, 0x15, 0x1b,
309 static hda_nid_t stac92hd73xx_pin_nids[12] = {
310 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x10, 0x11, 0x12, 0x13,
315 static hda_nid_t stac92hd71bxx_pin_nids[10] = {
316 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
317 0x0f, 0x14, 0x18, 0x19, 0x1e,
320 static hda_nid_t stac927x_pin_nids[14] = {
321 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
322 0x0f, 0x10, 0x11, 0x12, 0x13,
323 0x14, 0x21, 0x22, 0x23,
326 static hda_nid_t stac9205_pin_nids[12] = {
327 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
328 0x0f, 0x14, 0x16, 0x17, 0x18,
332 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
333 struct snd_ctl_elem_info *uinfo)
335 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
336 struct sigmatel_spec *spec = codec->spec;
337 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
340 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
341 struct snd_ctl_elem_value *ucontrol)
343 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
344 struct sigmatel_spec *spec = codec->spec;
345 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
347 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
351 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
352 struct snd_ctl_elem_value *ucontrol)
354 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
355 struct sigmatel_spec *spec = codec->spec;
356 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
358 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
359 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
362 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
364 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
365 struct sigmatel_spec *spec = codec->spec;
366 return snd_hda_input_mux_info(spec->input_mux, uinfo);
369 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
371 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
372 struct sigmatel_spec *spec = codec->spec;
373 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
375 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
379 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
381 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
382 struct sigmatel_spec *spec = codec->spec;
383 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
385 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
386 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
389 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
391 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
392 struct snd_ctl_elem_value *ucontrol)
394 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
395 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
396 struct sigmatel_spec *spec = codec->spec;
398 ucontrol->value.integer.value[0] = !!(spec->aloopback &
399 (spec->aloopback_mask << idx));
403 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
404 struct snd_ctl_elem_value *ucontrol)
406 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
407 struct sigmatel_spec *spec = codec->spec;
408 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
409 unsigned int dac_mode;
410 unsigned int val, idx_val;
412 idx_val = spec->aloopback_mask << idx;
413 if (ucontrol->value.integer.value[0])
414 val = spec->aloopback | idx_val;
416 val = spec->aloopback & ~idx_val;
417 if (spec->aloopback == val)
420 spec->aloopback = val;
422 /* Only return the bits defined by the shift value of the
423 * first two bytes of the mask
425 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
426 kcontrol->private_value & 0xFFFF, 0x0);
427 dac_mode >>= spec->aloopback_shift;
429 if (spec->aloopback & idx_val) {
430 snd_hda_power_up(codec);
433 snd_hda_power_down(codec);
434 dac_mode &= ~idx_val;
437 snd_hda_codec_write_cache(codec, codec->afg, 0,
438 kcontrol->private_value >> 16, dac_mode);
443 static struct hda_verb stac9200_core_init[] = {
444 /* set dac0mux for dac converter */
445 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
449 static struct hda_verb stac9200_eapd_init[] = {
450 /* set dac0mux for dac converter */
451 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
452 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
456 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
457 /* set master volume and direct control */
458 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
459 /* setup audio connections */
460 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
461 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
462 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
463 /* setup adcs to point to mixer */
464 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
465 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
466 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
467 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
468 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
469 /* setup import muxs */
470 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
471 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
472 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
473 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
477 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
478 /* set master volume and direct control */
479 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
480 /* setup audio connections */
481 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
482 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
483 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
484 /* connect hp ports to dac3 */
485 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x03},
486 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x03},
487 /* setup adcs to point to mixer */
488 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
489 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
490 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
491 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
492 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
493 /* setup import muxs */
494 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
495 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
496 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
497 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
501 static struct hda_verb stac92hd73xx_10ch_core_init[] = {
502 /* set master volume and direct control */
503 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
504 /* setup audio connections */
505 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
506 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01 },
507 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02 },
508 /* dac3 is connected to import3 mux */
509 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
510 /* connect hp ports to dac4 */
511 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x04},
512 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x04},
513 /* setup adcs to point to mixer */
514 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
515 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
516 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
517 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
518 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
519 /* setup import muxs */
520 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
521 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
522 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
523 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
527 static struct hda_verb stac92hd71bxx_core_init[] = {
528 /* set master volume and direct control */
529 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
530 /* connect headphone jack to dac1 */
531 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
532 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */
533 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
534 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
535 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
536 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
537 /* unmute mono out node */
538 { 0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
541 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
542 /* set master volume and direct control */
543 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
544 /* connect headphone jack to dac1 */
545 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
546 /* connect ports 0d and 0f to audio mixer */
547 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x2},
548 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
549 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
550 /* unmute dac0 input in audio mixer */
551 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
552 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
553 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
554 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
555 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
556 /* unmute mono out node */
557 { 0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
561 static struct hda_verb stac925x_core_init[] = {
562 /* set dac0mux for dac converter */
563 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
567 static struct hda_verb stac922x_core_init[] = {
568 /* set master volume and direct control */
569 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
573 static struct hda_verb d965_core_init[] = {
574 /* set master volume and direct control */
575 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
576 /* unmute node 0x1b */
577 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
578 /* select node 0x03 as DAC */
579 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
583 static struct hda_verb stac927x_core_init[] = {
584 /* set master volume and direct control */
585 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
589 static struct hda_verb stac9205_core_init[] = {
590 /* set master volume and direct control */
591 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
595 #define STAC_INPUT_SOURCE(cnt) \
597 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
598 .name = "Input Source", \
600 .info = stac92xx_mux_enum_info, \
601 .get = stac92xx_mux_enum_get, \
602 .put = stac92xx_mux_enum_put, \
605 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
607 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
608 .name = "Analog Loopback", \
610 .info = stac92xx_aloopback_info, \
611 .get = stac92xx_aloopback_get, \
612 .put = stac92xx_aloopback_put, \
613 .private_value = verb_read | (verb_write << 16), \
616 static struct snd_kcontrol_new stac9200_mixer[] = {
617 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
618 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
619 STAC_INPUT_SOURCE(1),
620 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
621 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
622 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT),
626 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
627 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
629 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
630 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
632 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
633 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
635 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
636 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
638 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
639 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
641 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
642 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
644 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
645 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
647 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
648 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
652 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
653 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
655 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
656 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
658 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
659 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
661 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
662 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
664 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
665 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
667 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
668 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
670 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
671 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
673 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
674 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
678 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
679 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
681 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
682 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
684 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
685 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
687 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
688 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
690 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
691 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
693 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
694 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
696 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
697 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
699 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
700 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
704 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
705 STAC_INPUT_SOURCE(2),
707 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
708 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
709 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
711 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
712 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
713 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
715 HDA_CODEC_MUTE("Analog Loopback 1", 0x17, 0x3, HDA_INPUT),
716 HDA_CODEC_MUTE("Analog Loopback 2", 0x17, 0x4, HDA_INPUT),
720 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
721 STAC_INPUT_SOURCE(2),
722 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
724 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
725 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
726 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
728 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
729 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
730 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
734 static struct snd_kcontrol_new stac925x_mixer[] = {
735 STAC_INPUT_SOURCE(1),
736 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
737 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_OUTPUT),
738 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT),
742 static struct snd_kcontrol_new stac9205_mixer[] = {
743 STAC_INPUT_SOURCE(2),
744 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
746 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
747 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
748 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT),
750 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
751 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
752 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT),
757 /* This needs to be generated dynamically based on sequence */
758 static struct snd_kcontrol_new stac922x_mixer[] = {
759 STAC_INPUT_SOURCE(2),
760 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
761 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
762 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT),
764 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
765 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
766 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT),
771 static struct snd_kcontrol_new stac927x_mixer[] = {
772 STAC_INPUT_SOURCE(3),
773 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
775 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
776 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
777 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT),
779 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
780 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
781 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT),
783 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
784 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
785 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT),
789 static struct snd_kcontrol_new stac_dmux_mixer = {
790 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
791 .name = "Digital Input Source",
792 /* count set later */
793 .info = stac92xx_dmux_enum_info,
794 .get = stac92xx_dmux_enum_get,
795 .put = stac92xx_dmux_enum_put,
798 static int stac92xx_build_controls(struct hda_codec *codec)
800 struct sigmatel_spec *spec = codec->spec;
804 err = snd_hda_add_new_ctls(codec, spec->mixer);
808 for (i = 0; i < spec->num_mixers; i++) {
809 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
813 if (spec->num_dmuxes > 0) {
814 stac_dmux_mixer.count = spec->num_dmuxes;
815 err = snd_ctl_add(codec->bus->card,
816 snd_ctl_new1(&stac_dmux_mixer, codec));
821 if (spec->multiout.dig_out_nid) {
822 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
826 if (spec->dig_in_nid) {
827 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
834 static unsigned int ref9200_pin_configs[8] = {
835 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
836 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
840 STAC 9200 pin configs for
845 static unsigned int dell9200_d21_pin_configs[8] = {
846 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
847 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
851 STAC 9200 pin configs for
855 static unsigned int dell9200_d22_pin_configs[8] = {
856 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
857 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
861 STAC 9200 pin configs for
862 102801C4 (Dell Dimension E310)
869 static unsigned int dell9200_d23_pin_configs[8] = {
870 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
871 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
876 STAC 9200-32 pin configs for
877 102801B5 (Dell Inspiron 630m)
878 102801D8 (Dell Inspiron 640m)
880 static unsigned int dell9200_m21_pin_configs[8] = {
881 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
882 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
886 STAC 9200-32 pin configs for
887 102801C2 (Dell Latitude D620)
889 102801CC (Dell Latitude D820)
893 static unsigned int dell9200_m22_pin_configs[8] = {
894 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
895 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
899 STAC 9200-32 pin configs for
900 102801CE (Dell XPS M1710)
901 102801CF (Dell Precision M90)
903 static unsigned int dell9200_m23_pin_configs[8] = {
904 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
905 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
909 STAC 9200-32 pin configs for
912 102801CB (Dell Latitude 120L)
915 static unsigned int dell9200_m24_pin_configs[8] = {
916 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
917 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
921 STAC 9200-32 pin configs for
922 102801BD (Dell Inspiron E1505n)
926 static unsigned int dell9200_m25_pin_configs[8] = {
927 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
928 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
932 STAC 9200-32 pin configs for
933 102801F5 (Dell Inspiron 1501)
936 static unsigned int dell9200_m26_pin_configs[8] = {
937 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
938 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
943 102801CD (Dell Inspiron E1705/9400)
945 static unsigned int dell9200_m27_pin_configs[8] = {
946 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
947 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
951 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
952 [STAC_REF] = ref9200_pin_configs,
953 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
954 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
955 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
956 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
957 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
958 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
959 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
960 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
961 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
962 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
965 static const char *stac9200_models[STAC_9200_MODELS] = {
967 [STAC_9200_DELL_D21] = "dell-d21",
968 [STAC_9200_DELL_D22] = "dell-d22",
969 [STAC_9200_DELL_D23] = "dell-d23",
970 [STAC_9200_DELL_M21] = "dell-m21",
971 [STAC_9200_DELL_M22] = "dell-m22",
972 [STAC_9200_DELL_M23] = "dell-m23",
973 [STAC_9200_DELL_M24] = "dell-m24",
974 [STAC_9200_DELL_M25] = "dell-m25",
975 [STAC_9200_DELL_M26] = "dell-m26",
976 [STAC_9200_DELL_M27] = "dell-m27",
977 [STAC_9200_GATEWAY] = "gateway",
980 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
981 /* SigmaTel reference board */
982 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
983 "DFI LanParty", STAC_REF),
984 /* Dell laptops have BIOS problem */
985 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
986 "unknown Dell", STAC_9200_DELL_D21),
987 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
988 "Dell Inspiron 630m", STAC_9200_DELL_M21),
989 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
990 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
991 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
992 "unknown Dell", STAC_9200_DELL_D22),
993 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
994 "unknown Dell", STAC_9200_DELL_D22),
995 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
996 "Dell Latitude D620", STAC_9200_DELL_M22),
997 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
998 "unknown Dell", STAC_9200_DELL_D23),
999 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1000 "unknown Dell", STAC_9200_DELL_D23),
1001 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1002 "unknown Dell", STAC_9200_DELL_M22),
1003 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1004 "unknown Dell", STAC_9200_DELL_M24),
1005 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1006 "unknown Dell", STAC_9200_DELL_M24),
1007 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1008 "Dell Latitude 120L", STAC_9200_DELL_M24),
1009 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1010 "Dell Latitude D820", STAC_9200_DELL_M22),
1011 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1012 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1013 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1014 "Dell XPS M1710", STAC_9200_DELL_M23),
1015 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1016 "Dell Precision M90", STAC_9200_DELL_M23),
1017 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1018 "unknown Dell", STAC_9200_DELL_M22),
1019 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1020 "unknown Dell", STAC_9200_DELL_M22),
1021 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1022 "unknown Dell", STAC_9200_DELL_M22),
1023 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1024 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1025 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1026 "unknown Dell", STAC_9200_DELL_D23),
1027 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1028 "unknown Dell", STAC_9200_DELL_D23),
1029 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1030 "unknown Dell", STAC_9200_DELL_D21),
1031 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1032 "unknown Dell", STAC_9200_DELL_D23),
1033 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1034 "unknown Dell", STAC_9200_DELL_D21),
1035 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1036 "unknown Dell", STAC_9200_DELL_M25),
1037 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1038 "unknown Dell", STAC_9200_DELL_M25),
1039 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1040 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1041 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1042 "unknown Dell", STAC_9200_DELL_M26),
1044 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_REF),
1045 /* Gateway machines needs EAPD to be set on resume */
1046 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
1047 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
1049 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
1054 static unsigned int ref925x_pin_configs[8] = {
1055 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1056 0x90a70320, 0x02214210, 0x400003f1, 0x9033032e,
1059 static unsigned int stac925x_MA6_pin_configs[8] = {
1060 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1061 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
1064 static unsigned int stac925x_PA6_pin_configs[8] = {
1065 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1066 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
1069 static unsigned int stac925xM2_2_pin_configs[8] = {
1070 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
1071 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
1074 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1075 [STAC_REF] = ref925x_pin_configs,
1076 [STAC_M2_2] = stac925xM2_2_pin_configs,
1077 [STAC_MA6] = stac925x_MA6_pin_configs,
1078 [STAC_PA6] = stac925x_PA6_pin_configs,
1081 static const char *stac925x_models[STAC_925x_MODELS] = {
1083 [STAC_M2_2] = "m2-2",
1088 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1089 /* SigmaTel reference board */
1090 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1091 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1092 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
1093 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
1094 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
1095 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
1096 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
1100 static unsigned int ref92hd73xx_pin_configs[12] = {
1101 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1102 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1103 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1106 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1107 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1110 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1111 [STAC_92HD73XX_REF] = "ref",
1114 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1115 /* SigmaTel reference board */
1116 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1117 "DFI LanParty", STAC_92HD73XX_REF),
1121 static unsigned int ref92hd71bxx_pin_configs[10] = {
1122 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1123 0x0181302e, 0x01114010, 0x01a19020, 0x90a000f0,
1124 0x90a000f0, 0x01452050,
1127 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1128 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1131 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1132 [STAC_92HD71BXX_REF] = "ref",
1135 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1136 /* SigmaTel reference board */
1137 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1138 "DFI LanParty", STAC_92HD71BXX_REF),
1142 static unsigned int ref922x_pin_configs[10] = {
1143 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1144 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1145 0x40000100, 0x40000100,
1149 STAC 922X pin configs for
1156 static unsigned int dell_922x_d81_pin_configs[10] = {
1157 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1158 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1159 0x01813122, 0x400001f2,
1163 STAC 922X pin configs for
1167 static unsigned int dell_922x_d82_pin_configs[10] = {
1168 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1169 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1170 0x01813122, 0x400001f1,
1174 STAC 922X pin configs for
1177 static unsigned int dell_922x_m81_pin_configs[10] = {
1178 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1179 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1180 0x40C003f1, 0x405003f0,
1184 STAC 9221 A1 pin configs for
1185 102801D7 (Dell XPS M1210)
1187 static unsigned int dell_922x_m82_pin_configs[10] = {
1188 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1189 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1190 0x508003f3, 0x405003f4,
1193 static unsigned int d945gtp3_pin_configs[10] = {
1194 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1195 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1196 0x02a19120, 0x40000100,
1199 static unsigned int d945gtp5_pin_configs[10] = {
1200 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1201 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1202 0x02a19320, 0x40000100,
1205 static unsigned int intel_mac_v1_pin_configs[10] = {
1206 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1207 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1208 0x400000fc, 0x400000fb,
1211 static unsigned int intel_mac_v2_pin_configs[10] = {
1212 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1213 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1214 0x400000fc, 0x400000fb,
1217 static unsigned int intel_mac_v3_pin_configs[10] = {
1218 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1219 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1220 0x400000fc, 0x400000fb,
1223 static unsigned int intel_mac_v4_pin_configs[10] = {
1224 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1225 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1226 0x400000fc, 0x400000fb,
1229 static unsigned int intel_mac_v5_pin_configs[10] = {
1230 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1231 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1232 0x400000fc, 0x400000fb,
1236 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1237 [STAC_D945_REF] = ref922x_pin_configs,
1238 [STAC_D945GTP3] = d945gtp3_pin_configs,
1239 [STAC_D945GTP5] = d945gtp5_pin_configs,
1240 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1241 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1242 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1243 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1244 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1245 /* for backward compatibility */
1246 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1247 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1248 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1249 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1250 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1251 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1252 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1253 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1254 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1255 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1258 static const char *stac922x_models[STAC_922X_MODELS] = {
1259 [STAC_D945_REF] = "ref",
1260 [STAC_D945GTP5] = "5stack",
1261 [STAC_D945GTP3] = "3stack",
1262 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1263 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1264 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1265 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1266 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1267 /* for backward compatibility */
1268 [STAC_MACMINI] = "macmini",
1269 [STAC_MACBOOK] = "macbook",
1270 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1271 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1272 [STAC_IMAC_INTEL] = "imac-intel",
1273 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1274 [STAC_922X_DELL_D81] = "dell-d81",
1275 [STAC_922X_DELL_D82] = "dell-d82",
1276 [STAC_922X_DELL_M81] = "dell-m81",
1277 [STAC_922X_DELL_M82] = "dell-m82",
1280 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1281 /* SigmaTel reference board */
1282 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1283 "DFI LanParty", STAC_D945_REF),
1284 /* Intel 945G based systems */
1285 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1286 "Intel D945G", STAC_D945GTP3),
1287 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1288 "Intel D945G", STAC_D945GTP3),
1289 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1290 "Intel D945G", STAC_D945GTP3),
1291 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1292 "Intel D945G", STAC_D945GTP3),
1293 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1294 "Intel D945G", STAC_D945GTP3),
1295 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1296 "Intel D945G", STAC_D945GTP3),
1297 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1298 "Intel D945G", STAC_D945GTP3),
1299 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1300 "Intel D945G", STAC_D945GTP3),
1301 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1302 "Intel D945G", STAC_D945GTP3),
1303 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1304 "Intel D945G", STAC_D945GTP3),
1305 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1306 "Intel D945G", STAC_D945GTP3),
1307 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1308 "Intel D945G", STAC_D945GTP3),
1309 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1310 "Intel D945G", STAC_D945GTP3),
1311 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1312 "Intel D945G", STAC_D945GTP3),
1313 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1314 "Intel D945G", STAC_D945GTP3),
1315 /* Intel D945G 5-stack systems */
1316 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1317 "Intel D945G", STAC_D945GTP5),
1318 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1319 "Intel D945G", STAC_D945GTP5),
1320 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1321 "Intel D945G", STAC_D945GTP5),
1322 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1323 "Intel D945G", STAC_D945GTP5),
1324 /* Intel 945P based systems */
1325 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1326 "Intel D945P", STAC_D945GTP3),
1327 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1328 "Intel D945P", STAC_D945GTP3),
1329 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1330 "Intel D945P", STAC_D945GTP3),
1331 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1332 "Intel D945P", STAC_D945GTP3),
1333 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1334 "Intel D945P", STAC_D945GTP3),
1335 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1336 "Intel D945P", STAC_D945GTP5),
1338 /* Apple Mac Mini (early 2006) */
1339 SND_PCI_QUIRK(0x8384, 0x7680,
1340 "Mac Mini", STAC_INTEL_MAC_V3),
1342 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1343 "unknown Dell", STAC_922X_DELL_D81),
1344 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1345 "unknown Dell", STAC_922X_DELL_D81),
1346 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1347 "unknown Dell", STAC_922X_DELL_D81),
1348 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1349 "unknown Dell", STAC_922X_DELL_D82),
1350 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1351 "unknown Dell", STAC_922X_DELL_M81),
1352 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1353 "unknown Dell", STAC_922X_DELL_D82),
1354 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1355 "unknown Dell", STAC_922X_DELL_D81),
1356 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1357 "unknown Dell", STAC_922X_DELL_D81),
1358 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1359 "Dell XPS M1210", STAC_922X_DELL_M82),
1363 static unsigned int ref927x_pin_configs[14] = {
1364 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1365 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1366 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1367 0x01c42190, 0x40000100,
1370 static unsigned int d965_3st_pin_configs[14] = {
1371 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
1372 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
1373 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1374 0x40000100, 0x40000100
1377 static unsigned int d965_5st_pin_configs[14] = {
1378 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1379 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
1380 0x40000100, 0x40000100, 0x40000100, 0x01442070,
1381 0x40000100, 0x40000100
1384 static unsigned int dell_3st_pin_configs[14] = {
1385 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
1386 0x01111212, 0x01116211, 0x01813050, 0x01112214,
1387 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
1388 0x40c003fc, 0x40000100
1391 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
1392 [STAC_D965_REF] = ref927x_pin_configs,
1393 [STAC_D965_3ST] = d965_3st_pin_configs,
1394 [STAC_D965_5ST] = d965_5st_pin_configs,
1395 [STAC_DELL_3ST] = dell_3st_pin_configs,
1396 [STAC_DELL_BIOS] = NULL,
1399 static const char *stac927x_models[STAC_927X_MODELS] = {
1400 [STAC_D965_REF] = "ref",
1401 [STAC_D965_3ST] = "3stack",
1402 [STAC_D965_5ST] = "5stack",
1403 [STAC_DELL_3ST] = "dell-3stack",
1404 [STAC_DELL_BIOS] = "dell-bios",
1407 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
1408 /* SigmaTel reference board */
1409 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1410 "DFI LanParty", STAC_D965_REF),
1411 /* Intel 946 based systems */
1412 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
1413 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
1414 /* 965 based 3 stack systems */
1415 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
1416 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
1417 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
1418 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
1419 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
1420 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
1421 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
1422 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
1423 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
1424 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
1425 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
1426 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
1427 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
1428 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
1429 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
1430 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
1431 /* Dell 3 stack systems */
1432 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_3ST),
1433 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
1434 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
1435 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
1436 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
1437 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_3ST),
1438 /* Dell 3 stack systems with verb table in BIOS */
1439 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell ", STAC_DELL_BIOS),
1440 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
1441 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
1442 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
1443 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
1444 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
1445 /* 965 based 5 stack systems */
1446 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
1447 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
1448 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
1449 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
1450 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
1451 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
1452 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
1453 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
1454 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
1458 static unsigned int ref9205_pin_configs[12] = {
1459 0x40000100, 0x40000100, 0x01016011, 0x01014010,
1460 0x01813122, 0x01a19021, 0x40000100, 0x40000100,
1461 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
1465 STAC 9205 pin configs for
1473 static unsigned int dell_9205_m42_pin_configs[12] = {
1474 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
1475 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
1476 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
1480 STAC 9205 pin configs for
1484 102801FF (Dell Precision M4300)
1489 static unsigned int dell_9205_m43_pin_configs[12] = {
1490 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
1491 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
1492 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
1495 static unsigned int dell_9205_m44_pin_configs[12] = {
1496 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
1497 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
1498 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
1501 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
1502 [STAC_9205_REF] = ref9205_pin_configs,
1503 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
1504 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
1505 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
1508 static const char *stac9205_models[STAC_9205_MODELS] = {
1509 [STAC_9205_REF] = "ref",
1510 [STAC_9205_DELL_M42] = "dell-m42",
1511 [STAC_9205_DELL_M43] = "dell-m43",
1512 [STAC_9205_DELL_M44] = "dell-m44",
1515 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
1516 /* SigmaTel reference board */
1517 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1518 "DFI LanParty", STAC_9205_REF),
1519 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1520 "unknown Dell", STAC_9205_DELL_M42),
1521 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1522 "unknown Dell", STAC_9205_DELL_M42),
1523 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
1524 "Dell Precision", STAC_9205_DELL_M43),
1525 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
1526 "Dell Precision", STAC_9205_DELL_M43),
1527 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
1528 "Dell Precision", STAC_9205_DELL_M43),
1529 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
1530 "Dell Precision", STAC_9205_DELL_M43),
1531 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
1532 "Dell Precision", STAC_9205_DELL_M43),
1533 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1534 "unknown Dell", STAC_9205_DELL_M42),
1535 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1536 "unknown Dell", STAC_9205_DELL_M42),
1537 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
1538 "Dell Precision", STAC_9205_DELL_M43),
1539 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
1540 "Dell Precision M4300", STAC_9205_DELL_M43),
1541 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
1542 "Dell Precision", STAC_9205_DELL_M43),
1543 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1544 "Dell Inspiron", STAC_9205_DELL_M44),
1545 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1546 "Dell Inspiron", STAC_9205_DELL_M44),
1547 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1548 "Dell Inspiron", STAC_9205_DELL_M44),
1549 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1550 "Dell Inspiron", STAC_9205_DELL_M44),
1551 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
1552 "unknown Dell", STAC_9205_DELL_M42),
1553 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
1554 "Dell Inspiron", STAC_9205_DELL_M44),
1558 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
1561 struct sigmatel_spec *spec = codec->spec;
1563 if (! spec->bios_pin_configs) {
1564 spec->bios_pin_configs = kcalloc(spec->num_pins,
1565 sizeof(*spec->bios_pin_configs), GFP_KERNEL);
1566 if (! spec->bios_pin_configs)
1570 for (i = 0; i < spec->num_pins; i++) {
1571 hda_nid_t nid = spec->pin_nids[i];
1572 unsigned int pin_cfg;
1574 pin_cfg = snd_hda_codec_read(codec, nid, 0,
1575 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
1576 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
1578 spec->bios_pin_configs[i] = pin_cfg;
1584 static void stac92xx_set_config_reg(struct hda_codec *codec,
1585 hda_nid_t pin_nid, unsigned int pin_config)
1588 snd_hda_codec_write(codec, pin_nid, 0,
1589 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
1590 pin_config & 0x000000ff);
1591 snd_hda_codec_write(codec, pin_nid, 0,
1592 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
1593 (pin_config & 0x0000ff00) >> 8);
1594 snd_hda_codec_write(codec, pin_nid, 0,
1595 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
1596 (pin_config & 0x00ff0000) >> 16);
1597 snd_hda_codec_write(codec, pin_nid, 0,
1598 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
1600 i = snd_hda_codec_read(codec, pin_nid, 0,
1601 AC_VERB_GET_CONFIG_DEFAULT,
1603 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
1607 static void stac92xx_set_config_regs(struct hda_codec *codec)
1610 struct sigmatel_spec *spec = codec->spec;
1612 if (!spec->pin_configs)
1615 for (i = 0; i < spec->num_pins; i++)
1616 stac92xx_set_config_reg(codec, spec->pin_nids[i],
1617 spec->pin_configs[i]);
1620 static void stac92xx_enable_gpio_mask(struct hda_codec *codec)
1622 struct sigmatel_spec *spec = codec->spec;
1623 /* Configure GPIOx as output */
1624 snd_hda_codec_write_cache(codec, codec->afg, 0,
1625 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_mask);
1626 /* Configure GPIOx as CMOS */
1627 snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7e7, 0x00000000);
1629 snd_hda_codec_write_cache(codec, codec->afg, 0,
1630 AC_VERB_SET_GPIO_DATA, spec->gpio_data);
1632 snd_hda_codec_write_cache(codec, codec->afg, 0,
1633 AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
1637 * Analog playback callbacks
1639 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
1640 struct hda_codec *codec,
1641 struct snd_pcm_substream *substream)
1643 struct sigmatel_spec *spec = codec->spec;
1644 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
1647 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1648 struct hda_codec *codec,
1649 unsigned int stream_tag,
1650 unsigned int format,
1651 struct snd_pcm_substream *substream)
1653 struct sigmatel_spec *spec = codec->spec;
1654 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
1657 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1658 struct hda_codec *codec,
1659 struct snd_pcm_substream *substream)
1661 struct sigmatel_spec *spec = codec->spec;
1662 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1666 * Digital playback callbacks
1668 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1669 struct hda_codec *codec,
1670 struct snd_pcm_substream *substream)
1672 struct sigmatel_spec *spec = codec->spec;
1673 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1676 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1677 struct hda_codec *codec,
1678 struct snd_pcm_substream *substream)
1680 struct sigmatel_spec *spec = codec->spec;
1681 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1684 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1685 struct hda_codec *codec,
1686 unsigned int stream_tag,
1687 unsigned int format,
1688 struct snd_pcm_substream *substream)
1690 struct sigmatel_spec *spec = codec->spec;
1691 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1692 stream_tag, format, substream);
1697 * Analog capture callbacks
1699 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1700 struct hda_codec *codec,
1701 unsigned int stream_tag,
1702 unsigned int format,
1703 struct snd_pcm_substream *substream)
1705 struct sigmatel_spec *spec = codec->spec;
1707 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1708 stream_tag, 0, format);
1712 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1713 struct hda_codec *codec,
1714 struct snd_pcm_substream *substream)
1716 struct sigmatel_spec *spec = codec->spec;
1718 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
1722 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
1726 /* NID is set in stac92xx_build_pcms */
1728 .open = stac92xx_dig_playback_pcm_open,
1729 .close = stac92xx_dig_playback_pcm_close,
1730 .prepare = stac92xx_dig_playback_pcm_prepare
1734 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
1738 /* NID is set in stac92xx_build_pcms */
1741 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
1745 .nid = 0x02, /* NID to query formats and rates */
1747 .open = stac92xx_playback_pcm_open,
1748 .prepare = stac92xx_playback_pcm_prepare,
1749 .cleanup = stac92xx_playback_pcm_cleanup
1753 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
1757 .nid = 0x06, /* NID to query formats and rates */
1759 .open = stac92xx_playback_pcm_open,
1760 .prepare = stac92xx_playback_pcm_prepare,
1761 .cleanup = stac92xx_playback_pcm_cleanup
1765 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
1768 /* NID + .substreams is set in stac92xx_build_pcms */
1770 .prepare = stac92xx_capture_pcm_prepare,
1771 .cleanup = stac92xx_capture_pcm_cleanup
1775 static int stac92xx_build_pcms(struct hda_codec *codec)
1777 struct sigmatel_spec *spec = codec->spec;
1778 struct hda_pcm *info = spec->pcm_rec;
1780 codec->num_pcms = 1;
1781 codec->pcm_info = info;
1783 info->name = "STAC92xx Analog";
1784 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
1785 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
1786 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1787 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
1789 if (spec->alt_switch) {
1792 info->name = "STAC92xx Analog Alt";
1793 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
1796 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1799 info->name = "STAC92xx Digital";
1800 if (spec->multiout.dig_out_nid) {
1801 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
1802 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
1804 if (spec->dig_in_nid) {
1805 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
1806 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
1813 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
1815 unsigned int pincap = snd_hda_param_read(codec, nid,
1817 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
1818 if (pincap & AC_PINCAP_VREF_100)
1819 return AC_PINCTL_VREF_100;
1820 if (pincap & AC_PINCAP_VREF_80)
1821 return AC_PINCTL_VREF_80;
1822 if (pincap & AC_PINCAP_VREF_50)
1823 return AC_PINCTL_VREF_50;
1824 if (pincap & AC_PINCAP_VREF_GRD)
1825 return AC_PINCTL_VREF_GRD;
1829 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
1832 snd_hda_codec_write_cache(codec, nid, 0,
1833 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
1836 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
1838 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1840 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1841 struct sigmatel_spec *spec = codec->spec;
1842 int io_idx = kcontrol-> private_value & 0xff;
1844 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
1848 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1850 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1851 struct sigmatel_spec *spec = codec->spec;
1852 hda_nid_t nid = kcontrol->private_value >> 8;
1853 int io_idx = kcontrol-> private_value & 0xff;
1854 unsigned short val = !!ucontrol->value.integer.value[0];
1856 spec->io_switch[io_idx] = val;
1859 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
1861 unsigned int pinctl = AC_PINCTL_IN_EN;
1862 if (io_idx) /* set VREF for mic */
1863 pinctl |= stac92xx_get_vref(codec, nid);
1864 stac92xx_auto_set_pinctl(codec, nid, pinctl);
1867 /* check the auto-mute again: we need to mute/unmute the speaker
1868 * appropriately according to the pin direction
1870 if (spec->hp_detect)
1871 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
1876 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
1878 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
1879 struct snd_ctl_elem_value *ucontrol)
1881 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1882 struct sigmatel_spec *spec = codec->spec;
1884 ucontrol->value.integer.value[0] = spec->clfe_swap;
1888 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
1889 struct snd_ctl_elem_value *ucontrol)
1891 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1892 struct sigmatel_spec *spec = codec->spec;
1893 hda_nid_t nid = kcontrol->private_value & 0xff;
1894 unsigned int val = !!ucontrol->value.integer.value[0];
1896 if (spec->clfe_swap == val)
1899 spec->clfe_swap = val;
1901 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1902 spec->clfe_swap ? 0x4 : 0x0);
1907 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
1908 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1911 .info = stac92xx_io_switch_info, \
1912 .get = stac92xx_io_switch_get, \
1913 .put = stac92xx_io_switch_put, \
1914 .private_value = xpval, \
1917 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
1918 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1921 .info = stac92xx_clfe_switch_info, \
1922 .get = stac92xx_clfe_switch_get, \
1923 .put = stac92xx_clfe_switch_put, \
1924 .private_value = xpval, \
1928 STAC_CTL_WIDGET_VOL,
1929 STAC_CTL_WIDGET_MUTE,
1930 STAC_CTL_WIDGET_IO_SWITCH,
1931 STAC_CTL_WIDGET_CLFE_SWITCH
1934 static struct snd_kcontrol_new stac92xx_control_templates[] = {
1935 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
1936 HDA_CODEC_MUTE(NULL, 0, 0, 0),
1937 STAC_CODEC_IO_SWITCH(NULL, 0),
1938 STAC_CODEC_CLFE_SWITCH(NULL, 0),
1941 /* add dynamic controls */
1942 static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val)
1944 struct snd_kcontrol_new *knew;
1946 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
1947 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
1949 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
1952 if (spec->kctl_alloc) {
1953 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
1954 kfree(spec->kctl_alloc);
1956 spec->kctl_alloc = knew;
1957 spec->num_kctl_alloc = num;
1960 knew = &spec->kctl_alloc[spec->num_kctl_used];
1961 *knew = stac92xx_control_templates[type];
1962 knew->name = kstrdup(name, GFP_KERNEL);
1965 knew->private_value = val;
1966 spec->num_kctl_used++;
1970 /* flag inputs as additional dynamic lineouts */
1971 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
1973 struct sigmatel_spec *spec = codec->spec;
1974 unsigned int wcaps, wtype;
1975 int i, num_dacs = 0;
1977 /* use the wcaps cache to count all DACs available for line-outs */
1978 for (i = 0; i < codec->num_nodes; i++) {
1979 wcaps = codec->wcaps[i];
1980 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
1982 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
1986 snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
1988 switch (cfg->line_outs) {
1990 /* add line-in as side */
1991 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
1992 cfg->line_out_pins[cfg->line_outs] =
1993 cfg->input_pins[AUTO_PIN_LINE];
1994 spec->line_switch = 1;
1999 /* add line-in as clfe and mic as side */
2000 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
2001 cfg->line_out_pins[cfg->line_outs] =
2002 cfg->input_pins[AUTO_PIN_LINE];
2003 spec->line_switch = 1;
2006 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
2007 cfg->line_out_pins[cfg->line_outs] =
2008 cfg->input_pins[AUTO_PIN_MIC];
2009 spec->mic_switch = 1;
2014 /* add line-in as surr and mic as clfe */
2015 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
2016 cfg->line_out_pins[cfg->line_outs] =
2017 cfg->input_pins[AUTO_PIN_LINE];
2018 spec->line_switch = 1;
2021 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
2022 cfg->line_out_pins[cfg->line_outs] =
2023 cfg->input_pins[AUTO_PIN_MIC];
2024 spec->mic_switch = 1;
2034 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2038 for (i = 0; i < spec->multiout.num_dacs; i++) {
2039 if (spec->multiout.dac_nids[i] == nid)
2047 * Fill in the dac_nids table from the parsed pin configuration
2048 * This function only works when every pin in line_out_pins[]
2049 * contains atleast one DAC in its connection list. Some 92xx
2050 * codecs are not connected directly to a DAC, such as the 9200
2051 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2053 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
2054 struct auto_pin_cfg *cfg)
2056 struct sigmatel_spec *spec = codec->spec;
2057 int i, j, conn_len = 0;
2058 hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
2059 unsigned int wcaps, wtype;
2061 for (i = 0; i < cfg->line_outs; i++) {
2062 nid = cfg->line_out_pins[i];
2063 conn_len = snd_hda_get_connections(codec, nid, conn,
2064 HDA_MAX_CONNECTIONS);
2065 for (j = 0; j < conn_len; j++) {
2066 wcaps = snd_hda_param_read(codec, conn[j],
2067 AC_PAR_AUDIO_WIDGET_CAP);
2068 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2069 if (wtype != AC_WID_AUD_OUT ||
2070 (wcaps & AC_WCAP_DIGITAL))
2072 /* conn[j] is a DAC routed to this line-out */
2073 if (!is_in_dac_nids(spec, conn[j]))
2077 if (j == conn_len) {
2078 if (spec->multiout.num_dacs > 0) {
2079 /* we have already working output pins,
2080 * so let's drop the broken ones again
2082 cfg->line_outs = spec->multiout.num_dacs;
2085 /* error out, no available DAC found */
2087 "%s: No available DAC for pin 0x%x\n",
2092 spec->multiout.dac_nids[i] = conn[j];
2093 spec->multiout.num_dacs++;
2095 /* select this DAC in the pin's input mux */
2096 snd_hda_codec_write_cache(codec, nid, 0,
2097 AC_VERB_SET_CONNECT_SEL, j);
2102 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2103 spec->multiout.num_dacs,
2104 spec->multiout.dac_nids[0],
2105 spec->multiout.dac_nids[1],
2106 spec->multiout.dac_nids[2],
2107 spec->multiout.dac_nids[3],
2108 spec->multiout.dac_nids[4]);
2112 /* create volume control/switch for the given prefx type */
2113 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
2118 sprintf(name, "%s Playback Volume", pfx);
2119 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
2120 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2123 sprintf(name, "%s Playback Switch", pfx);
2124 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
2125 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2131 /* add playback controls from the parsed DAC table */
2132 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
2133 const struct auto_pin_cfg *cfg)
2135 static const char *chname[4] = {
2136 "Front", "Surround", NULL /*CLFE*/, "Side"
2141 struct sigmatel_spec *spec = codec->spec;
2142 unsigned int wid_caps;
2145 for (i = 0; i < cfg->line_outs; i++) {
2146 if (!spec->multiout.dac_nids[i])
2149 nid = spec->multiout.dac_nids[i];
2153 err = create_controls(spec, "Center", nid, 1);
2156 err = create_controls(spec, "LFE", nid, 2);
2160 wid_caps = get_wcaps(codec, nid);
2162 if (wid_caps & AC_WCAP_LR_SWAP) {
2163 err = stac92xx_add_control(spec,
2164 STAC_CTL_WIDGET_CLFE_SWITCH,
2165 "Swap Center/LFE Playback Switch", nid);
2172 err = create_controls(spec, chname[i], nid, 3);
2178 if (spec->line_switch)
2179 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Line In as Output Switch", cfg->input_pins[AUTO_PIN_LINE] << 8)) < 0)
2182 if (spec->mic_switch)
2183 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Mic as Output Switch", (cfg->input_pins[AUTO_PIN_MIC] << 8) | 1)) < 0)
2189 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2191 if (is_in_dac_nids(spec, nid))
2193 if (spec->multiout.hp_nid == nid)
2198 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
2200 if (!spec->multiout.hp_nid)
2201 spec->multiout.hp_nid = nid;
2202 else if (spec->multiout.num_dacs > 4) {
2203 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
2206 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
2207 spec->multiout.num_dacs++;
2212 /* add playback controls for Speaker and HP outputs */
2213 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
2214 struct auto_pin_cfg *cfg)
2216 struct sigmatel_spec *spec = codec->spec;
2218 int i, old_num_dacs, err;
2220 old_num_dacs = spec->multiout.num_dacs;
2221 for (i = 0; i < cfg->hp_outs; i++) {
2222 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
2223 if (wid_caps & AC_WCAP_UNSOL_CAP)
2224 spec->hp_detect = 1;
2225 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
2226 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2227 if (check_in_dac_nids(spec, nid))
2231 add_spec_dacs(spec, nid);
2233 for (i = 0; i < cfg->speaker_outs; i++) {
2234 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
2235 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2236 if (check_in_dac_nids(spec, nid))
2240 add_spec_dacs(spec, nid);
2242 for (i = 0; i < cfg->line_outs; i++) {
2243 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
2244 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2245 if (check_in_dac_nids(spec, nid))
2249 add_spec_dacs(spec, nid);
2251 for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
2252 static const char *pfxs[] = {
2253 "Speaker", "External Speaker", "Speaker2",
2255 err = create_controls(spec, pfxs[i - old_num_dacs],
2256 spec->multiout.dac_nids[i], 3);
2260 if (spec->multiout.hp_nid) {
2262 if (old_num_dacs == spec->multiout.num_dacs)
2266 err = create_controls(spec, pfx, spec->multiout.hp_nid, 3);
2274 /* labels for dmic mux inputs */
2275 static const char *stac92xx_dmic_labels[5] = {
2276 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
2277 "Digital Mic 3", "Digital Mic 4"
2280 /* create playback/capture controls for input pins on dmic capable codecs */
2281 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
2282 const struct auto_pin_cfg *cfg)
2284 struct sigmatel_spec *spec = codec->spec;
2285 struct hda_input_mux *dimux = &spec->private_dimux;
2286 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2290 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
2291 dimux->items[dimux->num_items].index = 0;
2294 for (i = 0; i < spec->num_dmics; i++) {
2299 unsigned int def_conf;
2301 def_conf = snd_hda_codec_read(codec,
2304 AC_VERB_GET_CONFIG_DEFAULT,
2306 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
2309 nid = spec->dmic_nids[i];
2310 num_cons = snd_hda_get_connections(codec,
2313 HDA_MAX_NUM_INPUTS);
2314 for (j = 0; j < num_cons; j++)
2315 if (con_lst[j] == nid) {
2321 wcaps = get_wcaps(codec, nid);
2323 if (wcaps & AC_WCAP_OUT_AMP) {
2324 sprintf(name, "%s Capture Volume",
2325 stac92xx_dmic_labels[dimux->num_items]);
2327 err = stac92xx_add_control(spec,
2328 STAC_CTL_WIDGET_VOL,
2330 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
2335 dimux->items[dimux->num_items].label =
2336 stac92xx_dmic_labels[dimux->num_items];
2337 dimux->items[dimux->num_items].index = index;
2344 /* create playback/capture controls for input pins */
2345 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
2347 struct sigmatel_spec *spec = codec->spec;
2348 struct hda_input_mux *imux = &spec->private_imux;
2349 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2352 for (i = 0; i < AUTO_PIN_LAST; i++) {
2355 if (!cfg->input_pins[i])
2358 for (j = 0; j < spec->num_muxes; j++) {
2360 num_cons = snd_hda_get_connections(codec,
2363 HDA_MAX_NUM_INPUTS);
2364 for (k = 0; k < num_cons; k++)
2365 if (con_lst[k] == cfg->input_pins[i]) {
2372 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2373 imux->items[imux->num_items].index = index;
2377 if (imux->num_items) {
2379 * Set the current input for the muxes.
2380 * The STAC9221 has two input muxes with identical source
2381 * NID lists. Hopefully this won't get confused.
2383 for (i = 0; i < spec->num_muxes; i++) {
2384 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
2385 AC_VERB_SET_CONNECT_SEL,
2386 imux->items[0].index);
2393 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
2395 struct sigmatel_spec *spec = codec->spec;
2398 for (i = 0; i < spec->autocfg.line_outs; i++) {
2399 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2400 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2404 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
2406 struct sigmatel_spec *spec = codec->spec;
2409 for (i = 0; i < spec->autocfg.hp_outs; i++) {
2411 pin = spec->autocfg.hp_pins[i];
2412 if (pin) /* connect to front */
2413 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
2415 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
2417 pin = spec->autocfg.speaker_pins[i];
2418 if (pin) /* connect to front */
2419 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
2423 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
2425 struct sigmatel_spec *spec = codec->spec;
2427 int hp_speaker_swap = 0;
2429 if ((err = snd_hda_parse_pin_def_config(codec,
2431 spec->dmic_nids)) < 0)
2433 if (! spec->autocfg.line_outs)
2434 return 0; /* can't find valid pin config */
2436 /* If we have no real line-out pin and multiple hp-outs, HPs should
2437 * be set up as multi-channel outputs.
2439 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
2440 spec->autocfg.hp_outs > 1) {
2441 /* Copy hp_outs to line_outs, backup line_outs in
2442 * speaker_outs so that the following routines can handle
2443 * HP pins as primary outputs.
2445 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
2446 sizeof(spec->autocfg.line_out_pins));
2447 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
2448 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
2449 sizeof(spec->autocfg.hp_pins));
2450 spec->autocfg.line_outs = spec->autocfg.hp_outs;
2451 hp_speaker_swap = 1;
2454 if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
2456 if (spec->multiout.num_dacs == 0)
2457 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2460 err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
2465 if (hp_speaker_swap == 1) {
2466 /* Restore the hp_outs and line_outs */
2467 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
2468 sizeof(spec->autocfg.line_out_pins));
2469 spec->autocfg.hp_outs = spec->autocfg.line_outs;
2470 memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins,
2471 sizeof(spec->autocfg.speaker_pins));
2472 spec->autocfg.line_outs = spec->autocfg.speaker_outs;
2473 memset(spec->autocfg.speaker_pins, 0,
2474 sizeof(spec->autocfg.speaker_pins));
2475 spec->autocfg.speaker_outs = 0;
2478 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
2483 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
2488 if (spec->num_dmics > 0)
2489 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
2490 &spec->autocfg)) < 0)
2493 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2494 if (spec->multiout.max_channels > 2)
2495 spec->surr_switch = 1;
2497 if (spec->autocfg.dig_out_pin)
2498 spec->multiout.dig_out_nid = dig_out;
2499 if (spec->autocfg.dig_in_pin)
2500 spec->dig_in_nid = dig_in;
2502 if (spec->kctl_alloc)
2503 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2505 spec->input_mux = &spec->private_imux;
2506 if (!spec->dinput_mux)
2507 spec->dinput_mux = &spec->private_dimux;
2512 /* add playback controls for HP output */
2513 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
2514 struct auto_pin_cfg *cfg)
2516 struct sigmatel_spec *spec = codec->spec;
2517 hda_nid_t pin = cfg->hp_pins[0];
2518 unsigned int wid_caps;
2523 wid_caps = get_wcaps(codec, pin);
2524 if (wid_caps & AC_WCAP_UNSOL_CAP)
2525 spec->hp_detect = 1;
2530 /* add playback controls for LFE output */
2531 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
2532 struct auto_pin_cfg *cfg)
2534 struct sigmatel_spec *spec = codec->spec;
2536 hda_nid_t lfe_pin = 0x0;
2540 * search speaker outs and line outs for a mono speaker pin
2541 * with an amp. If one is found, add LFE controls
2544 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
2545 hda_nid_t pin = spec->autocfg.speaker_pins[i];
2546 unsigned long wcaps = get_wcaps(codec, pin);
2547 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2548 if (wcaps == AC_WCAP_OUT_AMP)
2549 /* found a mono speaker with an amp, must be lfe */
2553 /* if speaker_outs is 0, then speakers may be in line_outs */
2554 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
2555 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
2556 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2558 cfg = snd_hda_codec_read(codec, pin, 0,
2559 AC_VERB_GET_CONFIG_DEFAULT,
2561 if (get_defcfg_device(cfg) == AC_JACK_SPEAKER) {
2562 unsigned long wcaps = get_wcaps(codec, pin);
2563 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2564 if (wcaps == AC_WCAP_OUT_AMP)
2565 /* found a mono speaker with an amp,
2573 err = create_controls(spec, "LFE", lfe_pin, 1);
2581 static int stac9200_parse_auto_config(struct hda_codec *codec)
2583 struct sigmatel_spec *spec = codec->spec;
2586 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2589 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
2592 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
2595 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
2598 if (spec->autocfg.dig_out_pin)
2599 spec->multiout.dig_out_nid = 0x05;
2600 if (spec->autocfg.dig_in_pin)
2601 spec->dig_in_nid = 0x04;
2603 if (spec->kctl_alloc)
2604 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2606 spec->input_mux = &spec->private_imux;
2607 spec->dinput_mux = &spec->private_dimux;
2613 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
2614 * funky external mute control using GPIO pins.
2617 static void stac922x_gpio_mute(struct hda_codec *codec, int pin, int muted)
2619 unsigned int gpiostate, gpiomask, gpiodir;
2621 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
2622 AC_VERB_GET_GPIO_DATA, 0);
2625 gpiostate |= (1 << pin);
2627 gpiostate &= ~(1 << pin);
2629 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
2630 AC_VERB_GET_GPIO_MASK, 0);
2631 gpiomask |= (1 << pin);
2633 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
2634 AC_VERB_GET_GPIO_DIRECTION, 0);
2635 gpiodir |= (1 << pin);
2637 /* AppleHDA seems to do this -- WTF is this verb?? */
2638 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
2640 snd_hda_codec_write(codec, codec->afg, 0,
2641 AC_VERB_SET_GPIO_MASK, gpiomask);
2642 snd_hda_codec_write(codec, codec->afg, 0,
2643 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
2647 snd_hda_codec_write(codec, codec->afg, 0,
2648 AC_VERB_SET_GPIO_DATA, gpiostate);
2651 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
2654 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
2655 snd_hda_codec_write_cache(codec, nid, 0,
2656 AC_VERB_SET_UNSOLICITED_ENABLE,
2657 (AC_USRSP_EN | event));
2660 static int stac92xx_init(struct hda_codec *codec)
2662 struct sigmatel_spec *spec = codec->spec;
2663 struct auto_pin_cfg *cfg = &spec->autocfg;
2666 snd_hda_sequence_write(codec, spec->init);
2669 if (spec->hp_detect) {
2670 /* Enable unsolicited responses on the HP widget */
2671 for (i = 0; i < cfg->hp_outs; i++)
2672 enable_pin_detect(codec, cfg->hp_pins[i],
2674 /* force to enable the first line-out; the others are set up
2677 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
2679 stac92xx_auto_init_hp_out(codec);
2680 /* fake event to set up pins */
2681 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2683 stac92xx_auto_init_multi_out(codec);
2684 stac92xx_auto_init_hp_out(codec);
2686 for (i = 0; i < AUTO_PIN_LAST; i++) {
2687 hda_nid_t nid = cfg->input_pins[i];
2689 unsigned int pinctl = AC_PINCTL_IN_EN;
2690 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
2691 pinctl |= stac92xx_get_vref(codec, nid);
2692 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2695 if (spec->num_dmics > 0)
2696 for (i = 0; i < spec->num_dmics; i++)
2697 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
2700 if (cfg->dig_out_pin)
2701 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
2703 if (cfg->dig_in_pin)
2704 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
2707 if (spec->gpio_mute) {
2708 stac922x_gpio_mute(codec, 0, 0);
2709 stac922x_gpio_mute(codec, 1, 0);
2715 static void stac92xx_free(struct hda_codec *codec)
2717 struct sigmatel_spec *spec = codec->spec;
2723 if (spec->kctl_alloc) {
2724 for (i = 0; i < spec->num_kctl_used; i++)
2725 kfree(spec->kctl_alloc[i].name);
2726 kfree(spec->kctl_alloc);
2729 if (spec->bios_pin_configs)
2730 kfree(spec->bios_pin_configs);
2735 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
2738 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2739 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2741 if (pin_ctl & AC_PINCTL_IN_EN) {
2743 * we need to check the current set-up direction of
2744 * shared input pins since they can be switched via
2745 * "xxx as Output" mixer switch
2747 struct sigmatel_spec *spec = codec->spec;
2748 struct auto_pin_cfg *cfg = &spec->autocfg;
2749 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
2750 spec->line_switch) ||
2751 (nid == cfg->input_pins[AUTO_PIN_MIC] &&
2756 /* if setting pin direction bits, clear the current
2757 direction bits first */
2758 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
2759 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
2761 snd_hda_codec_write_cache(codec, nid, 0,
2762 AC_VERB_SET_PIN_WIDGET_CONTROL,
2766 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
2769 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2770 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2771 snd_hda_codec_write_cache(codec, nid, 0,
2772 AC_VERB_SET_PIN_WIDGET_CONTROL,
2776 static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid)
2780 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
2782 unsigned int pinctl;
2783 pinctl = snd_hda_codec_read(codec, nid, 0,
2784 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2785 if (pinctl & AC_PINCTL_IN_EN)
2786 return 0; /* mic- or line-input */
2788 return 1; /* HP-output */
2793 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
2795 struct sigmatel_spec *spec = codec->spec;
2796 struct auto_pin_cfg *cfg = &spec->autocfg;
2800 for (i = 0; i < cfg->hp_outs; i++) {
2801 presence = get_hp_pin_presence(codec, cfg->hp_pins[i]);
2807 /* disable lineouts, enable hp */
2808 for (i = 0; i < cfg->line_outs; i++)
2809 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
2811 for (i = 0; i < cfg->speaker_outs; i++)
2812 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
2815 /* enable lineouts, disable hp */
2816 for (i = 0; i < cfg->line_outs; i++)
2817 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
2819 for (i = 0; i < cfg->speaker_outs; i++)
2820 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
2825 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
2827 switch (res >> 26) {
2829 stac92xx_hp_detect(codec, res);
2834 #ifdef SND_HDA_NEEDS_RESUME
2835 static int stac92xx_resume(struct hda_codec *codec)
2837 struct sigmatel_spec *spec = codec->spec;
2839 stac92xx_set_config_regs(codec);
2840 snd_hda_sequence_write(codec, spec->init);
2841 if (spec->gpio_mute) {
2842 stac922x_gpio_mute(codec, 0, 0);
2843 stac922x_gpio_mute(codec, 1, 0);
2845 snd_hda_codec_resume_amp(codec);
2846 snd_hda_codec_resume_cache(codec);
2847 /* invoke unsolicited event to reset the HP state */
2848 if (spec->hp_detect)
2849 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2854 static struct hda_codec_ops stac92xx_patch_ops = {
2855 .build_controls = stac92xx_build_controls,
2856 .build_pcms = stac92xx_build_pcms,
2857 .init = stac92xx_init,
2858 .free = stac92xx_free,
2859 .unsol_event = stac92xx_unsol_event,
2860 #ifdef SND_HDA_NEEDS_RESUME
2861 .resume = stac92xx_resume,
2865 static int patch_stac9200(struct hda_codec *codec)
2867 struct sigmatel_spec *spec;
2870 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2875 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
2876 spec->pin_nids = stac9200_pin_nids;
2877 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
2880 if (spec->board_config < 0) {
2881 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
2882 err = stac92xx_save_bios_config_regs(codec);
2884 stac92xx_free(codec);
2887 spec->pin_configs = spec->bios_pin_configs;
2889 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
2890 stac92xx_set_config_regs(codec);
2893 spec->multiout.max_channels = 2;
2894 spec->multiout.num_dacs = 1;
2895 spec->multiout.dac_nids = stac9200_dac_nids;
2896 spec->adc_nids = stac9200_adc_nids;
2897 spec->mux_nids = stac9200_mux_nids;
2898 spec->num_muxes = 1;
2899 spec->num_dmics = 0;
2902 if (spec->board_config == STAC_9200_GATEWAY)
2903 spec->init = stac9200_eapd_init;
2905 spec->init = stac9200_core_init;
2906 spec->mixer = stac9200_mixer;
2908 err = stac9200_parse_auto_config(codec);
2910 stac92xx_free(codec);
2914 codec->patch_ops = stac92xx_patch_ops;
2919 static int patch_stac925x(struct hda_codec *codec)
2921 struct sigmatel_spec *spec;
2924 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2929 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
2930 spec->pin_nids = stac925x_pin_nids;
2931 spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
2935 if (spec->board_config < 0) {
2936 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
2937 "using BIOS defaults\n");
2938 err = stac92xx_save_bios_config_regs(codec);
2940 stac92xx_free(codec);
2943 spec->pin_configs = spec->bios_pin_configs;
2944 } else if (stac925x_brd_tbl[spec->board_config] != NULL){
2945 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
2946 stac92xx_set_config_regs(codec);
2949 spec->multiout.max_channels = 2;
2950 spec->multiout.num_dacs = 1;
2951 spec->multiout.dac_nids = stac925x_dac_nids;
2952 spec->adc_nids = stac925x_adc_nids;
2953 spec->mux_nids = stac925x_mux_nids;
2954 spec->num_muxes = 1;
2956 switch (codec->vendor_id) {
2957 case 0x83847632: /* STAC9202 */
2958 case 0x83847633: /* STAC9202D */
2959 case 0x83847636: /* STAC9251 */
2960 case 0x83847637: /* STAC9251D */
2961 spec->num_dmics = STAC925X_NUM_DMICS;
2962 spec->dmic_nids = stac925x_dmic_nids;
2963 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
2964 spec->dmux_nids = stac925x_dmux_nids;
2967 spec->num_dmics = 0;
2971 spec->init = stac925x_core_init;
2972 spec->mixer = stac925x_mixer;
2974 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
2976 if (spec->board_config < 0) {
2977 printk(KERN_WARNING "hda_codec: No auto-config is "
2978 "available, default to model=ref\n");
2979 spec->board_config = STAC_925x_REF;
2985 stac92xx_free(codec);
2989 codec->patch_ops = stac92xx_patch_ops;
2994 static struct hda_input_mux stac92hd73xx_dmux = {
2997 { "Analog Inputs", 0x0b },
2999 { "Digital Mic 1", 0x09 },
3000 { "Digital Mic 2", 0x0a },
3004 static int patch_stac92hd73xx(struct hda_codec *codec)
3006 struct sigmatel_spec *spec;
3007 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
3010 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3015 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
3016 spec->pin_nids = stac92hd73xx_pin_nids;
3017 spec->board_config = snd_hda_check_board_config(codec,
3018 STAC_92HD73XX_MODELS,
3019 stac92hd73xx_models,
3020 stac92hd73xx_cfg_tbl);
3022 if (spec->board_config < 0) {
3023 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3024 " STAC92HD73XX, using BIOS defaults\n");
3025 err = stac92xx_save_bios_config_regs(codec);
3027 stac92xx_free(codec);
3030 spec->pin_configs = spec->bios_pin_configs;
3032 spec->pin_configs = stac92hd73xx_brd_tbl[spec->board_config];
3033 stac92xx_set_config_regs(codec);
3036 spec->multiout.num_dacs = snd_hda_get_connections(codec, 0x0a,
3037 conn, STAC92HD73_DAC_COUNT + 2) - 1;
3039 if (spec->multiout.num_dacs < 0) {
3040 printk(KERN_WARNING "hda_codec: Could not determine "
3041 "number of channels defaulting to DAC count\n");
3042 spec->multiout.num_dacs = STAC92HD73_DAC_COUNT;
3045 switch (spec->multiout.num_dacs) {
3046 case 0x3: /* 6 Channel */
3047 spec->mixer = stac92hd73xx_6ch_mixer;
3048 spec->init = stac92hd73xx_6ch_core_init;
3050 case 0x4: /* 8 Channel */
3051 spec->multiout.hp_nid = 0x18;
3052 spec->mixer = stac92hd73xx_8ch_mixer;
3053 spec->init = stac92hd73xx_8ch_core_init;
3055 case 0x5: /* 10 Channel */
3056 spec->multiout.hp_nid = 0x19;
3057 spec->mixer = stac92hd73xx_10ch_mixer;
3058 spec->init = stac92hd73xx_10ch_core_init;
3061 spec->multiout.dac_nids = stac92hd73xx_dac_nids;
3062 spec->aloopback_mask = 0x01;
3063 spec->aloopback_shift = 8;
3065 spec->mux_nids = stac92hd73xx_mux_nids;
3066 spec->adc_nids = stac92hd73xx_adc_nids;
3067 spec->dmic_nids = stac92hd73xx_dmic_nids;
3068 spec->dmux_nids = stac92hd73xx_dmux_nids;
3070 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
3071 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
3072 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
3073 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
3074 spec->dinput_mux = &stac92hd73xx_dmux;
3075 /* GPIO0 High = Enable EAPD */
3076 spec->gpio_mask = spec->gpio_data = 0x000001;
3077 stac92xx_enable_gpio_mask(codec);
3079 err = stac92xx_parse_auto_config(codec, 0x22, 0x24);
3082 if (spec->board_config < 0) {
3083 printk(KERN_WARNING "hda_codec: No auto-config is "
3084 "available, default to model=ref\n");
3085 spec->board_config = STAC_92HD73XX_REF;
3092 stac92xx_free(codec);
3096 codec->patch_ops = stac92xx_patch_ops;
3101 static int patch_stac92hd71bxx(struct hda_codec *codec)
3103 struct sigmatel_spec *spec;
3106 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3111 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
3112 spec->pin_nids = stac92hd71bxx_pin_nids;
3113 spec->board_config = snd_hda_check_board_config(codec,
3114 STAC_92HD71BXX_MODELS,
3115 stac92hd71bxx_models,
3116 stac92hd71bxx_cfg_tbl);
3118 if (spec->board_config < 0) {
3119 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3120 " STAC92HD71BXX, using BIOS defaults\n");
3121 err = stac92xx_save_bios_config_regs(codec);
3123 stac92xx_free(codec);
3126 spec->pin_configs = spec->bios_pin_configs;
3128 spec->pin_configs = stac92hd71bxx_brd_tbl[spec->board_config];
3129 stac92xx_set_config_regs(codec);
3132 switch (codec->vendor_id) {
3133 case 0x111d76b6: /* 4 Port without Analog Mixer */
3135 case 0x111d76b4: /* 6 Port without Analog Mixer */
3137 spec->mixer = stac92hd71bxx_mixer;
3138 spec->init = stac92hd71bxx_core_init;
3141 spec->mixer = stac92hd71bxx_analog_mixer;
3142 spec->init = stac92hd71bxx_analog_core_init;
3145 spec->aloopback_mask = 0x20;
3146 spec->aloopback_shift = 0;
3148 spec->gpio_mask = spec->gpio_data = 0x00000001; /* GPIO0 High = EAPD */
3149 stac92xx_enable_gpio_mask(codec);
3151 spec->mux_nids = stac92hd71bxx_mux_nids;
3152 spec->adc_nids = stac92hd71bxx_adc_nids;
3153 spec->dmic_nids = stac92hd71bxx_dmic_nids;
3154 spec->dmux_nids = stac92hd71bxx_dmux_nids;
3156 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
3157 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
3158 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
3159 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
3161 spec->multiout.num_dacs = 2;
3162 spec->multiout.hp_nid = 0x11;
3163 spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
3165 err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
3167 if (spec->board_config < 0) {
3168 printk(KERN_WARNING "hda_codec: No auto-config is "
3169 "available, default to model=ref\n");
3170 spec->board_config = STAC_92HD71BXX_REF;
3177 stac92xx_free(codec);
3181 codec->patch_ops = stac92xx_patch_ops;
3186 static int patch_stac922x(struct hda_codec *codec)
3188 struct sigmatel_spec *spec;
3191 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3196 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
3197 spec->pin_nids = stac922x_pin_nids;
3198 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
3201 if (spec->board_config == STAC_INTEL_MAC_V3) {
3202 spec->gpio_mute = 1;
3203 /* Intel Macs have all same PCI SSID, so we need to check
3204 * codec SSID to distinguish the exact models
3206 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
3207 switch (codec->subsystem_id) {
3210 spec->board_config = STAC_INTEL_MAC_V1;
3214 spec->board_config = STAC_INTEL_MAC_V2;
3222 spec->board_config = STAC_INTEL_MAC_V3;
3226 spec->board_config = STAC_INTEL_MAC_V4;
3230 spec->board_config = STAC_INTEL_MAC_V5;
3236 if (spec->board_config < 0) {
3237 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
3238 "using BIOS defaults\n");
3239 err = stac92xx_save_bios_config_regs(codec);
3241 stac92xx_free(codec);
3244 spec->pin_configs = spec->bios_pin_configs;
3245 } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
3246 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
3247 stac92xx_set_config_regs(codec);
3250 spec->adc_nids = stac922x_adc_nids;
3251 spec->mux_nids = stac922x_mux_nids;
3252 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
3253 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
3254 spec->num_dmics = 0;
3256 spec->init = stac922x_core_init;
3257 spec->mixer = stac922x_mixer;
3259 spec->multiout.dac_nids = spec->dac_nids;
3261 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
3263 if (spec->board_config < 0) {
3264 printk(KERN_WARNING "hda_codec: No auto-config is "
3265 "available, default to model=ref\n");
3266 spec->board_config = STAC_D945_REF;
3272 stac92xx_free(codec);
3276 codec->patch_ops = stac92xx_patch_ops;
3278 /* Fix Mux capture level; max to 2 */
3279 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
3280 (0 << AC_AMPCAP_OFFSET_SHIFT) |
3281 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3282 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3283 (0 << AC_AMPCAP_MUTE_SHIFT));
3288 static int patch_stac927x(struct hda_codec *codec)
3290 struct sigmatel_spec *spec;
3293 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3298 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
3299 spec->pin_nids = stac927x_pin_nids;
3300 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
3304 if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
3305 if (spec->board_config < 0)
3306 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3307 "STAC927x, using BIOS defaults\n");
3308 err = stac92xx_save_bios_config_regs(codec);
3310 stac92xx_free(codec);
3313 spec->pin_configs = spec->bios_pin_configs;
3315 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
3316 stac92xx_set_config_regs(codec);
3319 spec->adc_nids = stac927x_adc_nids;
3320 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
3321 spec->mux_nids = stac927x_mux_nids;
3322 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
3323 spec->multiout.dac_nids = spec->dac_nids;
3325 switch (spec->board_config) {
3328 /* GPIO0 High = Enable EAPD */
3329 spec->gpio_mask = spec->gpio_data = 0x00000001;
3330 spec->num_dmics = 0;
3332 spec->init = d965_core_init;
3333 spec->mixer = stac927x_mixer;
3335 case STAC_DELL_BIOS:
3336 /* correct the front input jack as a mic */
3337 stac92xx_set_config_reg(codec, 0x0e, 0x02a79130);
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;
3348 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
3351 /* GPIO0 High = Enable EAPD */
3352 spec->gpio_mask = spec->gpio_data = 0x00000001;
3353 spec->num_dmics = 0;
3355 spec->init = stac927x_core_init;
3356 spec->mixer = stac927x_mixer;
3359 spec->aloopback_mask = 0x40;
3360 spec->aloopback_shift = 0;
3362 stac92xx_enable_gpio_mask(codec);
3363 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
3365 if (spec->board_config < 0) {
3366 printk(KERN_WARNING "hda_codec: No auto-config is "
3367 "available, default to model=ref\n");
3368 spec->board_config = STAC_D965_REF;
3374 stac92xx_free(codec);
3378 codec->patch_ops = stac92xx_patch_ops;
3383 static int patch_stac9205(struct hda_codec *codec)
3385 struct sigmatel_spec *spec;
3388 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3393 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
3394 spec->pin_nids = stac9205_pin_nids;
3395 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
3399 if (spec->board_config < 0) {
3400 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
3401 err = stac92xx_save_bios_config_regs(codec);
3403 stac92xx_free(codec);
3406 spec->pin_configs = spec->bios_pin_configs;
3408 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
3409 stac92xx_set_config_regs(codec);
3412 spec->adc_nids = stac9205_adc_nids;
3413 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
3414 spec->mux_nids = stac9205_mux_nids;
3415 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
3416 spec->dmic_nids = stac9205_dmic_nids;
3417 spec->num_dmics = STAC9205_NUM_DMICS;
3418 spec->dmux_nids = stac9205_dmux_nids;
3419 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
3421 spec->init = stac9205_core_init;
3422 spec->mixer = stac9205_mixer;
3424 spec->aloopback_mask = 0x40;
3425 spec->aloopback_shift = 0;
3426 spec->multiout.dac_nids = spec->dac_nids;
3428 switch (spec->board_config){
3429 case STAC_9205_DELL_M43:
3430 /* Enable SPDIF in/out */
3431 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
3432 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
3434 spec->gpio_mask = 0x00000007; /* GPIO0-2 */
3435 /* GPIO0 High = EAPD, GPIO1 Low = DRM,
3436 * GPIO2 High = Headphone Mute
3438 spec->gpio_data = 0x00000005;
3441 /* GPIO0 High = EAPD */
3442 spec->gpio_mask = spec->gpio_data = 0x00000001;
3446 stac92xx_enable_gpio_mask(codec);
3447 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
3449 if (spec->board_config < 0) {
3450 printk(KERN_WARNING "hda_codec: No auto-config is "
3451 "available, default to model=ref\n");
3452 spec->board_config = STAC_9205_REF;
3458 stac92xx_free(codec);
3462 codec->patch_ops = stac92xx_patch_ops;
3471 /* static config for Sony VAIO FE550G and Sony VAIO AR */
3472 static hda_nid_t vaio_dacs[] = { 0x2 };
3473 #define VAIO_HP_DAC 0x5
3474 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
3475 static hda_nid_t vaio_mux_nids[] = { 0x15 };
3477 static struct hda_input_mux vaio_mux = {
3480 /* { "HP", 0x0 }, */
3481 { "Mic Jack", 0x1 },
3482 { "Internal Mic", 0x2 },
3487 static struct hda_verb vaio_init[] = {
3488 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3489 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
3490 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3491 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3492 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3493 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3494 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3495 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3496 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3497 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3498 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3499 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3503 static struct hda_verb vaio_ar_init[] = {
3504 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3505 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3506 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3507 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3508 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
3509 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3510 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3511 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3512 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3513 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
3514 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3515 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3516 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3520 /* bind volumes of both NID 0x02 and 0x05 */
3521 static struct hda_bind_ctls vaio_bind_master_vol = {
3522 .ops = &snd_hda_bind_vol,
3524 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3525 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3530 /* bind volumes of both NID 0x02 and 0x05 */
3531 static struct hda_bind_ctls vaio_bind_master_sw = {
3532 .ops = &snd_hda_bind_sw,
3534 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3535 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3540 static struct snd_kcontrol_new vaio_mixer[] = {
3541 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3542 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3543 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3544 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3545 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3547 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3548 .name = "Capture Source",
3550 .info = stac92xx_mux_enum_info,
3551 .get = stac92xx_mux_enum_get,
3552 .put = stac92xx_mux_enum_put,
3557 static struct snd_kcontrol_new vaio_ar_mixer[] = {
3558 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3559 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3560 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3561 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3562 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3563 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
3564 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
3566 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3567 .name = "Capture Source",
3569 .info = stac92xx_mux_enum_info,
3570 .get = stac92xx_mux_enum_get,
3571 .put = stac92xx_mux_enum_put,
3576 static struct hda_codec_ops stac9872_patch_ops = {
3577 .build_controls = stac92xx_build_controls,
3578 .build_pcms = stac92xx_build_pcms,
3579 .init = stac92xx_init,
3580 .free = stac92xx_free,
3581 #ifdef SND_HDA_NEEDS_RESUME
3582 .resume = stac92xx_resume,
3586 static int stac9872_vaio_init(struct hda_codec *codec)
3590 err = stac92xx_init(codec);
3593 if (codec->patch_ops.unsol_event)
3594 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3598 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
3600 if (get_hp_pin_presence(codec, 0x0a)) {
3601 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3602 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3604 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3605 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3609 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
3611 switch (res >> 26) {
3613 stac9872_vaio_hp_detect(codec, res);
3618 static struct hda_codec_ops stac9872_vaio_patch_ops = {
3619 .build_controls = stac92xx_build_controls,
3620 .build_pcms = stac92xx_build_pcms,
3621 .init = stac9872_vaio_init,
3622 .free = stac92xx_free,
3623 .unsol_event = stac9872_vaio_unsol_event,
3625 .resume = stac92xx_resume,
3629 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
3631 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
3633 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
3635 /* AR Series. id=0x83847664 and subsys=104D1300 */
3640 static const char *stac9872_models[STAC_9872_MODELS] = {
3641 [CXD9872RD_VAIO] = "vaio",
3642 [CXD9872AKD_VAIO] = "vaio-ar",
3645 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
3646 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
3647 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
3648 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
3649 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
3653 static int patch_stac9872(struct hda_codec *codec)
3655 struct sigmatel_spec *spec;
3658 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
3661 if (board_config < 0)
3662 /* unknown config, let generic-parser do its job... */
3663 return snd_hda_parse_generic_codec(codec);
3665 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3670 switch (board_config) {
3671 case CXD9872RD_VAIO:
3672 case STAC9872AK_VAIO:
3673 case STAC9872K_VAIO:
3674 spec->mixer = vaio_mixer;
3675 spec->init = vaio_init;
3676 spec->multiout.max_channels = 2;
3677 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3678 spec->multiout.dac_nids = vaio_dacs;
3679 spec->multiout.hp_nid = VAIO_HP_DAC;
3680 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3681 spec->adc_nids = vaio_adcs;
3682 spec->input_mux = &vaio_mux;
3683 spec->mux_nids = vaio_mux_nids;
3684 codec->patch_ops = stac9872_vaio_patch_ops;
3687 case CXD9872AKD_VAIO:
3688 spec->mixer = vaio_ar_mixer;
3689 spec->init = vaio_ar_init;
3690 spec->multiout.max_channels = 2;
3691 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3692 spec->multiout.dac_nids = vaio_dacs;
3693 spec->multiout.hp_nid = VAIO_HP_DAC;
3694 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3695 spec->adc_nids = vaio_adcs;
3696 spec->input_mux = &vaio_mux;
3697 spec->mux_nids = vaio_mux_nids;
3698 codec->patch_ops = stac9872_patch_ops;
3709 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
3710 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
3711 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
3712 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
3713 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
3714 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
3715 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
3716 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
3717 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
3718 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
3719 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
3720 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
3721 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
3722 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
3723 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
3724 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
3725 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
3726 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
3727 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
3728 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
3729 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
3730 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
3731 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
3732 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
3733 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
3734 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
3735 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
3736 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
3737 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
3738 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
3739 /* The following does not take into account .id=0x83847661 when subsys =
3740 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
3741 * currently not fully supported.
3743 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
3744 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
3745 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
3746 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
3747 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
3748 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
3749 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
3750 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
3751 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
3752 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
3753 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
3754 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
3755 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
3756 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
3757 { .id = 0x111d7608, .name = "92HD71BXX", .patch = patch_stac92hd71bxx },
3758 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
3759 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
3760 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
3761 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
3762 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
3763 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
3764 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
3765 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },