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 */
113 struct sigmatel_spec {
114 struct snd_kcontrol_new *mixers[4];
115 unsigned int num_mixers;
118 unsigned int surr_switch: 1;
119 unsigned int line_switch: 1;
120 unsigned int mic_switch: 1;
121 unsigned int alt_switch: 1;
122 unsigned int hp_detect: 1;
123 unsigned int gpio_mute: 1;
125 unsigned int gpio_mask, gpio_data;
126 unsigned char aloopback_mask;
127 unsigned char aloopback_shift;
130 struct hda_multi_out multiout;
131 hda_nid_t dac_nids[5];
135 unsigned int num_adcs;
137 unsigned int num_muxes;
138 hda_nid_t *dmic_nids;
139 unsigned int num_dmics;
140 hda_nid_t *dmux_nids;
141 hda_nid_t dig_in_nid;
145 unsigned int num_pins;
146 unsigned int *pin_configs;
147 unsigned int *bios_pin_configs;
149 /* codec specific stuff */
150 struct hda_verb *init;
151 struct snd_kcontrol_new *mixer;
154 struct hda_input_mux *dinput_mux;
155 unsigned int cur_dmux[2];
156 struct hda_input_mux *input_mux;
157 unsigned int cur_mux[3];
160 unsigned int io_switch[2];
161 unsigned int clfe_swap;
162 unsigned int aloopback;
164 struct hda_pcm pcm_rec[2]; /* PCM information */
166 /* dynamic controls and input_mux */
167 struct auto_pin_cfg autocfg;
168 unsigned int num_kctl_alloc, num_kctl_used;
169 struct snd_kcontrol_new *kctl_alloc;
170 struct hda_input_mux private_dimux;
171 struct hda_input_mux private_imux;
174 static hda_nid_t stac9200_adc_nids[1] = {
178 static hda_nid_t stac9200_mux_nids[1] = {
182 static hda_nid_t stac9200_dac_nids[1] = {
186 static hda_nid_t stac92hd73xx_adc_nids[2] = {
190 #define STAC92HD73XX_NUM_DMICS 2
191 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
195 #define STAC92HD73_DAC_COUNT 5
196 static hda_nid_t stac92hd73xx_dac_nids[STAC92HD73_DAC_COUNT] = {
197 0x15, 0x16, 0x17, 0x18, 0x19,
200 static hda_nid_t stac92hd73xx_mux_nids[4] = {
201 0x28, 0x29, 0x2a, 0x2b,
204 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
208 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
212 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
216 static hda_nid_t stac92hd71bxx_dmux_nids[1] = {
220 static hda_nid_t stac92hd71bxx_dac_nids[2] = {
224 #define STAC92HD71BXX_NUM_DMICS 2
225 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
229 static hda_nid_t stac925x_adc_nids[1] = {
233 static hda_nid_t stac925x_mux_nids[1] = {
237 static hda_nid_t stac925x_dac_nids[1] = {
241 #define STAC925X_NUM_DMICS 1
242 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
246 static hda_nid_t stac922x_adc_nids[2] = {
250 static hda_nid_t stac922x_mux_nids[2] = {
254 static hda_nid_t stac927x_adc_nids[3] = {
258 static hda_nid_t stac927x_mux_nids[3] = {
262 static hda_nid_t stac927x_dmux_nids[1] = {
266 #define STAC927X_NUM_DMICS 2
267 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
271 static hda_nid_t stac9205_adc_nids[2] = {
275 static hda_nid_t stac9205_mux_nids[2] = {
279 static hda_nid_t stac9205_dmux_nids[1] = {
283 #define STAC9205_NUM_DMICS 2
284 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
288 static hda_nid_t stac9200_pin_nids[8] = {
289 0x08, 0x09, 0x0d, 0x0e,
290 0x0f, 0x10, 0x11, 0x12,
293 static hda_nid_t stac925x_pin_nids[8] = {
294 0x07, 0x08, 0x0a, 0x0b,
295 0x0c, 0x0d, 0x10, 0x11,
298 static hda_nid_t stac922x_pin_nids[10] = {
299 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
300 0x0f, 0x10, 0x11, 0x15, 0x1b,
303 static hda_nid_t stac92hd73xx_pin_nids[12] = {
304 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
305 0x0f, 0x10, 0x11, 0x12, 0x13,
309 static hda_nid_t stac92hd71bxx_pin_nids[10] = {
310 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
311 0x0f, 0x14, 0x18, 0x19, 0x1e,
314 static hda_nid_t stac927x_pin_nids[14] = {
315 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
316 0x0f, 0x10, 0x11, 0x12, 0x13,
317 0x14, 0x21, 0x22, 0x23,
320 static hda_nid_t stac9205_pin_nids[12] = {
321 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
322 0x0f, 0x14, 0x16, 0x17, 0x18,
326 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
327 struct snd_ctl_elem_info *uinfo)
329 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
330 struct sigmatel_spec *spec = codec->spec;
331 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
334 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
335 struct snd_ctl_elem_value *ucontrol)
337 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
338 struct sigmatel_spec *spec = codec->spec;
339 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
341 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
345 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
346 struct snd_ctl_elem_value *ucontrol)
348 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
349 struct sigmatel_spec *spec = codec->spec;
350 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
352 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
353 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
356 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
358 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
359 struct sigmatel_spec *spec = codec->spec;
360 return snd_hda_input_mux_info(spec->input_mux, uinfo);
363 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
365 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
366 struct sigmatel_spec *spec = codec->spec;
367 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
369 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
373 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
375 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
376 struct sigmatel_spec *spec = codec->spec;
377 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
379 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
380 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
383 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
385 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
386 struct snd_ctl_elem_value *ucontrol)
388 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
389 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
390 struct sigmatel_spec *spec = codec->spec;
392 ucontrol->value.integer.value[0] = !!(spec->aloopback &
393 (spec->aloopback_mask << idx));
397 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
398 struct snd_ctl_elem_value *ucontrol)
400 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
401 struct sigmatel_spec *spec = codec->spec;
402 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
403 unsigned int dac_mode;
404 unsigned int val, idx_val;
406 idx_val = spec->aloopback_mask << idx;
407 if (ucontrol->value.integer.value[0])
408 val = spec->aloopback | idx_val;
410 val = spec->aloopback & ~idx_val;
411 if (spec->aloopback == val)
414 spec->aloopback = val;
416 /* Only return the bits defined by the shift value of the
417 * first two bytes of the mask
419 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
420 kcontrol->private_value & 0xFFFF, 0x0);
421 dac_mode >>= spec->aloopback_shift;
423 if (spec->aloopback & idx_val) {
424 snd_hda_power_up(codec);
427 snd_hda_power_down(codec);
428 dac_mode &= ~idx_val;
431 snd_hda_codec_write_cache(codec, codec->afg, 0,
432 kcontrol->private_value >> 16, dac_mode);
437 static struct hda_verb stac9200_core_init[] = {
438 /* set dac0mux for dac converter */
439 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
443 static struct hda_verb stac9200_eapd_init[] = {
444 /* set dac0mux for dac converter */
445 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
446 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
450 static struct hda_verb stac92hd73xx_6ch_core_init[] = {
451 /* set master volume and direct control */
452 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
453 /* setup audio connections */
454 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
455 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
456 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
457 /* setup adcs to point to mixer */
458 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
459 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
460 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Front Mic */
461 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Mic */
462 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Line In */
463 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
464 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
465 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
466 /* setup import muxs */
467 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
468 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
469 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
470 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
474 static struct hda_verb stac92hd73xx_8ch_core_init[] = {
475 /* set master volume and direct control */
476 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
477 /* setup audio connections */
478 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00},
479 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01},
480 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02},
481 /* connect hp ports to dac3 */
482 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x03},
483 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x03},
484 /* setup adcs to point to mixer */
485 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
486 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
487 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Front Mic */
488 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Mic */
489 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Line In */
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 { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Front Mic */
517 { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Mic */
518 { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Line In */
519 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
520 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
521 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
522 /* setup import muxs */
523 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
524 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
525 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
526 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
530 static struct hda_verb stac92hd71bxx_core_init[] = {
531 /* set master volume and direct control */
532 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
533 /* connect headphone jack to dac1 */
534 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
535 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */
536 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
537 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
538 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
539 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
540 /* unmute mono out node */
541 { 0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
544 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
545 /* set master volume and direct control */
546 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
547 /* connect headphone jack to dac1 */
548 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
549 /* connect ports 0d and 0f to audio mixer */
550 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x2},
551 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
552 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
553 /* unmute dac0 input in audio mixer */
554 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
555 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
556 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
557 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
558 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
559 /* unmute mono out node */
560 { 0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
564 static struct hda_verb stac925x_core_init[] = {
565 /* set dac0mux for dac converter */
566 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
570 static struct hda_verb stac922x_core_init[] = {
571 /* set master volume and direct control */
572 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
576 static struct hda_verb d965_core_init[] = {
577 /* set master volume and direct control */
578 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
579 /* unmute node 0x1b */
580 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
581 /* select node 0x03 as DAC */
582 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
586 static struct hda_verb stac927x_core_init[] = {
587 /* set master volume and direct control */
588 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
592 static struct hda_verb stac9205_core_init[] = {
593 /* set master volume and direct control */
594 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
598 #define STAC_DIGITAL_INPUT_SOURCE(cnt) \
600 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
601 .name = "Digital Input Source", \
603 .info = stac92xx_dmux_enum_info, \
604 .get = stac92xx_dmux_enum_get, \
605 .put = stac92xx_dmux_enum_put,\
608 #define STAC_INPUT_SOURCE(cnt) \
610 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
611 .name = "Input Source", \
613 .info = stac92xx_mux_enum_info, \
614 .get = stac92xx_mux_enum_get, \
615 .put = stac92xx_mux_enum_put, \
618 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
620 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
621 .name = "Analog Loopback", \
623 .info = stac92xx_aloopback_info, \
624 .get = stac92xx_aloopback_get, \
625 .put = stac92xx_aloopback_put, \
626 .private_value = verb_read | (verb_write << 16), \
629 static struct snd_kcontrol_new stac9200_mixer[] = {
630 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
631 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
632 STAC_INPUT_SOURCE(1),
633 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
634 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
635 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT),
639 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
640 STAC_DIGITAL_INPUT_SOURCE(2),
641 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
643 /* hardware gain controls */
644 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x13, 0x0, HDA_INPUT),
645 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x14, 0x0, HDA_INPUT),
647 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
648 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
650 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
651 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
653 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
654 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
656 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
657 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
659 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
660 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
662 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
663 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
665 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
666 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
670 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
671 STAC_DIGITAL_INPUT_SOURCE(2),
672 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
674 /* hardware gain controls */
675 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x13, 0x0, HDA_INPUT),
676 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x14, 0x0, HDA_INPUT),
678 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
679 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
681 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
682 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
684 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
685 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
687 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
688 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
690 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
691 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
693 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
694 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
696 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
697 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
701 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
702 STAC_DIGITAL_INPUT_SOURCE(2),
703 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
705 /* hardware gain controls */
706 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x13, 0x0, HDA_INPUT),
707 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x14, 0x0, HDA_INPUT),
709 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
710 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
712 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
713 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
715 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
716 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
718 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
719 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
721 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
722 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
724 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
725 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
727 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
728 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
732 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
733 STAC_DIGITAL_INPUT_SOURCE(1),
734 STAC_INPUT_SOURCE(2),
736 /* hardware gain controls */
737 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x18, 0x0, HDA_OUTPUT),
738 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x19, 0x0, HDA_OUTPUT),
740 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
741 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
742 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
744 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
745 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
746 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
748 HDA_CODEC_MUTE("Analog Loopback 1", 0x17, 0x3, HDA_INPUT),
749 HDA_CODEC_MUTE("Analog Loopback 2", 0x17, 0x4, HDA_INPUT),
753 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
754 STAC_DIGITAL_INPUT_SOURCE(1),
755 STAC_INPUT_SOURCE(2),
756 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
758 /* hardware gain controls */
759 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x0, 0x18, 0x0, HDA_OUTPUT),
760 HDA_CODEC_VOLUME_IDX("Digital Mic Volume", 0x1, 0x19, 0x0, HDA_OUTPUT),
762 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
763 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
764 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
766 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
767 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
768 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
772 static struct snd_kcontrol_new stac925x_mixer[] = {
773 STAC_INPUT_SOURCE(1),
774 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
775 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_OUTPUT),
776 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT),
780 static struct snd_kcontrol_new stac9205_mixer[] = {
781 STAC_DIGITAL_INPUT_SOURCE(1),
782 STAC_INPUT_SOURCE(2),
783 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
785 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
786 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
787 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT),
789 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
790 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
791 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT),
796 /* This needs to be generated dynamically based on sequence */
797 static struct snd_kcontrol_new stac922x_mixer[] = {
798 STAC_INPUT_SOURCE(2),
799 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
800 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
801 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT),
803 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
804 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
805 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT),
810 static struct snd_kcontrol_new stac927x_mixer[] = {
811 STAC_DIGITAL_INPUT_SOURCE(1),
812 STAC_INPUT_SOURCE(3),
813 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
815 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
816 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
817 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT),
819 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
820 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
821 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT),
823 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
824 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
825 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT),
829 static int stac92xx_build_controls(struct hda_codec *codec)
831 struct sigmatel_spec *spec = codec->spec;
835 err = snd_hda_add_new_ctls(codec, spec->mixer);
839 for (i = 0; i < spec->num_mixers; i++) {
840 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
845 if (spec->multiout.dig_out_nid) {
846 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
850 if (spec->dig_in_nid) {
851 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
858 static unsigned int ref9200_pin_configs[8] = {
859 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
860 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
864 STAC 9200 pin configs for
869 static unsigned int dell9200_d21_pin_configs[8] = {
870 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
871 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
875 STAC 9200 pin configs for
879 static unsigned int dell9200_d22_pin_configs[8] = {
880 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
881 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
885 STAC 9200 pin configs for
886 102801C4 (Dell Dimension E310)
893 static unsigned int dell9200_d23_pin_configs[8] = {
894 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
895 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
900 STAC 9200-32 pin configs for
901 102801B5 (Dell Inspiron 630m)
902 102801D8 (Dell Inspiron 640m)
904 static unsigned int dell9200_m21_pin_configs[8] = {
905 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
906 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
910 STAC 9200-32 pin configs for
911 102801C2 (Dell Latitude D620)
913 102801CC (Dell Latitude D820)
917 static unsigned int dell9200_m22_pin_configs[8] = {
918 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
919 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
923 STAC 9200-32 pin configs for
924 102801CE (Dell XPS M1710)
925 102801CF (Dell Precision M90)
927 static unsigned int dell9200_m23_pin_configs[8] = {
928 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
929 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
933 STAC 9200-32 pin configs for
936 102801CB (Dell Latitude 120L)
939 static unsigned int dell9200_m24_pin_configs[8] = {
940 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
941 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
945 STAC 9200-32 pin configs for
946 102801BD (Dell Inspiron E1505n)
950 static unsigned int dell9200_m25_pin_configs[8] = {
951 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
952 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
956 STAC 9200-32 pin configs for
957 102801F5 (Dell Inspiron 1501)
960 static unsigned int dell9200_m26_pin_configs[8] = {
961 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
962 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
967 102801CD (Dell Inspiron E1705/9400)
969 static unsigned int dell9200_m27_pin_configs[8] = {
970 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
971 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
975 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
976 [STAC_REF] = ref9200_pin_configs,
977 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
978 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
979 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
980 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
981 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
982 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
983 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
984 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
985 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
986 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
989 static const char *stac9200_models[STAC_9200_MODELS] = {
991 [STAC_9200_DELL_D21] = "dell-d21",
992 [STAC_9200_DELL_D22] = "dell-d22",
993 [STAC_9200_DELL_D23] = "dell-d23",
994 [STAC_9200_DELL_M21] = "dell-m21",
995 [STAC_9200_DELL_M22] = "dell-m22",
996 [STAC_9200_DELL_M23] = "dell-m23",
997 [STAC_9200_DELL_M24] = "dell-m24",
998 [STAC_9200_DELL_M25] = "dell-m25",
999 [STAC_9200_DELL_M26] = "dell-m26",
1000 [STAC_9200_DELL_M27] = "dell-m27",
1001 [STAC_9200_GATEWAY] = "gateway",
1004 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1005 /* SigmaTel reference board */
1006 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1007 "DFI LanParty", STAC_REF),
1008 /* Dell laptops have BIOS problem */
1009 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1010 "unknown Dell", STAC_9200_DELL_D21),
1011 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1012 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1013 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1014 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1015 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1016 "unknown Dell", STAC_9200_DELL_D22),
1017 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1018 "unknown Dell", STAC_9200_DELL_D22),
1019 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1020 "Dell Latitude D620", STAC_9200_DELL_M22),
1021 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1022 "unknown Dell", STAC_9200_DELL_D23),
1023 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1024 "unknown Dell", STAC_9200_DELL_D23),
1025 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1026 "unknown Dell", STAC_9200_DELL_M22),
1027 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1028 "unknown Dell", STAC_9200_DELL_M24),
1029 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1030 "unknown Dell", STAC_9200_DELL_M24),
1031 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1032 "Dell Latitude 120L", STAC_9200_DELL_M24),
1033 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1034 "Dell Latitude D820", STAC_9200_DELL_M22),
1035 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1036 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1037 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1038 "Dell XPS M1710", STAC_9200_DELL_M23),
1039 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1040 "Dell Precision M90", STAC_9200_DELL_M23),
1041 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1042 "unknown Dell", STAC_9200_DELL_M22),
1043 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1044 "unknown Dell", STAC_9200_DELL_M22),
1045 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1046 "unknown Dell", STAC_9200_DELL_M22),
1047 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1048 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1049 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1050 "unknown Dell", STAC_9200_DELL_D23),
1051 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1052 "unknown Dell", STAC_9200_DELL_D23),
1053 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1054 "unknown Dell", STAC_9200_DELL_D21),
1055 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1056 "unknown Dell", STAC_9200_DELL_D23),
1057 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1058 "unknown Dell", STAC_9200_DELL_D21),
1059 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1060 "unknown Dell", STAC_9200_DELL_M25),
1061 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1062 "unknown Dell", STAC_9200_DELL_M25),
1063 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1064 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1065 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1066 "unknown Dell", STAC_9200_DELL_M26),
1068 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_REF),
1069 /* Gateway machines needs EAPD to be set on resume */
1070 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY),
1071 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
1073 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
1078 static unsigned int ref925x_pin_configs[8] = {
1079 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1080 0x90a70320, 0x02214210, 0x400003f1, 0x9033032e,
1083 static unsigned int stac925x_MA6_pin_configs[8] = {
1084 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1085 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
1088 static unsigned int stac925x_PA6_pin_configs[8] = {
1089 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1090 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
1093 static unsigned int stac925xM2_2_pin_configs[8] = {
1094 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
1095 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
1098 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1099 [STAC_REF] = ref925x_pin_configs,
1100 [STAC_M2_2] = stac925xM2_2_pin_configs,
1101 [STAC_MA6] = stac925x_MA6_pin_configs,
1102 [STAC_PA6] = stac925x_PA6_pin_configs,
1105 static const char *stac925x_models[STAC_925x_MODELS] = {
1107 [STAC_M2_2] = "m2-2",
1112 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1113 /* SigmaTel reference board */
1114 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1115 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1116 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF),
1117 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF),
1118 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6),
1119 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6),
1120 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2),
1124 static unsigned int ref92hd73xx_pin_configs[12] = {
1125 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1126 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1127 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1130 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1131 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1134 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1135 [STAC_92HD73XX_REF] = "ref",
1138 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1139 /* SigmaTel reference board */
1140 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1141 "DFI LanParty", STAC_92HD73XX_REF),
1145 static unsigned int ref92hd71bxx_pin_configs[10] = {
1146 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1147 0x0181302e, 0x01114010, 0x01a19020, 0x90a000f0,
1148 0x90a000f0, 0x01452050,
1151 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1152 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1155 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1156 [STAC_92HD71BXX_REF] = "ref",
1159 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1160 /* SigmaTel reference board */
1161 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1162 "DFI LanParty", STAC_92HD71BXX_REF),
1166 static unsigned int ref922x_pin_configs[10] = {
1167 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1168 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1169 0x40000100, 0x40000100,
1173 STAC 922X pin configs for
1180 static unsigned int dell_922x_d81_pin_configs[10] = {
1181 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1182 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1183 0x01813122, 0x400001f2,
1187 STAC 922X pin configs for
1191 static unsigned int dell_922x_d82_pin_configs[10] = {
1192 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1193 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1194 0x01813122, 0x400001f1,
1198 STAC 922X pin configs for
1201 static unsigned int dell_922x_m81_pin_configs[10] = {
1202 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1203 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1204 0x40C003f1, 0x405003f0,
1208 STAC 9221 A1 pin configs for
1209 102801D7 (Dell XPS M1210)
1211 static unsigned int dell_922x_m82_pin_configs[10] = {
1212 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1213 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1214 0x508003f3, 0x405003f4,
1217 static unsigned int d945gtp3_pin_configs[10] = {
1218 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1219 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1220 0x02a19120, 0x40000100,
1223 static unsigned int d945gtp5_pin_configs[10] = {
1224 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1225 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1226 0x02a19320, 0x40000100,
1229 static unsigned int intel_mac_v1_pin_configs[10] = {
1230 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1231 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1232 0x400000fc, 0x400000fb,
1235 static unsigned int intel_mac_v2_pin_configs[10] = {
1236 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1237 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1238 0x400000fc, 0x400000fb,
1241 static unsigned int intel_mac_v3_pin_configs[10] = {
1242 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1243 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1244 0x400000fc, 0x400000fb,
1247 static unsigned int intel_mac_v4_pin_configs[10] = {
1248 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1249 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1250 0x400000fc, 0x400000fb,
1253 static unsigned int intel_mac_v5_pin_configs[10] = {
1254 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1255 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1256 0x400000fc, 0x400000fb,
1260 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1261 [STAC_D945_REF] = ref922x_pin_configs,
1262 [STAC_D945GTP3] = d945gtp3_pin_configs,
1263 [STAC_D945GTP5] = d945gtp5_pin_configs,
1264 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1265 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1266 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1267 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1268 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1269 /* for backward compatibility */
1270 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1271 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1272 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1273 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1274 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1275 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1276 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1277 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1278 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1279 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1282 static const char *stac922x_models[STAC_922X_MODELS] = {
1283 [STAC_D945_REF] = "ref",
1284 [STAC_D945GTP5] = "5stack",
1285 [STAC_D945GTP3] = "3stack",
1286 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1287 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1288 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1289 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1290 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1291 /* for backward compatibility */
1292 [STAC_MACMINI] = "macmini",
1293 [STAC_MACBOOK] = "macbook",
1294 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1295 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1296 [STAC_IMAC_INTEL] = "imac-intel",
1297 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1298 [STAC_922X_DELL_D81] = "dell-d81",
1299 [STAC_922X_DELL_D82] = "dell-d82",
1300 [STAC_922X_DELL_M81] = "dell-m81",
1301 [STAC_922X_DELL_M82] = "dell-m82",
1304 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1305 /* SigmaTel reference board */
1306 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1307 "DFI LanParty", STAC_D945_REF),
1308 /* Intel 945G based systems */
1309 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1310 "Intel D945G", STAC_D945GTP3),
1311 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1312 "Intel D945G", STAC_D945GTP3),
1313 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1314 "Intel D945G", STAC_D945GTP3),
1315 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1316 "Intel D945G", STAC_D945GTP3),
1317 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1318 "Intel D945G", STAC_D945GTP3),
1319 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1320 "Intel D945G", STAC_D945GTP3),
1321 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1322 "Intel D945G", STAC_D945GTP3),
1323 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1324 "Intel D945G", STAC_D945GTP3),
1325 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1326 "Intel D945G", STAC_D945GTP3),
1327 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1328 "Intel D945G", STAC_D945GTP3),
1329 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1330 "Intel D945G", STAC_D945GTP3),
1331 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1332 "Intel D945G", STAC_D945GTP3),
1333 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1334 "Intel D945G", STAC_D945GTP3),
1335 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1336 "Intel D945G", STAC_D945GTP3),
1337 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1338 "Intel D945G", STAC_D945GTP3),
1339 /* Intel D945G 5-stack systems */
1340 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1341 "Intel D945G", STAC_D945GTP5),
1342 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1343 "Intel D945G", STAC_D945GTP5),
1344 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1345 "Intel D945G", STAC_D945GTP5),
1346 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1347 "Intel D945G", STAC_D945GTP5),
1348 /* Intel 945P based systems */
1349 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1350 "Intel D945P", STAC_D945GTP3),
1351 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1352 "Intel D945P", STAC_D945GTP3),
1353 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1354 "Intel D945P", STAC_D945GTP3),
1355 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1356 "Intel D945P", STAC_D945GTP3),
1357 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1358 "Intel D945P", STAC_D945GTP3),
1359 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1360 "Intel D945P", STAC_D945GTP5),
1362 /* Apple Mac Mini (early 2006) */
1363 SND_PCI_QUIRK(0x8384, 0x7680,
1364 "Mac Mini", STAC_INTEL_MAC_V3),
1366 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1367 "unknown Dell", STAC_922X_DELL_D81),
1368 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1369 "unknown Dell", STAC_922X_DELL_D81),
1370 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1371 "unknown Dell", STAC_922X_DELL_D81),
1372 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1373 "unknown Dell", STAC_922X_DELL_D82),
1374 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1375 "unknown Dell", STAC_922X_DELL_M81),
1376 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1377 "unknown Dell", STAC_922X_DELL_D82),
1378 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1379 "unknown Dell", STAC_922X_DELL_D81),
1380 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1381 "unknown Dell", STAC_922X_DELL_D81),
1382 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1383 "Dell XPS M1210", STAC_922X_DELL_M82),
1387 static unsigned int ref927x_pin_configs[14] = {
1388 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1389 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1390 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1391 0x01c42190, 0x40000100,
1394 static unsigned int d965_3st_pin_configs[14] = {
1395 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
1396 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
1397 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1398 0x40000100, 0x40000100
1401 static unsigned int d965_5st_pin_configs[14] = {
1402 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1403 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
1404 0x40000100, 0x40000100, 0x40000100, 0x01442070,
1405 0x40000100, 0x40000100
1408 static unsigned int dell_3st_pin_configs[14] = {
1409 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
1410 0x01111212, 0x01116211, 0x01813050, 0x01112214,
1411 0x403003fa, 0x40000100, 0x40000100, 0x404003fb,
1412 0x40c003fc, 0x40000100
1415 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
1416 [STAC_D965_REF] = ref927x_pin_configs,
1417 [STAC_D965_3ST] = d965_3st_pin_configs,
1418 [STAC_D965_5ST] = d965_5st_pin_configs,
1419 [STAC_DELL_3ST] = dell_3st_pin_configs,
1422 static const char *stac927x_models[STAC_927X_MODELS] = {
1423 [STAC_D965_REF] = "ref",
1424 [STAC_D965_3ST] = "3stack",
1425 [STAC_D965_5ST] = "5stack",
1426 [STAC_DELL_3ST] = "dell-3stack",
1429 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
1430 /* SigmaTel reference board */
1431 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1432 "DFI LanParty", STAC_D965_REF),
1433 /* Intel 946 based systems */
1434 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
1435 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
1436 /* 965 based 3 stack systems */
1437 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
1438 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
1439 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
1440 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
1441 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
1442 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
1443 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
1444 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
1445 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
1446 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
1447 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
1448 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
1449 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
1450 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
1451 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
1452 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
1453 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_D965_3ST),
1454 /* Dell 3 stack systems */
1455 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
1456 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
1457 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
1458 /* 965 based 5 stack systems */
1459 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_D965_5ST),
1460 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
1461 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
1462 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
1463 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
1464 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
1465 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
1466 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
1467 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
1468 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
1472 static unsigned int ref9205_pin_configs[12] = {
1473 0x40000100, 0x40000100, 0x01016011, 0x01014010,
1474 0x01813122, 0x01a19021, 0x40000100, 0x40000100,
1475 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
1479 STAC 9205 pin configs for
1487 static unsigned int dell_9205_m42_pin_configs[12] = {
1488 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
1489 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
1490 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
1494 STAC 9205 pin configs for
1498 102801FF (Dell Precision M4300)
1503 static unsigned int dell_9205_m43_pin_configs[12] = {
1504 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
1505 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
1506 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
1509 static unsigned int dell_9205_m44_pin_configs[12] = {
1510 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
1511 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
1512 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
1515 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
1516 [STAC_9205_REF] = ref9205_pin_configs,
1517 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
1518 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
1519 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
1522 static const char *stac9205_models[STAC_9205_MODELS] = {
1523 [STAC_9205_REF] = "ref",
1524 [STAC_9205_DELL_M42] = "dell-m42",
1525 [STAC_9205_DELL_M43] = "dell-m43",
1526 [STAC_9205_DELL_M44] = "dell-m44",
1529 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
1530 /* SigmaTel reference board */
1531 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1532 "DFI LanParty", STAC_9205_REF),
1533 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1534 "unknown Dell", STAC_9205_DELL_M42),
1535 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1536 "unknown Dell", STAC_9205_DELL_M42),
1537 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
1538 "Dell Precision", STAC_9205_DELL_M43),
1539 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
1540 "Dell Precision", STAC_9205_DELL_M43),
1541 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
1542 "Dell Precision", STAC_9205_DELL_M43),
1543 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
1544 "Dell Precision", STAC_9205_DELL_M43),
1545 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
1546 "Dell Precision", STAC_9205_DELL_M43),
1547 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1548 "unknown Dell", STAC_9205_DELL_M42),
1549 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1550 "unknown Dell", STAC_9205_DELL_M42),
1551 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
1552 "Dell Precision", STAC_9205_DELL_M43),
1553 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
1554 "Dell Precision M4300", STAC_9205_DELL_M43),
1555 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
1556 "Dell Precision", STAC_9205_DELL_M43),
1557 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
1558 "Dell Inspiron", STAC_9205_DELL_M44),
1559 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
1560 "Dell Inspiron", STAC_9205_DELL_M44),
1561 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
1562 "Dell Inspiron", STAC_9205_DELL_M44),
1563 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
1564 "Dell Inspiron", STAC_9205_DELL_M44),
1565 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
1566 "unknown Dell", STAC_9205_DELL_M42),
1567 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
1568 "Dell Inspiron", STAC_9205_DELL_M44),
1572 static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
1575 struct sigmatel_spec *spec = codec->spec;
1577 if (! spec->bios_pin_configs) {
1578 spec->bios_pin_configs = kcalloc(spec->num_pins,
1579 sizeof(*spec->bios_pin_configs), GFP_KERNEL);
1580 if (! spec->bios_pin_configs)
1584 for (i = 0; i < spec->num_pins; i++) {
1585 hda_nid_t nid = spec->pin_nids[i];
1586 unsigned int pin_cfg;
1588 pin_cfg = snd_hda_codec_read(codec, nid, 0,
1589 AC_VERB_GET_CONFIG_DEFAULT, 0x00);
1590 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
1592 spec->bios_pin_configs[i] = pin_cfg;
1598 static void stac92xx_set_config_reg(struct hda_codec *codec,
1599 hda_nid_t pin_nid, unsigned int pin_config)
1602 snd_hda_codec_write(codec, pin_nid, 0,
1603 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
1604 pin_config & 0x000000ff);
1605 snd_hda_codec_write(codec, pin_nid, 0,
1606 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
1607 (pin_config & 0x0000ff00) >> 8);
1608 snd_hda_codec_write(codec, pin_nid, 0,
1609 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
1610 (pin_config & 0x00ff0000) >> 16);
1611 snd_hda_codec_write(codec, pin_nid, 0,
1612 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
1614 i = snd_hda_codec_read(codec, pin_nid, 0,
1615 AC_VERB_GET_CONFIG_DEFAULT,
1617 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
1621 static void stac92xx_set_config_regs(struct hda_codec *codec)
1624 struct sigmatel_spec *spec = codec->spec;
1626 if (!spec->pin_configs)
1629 for (i = 0; i < spec->num_pins; i++)
1630 stac92xx_set_config_reg(codec, spec->pin_nids[i],
1631 spec->pin_configs[i]);
1634 static void stac92xx_enable_gpio_mask(struct hda_codec *codec)
1636 struct sigmatel_spec *spec = codec->spec;
1637 /* Configure GPIOx as output */
1638 snd_hda_codec_write_cache(codec, codec->afg, 0,
1639 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_mask);
1640 /* Configure GPIOx as CMOS */
1641 snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7e7, 0x00000000);
1643 snd_hda_codec_write_cache(codec, codec->afg, 0,
1644 AC_VERB_SET_GPIO_DATA, spec->gpio_data);
1646 snd_hda_codec_write_cache(codec, codec->afg, 0,
1647 AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
1651 * Analog playback callbacks
1653 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
1654 struct hda_codec *codec,
1655 struct snd_pcm_substream *substream)
1657 struct sigmatel_spec *spec = codec->spec;
1658 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
1661 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1662 struct hda_codec *codec,
1663 unsigned int stream_tag,
1664 unsigned int format,
1665 struct snd_pcm_substream *substream)
1667 struct sigmatel_spec *spec = codec->spec;
1668 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
1671 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1672 struct hda_codec *codec,
1673 struct snd_pcm_substream *substream)
1675 struct sigmatel_spec *spec = codec->spec;
1676 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1680 * Digital playback callbacks
1682 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1683 struct hda_codec *codec,
1684 struct snd_pcm_substream *substream)
1686 struct sigmatel_spec *spec = codec->spec;
1687 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1690 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1691 struct hda_codec *codec,
1692 struct snd_pcm_substream *substream)
1694 struct sigmatel_spec *spec = codec->spec;
1695 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1698 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1699 struct hda_codec *codec,
1700 unsigned int stream_tag,
1701 unsigned int format,
1702 struct snd_pcm_substream *substream)
1704 struct sigmatel_spec *spec = codec->spec;
1705 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1706 stream_tag, format, substream);
1711 * Analog capture callbacks
1713 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1714 struct hda_codec *codec,
1715 unsigned int stream_tag,
1716 unsigned int format,
1717 struct snd_pcm_substream *substream)
1719 struct sigmatel_spec *spec = codec->spec;
1721 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1722 stream_tag, 0, format);
1726 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1727 struct hda_codec *codec,
1728 struct snd_pcm_substream *substream)
1730 struct sigmatel_spec *spec = codec->spec;
1732 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
1736 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
1740 /* NID is set in stac92xx_build_pcms */
1742 .open = stac92xx_dig_playback_pcm_open,
1743 .close = stac92xx_dig_playback_pcm_close,
1744 .prepare = stac92xx_dig_playback_pcm_prepare
1748 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
1752 /* NID is set in stac92xx_build_pcms */
1755 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
1759 .nid = 0x02, /* NID to query formats and rates */
1761 .open = stac92xx_playback_pcm_open,
1762 .prepare = stac92xx_playback_pcm_prepare,
1763 .cleanup = stac92xx_playback_pcm_cleanup
1767 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
1771 .nid = 0x06, /* NID to query formats and rates */
1773 .open = stac92xx_playback_pcm_open,
1774 .prepare = stac92xx_playback_pcm_prepare,
1775 .cleanup = stac92xx_playback_pcm_cleanup
1779 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
1782 /* NID + .substreams is set in stac92xx_build_pcms */
1784 .prepare = stac92xx_capture_pcm_prepare,
1785 .cleanup = stac92xx_capture_pcm_cleanup
1789 static int stac92xx_build_pcms(struct hda_codec *codec)
1791 struct sigmatel_spec *spec = codec->spec;
1792 struct hda_pcm *info = spec->pcm_rec;
1794 codec->num_pcms = 1;
1795 codec->pcm_info = info;
1797 info->name = "STAC92xx Analog";
1798 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
1799 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
1800 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1801 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
1803 if (spec->alt_switch) {
1806 info->name = "STAC92xx Analog Alt";
1807 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
1810 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1813 info->name = "STAC92xx Digital";
1814 if (spec->multiout.dig_out_nid) {
1815 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
1816 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
1818 if (spec->dig_in_nid) {
1819 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
1820 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
1827 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
1829 unsigned int pincap = snd_hda_param_read(codec, nid,
1831 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
1832 if (pincap & AC_PINCAP_VREF_100)
1833 return AC_PINCTL_VREF_100;
1834 if (pincap & AC_PINCAP_VREF_80)
1835 return AC_PINCTL_VREF_80;
1836 if (pincap & AC_PINCAP_VREF_50)
1837 return AC_PINCTL_VREF_50;
1838 if (pincap & AC_PINCAP_VREF_GRD)
1839 return AC_PINCTL_VREF_GRD;
1843 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
1846 snd_hda_codec_write_cache(codec, nid, 0,
1847 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
1850 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
1852 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1854 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1855 struct sigmatel_spec *spec = codec->spec;
1856 int io_idx = kcontrol-> private_value & 0xff;
1858 ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
1862 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1864 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1865 struct sigmatel_spec *spec = codec->spec;
1866 hda_nid_t nid = kcontrol->private_value >> 8;
1867 int io_idx = kcontrol-> private_value & 0xff;
1868 unsigned short val = !!ucontrol->value.integer.value[0];
1870 spec->io_switch[io_idx] = val;
1873 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
1875 unsigned int pinctl = AC_PINCTL_IN_EN;
1876 if (io_idx) /* set VREF for mic */
1877 pinctl |= stac92xx_get_vref(codec, nid);
1878 stac92xx_auto_set_pinctl(codec, nid, pinctl);
1881 /* check the auto-mute again: we need to mute/unmute the speaker
1882 * appropriately according to the pin direction
1884 if (spec->hp_detect)
1885 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
1890 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
1892 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
1893 struct snd_ctl_elem_value *ucontrol)
1895 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1896 struct sigmatel_spec *spec = codec->spec;
1898 ucontrol->value.integer.value[0] = spec->clfe_swap;
1902 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
1903 struct snd_ctl_elem_value *ucontrol)
1905 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1906 struct sigmatel_spec *spec = codec->spec;
1907 hda_nid_t nid = kcontrol->private_value & 0xff;
1908 unsigned int val = !!ucontrol->value.integer.value[0];
1910 if (spec->clfe_swap == val)
1913 spec->clfe_swap = val;
1915 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1916 spec->clfe_swap ? 0x4 : 0x0);
1921 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
1922 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1925 .info = stac92xx_io_switch_info, \
1926 .get = stac92xx_io_switch_get, \
1927 .put = stac92xx_io_switch_put, \
1928 .private_value = xpval, \
1931 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
1932 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1935 .info = stac92xx_clfe_switch_info, \
1936 .get = stac92xx_clfe_switch_get, \
1937 .put = stac92xx_clfe_switch_put, \
1938 .private_value = xpval, \
1942 STAC_CTL_WIDGET_VOL,
1943 STAC_CTL_WIDGET_MUTE,
1944 STAC_CTL_WIDGET_IO_SWITCH,
1945 STAC_CTL_WIDGET_CLFE_SWITCH
1948 static struct snd_kcontrol_new stac92xx_control_templates[] = {
1949 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
1950 HDA_CODEC_MUTE(NULL, 0, 0, 0),
1951 STAC_CODEC_IO_SWITCH(NULL, 0),
1952 STAC_CODEC_CLFE_SWITCH(NULL, 0),
1955 /* add dynamic controls */
1956 static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val)
1958 struct snd_kcontrol_new *knew;
1960 if (spec->num_kctl_used >= spec->num_kctl_alloc) {
1961 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
1963 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
1966 if (spec->kctl_alloc) {
1967 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
1968 kfree(spec->kctl_alloc);
1970 spec->kctl_alloc = knew;
1971 spec->num_kctl_alloc = num;
1974 knew = &spec->kctl_alloc[spec->num_kctl_used];
1975 *knew = stac92xx_control_templates[type];
1976 knew->name = kstrdup(name, GFP_KERNEL);
1979 knew->private_value = val;
1980 spec->num_kctl_used++;
1984 /* flag inputs as additional dynamic lineouts */
1985 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
1987 struct sigmatel_spec *spec = codec->spec;
1988 unsigned int wcaps, wtype;
1989 int i, num_dacs = 0;
1991 /* use the wcaps cache to count all DACs available for line-outs */
1992 for (i = 0; i < codec->num_nodes; i++) {
1993 wcaps = codec->wcaps[i];
1994 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
1995 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL))
1999 snd_printdd("%s: total dac count=%d\n", __func__, num_dacs);
2001 switch (cfg->line_outs) {
2003 /* add line-in as side */
2004 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) {
2005 cfg->line_out_pins[cfg->line_outs] =
2006 cfg->input_pins[AUTO_PIN_LINE];
2007 spec->line_switch = 1;
2012 /* add line-in as clfe and mic as side */
2013 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) {
2014 cfg->line_out_pins[cfg->line_outs] =
2015 cfg->input_pins[AUTO_PIN_LINE];
2016 spec->line_switch = 1;
2019 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) {
2020 cfg->line_out_pins[cfg->line_outs] =
2021 cfg->input_pins[AUTO_PIN_MIC];
2022 spec->mic_switch = 1;
2027 /* add line-in as surr and mic as clfe */
2028 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) {
2029 cfg->line_out_pins[cfg->line_outs] =
2030 cfg->input_pins[AUTO_PIN_LINE];
2031 spec->line_switch = 1;
2034 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) {
2035 cfg->line_out_pins[cfg->line_outs] =
2036 cfg->input_pins[AUTO_PIN_MIC];
2037 spec->mic_switch = 1;
2047 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2051 for (i = 0; i < spec->multiout.num_dacs; i++) {
2052 if (spec->multiout.dac_nids[i] == nid)
2060 * Fill in the dac_nids table from the parsed pin configuration
2061 * This function only works when every pin in line_out_pins[]
2062 * contains atleast one DAC in its connection list. Some 92xx
2063 * codecs are not connected directly to a DAC, such as the 9200
2064 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2066 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec,
2067 struct auto_pin_cfg *cfg)
2069 struct sigmatel_spec *spec = codec->spec;
2070 int i, j, conn_len = 0;
2071 hda_nid_t nid, conn[HDA_MAX_CONNECTIONS];
2072 unsigned int wcaps, wtype;
2074 for (i = 0; i < cfg->line_outs; i++) {
2075 nid = cfg->line_out_pins[i];
2076 conn_len = snd_hda_get_connections(codec, nid, conn,
2077 HDA_MAX_CONNECTIONS);
2078 for (j = 0; j < conn_len; j++) {
2079 wcaps = snd_hda_param_read(codec, conn[j],
2080 AC_PAR_AUDIO_WIDGET_CAP);
2081 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2083 if (wtype != AC_WID_AUD_OUT ||
2084 (wcaps & AC_WCAP_DIGITAL))
2086 /* conn[j] is a DAC routed to this line-out */
2087 if (!is_in_dac_nids(spec, conn[j]))
2091 if (j == conn_len) {
2092 if (spec->multiout.num_dacs > 0) {
2093 /* we have already working output pins,
2094 * so let's drop the broken ones again
2096 cfg->line_outs = spec->multiout.num_dacs;
2099 /* error out, no available DAC found */
2101 "%s: No available DAC for pin 0x%x\n",
2106 spec->multiout.dac_nids[i] = conn[j];
2107 spec->multiout.num_dacs++;
2109 /* select this DAC in the pin's input mux */
2110 snd_hda_codec_write_cache(codec, nid, 0,
2111 AC_VERB_SET_CONNECT_SEL, j);
2116 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2117 spec->multiout.num_dacs,
2118 spec->multiout.dac_nids[0],
2119 spec->multiout.dac_nids[1],
2120 spec->multiout.dac_nids[2],
2121 spec->multiout.dac_nids[3],
2122 spec->multiout.dac_nids[4]);
2126 /* create volume control/switch for the given prefx type */
2127 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
2132 sprintf(name, "%s Playback Volume", pfx);
2133 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
2134 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2137 sprintf(name, "%s Playback Switch", pfx);
2138 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
2139 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2145 /* add playback controls from the parsed DAC table */
2146 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
2147 const struct auto_pin_cfg *cfg)
2149 static const char *chname[4] = {
2150 "Front", "Surround", NULL /*CLFE*/, "Side"
2155 struct sigmatel_spec *spec = codec->spec;
2156 unsigned int wid_caps;
2159 for (i = 0; i < cfg->line_outs; i++) {
2160 if (!spec->multiout.dac_nids[i])
2163 nid = spec->multiout.dac_nids[i];
2167 err = create_controls(spec, "Center", nid, 1);
2170 err = create_controls(spec, "LFE", nid, 2);
2174 wid_caps = get_wcaps(codec, nid);
2176 if (wid_caps & AC_WCAP_LR_SWAP) {
2177 err = stac92xx_add_control(spec,
2178 STAC_CTL_WIDGET_CLFE_SWITCH,
2179 "Swap Center/LFE Playback Switch", nid);
2186 err = create_controls(spec, chname[i], nid, 3);
2192 if (spec->line_switch)
2193 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Line In as Output Switch", cfg->input_pins[AUTO_PIN_LINE] << 8)) < 0)
2196 if (spec->mic_switch)
2197 if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH, "Mic as Output Switch", (cfg->input_pins[AUTO_PIN_MIC] << 8) | 1)) < 0)
2203 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2205 if (is_in_dac_nids(spec, nid))
2207 if (spec->multiout.hp_nid == nid)
2212 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
2214 if (!spec->multiout.hp_nid)
2215 spec->multiout.hp_nid = nid;
2216 else if (spec->multiout.num_dacs > 4) {
2217 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
2220 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
2221 spec->multiout.num_dacs++;
2226 /* add playback controls for Speaker and HP outputs */
2227 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
2228 struct auto_pin_cfg *cfg)
2230 struct sigmatel_spec *spec = codec->spec;
2232 int i, old_num_dacs, err;
2234 old_num_dacs = spec->multiout.num_dacs;
2235 for (i = 0; i < cfg->hp_outs; i++) {
2236 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
2237 if (wid_caps & AC_WCAP_UNSOL_CAP)
2238 spec->hp_detect = 1;
2239 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
2240 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2241 if (check_in_dac_nids(spec, nid))
2245 add_spec_dacs(spec, nid);
2247 for (i = 0; i < cfg->speaker_outs; i++) {
2248 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0,
2249 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2250 if (check_in_dac_nids(spec, nid))
2254 add_spec_dacs(spec, nid);
2256 for (i = 0; i < cfg->line_outs; i++) {
2257 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0,
2258 AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
2259 if (check_in_dac_nids(spec, nid))
2263 add_spec_dacs(spec, nid);
2265 for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) {
2266 static const char *pfxs[] = {
2267 "Speaker", "External Speaker", "Speaker2",
2269 err = create_controls(spec, pfxs[i - old_num_dacs],
2270 spec->multiout.dac_nids[i], 3);
2274 if (spec->multiout.hp_nid) {
2276 if (old_num_dacs == spec->multiout.num_dacs)
2280 err = create_controls(spec, pfx, spec->multiout.hp_nid, 3);
2288 /* labels for dmic mux inputs */
2289 static const char *stac92xx_dmic_labels[5] = {
2290 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
2291 "Digital Mic 3", "Digital Mic 4"
2294 /* create playback/capture controls for input pins on dmic capable codecs */
2295 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
2296 const struct auto_pin_cfg *cfg)
2298 struct sigmatel_spec *spec = codec->spec;
2299 struct hda_input_mux *dimux = &spec->private_dimux;
2300 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2303 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
2304 dimux->items[dimux->num_items].index = 0;
2307 for (i = 0; i < spec->num_dmics; i++) {
2310 unsigned int def_conf;
2312 def_conf = snd_hda_codec_read(codec,
2315 AC_VERB_GET_CONFIG_DEFAULT,
2317 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
2320 num_cons = snd_hda_get_connections(codec,
2323 HDA_MAX_NUM_INPUTS);
2324 for (j = 0; j < num_cons; j++)
2325 if (con_lst[j] == spec->dmic_nids[i]) {
2331 dimux->items[dimux->num_items].label =
2332 stac92xx_dmic_labels[dimux->num_items];
2333 dimux->items[dimux->num_items].index = index;
2340 /* create playback/capture controls for input pins */
2341 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
2343 struct sigmatel_spec *spec = codec->spec;
2344 struct hda_input_mux *imux = &spec->private_imux;
2345 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
2348 for (i = 0; i < AUTO_PIN_LAST; i++) {
2351 if (!cfg->input_pins[i])
2354 for (j = 0; j < spec->num_muxes; j++) {
2356 num_cons = snd_hda_get_connections(codec,
2359 HDA_MAX_NUM_INPUTS);
2360 for (k = 0; k < num_cons; k++)
2361 if (con_lst[k] == cfg->input_pins[i]) {
2368 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2369 imux->items[imux->num_items].index = index;
2373 if (imux->num_items) {
2375 * Set the current input for the muxes.
2376 * The STAC9221 has two input muxes with identical source
2377 * NID lists. Hopefully this won't get confused.
2379 for (i = 0; i < spec->num_muxes; i++) {
2380 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
2381 AC_VERB_SET_CONNECT_SEL,
2382 imux->items[0].index);
2389 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
2391 struct sigmatel_spec *spec = codec->spec;
2394 for (i = 0; i < spec->autocfg.line_outs; i++) {
2395 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2396 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2400 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
2402 struct sigmatel_spec *spec = codec->spec;
2405 for (i = 0; i < spec->autocfg.hp_outs; i++) {
2407 pin = spec->autocfg.hp_pins[i];
2408 if (pin) /* connect to front */
2409 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
2411 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
2413 pin = spec->autocfg.speaker_pins[i];
2414 if (pin) /* connect to front */
2415 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
2419 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
2421 struct sigmatel_spec *spec = codec->spec;
2423 int hp_speaker_swap = 0;
2425 if ((err = snd_hda_parse_pin_def_config(codec,
2427 spec->dmic_nids)) < 0)
2429 if (! spec->autocfg.line_outs)
2430 return 0; /* can't find valid pin config */
2432 /* If we have no real line-out pin and multiple hp-outs, HPs should
2433 * be set up as multi-channel outputs.
2435 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
2436 spec->autocfg.hp_outs > 1) {
2437 /* Copy hp_outs to line_outs, backup line_outs in
2438 * speaker_outs so that the following routines can handle
2439 * HP pins as primary outputs.
2441 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
2442 sizeof(spec->autocfg.line_out_pins));
2443 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
2444 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
2445 sizeof(spec->autocfg.hp_pins));
2446 spec->autocfg.line_outs = spec->autocfg.hp_outs;
2447 hp_speaker_swap = 1;
2450 if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0)
2452 if (spec->multiout.num_dacs == 0)
2453 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2456 err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg);
2461 if (hp_speaker_swap == 1) {
2462 /* Restore the hp_outs and line_outs */
2463 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
2464 sizeof(spec->autocfg.line_out_pins));
2465 spec->autocfg.hp_outs = spec->autocfg.line_outs;
2466 memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins,
2467 sizeof(spec->autocfg.speaker_pins));
2468 spec->autocfg.line_outs = spec->autocfg.speaker_outs;
2469 memset(spec->autocfg.speaker_pins, 0,
2470 sizeof(spec->autocfg.speaker_pins));
2471 spec->autocfg.speaker_outs = 0;
2474 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
2479 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
2484 if (spec->num_dmics > 0)
2485 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
2486 &spec->autocfg)) < 0)
2489 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2490 if (spec->multiout.max_channels > 2)
2491 spec->surr_switch = 1;
2493 if (spec->autocfg.dig_out_pin)
2494 spec->multiout.dig_out_nid = dig_out;
2495 if (spec->autocfg.dig_in_pin)
2496 spec->dig_in_nid = dig_in;
2498 if (spec->kctl_alloc)
2499 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2501 spec->input_mux = &spec->private_imux;
2502 if (!spec->dinput_mux)
2503 spec->dinput_mux = &spec->private_dimux;
2508 /* add playback controls for HP output */
2509 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
2510 struct auto_pin_cfg *cfg)
2512 struct sigmatel_spec *spec = codec->spec;
2513 hda_nid_t pin = cfg->hp_pins[0];
2514 unsigned int wid_caps;
2519 wid_caps = get_wcaps(codec, pin);
2520 if (wid_caps & AC_WCAP_UNSOL_CAP)
2521 spec->hp_detect = 1;
2526 /* add playback controls for LFE output */
2527 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
2528 struct auto_pin_cfg *cfg)
2530 struct sigmatel_spec *spec = codec->spec;
2532 hda_nid_t lfe_pin = 0x0;
2536 * search speaker outs and line outs for a mono speaker pin
2537 * with an amp. If one is found, add LFE controls
2540 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
2541 hda_nid_t pin = spec->autocfg.speaker_pins[i];
2542 unsigned long wcaps = get_wcaps(codec, pin);
2543 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2544 if (wcaps == AC_WCAP_OUT_AMP)
2545 /* found a mono speaker with an amp, must be lfe */
2549 /* if speaker_outs is 0, then speakers may be in line_outs */
2550 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
2551 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
2552 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2554 cfg = snd_hda_codec_read(codec, pin, 0,
2555 AC_VERB_GET_CONFIG_DEFAULT,
2557 if (get_defcfg_device(cfg) == AC_JACK_SPEAKER) {
2558 unsigned long wcaps = get_wcaps(codec, pin);
2559 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
2560 if (wcaps == AC_WCAP_OUT_AMP)
2561 /* found a mono speaker with an amp,
2569 err = create_controls(spec, "LFE", lfe_pin, 1);
2577 static int stac9200_parse_auto_config(struct hda_codec *codec)
2579 struct sigmatel_spec *spec = codec->spec;
2582 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2585 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
2588 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
2591 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
2594 if (spec->autocfg.dig_out_pin)
2595 spec->multiout.dig_out_nid = 0x05;
2596 if (spec->autocfg.dig_in_pin)
2597 spec->dig_in_nid = 0x04;
2599 if (spec->kctl_alloc)
2600 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2602 spec->input_mux = &spec->private_imux;
2603 spec->dinput_mux = &spec->private_dimux;
2609 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
2610 * funky external mute control using GPIO pins.
2613 static void stac922x_gpio_mute(struct hda_codec *codec, int pin, int muted)
2615 unsigned int gpiostate, gpiomask, gpiodir;
2617 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
2618 AC_VERB_GET_GPIO_DATA, 0);
2621 gpiostate |= (1 << pin);
2623 gpiostate &= ~(1 << pin);
2625 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
2626 AC_VERB_GET_GPIO_MASK, 0);
2627 gpiomask |= (1 << pin);
2629 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
2630 AC_VERB_GET_GPIO_DIRECTION, 0);
2631 gpiodir |= (1 << pin);
2633 /* AppleHDA seems to do this -- WTF is this verb?? */
2634 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
2636 snd_hda_codec_write(codec, codec->afg, 0,
2637 AC_VERB_SET_GPIO_MASK, gpiomask);
2638 snd_hda_codec_write(codec, codec->afg, 0,
2639 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
2643 snd_hda_codec_write(codec, codec->afg, 0,
2644 AC_VERB_SET_GPIO_DATA, gpiostate);
2647 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
2650 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP)
2651 snd_hda_codec_write_cache(codec, nid, 0,
2652 AC_VERB_SET_UNSOLICITED_ENABLE,
2653 (AC_USRSP_EN | event));
2656 static int stac92xx_init(struct hda_codec *codec)
2658 struct sigmatel_spec *spec = codec->spec;
2659 struct auto_pin_cfg *cfg = &spec->autocfg;
2662 snd_hda_sequence_write(codec, spec->init);
2665 if (spec->hp_detect) {
2666 /* Enable unsolicited responses on the HP widget */
2667 for (i = 0; i < cfg->hp_outs; i++)
2668 enable_pin_detect(codec, cfg->hp_pins[i],
2670 /* force to enable the first line-out; the others are set up
2673 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
2675 stac92xx_auto_init_hp_out(codec);
2676 /* fake event to set up pins */
2677 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2679 stac92xx_auto_init_multi_out(codec);
2680 stac92xx_auto_init_hp_out(codec);
2682 for (i = 0; i < AUTO_PIN_LAST; i++) {
2683 hda_nid_t nid = cfg->input_pins[i];
2685 unsigned int pinctl = AC_PINCTL_IN_EN;
2686 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
2687 pinctl |= stac92xx_get_vref(codec, nid);
2688 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2691 if (spec->num_dmics > 0)
2692 for (i = 0; i < spec->num_dmics; i++)
2693 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
2696 if (cfg->dig_out_pin)
2697 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
2699 if (cfg->dig_in_pin)
2700 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
2703 if (spec->gpio_mute) {
2704 stac922x_gpio_mute(codec, 0, 0);
2705 stac922x_gpio_mute(codec, 1, 0);
2711 static void stac92xx_free(struct hda_codec *codec)
2713 struct sigmatel_spec *spec = codec->spec;
2719 if (spec->kctl_alloc) {
2720 for (i = 0; i < spec->num_kctl_used; i++)
2721 kfree(spec->kctl_alloc[i].name);
2722 kfree(spec->kctl_alloc);
2725 if (spec->bios_pin_configs)
2726 kfree(spec->bios_pin_configs);
2731 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
2734 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2735 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2737 if (pin_ctl & AC_PINCTL_IN_EN) {
2739 * we need to check the current set-up direction of
2740 * shared input pins since they can be switched via
2741 * "xxx as Output" mixer switch
2743 struct sigmatel_spec *spec = codec->spec;
2744 struct auto_pin_cfg *cfg = &spec->autocfg;
2745 if ((nid == cfg->input_pins[AUTO_PIN_LINE] &&
2746 spec->line_switch) ||
2747 (nid == cfg->input_pins[AUTO_PIN_MIC] &&
2752 /* if setting pin direction bits, clear the current
2753 direction bits first */
2754 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
2755 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
2757 snd_hda_codec_write_cache(codec, nid, 0,
2758 AC_VERB_SET_PIN_WIDGET_CONTROL,
2762 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
2765 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
2766 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
2767 snd_hda_codec_write_cache(codec, nid, 0,
2768 AC_VERB_SET_PIN_WIDGET_CONTROL,
2772 static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid)
2776 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
2778 unsigned int pinctl;
2779 pinctl = snd_hda_codec_read(codec, nid, 0,
2780 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2781 if (pinctl & AC_PINCTL_IN_EN)
2782 return 0; /* mic- or line-input */
2784 return 1; /* HP-output */
2789 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res)
2791 struct sigmatel_spec *spec = codec->spec;
2792 struct auto_pin_cfg *cfg = &spec->autocfg;
2796 for (i = 0; i < cfg->hp_outs; i++) {
2797 presence = get_hp_pin_presence(codec, cfg->hp_pins[i]);
2803 /* disable lineouts, enable hp */
2804 for (i = 0; i < cfg->line_outs; i++)
2805 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
2807 for (i = 0; i < cfg->speaker_outs; i++)
2808 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
2811 /* enable lineouts, disable hp */
2812 for (i = 0; i < cfg->line_outs; i++)
2813 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
2815 for (i = 0; i < cfg->speaker_outs; i++)
2816 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
2821 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
2823 switch (res >> 26) {
2825 stac92xx_hp_detect(codec, res);
2830 #ifdef SND_HDA_NEEDS_RESUME
2831 static int stac92xx_resume(struct hda_codec *codec)
2833 struct sigmatel_spec *spec = codec->spec;
2835 stac92xx_set_config_regs(codec);
2836 snd_hda_sequence_write(codec, spec->init);
2837 if (spec->gpio_mute) {
2838 stac922x_gpio_mute(codec, 0, 0);
2839 stac922x_gpio_mute(codec, 1, 0);
2841 snd_hda_codec_resume_amp(codec);
2842 snd_hda_codec_resume_cache(codec);
2843 /* invoke unsolicited event to reset the HP state */
2844 if (spec->hp_detect)
2845 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
2850 static struct hda_codec_ops stac92xx_patch_ops = {
2851 .build_controls = stac92xx_build_controls,
2852 .build_pcms = stac92xx_build_pcms,
2853 .init = stac92xx_init,
2854 .free = stac92xx_free,
2855 .unsol_event = stac92xx_unsol_event,
2856 #ifdef SND_HDA_NEEDS_RESUME
2857 .resume = stac92xx_resume,
2861 static int patch_stac9200(struct hda_codec *codec)
2863 struct sigmatel_spec *spec;
2866 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2871 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
2872 spec->pin_nids = stac9200_pin_nids;
2873 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
2876 if (spec->board_config < 0) {
2877 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
2878 err = stac92xx_save_bios_config_regs(codec);
2880 stac92xx_free(codec);
2883 spec->pin_configs = spec->bios_pin_configs;
2885 spec->pin_configs = stac9200_brd_tbl[spec->board_config];
2886 stac92xx_set_config_regs(codec);
2889 spec->multiout.max_channels = 2;
2890 spec->multiout.num_dacs = 1;
2891 spec->multiout.dac_nids = stac9200_dac_nids;
2892 spec->adc_nids = stac9200_adc_nids;
2893 spec->mux_nids = stac9200_mux_nids;
2894 spec->num_muxes = 1;
2895 spec->num_dmics = 0;
2898 if (spec->board_config == STAC_9200_GATEWAY)
2899 spec->init = stac9200_eapd_init;
2901 spec->init = stac9200_core_init;
2902 spec->mixer = stac9200_mixer;
2904 err = stac9200_parse_auto_config(codec);
2906 stac92xx_free(codec);
2910 codec->patch_ops = stac92xx_patch_ops;
2915 static int patch_stac925x(struct hda_codec *codec)
2917 struct sigmatel_spec *spec;
2920 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2925 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
2926 spec->pin_nids = stac925x_pin_nids;
2927 spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS,
2931 if (spec->board_config < 0) {
2932 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
2933 "using BIOS defaults\n");
2934 err = stac92xx_save_bios_config_regs(codec);
2936 stac92xx_free(codec);
2939 spec->pin_configs = spec->bios_pin_configs;
2940 } else if (stac925x_brd_tbl[spec->board_config] != NULL){
2941 spec->pin_configs = stac925x_brd_tbl[spec->board_config];
2942 stac92xx_set_config_regs(codec);
2945 spec->multiout.max_channels = 2;
2946 spec->multiout.num_dacs = 1;
2947 spec->multiout.dac_nids = stac925x_dac_nids;
2948 spec->adc_nids = stac925x_adc_nids;
2949 spec->mux_nids = stac925x_mux_nids;
2950 spec->num_muxes = 1;
2952 switch (codec->vendor_id) {
2953 case 0x83847632: /* STAC9202 */
2954 case 0x83847633: /* STAC9202D */
2955 case 0x83847636: /* STAC9251 */
2956 case 0x83847637: /* STAC9251D */
2957 spec->num_dmics = STAC925X_NUM_DMICS;
2958 spec->dmic_nids = stac925x_dmic_nids;
2961 spec->num_dmics = 0;
2965 spec->init = stac925x_core_init;
2966 spec->mixer = stac925x_mixer;
2968 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
2970 if (spec->board_config < 0) {
2971 printk(KERN_WARNING "hda_codec: No auto-config is "
2972 "available, default to model=ref\n");
2973 spec->board_config = STAC_925x_REF;
2979 stac92xx_free(codec);
2983 codec->patch_ops = stac92xx_patch_ops;
2988 static struct hda_input_mux stac92hd73xx_dmux = {
2991 { "Analog Inputs", 0x0b },
2993 { "Digital Mic 1", 0x09 },
2994 { "Digital Mic 2", 0x0a },
2998 static int patch_stac92hd73xx(struct hda_codec *codec)
3000 struct sigmatel_spec *spec;
3001 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
3004 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3009 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
3010 spec->pin_nids = stac92hd73xx_pin_nids;
3011 spec->board_config = snd_hda_check_board_config(codec,
3012 STAC_92HD73XX_MODELS,
3013 stac92hd73xx_models,
3014 stac92hd73xx_cfg_tbl);
3016 if (spec->board_config < 0) {
3017 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3018 " STAC92HD73XX, using BIOS defaults\n");
3019 err = stac92xx_save_bios_config_regs(codec);
3021 stac92xx_free(codec);
3024 spec->pin_configs = spec->bios_pin_configs;
3026 spec->pin_configs = stac92hd73xx_brd_tbl[spec->board_config];
3027 stac92xx_set_config_regs(codec);
3030 spec->multiout.num_dacs = snd_hda_get_connections(codec, 0x0a,
3031 conn, STAC92HD73_DAC_COUNT + 2) - 1;
3033 if (spec->multiout.num_dacs < 0) {
3034 printk(KERN_WARNING "hda_codec: Could not determine "
3035 "number of channels defaulting to DAC count\n");
3036 spec->multiout.num_dacs = STAC92HD73_DAC_COUNT;
3039 switch (spec->multiout.num_dacs) {
3040 case 0x3: /* 6 Channel */
3041 spec->mixer = stac92hd73xx_6ch_mixer;
3042 spec->init = stac92hd73xx_6ch_core_init;
3044 case 0x4: /* 8 Channel */
3045 spec->multiout.hp_nid = 0x18;
3046 spec->mixer = stac92hd73xx_8ch_mixer;
3047 spec->init = stac92hd73xx_8ch_core_init;
3049 case 0x5: /* 10 Channel */
3050 spec->multiout.hp_nid = 0x19;
3051 spec->mixer = stac92hd73xx_10ch_mixer;
3052 spec->init = stac92hd73xx_10ch_core_init;
3055 spec->multiout.dac_nids = stac92hd73xx_dac_nids;
3056 spec->aloopback_mask = 0x01;
3057 spec->aloopback_shift = 8;
3059 spec->mux_nids = stac92hd73xx_mux_nids;
3060 spec->adc_nids = stac92hd73xx_adc_nids;
3061 spec->dmic_nids = stac92hd73xx_dmic_nids;
3062 spec->dmux_nids = stac92hd73xx_dmux_nids;
3064 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
3065 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
3066 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
3067 spec->dinput_mux = &stac92hd73xx_dmux;
3068 /* GPIO0 High = Enable EAPD */
3069 spec->gpio_mask = spec->gpio_data = 0x000001;
3070 stac92xx_enable_gpio_mask(codec);
3072 err = stac92xx_parse_auto_config(codec, 0x22, 0x24);
3075 if (spec->board_config < 0) {
3076 printk(KERN_WARNING "hda_codec: No auto-config is "
3077 "available, default to model=ref\n");
3078 spec->board_config = STAC_92HD73XX_REF;
3085 stac92xx_free(codec);
3089 codec->patch_ops = stac92xx_patch_ops;
3094 static int patch_stac92hd71bxx(struct hda_codec *codec)
3096 struct sigmatel_spec *spec;
3099 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3104 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
3105 spec->pin_nids = stac92hd71bxx_pin_nids;
3106 spec->board_config = snd_hda_check_board_config(codec,
3107 STAC_92HD71BXX_MODELS,
3108 stac92hd71bxx_models,
3109 stac92hd71bxx_cfg_tbl);
3111 if (spec->board_config < 0) {
3112 snd_printdd(KERN_INFO "hda_codec: Unknown model for"
3113 " STAC92HD71BXX, using BIOS defaults\n");
3114 err = stac92xx_save_bios_config_regs(codec);
3116 stac92xx_free(codec);
3119 spec->pin_configs = spec->bios_pin_configs;
3121 spec->pin_configs = stac92hd71bxx_brd_tbl[spec->board_config];
3122 stac92xx_set_config_regs(codec);
3125 switch (codec->vendor_id) {
3126 case 0x111d76b6: /* 4 Port without Analog Mixer */
3128 case 0x111d76b4: /* 6 Port without Analog Mixer */
3130 spec->mixer = stac92hd71bxx_mixer;
3131 spec->init = stac92hd71bxx_core_init;
3134 spec->mixer = stac92hd71bxx_analog_mixer;
3135 spec->init = stac92hd71bxx_analog_core_init;
3138 spec->aloopback_mask = 0x20;
3139 spec->aloopback_shift = 0;
3141 spec->gpio_mask = spec->gpio_data = 0x00000001; /* GPIO0 High = EAPD */
3142 stac92xx_enable_gpio_mask(codec);
3144 spec->mux_nids = stac92hd71bxx_mux_nids;
3145 spec->adc_nids = stac92hd71bxx_adc_nids;
3146 spec->dmic_nids = stac92hd71bxx_dmic_nids;
3147 spec->dmux_nids = stac92hd71bxx_dmux_nids;
3149 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
3150 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
3151 spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
3153 spec->multiout.num_dacs = 2;
3154 spec->multiout.hp_nid = 0x11;
3155 spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
3157 err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
3159 if (spec->board_config < 0) {
3160 printk(KERN_WARNING "hda_codec: No auto-config is "
3161 "available, default to model=ref\n");
3162 spec->board_config = STAC_92HD71BXX_REF;
3169 stac92xx_free(codec);
3173 codec->patch_ops = stac92xx_patch_ops;
3178 static int patch_stac922x(struct hda_codec *codec)
3180 struct sigmatel_spec *spec;
3183 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3188 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
3189 spec->pin_nids = stac922x_pin_nids;
3190 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
3193 if (spec->board_config == STAC_INTEL_MAC_V3) {
3194 spec->gpio_mute = 1;
3195 /* Intel Macs have all same PCI SSID, so we need to check
3196 * codec SSID to distinguish the exact models
3198 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
3199 switch (codec->subsystem_id) {
3202 spec->board_config = STAC_INTEL_MAC_V1;
3206 spec->board_config = STAC_INTEL_MAC_V2;
3214 spec->board_config = STAC_INTEL_MAC_V3;
3218 spec->board_config = STAC_INTEL_MAC_V4;
3222 spec->board_config = STAC_INTEL_MAC_V5;
3228 if (spec->board_config < 0) {
3229 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
3230 "using BIOS defaults\n");
3231 err = stac92xx_save_bios_config_regs(codec);
3233 stac92xx_free(codec);
3236 spec->pin_configs = spec->bios_pin_configs;
3237 } else if (stac922x_brd_tbl[spec->board_config] != NULL) {
3238 spec->pin_configs = stac922x_brd_tbl[spec->board_config];
3239 stac92xx_set_config_regs(codec);
3242 spec->adc_nids = stac922x_adc_nids;
3243 spec->mux_nids = stac922x_mux_nids;
3244 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
3245 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
3246 spec->num_dmics = 0;
3248 spec->init = stac922x_core_init;
3249 spec->mixer = stac922x_mixer;
3251 spec->multiout.dac_nids = spec->dac_nids;
3253 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
3255 if (spec->board_config < 0) {
3256 printk(KERN_WARNING "hda_codec: No auto-config is "
3257 "available, default to model=ref\n");
3258 spec->board_config = STAC_D945_REF;
3264 stac92xx_free(codec);
3268 codec->patch_ops = stac92xx_patch_ops;
3270 /* Fix Mux capture level; max to 2 */
3271 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
3272 (0 << AC_AMPCAP_OFFSET_SHIFT) |
3273 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3274 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3275 (0 << AC_AMPCAP_MUTE_SHIFT));
3280 static int patch_stac927x(struct hda_codec *codec)
3282 struct sigmatel_spec *spec;
3285 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3290 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
3291 spec->pin_nids = stac927x_pin_nids;
3292 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
3296 if (spec->board_config < 0) {
3297 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC927x, using BIOS defaults\n");
3298 err = stac92xx_save_bios_config_regs(codec);
3300 stac92xx_free(codec);
3303 spec->pin_configs = spec->bios_pin_configs;
3304 } else if (stac927x_brd_tbl[spec->board_config] != NULL) {
3305 spec->pin_configs = stac927x_brd_tbl[spec->board_config];
3306 stac92xx_set_config_regs(codec);
3309 switch (spec->board_config) {
3311 spec->adc_nids = stac927x_adc_nids;
3312 spec->mux_nids = stac927x_mux_nids;
3313 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
3314 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
3315 spec->init = d965_core_init;
3316 spec->mixer = stac927x_mixer;
3319 spec->adc_nids = stac927x_adc_nids;
3320 spec->mux_nids = stac927x_mux_nids;
3321 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
3322 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
3323 spec->init = d965_core_init;
3324 spec->mixer = stac927x_mixer;
3327 spec->adc_nids = stac927x_adc_nids;
3328 spec->mux_nids = stac927x_mux_nids;
3329 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
3330 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
3331 spec->init = stac927x_core_init;
3332 spec->mixer = stac927x_mixer;
3335 switch (codec->subsystem_id) {
3336 case 0x10280242: /* STAC 9228 */
3340 spec->dmic_nids = stac927x_dmic_nids;
3341 spec->num_dmics = STAC927X_NUM_DMICS;
3342 spec->dmux_nids = stac927x_dmux_nids;
3345 stac92xx_set_config_reg(codec, 0x13, 0x90a60040);
3347 /* GPIO2 High = Enable EAPD */
3348 spec->gpio_mask = spec->gpio_data = 0x00000004;
3351 spec->num_dmics = 0;
3353 /* GPIO0 High = Enable EAPD */
3354 spec->gpio_mask = spec->gpio_data = 0x00000001;
3357 spec->multiout.dac_nids = spec->dac_nids;
3358 spec->aloopback_mask = 0x40;
3359 spec->aloopback_shift = 0;
3360 stac92xx_enable_gpio_mask(codec);
3362 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
3364 if (spec->board_config < 0) {
3365 printk(KERN_WARNING "hda_codec: No auto-config is "
3366 "available, default to model=ref\n");
3367 spec->board_config = STAC_D965_REF;
3373 stac92xx_free(codec);
3377 codec->patch_ops = stac92xx_patch_ops;
3382 static int patch_stac9205(struct hda_codec *codec)
3384 struct sigmatel_spec *spec;
3387 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3392 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
3393 spec->pin_nids = stac9205_pin_nids;
3394 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
3398 if (spec->board_config < 0) {
3399 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
3400 err = stac92xx_save_bios_config_regs(codec);
3402 stac92xx_free(codec);
3405 spec->pin_configs = spec->bios_pin_configs;
3407 spec->pin_configs = stac9205_brd_tbl[spec->board_config];
3408 stac92xx_set_config_regs(codec);
3411 spec->adc_nids = stac9205_adc_nids;
3412 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
3413 spec->mux_nids = stac9205_mux_nids;
3414 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
3415 spec->dmic_nids = stac9205_dmic_nids;
3416 spec->num_dmics = STAC9205_NUM_DMICS;
3417 spec->dmux_nids = stac9205_dmux_nids;
3419 spec->init = stac9205_core_init;
3420 spec->mixer = stac9205_mixer;
3422 spec->aloopback_mask = 0x40;
3423 spec->aloopback_shift = 0;
3424 spec->multiout.dac_nids = spec->dac_nids;
3426 switch (spec->board_config){
3427 case STAC_9205_DELL_M43:
3428 /* Enable SPDIF in/out */
3429 stac92xx_set_config_reg(codec, 0x1f, 0x01441030);
3430 stac92xx_set_config_reg(codec, 0x20, 0x1c410030);
3432 spec->gpio_mask = 0x00000007; /* GPIO0-2 */
3433 /* GPIO0 High = EAPD, GPIO1 Low = DRM,
3434 * GPIO2 High = Headphone Mute
3436 spec->gpio_data = 0x00000005;
3439 /* GPIO0 High = EAPD */
3440 spec->gpio_mask = spec->gpio_data = 0x00000001;
3444 stac92xx_enable_gpio_mask(codec);
3445 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
3447 if (spec->board_config < 0) {
3448 printk(KERN_WARNING "hda_codec: No auto-config is "
3449 "available, default to model=ref\n");
3450 spec->board_config = STAC_9205_REF;
3456 stac92xx_free(codec);
3460 codec->patch_ops = stac92xx_patch_ops;
3469 /* static config for Sony VAIO FE550G and Sony VAIO AR */
3470 static hda_nid_t vaio_dacs[] = { 0x2 };
3471 #define VAIO_HP_DAC 0x5
3472 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
3473 static hda_nid_t vaio_mux_nids[] = { 0x15 };
3475 static struct hda_input_mux vaio_mux = {
3478 /* { "HP", 0x0 }, */
3479 { "Mic Jack", 0x1 },
3480 { "Internal Mic", 0x2 },
3485 static struct hda_verb vaio_init[] = {
3486 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3487 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
3488 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3489 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3490 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3491 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3492 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3493 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3494 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3495 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3496 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3497 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3501 static struct hda_verb vaio_ar_init[] = {
3502 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
3503 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
3504 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
3505 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
3506 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
3507 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
3508 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
3509 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
3510 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
3511 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
3512 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3513 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3514 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
3518 /* bind volumes of both NID 0x02 and 0x05 */
3519 static struct hda_bind_ctls vaio_bind_master_vol = {
3520 .ops = &snd_hda_bind_vol,
3522 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3523 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3528 /* bind volumes of both NID 0x02 and 0x05 */
3529 static struct hda_bind_ctls vaio_bind_master_sw = {
3530 .ops = &snd_hda_bind_sw,
3532 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
3533 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
3538 static struct snd_kcontrol_new vaio_mixer[] = {
3539 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3540 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3541 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3542 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3543 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3545 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3546 .name = "Capture Source",
3548 .info = stac92xx_mux_enum_info,
3549 .get = stac92xx_mux_enum_get,
3550 .put = stac92xx_mux_enum_put,
3555 static struct snd_kcontrol_new vaio_ar_mixer[] = {
3556 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol),
3557 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw),
3558 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3559 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
3560 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
3561 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
3562 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
3564 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3565 .name = "Capture Source",
3567 .info = stac92xx_mux_enum_info,
3568 .get = stac92xx_mux_enum_get,
3569 .put = stac92xx_mux_enum_put,
3574 static struct hda_codec_ops stac9872_patch_ops = {
3575 .build_controls = stac92xx_build_controls,
3576 .build_pcms = stac92xx_build_pcms,
3577 .init = stac92xx_init,
3578 .free = stac92xx_free,
3579 #ifdef SND_HDA_NEEDS_RESUME
3580 .resume = stac92xx_resume,
3584 static int stac9872_vaio_init(struct hda_codec *codec)
3588 err = stac92xx_init(codec);
3591 if (codec->patch_ops.unsol_event)
3592 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
3596 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
3598 if (get_hp_pin_presence(codec, 0x0a)) {
3599 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3600 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3602 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
3603 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
3607 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
3609 switch (res >> 26) {
3611 stac9872_vaio_hp_detect(codec, res);
3616 static struct hda_codec_ops stac9872_vaio_patch_ops = {
3617 .build_controls = stac92xx_build_controls,
3618 .build_pcms = stac92xx_build_pcms,
3619 .init = stac9872_vaio_init,
3620 .free = stac92xx_free,
3621 .unsol_event = stac9872_vaio_unsol_event,
3623 .resume = stac92xx_resume,
3627 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
3629 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
3631 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
3633 /* AR Series. id=0x83847664 and subsys=104D1300 */
3638 static const char *stac9872_models[STAC_9872_MODELS] = {
3639 [CXD9872RD_VAIO] = "vaio",
3640 [CXD9872AKD_VAIO] = "vaio-ar",
3643 static struct snd_pci_quirk stac9872_cfg_tbl[] = {
3644 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
3645 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
3646 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
3647 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
3651 static int patch_stac9872(struct hda_codec *codec)
3653 struct sigmatel_spec *spec;
3656 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
3659 if (board_config < 0)
3660 /* unknown config, let generic-parser do its job... */
3661 return snd_hda_parse_generic_codec(codec);
3663 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3668 switch (board_config) {
3669 case CXD9872RD_VAIO:
3670 case STAC9872AK_VAIO:
3671 case STAC9872K_VAIO:
3672 spec->mixer = vaio_mixer;
3673 spec->init = vaio_init;
3674 spec->multiout.max_channels = 2;
3675 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3676 spec->multiout.dac_nids = vaio_dacs;
3677 spec->multiout.hp_nid = VAIO_HP_DAC;
3678 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3679 spec->adc_nids = vaio_adcs;
3680 spec->input_mux = &vaio_mux;
3681 spec->mux_nids = vaio_mux_nids;
3682 codec->patch_ops = stac9872_vaio_patch_ops;
3685 case CXD9872AKD_VAIO:
3686 spec->mixer = vaio_ar_mixer;
3687 spec->init = vaio_ar_init;
3688 spec->multiout.max_channels = 2;
3689 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
3690 spec->multiout.dac_nids = vaio_dacs;
3691 spec->multiout.hp_nid = VAIO_HP_DAC;
3692 spec->num_adcs = ARRAY_SIZE(vaio_adcs);
3693 spec->adc_nids = vaio_adcs;
3694 spec->input_mux = &vaio_mux;
3695 spec->mux_nids = vaio_mux_nids;
3696 codec->patch_ops = stac9872_patch_ops;
3707 struct hda_codec_preset snd_hda_preset_sigmatel[] = {
3708 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
3709 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
3710 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
3711 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
3712 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
3713 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
3714 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
3715 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
3716 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
3717 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
3718 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
3719 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
3720 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
3721 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
3722 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
3723 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
3724 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
3725 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
3726 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
3727 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
3728 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
3729 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
3730 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
3731 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
3732 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
3733 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
3734 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
3735 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
3736 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
3737 /* The following does not take into account .id=0x83847661 when subsys =
3738 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
3739 * currently not fully supported.
3741 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
3742 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
3743 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
3744 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
3745 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
3746 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
3747 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
3748 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
3749 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
3750 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
3751 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
3752 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
3753 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
3754 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
3755 { .id = 0x111d7608, .name = "92HD71BXX", .patch = patch_stac92hd71bxx },
3756 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
3757 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
3758 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
3759 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
3760 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
3761 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
3762 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
3763 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },