2 * Universal Interface for Intel High Definition Audio Codec
4 * HD audio interface patch for SigmaTel STAC92xx
6 * Copyright (c) 2005 Embedded Alley Solutions, Inc.
7 * Matt Porter <mporter@embeddedalley.com>
9 * Based on patch_cmedia.c and patch_realtek.c
10 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
12 * This driver is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This driver is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include <linux/init.h>
28 #include <linux/delay.h>
29 #include <linux/slab.h>
30 #include <linux/pci.h>
31 #include <sound/core.h>
32 #include <sound/asoundef.h>
33 #include "hda_codec.h"
34 #include "hda_local.h"
36 #define NUM_CONTROL_ALLOC 32
37 #define STAC_PWR_EVENT 0x20
38 #define STAC_HP_EVENT 0x30
95 /* for backward compatibility */
118 struct sigmatel_spec
{
119 struct snd_kcontrol_new
*mixers
[4];
120 unsigned int num_mixers
;
123 unsigned int surr_switch
: 1;
124 unsigned int line_switch
: 1;
125 unsigned int mic_switch
: 1;
126 unsigned int alt_switch
: 1;
127 unsigned int hp_detect
: 1;
130 unsigned int gpio_mask
;
131 unsigned int gpio_dir
;
132 unsigned int gpio_data
;
133 unsigned int gpio_mute
;
135 /* analog loopback */
136 unsigned char aloopback_mask
;
137 unsigned char aloopback_shift
;
139 /* power management */
140 unsigned int num_pwrs
;
145 struct hda_input_mux
*mono_mux
;
146 unsigned int cur_mmux
;
147 struct hda_multi_out multiout
;
148 hda_nid_t dac_nids
[5];
152 unsigned int num_adcs
;
154 unsigned int num_muxes
;
155 hda_nid_t
*dmic_nids
;
156 unsigned int num_dmics
;
157 hda_nid_t
*dmux_nids
;
158 unsigned int num_dmuxes
;
159 hda_nid_t dig_in_nid
;
164 unsigned int num_pins
;
165 unsigned int *pin_configs
;
166 unsigned int *bios_pin_configs
;
168 /* codec specific stuff */
169 struct hda_verb
*init
;
170 struct snd_kcontrol_new
*mixer
;
173 struct hda_input_mux
*dinput_mux
;
174 unsigned int cur_dmux
[2];
175 struct hda_input_mux
*input_mux
;
176 unsigned int cur_mux
[3];
179 unsigned int io_switch
[2];
180 unsigned int clfe_swap
;
181 unsigned int aloopback
;
183 struct hda_pcm pcm_rec
[2]; /* PCM information */
185 /* dynamic controls and input_mux */
186 struct auto_pin_cfg autocfg
;
187 unsigned int num_kctl_alloc
, num_kctl_used
;
188 struct snd_kcontrol_new
*kctl_alloc
;
189 struct hda_input_mux private_dimux
;
190 struct hda_input_mux private_imux
;
191 struct hda_input_mux private_mono_mux
;
194 static hda_nid_t stac9200_adc_nids
[1] = {
198 static hda_nid_t stac9200_mux_nids
[1] = {
202 static hda_nid_t stac9200_dac_nids
[1] = {
206 static hda_nid_t stac92hd73xx_pwr_nids
[8] = {
207 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
211 static hda_nid_t stac92hd73xx_adc_nids
[2] = {
215 #define STAC92HD73XX_NUM_DMICS 2
216 static hda_nid_t stac92hd73xx_dmic_nids
[STAC92HD73XX_NUM_DMICS
+ 1] = {
220 #define STAC92HD73_DAC_COUNT 5
221 static hda_nid_t stac92hd73xx_dac_nids
[STAC92HD73_DAC_COUNT
] = {
222 0x15, 0x16, 0x17, 0x18, 0x19,
225 static hda_nid_t stac92hd73xx_mux_nids
[4] = {
226 0x28, 0x29, 0x2a, 0x2b,
229 static hda_nid_t stac92hd73xx_dmux_nids
[2] = {
233 static hda_nid_t stac92hd71bxx_pwr_nids
[3] = {
237 static hda_nid_t stac92hd71bxx_adc_nids
[2] = {
241 static hda_nid_t stac92hd71bxx_mux_nids
[2] = {
245 static hda_nid_t stac92hd71bxx_dmux_nids
[1] = {
249 static hda_nid_t stac92hd71bxx_dac_nids
[1] = {
253 #define STAC92HD71BXX_NUM_DMICS 2
254 static hda_nid_t stac92hd71bxx_dmic_nids
[STAC92HD71BXX_NUM_DMICS
+ 1] = {
258 static hda_nid_t stac925x_adc_nids
[1] = {
262 static hda_nid_t stac925x_mux_nids
[1] = {
266 static hda_nid_t stac925x_dac_nids
[1] = {
270 #define STAC925X_NUM_DMICS 1
271 static hda_nid_t stac925x_dmic_nids
[STAC925X_NUM_DMICS
+ 1] = {
275 static hda_nid_t stac925x_dmux_nids
[1] = {
279 static hda_nid_t stac922x_adc_nids
[2] = {
283 static hda_nid_t stac922x_mux_nids
[2] = {
287 static hda_nid_t stac927x_adc_nids
[3] = {
291 static hda_nid_t stac927x_mux_nids
[3] = {
295 static hda_nid_t stac927x_dac_nids
[6] = {
296 0x02, 0x03, 0x04, 0x05, 0x06, 0
299 static hda_nid_t stac927x_dmux_nids
[1] = {
303 #define STAC927X_NUM_DMICS 2
304 static hda_nid_t stac927x_dmic_nids
[STAC927X_NUM_DMICS
+ 1] = {
308 static hda_nid_t stac9205_adc_nids
[2] = {
312 static hda_nid_t stac9205_mux_nids
[2] = {
316 static hda_nid_t stac9205_dmux_nids
[1] = {
320 #define STAC9205_NUM_DMICS 2
321 static hda_nid_t stac9205_dmic_nids
[STAC9205_NUM_DMICS
+ 1] = {
325 static hda_nid_t stac9200_pin_nids
[8] = {
326 0x08, 0x09, 0x0d, 0x0e,
327 0x0f, 0x10, 0x11, 0x12,
330 static hda_nid_t stac925x_pin_nids
[8] = {
331 0x07, 0x08, 0x0a, 0x0b,
332 0x0c, 0x0d, 0x10, 0x11,
335 static hda_nid_t stac922x_pin_nids
[10] = {
336 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
337 0x0f, 0x10, 0x11, 0x15, 0x1b,
340 static hda_nid_t stac92hd73xx_pin_nids
[13] = {
341 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
342 0x0f, 0x10, 0x11, 0x12, 0x13,
346 static hda_nid_t stac92hd71bxx_pin_nids
[10] = {
347 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
348 0x0f, 0x14, 0x18, 0x19, 0x1e,
351 static hda_nid_t stac927x_pin_nids
[14] = {
352 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
353 0x0f, 0x10, 0x11, 0x12, 0x13,
354 0x14, 0x21, 0x22, 0x23,
357 static hda_nid_t stac9205_pin_nids
[12] = {
358 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
359 0x0f, 0x14, 0x16, 0x17, 0x18,
363 static int stac92xx_dmux_enum_info(struct snd_kcontrol
*kcontrol
,
364 struct snd_ctl_elem_info
*uinfo
)
366 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
367 struct sigmatel_spec
*spec
= codec
->spec
;
368 return snd_hda_input_mux_info(spec
->dinput_mux
, uinfo
);
371 static int stac92xx_dmux_enum_get(struct snd_kcontrol
*kcontrol
,
372 struct snd_ctl_elem_value
*ucontrol
)
374 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
375 struct sigmatel_spec
*spec
= codec
->spec
;
376 unsigned int dmux_idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
378 ucontrol
->value
.enumerated
.item
[0] = spec
->cur_dmux
[dmux_idx
];
382 static int stac92xx_dmux_enum_put(struct snd_kcontrol
*kcontrol
,
383 struct snd_ctl_elem_value
*ucontrol
)
385 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
386 struct sigmatel_spec
*spec
= codec
->spec
;
387 unsigned int dmux_idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
389 return snd_hda_input_mux_put(codec
, spec
->dinput_mux
, ucontrol
,
390 spec
->dmux_nids
[dmux_idx
], &spec
->cur_dmux
[dmux_idx
]);
393 static int stac92xx_mux_enum_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
395 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
396 struct sigmatel_spec
*spec
= codec
->spec
;
397 return snd_hda_input_mux_info(spec
->input_mux
, uinfo
);
400 static int stac92xx_mux_enum_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
402 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
403 struct sigmatel_spec
*spec
= codec
->spec
;
404 unsigned int adc_idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
406 ucontrol
->value
.enumerated
.item
[0] = spec
->cur_mux
[adc_idx
];
410 static int stac92xx_mux_enum_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
412 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
413 struct sigmatel_spec
*spec
= codec
->spec
;
414 unsigned int adc_idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
416 return snd_hda_input_mux_put(codec
, spec
->input_mux
, ucontrol
,
417 spec
->mux_nids
[adc_idx
], &spec
->cur_mux
[adc_idx
]);
420 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol
*kcontrol
,
421 struct snd_ctl_elem_info
*uinfo
)
423 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
424 struct sigmatel_spec
*spec
= codec
->spec
;
425 return snd_hda_input_mux_info(spec
->mono_mux
, uinfo
);
428 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol
*kcontrol
,
429 struct snd_ctl_elem_value
*ucontrol
)
431 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
432 struct sigmatel_spec
*spec
= codec
->spec
;
434 ucontrol
->value
.enumerated
.item
[0] = spec
->cur_mmux
;
438 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol
*kcontrol
,
439 struct snd_ctl_elem_value
*ucontrol
)
441 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
442 struct sigmatel_spec
*spec
= codec
->spec
;
444 return snd_hda_input_mux_put(codec
, spec
->mono_mux
, ucontrol
,
445 spec
->mono_nid
, &spec
->cur_mmux
);
448 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
450 static int stac92xx_aloopback_get(struct snd_kcontrol
*kcontrol
,
451 struct snd_ctl_elem_value
*ucontrol
)
453 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
454 unsigned int idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
455 struct sigmatel_spec
*spec
= codec
->spec
;
457 ucontrol
->value
.integer
.value
[0] = !!(spec
->aloopback
&
458 (spec
->aloopback_mask
<< idx
));
462 static int stac92xx_aloopback_put(struct snd_kcontrol
*kcontrol
,
463 struct snd_ctl_elem_value
*ucontrol
)
465 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
466 struct sigmatel_spec
*spec
= codec
->spec
;
467 unsigned int idx
= snd_ctl_get_ioffidx(kcontrol
, &ucontrol
->id
);
468 unsigned int dac_mode
;
469 unsigned int val
, idx_val
;
471 idx_val
= spec
->aloopback_mask
<< idx
;
472 if (ucontrol
->value
.integer
.value
[0])
473 val
= spec
->aloopback
| idx_val
;
475 val
= spec
->aloopback
& ~idx_val
;
476 if (spec
->aloopback
== val
)
479 spec
->aloopback
= val
;
481 /* Only return the bits defined by the shift value of the
482 * first two bytes of the mask
484 dac_mode
= snd_hda_codec_read(codec
, codec
->afg
, 0,
485 kcontrol
->private_value
& 0xFFFF, 0x0);
486 dac_mode
>>= spec
->aloopback_shift
;
488 if (spec
->aloopback
& idx_val
) {
489 snd_hda_power_up(codec
);
492 snd_hda_power_down(codec
);
493 dac_mode
&= ~idx_val
;
496 snd_hda_codec_write_cache(codec
, codec
->afg
, 0,
497 kcontrol
->private_value
>> 16, dac_mode
);
502 static struct hda_verb stac9200_core_init
[] = {
503 /* set dac0mux for dac converter */
504 { 0x07, AC_VERB_SET_CONNECT_SEL
, 0x00},
508 static struct hda_verb stac9200_eapd_init
[] = {
509 /* set dac0mux for dac converter */
510 {0x07, AC_VERB_SET_CONNECT_SEL
, 0x00},
511 {0x08, AC_VERB_SET_EAPD_BTLENABLE
, 0x02},
515 static struct hda_verb stac92hd73xx_6ch_core_init
[] = {
516 /* set master volume and direct control */
517 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL
, 0xff},
518 /* setup audio connections */
519 { 0x0f, AC_VERB_SET_CONNECT_SEL
, 0x00},
520 { 0x10, AC_VERB_SET_CONNECT_SEL
, 0x01},
521 { 0x11, AC_VERB_SET_CONNECT_SEL
, 0x02},
522 /* setup adcs to point to mixer */
523 { 0x20, AC_VERB_SET_CONNECT_SEL
, 0x0b},
524 { 0x21, AC_VERB_SET_CONNECT_SEL
, 0x0b},
525 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
526 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
527 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
528 /* setup import muxs */
529 { 0x28, AC_VERB_SET_CONNECT_SEL
, 0x01},
530 { 0x29, AC_VERB_SET_CONNECT_SEL
, 0x01},
531 { 0x2a, AC_VERB_SET_CONNECT_SEL
, 0x01},
532 { 0x2b, AC_VERB_SET_CONNECT_SEL
, 0x00},
536 static struct hda_verb stac92hd73xx_8ch_core_init
[] = {
537 /* set master volume and direct control */
538 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL
, 0xff},
539 /* setup audio connections */
540 { 0x0f, AC_VERB_SET_CONNECT_SEL
, 0x00},
541 { 0x10, AC_VERB_SET_CONNECT_SEL
, 0x01},
542 { 0x11, AC_VERB_SET_CONNECT_SEL
, 0x02},
543 /* connect hp ports to dac3 */
544 { 0x0a, AC_VERB_SET_CONNECT_SEL
, 0x03},
545 { 0x0d, AC_VERB_SET_CONNECT_SEL
, 0x03},
546 /* setup adcs to point to mixer */
547 { 0x20, AC_VERB_SET_CONNECT_SEL
, 0x0b},
548 { 0x21, AC_VERB_SET_CONNECT_SEL
, 0x0b},
549 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
550 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
551 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
552 /* setup import muxs */
553 { 0x28, AC_VERB_SET_CONNECT_SEL
, 0x01},
554 { 0x29, AC_VERB_SET_CONNECT_SEL
, 0x01},
555 { 0x2a, AC_VERB_SET_CONNECT_SEL
, 0x01},
556 { 0x2b, AC_VERB_SET_CONNECT_SEL
, 0x03},
560 static struct hda_verb stac92hd73xx_10ch_core_init
[] = {
561 /* set master volume and direct control */
562 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL
, 0xff},
563 /* setup audio connections */
564 { 0x0f, AC_VERB_SET_CONNECT_SEL
, 0x00 },
565 { 0x10, AC_VERB_SET_CONNECT_SEL
, 0x01 },
566 { 0x11, AC_VERB_SET_CONNECT_SEL
, 0x02 },
567 /* dac3 is connected to import3 mux */
568 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE
, 0xb07f},
569 /* connect hp ports to dac4 */
570 { 0x0a, AC_VERB_SET_CONNECT_SEL
, 0x04},
571 { 0x0d, AC_VERB_SET_CONNECT_SEL
, 0x04},
572 /* setup adcs to point to mixer */
573 { 0x20, AC_VERB_SET_CONNECT_SEL
, 0x0b},
574 { 0x21, AC_VERB_SET_CONNECT_SEL
, 0x0b},
575 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
576 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
577 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
578 /* setup import muxs */
579 { 0x28, AC_VERB_SET_CONNECT_SEL
, 0x01},
580 { 0x29, AC_VERB_SET_CONNECT_SEL
, 0x01},
581 { 0x2a, AC_VERB_SET_CONNECT_SEL
, 0x01},
582 { 0x2b, AC_VERB_SET_CONNECT_SEL
, 0x03},
586 static struct hda_verb stac92hd71bxx_core_init
[] = {
587 /* set master volume and direct control */
588 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL
, 0xff},
589 /* connect headphone jack to dac1 */
590 { 0x0a, AC_VERB_SET_CONNECT_SEL
, 0x01},
591 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
}, /* Speaker */
592 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
593 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
594 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
595 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
598 static struct hda_verb stac92hd71bxx_analog_core_init
[] = {
599 /* set master volume and direct control */
600 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL
, 0xff},
601 /* connect headphone jack to dac1 */
602 { 0x0a, AC_VERB_SET_CONNECT_SEL
, 0x01},
603 /* connect ports 0d and 0f to audio mixer */
604 { 0x0d, AC_VERB_SET_CONNECT_SEL
, 0x2},
605 { 0x0f, AC_VERB_SET_CONNECT_SEL
, 0x2},
606 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
}, /* Speaker */
607 /* unmute dac0 input in audio mixer */
608 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE
, 0x701f},
609 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
610 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
611 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
612 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)},
616 static struct hda_verb stac925x_core_init
[] = {
617 /* set dac0mux for dac converter */
618 { 0x06, AC_VERB_SET_CONNECT_SEL
, 0x00},
622 static struct hda_verb stac922x_core_init
[] = {
623 /* set master volume and direct control */
624 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL
, 0xff},
628 static struct hda_verb d965_core_init
[] = {
629 /* set master volume and direct control */
630 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL
, 0xff},
631 /* unmute node 0x1b */
632 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE
, 0xb000},
633 /* select node 0x03 as DAC */
634 { 0x0b, AC_VERB_SET_CONNECT_SEL
, 0x01},
638 static struct hda_verb stac927x_core_init
[] = {
639 /* set master volume and direct control */
640 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL
, 0xff},
644 static struct hda_verb stac9205_core_init
[] = {
645 /* set master volume and direct control */
646 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL
, 0xff},
650 #define STAC_MONO_MUX \
652 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
653 .name = "Mono Mux", \
655 .info = stac92xx_mono_mux_enum_info, \
656 .get = stac92xx_mono_mux_enum_get, \
657 .put = stac92xx_mono_mux_enum_put, \
660 #define STAC_INPUT_SOURCE(cnt) \
662 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
663 .name = "Input Source", \
665 .info = stac92xx_mux_enum_info, \
666 .get = stac92xx_mux_enum_get, \
667 .put = stac92xx_mux_enum_put, \
670 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
672 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
673 .name = "Analog Loopback", \
675 .info = stac92xx_aloopback_info, \
676 .get = stac92xx_aloopback_get, \
677 .put = stac92xx_aloopback_put, \
678 .private_value = verb_read | (verb_write << 16), \
681 static struct snd_kcontrol_new stac9200_mixer
[] = {
682 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT
),
683 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT
),
684 STAC_INPUT_SOURCE(1),
685 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT
),
686 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT
),
687 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT
),
691 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer
[] = {
692 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
694 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT
),
695 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT
),
697 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT
),
698 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT
),
700 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT
),
701 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT
),
703 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT
),
704 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT
),
706 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT
),
707 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT
),
709 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT
),
710 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT
),
712 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT
),
713 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT
),
717 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer
[] = {
718 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
720 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT
),
721 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT
),
723 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT
),
724 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT
),
726 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT
),
727 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT
),
729 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT
),
730 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT
),
732 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT
),
733 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT
),
735 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT
),
736 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT
),
738 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT
),
739 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT
),
743 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer
[] = {
744 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
746 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT
),
747 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT
),
749 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT
),
750 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT
),
752 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT
),
753 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT
),
755 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT
),
756 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT
),
758 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT
),
759 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT
),
761 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT
),
762 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT
),
764 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT
),
765 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT
),
769 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer
[] = {
770 STAC_INPUT_SOURCE(2),
772 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT
),
773 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT
),
774 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT
),
776 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT
),
777 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT
),
778 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT
),
780 HDA_CODEC_MUTE("Analog Loopback 1", 0x17, 0x3, HDA_INPUT
),
781 HDA_CODEC_MUTE("Analog Loopback 2", 0x17, 0x4, HDA_INPUT
),
785 static struct snd_kcontrol_new stac92hd71bxx_mixer
[] = {
786 STAC_INPUT_SOURCE(2),
787 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
789 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT
),
790 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT
),
791 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT
),
793 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT
),
794 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT
),
795 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT
),
799 static struct snd_kcontrol_new stac925x_mixer
[] = {
800 STAC_INPUT_SOURCE(1),
801 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT
),
802 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_OUTPUT
),
803 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT
),
807 static struct snd_kcontrol_new stac9205_mixer
[] = {
808 STAC_INPUT_SOURCE(2),
809 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
811 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT
),
812 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT
),
813 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT
),
815 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT
),
816 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT
),
817 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT
),
822 /* This needs to be generated dynamically based on sequence */
823 static struct snd_kcontrol_new stac922x_mixer
[] = {
824 STAC_INPUT_SOURCE(2),
825 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT
),
826 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT
),
827 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT
),
829 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT
),
830 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT
),
831 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT
),
836 static struct snd_kcontrol_new stac927x_mixer
[] = {
837 STAC_INPUT_SOURCE(3),
838 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
840 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT
),
841 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT
),
842 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT
),
844 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT
),
845 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT
),
846 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT
),
848 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT
),
849 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT
),
850 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT
),
854 static struct snd_kcontrol_new stac_dmux_mixer
= {
855 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
856 .name
= "Digital Input Source",
857 /* count set later */
858 .info
= stac92xx_dmux_enum_info
,
859 .get
= stac92xx_dmux_enum_get
,
860 .put
= stac92xx_dmux_enum_put
,
863 static const char *slave_vols
[] = {
864 "Front Playback Volume",
865 "Surround Playback Volume",
866 "Center Playback Volume",
867 "LFE Playback Volume",
868 "Side Playback Volume",
869 "Headphone Playback Volume",
870 "Headphone Playback Volume",
871 "Speaker Playback Volume",
872 "External Speaker Playback Volume",
873 "Speaker2 Playback Volume",
877 static const char *slave_sws
[] = {
878 "Front Playback Switch",
879 "Surround Playback Switch",
880 "Center Playback Switch",
881 "LFE Playback Switch",
882 "Side Playback Switch",
883 "Headphone Playback Switch",
884 "Headphone Playback Switch",
885 "Speaker Playback Switch",
886 "External Speaker Playback Switch",
887 "Speaker2 Playback Switch",
888 "IEC958 Playback Switch",
892 static int stac92xx_build_controls(struct hda_codec
*codec
)
894 struct sigmatel_spec
*spec
= codec
->spec
;
898 err
= snd_hda_add_new_ctls(codec
, spec
->mixer
);
902 for (i
= 0; i
< spec
->num_mixers
; i
++) {
903 err
= snd_hda_add_new_ctls(codec
, spec
->mixers
[i
]);
907 if (spec
->num_dmuxes
> 0) {
908 stac_dmux_mixer
.count
= spec
->num_dmuxes
;
909 err
= snd_ctl_add(codec
->bus
->card
,
910 snd_ctl_new1(&stac_dmux_mixer
, codec
));
915 if (spec
->multiout
.dig_out_nid
) {
916 err
= snd_hda_create_spdif_out_ctls(codec
, spec
->multiout
.dig_out_nid
);
919 err
= snd_hda_create_spdif_share_sw(codec
,
923 spec
->multiout
.share_spdif
= 1;
925 if (spec
->dig_in_nid
) {
926 err
= snd_hda_create_spdif_in_ctls(codec
, spec
->dig_in_nid
);
931 /* if we have no master control, let's create it */
932 if (!snd_hda_find_mixer_ctl(codec
, "Master Playback Volume")) {
933 unsigned int vmaster_tlv
[4];
934 snd_hda_set_vmaster_tlv(codec
, spec
->multiout
.dac_nids
[0],
935 HDA_OUTPUT
, vmaster_tlv
);
936 err
= snd_hda_add_vmaster(codec
, "Master Playback Volume",
937 vmaster_tlv
, slave_vols
);
941 if (!snd_hda_find_mixer_ctl(codec
, "Master Playback Switch")) {
942 err
= snd_hda_add_vmaster(codec
, "Master Playback Switch",
951 static unsigned int ref9200_pin_configs
[8] = {
952 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
953 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
957 STAC 9200 pin configs for
962 static unsigned int dell9200_d21_pin_configs
[8] = {
963 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
964 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
968 STAC 9200 pin configs for
972 static unsigned int dell9200_d22_pin_configs
[8] = {
973 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
974 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
978 STAC 9200 pin configs for
979 102801C4 (Dell Dimension E310)
986 static unsigned int dell9200_d23_pin_configs
[8] = {
987 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
988 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
993 STAC 9200-32 pin configs for
994 102801B5 (Dell Inspiron 630m)
995 102801D8 (Dell Inspiron 640m)
997 static unsigned int dell9200_m21_pin_configs
[8] = {
998 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
999 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1003 STAC 9200-32 pin configs for
1004 102801C2 (Dell Latitude D620)
1006 102801CC (Dell Latitude D820)
1010 static unsigned int dell9200_m22_pin_configs
[8] = {
1011 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1012 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1016 STAC 9200-32 pin configs for
1017 102801CE (Dell XPS M1710)
1018 102801CF (Dell Precision M90)
1020 static unsigned int dell9200_m23_pin_configs
[8] = {
1021 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1022 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1026 STAC 9200-32 pin configs for
1029 102801CB (Dell Latitude 120L)
1032 static unsigned int dell9200_m24_pin_configs
[8] = {
1033 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1034 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1038 STAC 9200-32 pin configs for
1039 102801BD (Dell Inspiron E1505n)
1043 static unsigned int dell9200_m25_pin_configs
[8] = {
1044 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1045 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1049 STAC 9200-32 pin configs for
1050 102801F5 (Dell Inspiron 1501)
1053 static unsigned int dell9200_m26_pin_configs
[8] = {
1054 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1055 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1060 102801CD (Dell Inspiron E1705/9400)
1062 static unsigned int dell9200_m27_pin_configs
[8] = {
1063 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1064 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1067 static unsigned int oqo9200_pin_configs
[8] = {
1068 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1069 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1073 static unsigned int *stac9200_brd_tbl
[STAC_9200_MODELS
] = {
1074 [STAC_REF
] = ref9200_pin_configs
,
1075 [STAC_9200_OQO
] = oqo9200_pin_configs
,
1076 [STAC_9200_DELL_D21
] = dell9200_d21_pin_configs
,
1077 [STAC_9200_DELL_D22
] = dell9200_d22_pin_configs
,
1078 [STAC_9200_DELL_D23
] = dell9200_d23_pin_configs
,
1079 [STAC_9200_DELL_M21
] = dell9200_m21_pin_configs
,
1080 [STAC_9200_DELL_M22
] = dell9200_m22_pin_configs
,
1081 [STAC_9200_DELL_M23
] = dell9200_m23_pin_configs
,
1082 [STAC_9200_DELL_M24
] = dell9200_m24_pin_configs
,
1083 [STAC_9200_DELL_M25
] = dell9200_m25_pin_configs
,
1084 [STAC_9200_DELL_M26
] = dell9200_m26_pin_configs
,
1085 [STAC_9200_DELL_M27
] = dell9200_m27_pin_configs
,
1088 static const char *stac9200_models
[STAC_9200_MODELS
] = {
1090 [STAC_9200_OQO
] = "oqo",
1091 [STAC_9200_DELL_D21
] = "dell-d21",
1092 [STAC_9200_DELL_D22
] = "dell-d22",
1093 [STAC_9200_DELL_D23
] = "dell-d23",
1094 [STAC_9200_DELL_M21
] = "dell-m21",
1095 [STAC_9200_DELL_M22
] = "dell-m22",
1096 [STAC_9200_DELL_M23
] = "dell-m23",
1097 [STAC_9200_DELL_M24
] = "dell-m24",
1098 [STAC_9200_DELL_M25
] = "dell-m25",
1099 [STAC_9200_DELL_M26
] = "dell-m26",
1100 [STAC_9200_DELL_M27
] = "dell-m27",
1101 [STAC_9200_GATEWAY
] = "gateway",
1104 static struct snd_pci_quirk stac9200_cfg_tbl
[] = {
1105 /* SigmaTel reference board */
1106 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2668,
1107 "DFI LanParty", STAC_REF
),
1108 /* Dell laptops have BIOS problem */
1109 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01a8,
1110 "unknown Dell", STAC_9200_DELL_D21
),
1111 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01b5,
1112 "Dell Inspiron 630m", STAC_9200_DELL_M21
),
1113 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01bd,
1114 "Dell Inspiron E1505n", STAC_9200_DELL_M25
),
1115 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01c0,
1116 "unknown Dell", STAC_9200_DELL_D22
),
1117 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01c1,
1118 "unknown Dell", STAC_9200_DELL_D22
),
1119 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01c2,
1120 "Dell Latitude D620", STAC_9200_DELL_M22
),
1121 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01c5,
1122 "unknown Dell", STAC_9200_DELL_D23
),
1123 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01c7,
1124 "unknown Dell", STAC_9200_DELL_D23
),
1125 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01c8,
1126 "unknown Dell", STAC_9200_DELL_M22
),
1127 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01c9,
1128 "unknown Dell", STAC_9200_DELL_M24
),
1129 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01ca,
1130 "unknown Dell", STAC_9200_DELL_M24
),
1131 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01cb,
1132 "Dell Latitude 120L", STAC_9200_DELL_M24
),
1133 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01cc,
1134 "Dell Latitude D820", STAC_9200_DELL_M22
),
1135 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01cd,
1136 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27
),
1137 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01ce,
1138 "Dell XPS M1710", STAC_9200_DELL_M23
),
1139 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01cf,
1140 "Dell Precision M90", STAC_9200_DELL_M23
),
1141 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01d3,
1142 "unknown Dell", STAC_9200_DELL_M22
),
1143 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01d4,
1144 "unknown Dell", STAC_9200_DELL_M22
),
1145 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01d6,
1146 "unknown Dell", STAC_9200_DELL_M22
),
1147 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01d8,
1148 "Dell Inspiron 640m", STAC_9200_DELL_M21
),
1149 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01d9,
1150 "unknown Dell", STAC_9200_DELL_D23
),
1151 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01da,
1152 "unknown Dell", STAC_9200_DELL_D23
),
1153 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01de,
1154 "unknown Dell", STAC_9200_DELL_D21
),
1155 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01e3,
1156 "unknown Dell", STAC_9200_DELL_D23
),
1157 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01e8,
1158 "unknown Dell", STAC_9200_DELL_D21
),
1159 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01ee,
1160 "unknown Dell", STAC_9200_DELL_M25
),
1161 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01ef,
1162 "unknown Dell", STAC_9200_DELL_M25
),
1163 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01f5,
1164 "Dell Inspiron 1501", STAC_9200_DELL_M26
),
1165 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01f6,
1166 "unknown Dell", STAC_9200_DELL_M26
),
1168 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_REF
),
1169 /* Gateway machines needs EAPD to be set on resume */
1170 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY
),
1171 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*",
1173 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707",
1176 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO
),
1180 static unsigned int ref925x_pin_configs
[8] = {
1181 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1182 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1185 static unsigned int stac925x_MA6_pin_configs
[8] = {
1186 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1187 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e,
1190 static unsigned int stac925x_PA6_pin_configs
[8] = {
1191 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1192 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e,
1195 static unsigned int stac925xM2_2_pin_configs
[8] = {
1196 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020,
1197 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e,
1200 static unsigned int *stac925x_brd_tbl
[STAC_925x_MODELS
] = {
1201 [STAC_REF
] = ref925x_pin_configs
,
1202 [STAC_M2_2
] = stac925xM2_2_pin_configs
,
1203 [STAC_MA6
] = stac925x_MA6_pin_configs
,
1204 [STAC_PA6
] = stac925x_PA6_pin_configs
,
1207 static const char *stac925x_models
[STAC_925x_MODELS
] = {
1209 [STAC_M2_2
] = "m2-2",
1214 static struct snd_pci_quirk stac925x_cfg_tbl
[] = {
1215 /* SigmaTel reference board */
1216 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2668, "DFI LanParty", STAC_REF
),
1217 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF
),
1218 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF
),
1219 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF
),
1220 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6
),
1221 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6
),
1222 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2
),
1226 static unsigned int ref92hd73xx_pin_configs
[13] = {
1227 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1228 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1229 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1233 static unsigned int dell_m6_pin_configs
[13] = {
1234 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1235 0x03a11020, 0x03011050, 0x4f0000f0, 0x4f0000f0,
1236 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1240 static unsigned int *stac92hd73xx_brd_tbl
[STAC_92HD73XX_MODELS
] = {
1241 [STAC_92HD73XX_REF
] = ref92hd73xx_pin_configs
,
1242 [STAC_DELL_M6
] = dell_m6_pin_configs
,
1245 static const char *stac92hd73xx_models
[STAC_92HD73XX_MODELS
] = {
1246 [STAC_92HD73XX_REF
] = "ref",
1247 [STAC_DELL_M6
] = "dell-m6",
1250 static struct snd_pci_quirk stac92hd73xx_cfg_tbl
[] = {
1251 /* SigmaTel reference board */
1252 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2668,
1253 "DFI LanParty", STAC_92HD73XX_REF
),
1254 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0254,
1255 "unknown Dell", STAC_DELL_M6
),
1256 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0255,
1257 "unknown Dell", STAC_DELL_M6
),
1258 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0256,
1259 "unknown Dell", STAC_DELL_M6
),
1260 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0257,
1261 "unknown Dell", STAC_DELL_M6
),
1262 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x025e,
1263 "unknown Dell", STAC_DELL_M6
),
1264 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x025f,
1265 "unknown Dell", STAC_DELL_M6
),
1266 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0271,
1267 "unknown Dell", STAC_DELL_M6
),
1271 static unsigned int ref92hd71bxx_pin_configs
[10] = {
1272 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1273 0x0181302e, 0x01114010, 0x01019020, 0x90a000f0,
1274 0x90a000f0, 0x01452050,
1277 static unsigned int dell_m4_1_pin_configs
[13] = {
1278 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1279 0x23a1902e, 0x23014250, 0x40f000f0, 0x4f0000f0,
1280 0x40f000f0, 0x4f0000f0,
1283 static unsigned int dell_m4_2_pin_configs
[13] = {
1284 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1285 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1286 0x40f000f0, 0x044413b0,
1289 static unsigned int *stac92hd71bxx_brd_tbl
[STAC_92HD71BXX_MODELS
] = {
1290 [STAC_92HD71BXX_REF
] = ref92hd71bxx_pin_configs
,
1291 [STAC_DELL_M4_1
] = dell_m4_1_pin_configs
,
1292 [STAC_DELL_M4_2
] = dell_m4_2_pin_configs
,
1295 static const char *stac92hd71bxx_models
[STAC_92HD71BXX_MODELS
] = {
1296 [STAC_92HD71BXX_REF
] = "ref",
1297 [STAC_DELL_M4_1
] = "dell-m4-1",
1298 [STAC_DELL_M4_2
] = "dell-m4-2",
1301 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl
[] = {
1302 /* SigmaTel reference board */
1303 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2668,
1304 "DFI LanParty", STAC_92HD71BXX_REF
),
1305 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0233,
1306 "unknown Dell", STAC_DELL_M4_1
),
1307 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0234,
1308 "unknown Dell", STAC_DELL_M4_1
),
1309 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0250,
1310 "unknown Dell", STAC_DELL_M4_1
),
1311 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x024f,
1312 "unknown Dell", STAC_DELL_M4_1
),
1313 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x024d,
1314 "unknown Dell", STAC_DELL_M4_1
),
1315 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0251,
1316 "unknown Dell", STAC_DELL_M4_1
),
1317 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0277,
1318 "unknown Dell", STAC_DELL_M4_1
),
1319 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0263,
1320 "unknown Dell", STAC_DELL_M4_2
),
1321 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0265,
1322 "unknown Dell", STAC_DELL_M4_2
),
1323 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0262,
1324 "unknown Dell", STAC_DELL_M4_2
),
1325 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0264,
1326 "unknown Dell", STAC_DELL_M4_2
),
1330 static unsigned int ref922x_pin_configs
[10] = {
1331 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1332 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1333 0x40000100, 0x40000100,
1337 STAC 922X pin configs for
1344 static unsigned int dell_922x_d81_pin_configs
[10] = {
1345 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1346 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1347 0x01813122, 0x400001f2,
1351 STAC 922X pin configs for
1355 static unsigned int dell_922x_d82_pin_configs
[10] = {
1356 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1357 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1358 0x01813122, 0x400001f1,
1362 STAC 922X pin configs for
1365 static unsigned int dell_922x_m81_pin_configs
[10] = {
1366 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1367 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1368 0x40C003f1, 0x405003f0,
1372 STAC 9221 A1 pin configs for
1373 102801D7 (Dell XPS M1210)
1375 static unsigned int dell_922x_m82_pin_configs
[10] = {
1376 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1377 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1378 0x508003f3, 0x405003f4,
1381 static unsigned int d945gtp3_pin_configs
[10] = {
1382 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1383 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1384 0x02a19120, 0x40000100,
1387 static unsigned int d945gtp5_pin_configs
[10] = {
1388 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1389 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1390 0x02a19320, 0x40000100,
1393 static unsigned int intel_mac_v1_pin_configs
[10] = {
1394 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1395 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1396 0x400000fc, 0x400000fb,
1399 static unsigned int intel_mac_v2_pin_configs
[10] = {
1400 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1401 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1402 0x400000fc, 0x400000fb,
1405 static unsigned int intel_mac_v3_pin_configs
[10] = {
1406 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1407 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1408 0x400000fc, 0x400000fb,
1411 static unsigned int intel_mac_v4_pin_configs
[10] = {
1412 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1413 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1414 0x400000fc, 0x400000fb,
1417 static unsigned int intel_mac_v5_pin_configs
[10] = {
1418 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1419 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1420 0x400000fc, 0x400000fb,
1424 static unsigned int *stac922x_brd_tbl
[STAC_922X_MODELS
] = {
1425 [STAC_D945_REF
] = ref922x_pin_configs
,
1426 [STAC_D945GTP3
] = d945gtp3_pin_configs
,
1427 [STAC_D945GTP5
] = d945gtp5_pin_configs
,
1428 [STAC_INTEL_MAC_V1
] = intel_mac_v1_pin_configs
,
1429 [STAC_INTEL_MAC_V2
] = intel_mac_v2_pin_configs
,
1430 [STAC_INTEL_MAC_V3
] = intel_mac_v3_pin_configs
,
1431 [STAC_INTEL_MAC_V4
] = intel_mac_v4_pin_configs
,
1432 [STAC_INTEL_MAC_V5
] = intel_mac_v5_pin_configs
,
1433 /* for backward compatibility */
1434 [STAC_MACMINI
] = intel_mac_v3_pin_configs
,
1435 [STAC_MACBOOK
] = intel_mac_v5_pin_configs
,
1436 [STAC_MACBOOK_PRO_V1
] = intel_mac_v3_pin_configs
,
1437 [STAC_MACBOOK_PRO_V2
] = intel_mac_v3_pin_configs
,
1438 [STAC_IMAC_INTEL
] = intel_mac_v2_pin_configs
,
1439 [STAC_IMAC_INTEL_20
] = intel_mac_v3_pin_configs
,
1440 [STAC_922X_DELL_D81
] = dell_922x_d81_pin_configs
,
1441 [STAC_922X_DELL_D82
] = dell_922x_d82_pin_configs
,
1442 [STAC_922X_DELL_M81
] = dell_922x_m81_pin_configs
,
1443 [STAC_922X_DELL_M82
] = dell_922x_m82_pin_configs
,
1446 static const char *stac922x_models
[STAC_922X_MODELS
] = {
1447 [STAC_D945_REF
] = "ref",
1448 [STAC_D945GTP5
] = "5stack",
1449 [STAC_D945GTP3
] = "3stack",
1450 [STAC_INTEL_MAC_V1
] = "intel-mac-v1",
1451 [STAC_INTEL_MAC_V2
] = "intel-mac-v2",
1452 [STAC_INTEL_MAC_V3
] = "intel-mac-v3",
1453 [STAC_INTEL_MAC_V4
] = "intel-mac-v4",
1454 [STAC_INTEL_MAC_V5
] = "intel-mac-v5",
1455 /* for backward compatibility */
1456 [STAC_MACMINI
] = "macmini",
1457 [STAC_MACBOOK
] = "macbook",
1458 [STAC_MACBOOK_PRO_V1
] = "macbook-pro-v1",
1459 [STAC_MACBOOK_PRO_V2
] = "macbook-pro",
1460 [STAC_IMAC_INTEL
] = "imac-intel",
1461 [STAC_IMAC_INTEL_20
] = "imac-intel-20",
1462 [STAC_922X_DELL_D81
] = "dell-d81",
1463 [STAC_922X_DELL_D82
] = "dell-d82",
1464 [STAC_922X_DELL_M81
] = "dell-m81",
1465 [STAC_922X_DELL_M82
] = "dell-m82",
1468 static struct snd_pci_quirk stac922x_cfg_tbl
[] = {
1469 /* SigmaTel reference board */
1470 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2668,
1471 "DFI LanParty", STAC_D945_REF
),
1472 /* Intel 945G based systems */
1473 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0101,
1474 "Intel D945G", STAC_D945GTP3
),
1475 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0202,
1476 "Intel D945G", STAC_D945GTP3
),
1477 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0606,
1478 "Intel D945G", STAC_D945GTP3
),
1479 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0601,
1480 "Intel D945G", STAC_D945GTP3
),
1481 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0111,
1482 "Intel D945G", STAC_D945GTP3
),
1483 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x1115,
1484 "Intel D945G", STAC_D945GTP3
),
1485 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x1116,
1486 "Intel D945G", STAC_D945GTP3
),
1487 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x1117,
1488 "Intel D945G", STAC_D945GTP3
),
1489 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x1118,
1490 "Intel D945G", STAC_D945GTP3
),
1491 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x1119,
1492 "Intel D945G", STAC_D945GTP3
),
1493 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x8826,
1494 "Intel D945G", STAC_D945GTP3
),
1495 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x5049,
1496 "Intel D945G", STAC_D945GTP3
),
1497 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x5055,
1498 "Intel D945G", STAC_D945GTP3
),
1499 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x5048,
1500 "Intel D945G", STAC_D945GTP3
),
1501 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0110,
1502 "Intel D945G", STAC_D945GTP3
),
1503 /* Intel D945G 5-stack systems */
1504 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0404,
1505 "Intel D945G", STAC_D945GTP5
),
1506 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0303,
1507 "Intel D945G", STAC_D945GTP5
),
1508 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0013,
1509 "Intel D945G", STAC_D945GTP5
),
1510 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0417,
1511 "Intel D945G", STAC_D945GTP5
),
1512 /* Intel 945P based systems */
1513 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0b0b,
1514 "Intel D945P", STAC_D945GTP3
),
1515 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0112,
1516 "Intel D945P", STAC_D945GTP3
),
1517 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0d0d,
1518 "Intel D945P", STAC_D945GTP3
),
1519 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0909,
1520 "Intel D945P", STAC_D945GTP3
),
1521 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0505,
1522 "Intel D945P", STAC_D945GTP3
),
1523 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x0707,
1524 "Intel D945P", STAC_D945GTP5
),
1526 /* Apple Mac Mini (early 2006) */
1527 SND_PCI_QUIRK(0x8384, 0x7680,
1528 "Mac Mini", STAC_INTEL_MAC_V3
),
1530 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01a7,
1531 "unknown Dell", STAC_922X_DELL_D81
),
1532 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01a9,
1533 "unknown Dell", STAC_922X_DELL_D81
),
1534 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01ab,
1535 "unknown Dell", STAC_922X_DELL_D81
),
1536 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01ac,
1537 "unknown Dell", STAC_922X_DELL_D82
),
1538 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01bf,
1539 "unknown Dell", STAC_922X_DELL_M81
),
1540 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01d0,
1541 "unknown Dell", STAC_922X_DELL_D82
),
1542 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01d1,
1543 "unknown Dell", STAC_922X_DELL_D81
),
1544 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01d2,
1545 "unknown Dell", STAC_922X_DELL_D81
),
1546 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01d7,
1547 "Dell XPS M1210", STAC_922X_DELL_M82
),
1551 static unsigned int ref927x_pin_configs
[14] = {
1552 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1553 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
1554 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
1555 0x01c42190, 0x40000100,
1558 static unsigned int d965_3st_pin_configs
[14] = {
1559 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
1560 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
1561 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1562 0x40000100, 0x40000100
1565 static unsigned int d965_5st_pin_configs
[14] = {
1566 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
1567 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
1568 0x40000100, 0x40000100, 0x40000100, 0x01442070,
1569 0x40000100, 0x40000100
1572 static unsigned int dell_3st_pin_configs
[14] = {
1573 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
1574 0x01111212, 0x01116211, 0x01813050, 0x01112214,
1575 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
1576 0x40c003fc, 0x40000100
1579 static unsigned int *stac927x_brd_tbl
[STAC_927X_MODELS
] = {
1580 [STAC_D965_REF
] = ref927x_pin_configs
,
1581 [STAC_D965_3ST
] = d965_3st_pin_configs
,
1582 [STAC_D965_5ST
] = d965_5st_pin_configs
,
1583 [STAC_DELL_3ST
] = dell_3st_pin_configs
,
1584 [STAC_DELL_BIOS
] = NULL
,
1587 static const char *stac927x_models
[STAC_927X_MODELS
] = {
1588 [STAC_D965_REF
] = "ref",
1589 [STAC_D965_3ST
] = "3stack",
1590 [STAC_D965_5ST
] = "5stack",
1591 [STAC_DELL_3ST
] = "dell-3stack",
1592 [STAC_DELL_BIOS
] = "dell-bios",
1595 static struct snd_pci_quirk stac927x_cfg_tbl
[] = {
1596 /* SigmaTel reference board */
1597 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2668,
1598 "DFI LanParty", STAC_D965_REF
),
1599 /* Intel 946 based systems */
1600 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x3d01, "Intel D946", STAC_D965_3ST
),
1601 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0xa301, "Intel D946", STAC_D965_3ST
),
1602 /* 965 based 3 stack systems */
1603 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2116, "Intel D965", STAC_D965_3ST
),
1604 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2115, "Intel D965", STAC_D965_3ST
),
1605 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2114, "Intel D965", STAC_D965_3ST
),
1606 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2113, "Intel D965", STAC_D965_3ST
),
1607 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2112, "Intel D965", STAC_D965_3ST
),
1608 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2111, "Intel D965", STAC_D965_3ST
),
1609 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2110, "Intel D965", STAC_D965_3ST
),
1610 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2009, "Intel D965", STAC_D965_3ST
),
1611 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2008, "Intel D965", STAC_D965_3ST
),
1612 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2007, "Intel D965", STAC_D965_3ST
),
1613 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2006, "Intel D965", STAC_D965_3ST
),
1614 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2005, "Intel D965", STAC_D965_3ST
),
1615 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2004, "Intel D965", STAC_D965_3ST
),
1616 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2003, "Intel D965", STAC_D965_3ST
),
1617 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2002, "Intel D965", STAC_D965_3ST
),
1618 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2001, "Intel D965", STAC_D965_3ST
),
1619 /* Dell 3 stack systems */
1620 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST
),
1621 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST
),
1622 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01ed, "Dell ", STAC_DELL_3ST
),
1623 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01f4, "Dell ", STAC_DELL_3ST
),
1624 /* Dell 3 stack systems with verb table in BIOS */
1625 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS
),
1626 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS
),
1627 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x022f, "Dell ", STAC_DELL_BIOS
),
1628 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x022e, "Dell ", STAC_DELL_BIOS
),
1629 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0242, "Dell ", STAC_DELL_BIOS
),
1630 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0243, "Dell ", STAC_DELL_BIOS
),
1631 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x02ff, "Dell ", STAC_DELL_BIOS
),
1632 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS
),
1633 /* 965 based 5 stack systems */
1634 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2301, "Intel D965", STAC_D965_5ST
),
1635 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2302, "Intel D965", STAC_D965_5ST
),
1636 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2303, "Intel D965", STAC_D965_5ST
),
1637 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2304, "Intel D965", STAC_D965_5ST
),
1638 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2305, "Intel D965", STAC_D965_5ST
),
1639 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2501, "Intel D965", STAC_D965_5ST
),
1640 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2502, "Intel D965", STAC_D965_5ST
),
1641 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2503, "Intel D965", STAC_D965_5ST
),
1642 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2504, "Intel D965", STAC_D965_5ST
),
1646 static unsigned int ref9205_pin_configs
[12] = {
1647 0x40000100, 0x40000100, 0x01016011, 0x01014010,
1648 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
1649 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
1653 STAC 9205 pin configs for
1660 10280228 (Dell Vostro 1500)
1662 static unsigned int dell_9205_m42_pin_configs
[12] = {
1663 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
1664 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
1665 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
1669 STAC 9205 pin configs for
1673 102801FF (Dell Precision M4300)
1678 static unsigned int dell_9205_m43_pin_configs
[12] = {
1679 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
1680 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
1681 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
1684 static unsigned int dell_9205_m44_pin_configs
[12] = {
1685 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
1686 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
1687 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
1690 static unsigned int *stac9205_brd_tbl
[STAC_9205_MODELS
] = {
1691 [STAC_9205_REF
] = ref9205_pin_configs
,
1692 [STAC_9205_DELL_M42
] = dell_9205_m42_pin_configs
,
1693 [STAC_9205_DELL_M43
] = dell_9205_m43_pin_configs
,
1694 [STAC_9205_DELL_M44
] = dell_9205_m44_pin_configs
,
1697 static const char *stac9205_models
[STAC_9205_MODELS
] = {
1698 [STAC_9205_REF
] = "ref",
1699 [STAC_9205_DELL_M42
] = "dell-m42",
1700 [STAC_9205_DELL_M43
] = "dell-m43",
1701 [STAC_9205_DELL_M44
] = "dell-m44",
1704 static struct snd_pci_quirk stac9205_cfg_tbl
[] = {
1705 /* SigmaTel reference board */
1706 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL
, 0x2668,
1707 "DFI LanParty", STAC_9205_REF
),
1708 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01f1,
1709 "unknown Dell", STAC_9205_DELL_M42
),
1710 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01f2,
1711 "unknown Dell", STAC_9205_DELL_M42
),
1712 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01f8,
1713 "Dell Precision", STAC_9205_DELL_M43
),
1714 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x021c,
1715 "Dell Precision", STAC_9205_DELL_M43
),
1716 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01f9,
1717 "Dell Precision", STAC_9205_DELL_M43
),
1718 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x021b,
1719 "Dell Precision", STAC_9205_DELL_M43
),
1720 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01fa,
1721 "Dell Precision", STAC_9205_DELL_M43
),
1722 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01fc,
1723 "unknown Dell", STAC_9205_DELL_M42
),
1724 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01fd,
1725 "unknown Dell", STAC_9205_DELL_M42
),
1726 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01fe,
1727 "Dell Precision", STAC_9205_DELL_M43
),
1728 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01ff,
1729 "Dell Precision M4300", STAC_9205_DELL_M43
),
1730 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0206,
1731 "Dell Precision", STAC_9205_DELL_M43
),
1732 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01f1,
1733 "Dell Inspiron", STAC_9205_DELL_M44
),
1734 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01f2,
1735 "Dell Inspiron", STAC_9205_DELL_M44
),
1736 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01fc,
1737 "Dell Inspiron", STAC_9205_DELL_M44
),
1738 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x01fd,
1739 "Dell Inspiron", STAC_9205_DELL_M44
),
1740 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0204,
1741 "unknown Dell", STAC_9205_DELL_M42
),
1742 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x021f,
1743 "Dell Inspiron", STAC_9205_DELL_M44
),
1744 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL
, 0x0228,
1745 "Dell Vostro 1500", STAC_9205_DELL_M42
),
1749 static int stac92xx_save_bios_config_regs(struct hda_codec
*codec
)
1752 struct sigmatel_spec
*spec
= codec
->spec
;
1754 if (! spec
->bios_pin_configs
) {
1755 spec
->bios_pin_configs
= kcalloc(spec
->num_pins
,
1756 sizeof(*spec
->bios_pin_configs
), GFP_KERNEL
);
1757 if (! spec
->bios_pin_configs
)
1761 for (i
= 0; i
< spec
->num_pins
; i
++) {
1762 hda_nid_t nid
= spec
->pin_nids
[i
];
1763 unsigned int pin_cfg
;
1765 pin_cfg
= snd_hda_codec_read(codec
, nid
, 0,
1766 AC_VERB_GET_CONFIG_DEFAULT
, 0x00);
1767 snd_printdd(KERN_INFO
"hda_codec: pin nid %2.2x bios pin config %8.8x\n",
1769 spec
->bios_pin_configs
[i
] = pin_cfg
;
1775 static void stac92xx_set_config_reg(struct hda_codec
*codec
,
1776 hda_nid_t pin_nid
, unsigned int pin_config
)
1779 snd_hda_codec_write(codec
, pin_nid
, 0,
1780 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0
,
1781 pin_config
& 0x000000ff);
1782 snd_hda_codec_write(codec
, pin_nid
, 0,
1783 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1
,
1784 (pin_config
& 0x0000ff00) >> 8);
1785 snd_hda_codec_write(codec
, pin_nid
, 0,
1786 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2
,
1787 (pin_config
& 0x00ff0000) >> 16);
1788 snd_hda_codec_write(codec
, pin_nid
, 0,
1789 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3
,
1791 i
= snd_hda_codec_read(codec
, pin_nid
, 0,
1792 AC_VERB_GET_CONFIG_DEFAULT
,
1794 snd_printdd(KERN_INFO
"hda_codec: pin nid %2.2x pin config %8.8x\n",
1798 static void stac92xx_set_config_regs(struct hda_codec
*codec
)
1801 struct sigmatel_spec
*spec
= codec
->spec
;
1803 if (!spec
->pin_configs
)
1806 for (i
= 0; i
< spec
->num_pins
; i
++)
1807 stac92xx_set_config_reg(codec
, spec
->pin_nids
[i
],
1808 spec
->pin_configs
[i
]);
1812 * Analog playback callbacks
1814 static int stac92xx_playback_pcm_open(struct hda_pcm_stream
*hinfo
,
1815 struct hda_codec
*codec
,
1816 struct snd_pcm_substream
*substream
)
1818 struct sigmatel_spec
*spec
= codec
->spec
;
1819 return snd_hda_multi_out_analog_open(codec
, &spec
->multiout
, substream
,
1823 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
1824 struct hda_codec
*codec
,
1825 unsigned int stream_tag
,
1826 unsigned int format
,
1827 struct snd_pcm_substream
*substream
)
1829 struct sigmatel_spec
*spec
= codec
->spec
;
1830 return snd_hda_multi_out_analog_prepare(codec
, &spec
->multiout
, stream_tag
, format
, substream
);
1833 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
1834 struct hda_codec
*codec
,
1835 struct snd_pcm_substream
*substream
)
1837 struct sigmatel_spec
*spec
= codec
->spec
;
1838 return snd_hda_multi_out_analog_cleanup(codec
, &spec
->multiout
);
1842 * Digital playback callbacks
1844 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream
*hinfo
,
1845 struct hda_codec
*codec
,
1846 struct snd_pcm_substream
*substream
)
1848 struct sigmatel_spec
*spec
= codec
->spec
;
1849 return snd_hda_multi_out_dig_open(codec
, &spec
->multiout
);
1852 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream
*hinfo
,
1853 struct hda_codec
*codec
,
1854 struct snd_pcm_substream
*substream
)
1856 struct sigmatel_spec
*spec
= codec
->spec
;
1857 return snd_hda_multi_out_dig_close(codec
, &spec
->multiout
);
1860 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
1861 struct hda_codec
*codec
,
1862 unsigned int stream_tag
,
1863 unsigned int format
,
1864 struct snd_pcm_substream
*substream
)
1866 struct sigmatel_spec
*spec
= codec
->spec
;
1867 return snd_hda_multi_out_dig_prepare(codec
, &spec
->multiout
,
1868 stream_tag
, format
, substream
);
1873 * Analog capture callbacks
1875 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream
*hinfo
,
1876 struct hda_codec
*codec
,
1877 unsigned int stream_tag
,
1878 unsigned int format
,
1879 struct snd_pcm_substream
*substream
)
1881 struct sigmatel_spec
*spec
= codec
->spec
;
1883 snd_hda_codec_setup_stream(codec
, spec
->adc_nids
[substream
->number
],
1884 stream_tag
, 0, format
);
1888 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
1889 struct hda_codec
*codec
,
1890 struct snd_pcm_substream
*substream
)
1892 struct sigmatel_spec
*spec
= codec
->spec
;
1894 snd_hda_codec_setup_stream(codec
, spec
->adc_nids
[substream
->number
], 0, 0, 0);
1898 static struct hda_pcm_stream stac92xx_pcm_digital_playback
= {
1902 /* NID is set in stac92xx_build_pcms */
1904 .open
= stac92xx_dig_playback_pcm_open
,
1905 .close
= stac92xx_dig_playback_pcm_close
,
1906 .prepare
= stac92xx_dig_playback_pcm_prepare
1910 static struct hda_pcm_stream stac92xx_pcm_digital_capture
= {
1914 /* NID is set in stac92xx_build_pcms */
1917 static struct hda_pcm_stream stac92xx_pcm_analog_playback
= {
1921 .nid
= 0x02, /* NID to query formats and rates */
1923 .open
= stac92xx_playback_pcm_open
,
1924 .prepare
= stac92xx_playback_pcm_prepare
,
1925 .cleanup
= stac92xx_playback_pcm_cleanup
1929 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback
= {
1933 .nid
= 0x06, /* NID to query formats and rates */
1935 .open
= stac92xx_playback_pcm_open
,
1936 .prepare
= stac92xx_playback_pcm_prepare
,
1937 .cleanup
= stac92xx_playback_pcm_cleanup
1941 static struct hda_pcm_stream stac92xx_pcm_analog_capture
= {
1944 /* NID + .substreams is set in stac92xx_build_pcms */
1946 .prepare
= stac92xx_capture_pcm_prepare
,
1947 .cleanup
= stac92xx_capture_pcm_cleanup
1951 static int stac92xx_build_pcms(struct hda_codec
*codec
)
1953 struct sigmatel_spec
*spec
= codec
->spec
;
1954 struct hda_pcm
*info
= spec
->pcm_rec
;
1956 codec
->num_pcms
= 1;
1957 codec
->pcm_info
= info
;
1959 info
->name
= "STAC92xx Analog";
1960 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] = stac92xx_pcm_analog_playback
;
1961 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] = stac92xx_pcm_analog_capture
;
1962 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
= spec
->adc_nids
[0];
1963 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].substreams
= spec
->num_adcs
;
1965 if (spec
->alt_switch
) {
1968 info
->name
= "STAC92xx Analog Alt";
1969 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] = stac92xx_pcm_analog_alt_playback
;
1972 if (spec
->multiout
.dig_out_nid
|| spec
->dig_in_nid
) {
1975 info
->name
= "STAC92xx Digital";
1976 info
->pcm_type
= HDA_PCM_TYPE_SPDIF
;
1977 if (spec
->multiout
.dig_out_nid
) {
1978 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] = stac92xx_pcm_digital_playback
;
1979 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].nid
= spec
->multiout
.dig_out_nid
;
1981 if (spec
->dig_in_nid
) {
1982 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] = stac92xx_pcm_digital_capture
;
1983 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
= spec
->dig_in_nid
;
1990 static unsigned int stac92xx_get_vref(struct hda_codec
*codec
, hda_nid_t nid
)
1992 unsigned int pincap
= snd_hda_param_read(codec
, nid
,
1994 pincap
= (pincap
& AC_PINCAP_VREF
) >> AC_PINCAP_VREF_SHIFT
;
1995 if (pincap
& AC_PINCAP_VREF_100
)
1996 return AC_PINCTL_VREF_100
;
1997 if (pincap
& AC_PINCAP_VREF_80
)
1998 return AC_PINCTL_VREF_80
;
1999 if (pincap
& AC_PINCAP_VREF_50
)
2000 return AC_PINCTL_VREF_50
;
2001 if (pincap
& AC_PINCAP_VREF_GRD
)
2002 return AC_PINCTL_VREF_GRD
;
2006 static void stac92xx_auto_set_pinctl(struct hda_codec
*codec
, hda_nid_t nid
, int pin_type
)
2009 snd_hda_codec_write_cache(codec
, nid
, 0,
2010 AC_VERB_SET_PIN_WIDGET_CONTROL
, pin_type
);
2013 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info
2015 static int stac92xx_io_switch_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
2017 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2018 struct sigmatel_spec
*spec
= codec
->spec
;
2019 int io_idx
= kcontrol
-> private_value
& 0xff;
2021 ucontrol
->value
.integer
.value
[0] = spec
->io_switch
[io_idx
];
2025 static int stac92xx_io_switch_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
2027 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2028 struct sigmatel_spec
*spec
= codec
->spec
;
2029 hda_nid_t nid
= kcontrol
->private_value
>> 8;
2030 int io_idx
= kcontrol
-> private_value
& 0xff;
2031 unsigned short val
= !!ucontrol
->value
.integer
.value
[0];
2033 spec
->io_switch
[io_idx
] = val
;
2036 stac92xx_auto_set_pinctl(codec
, nid
, AC_PINCTL_OUT_EN
);
2038 unsigned int pinctl
= AC_PINCTL_IN_EN
;
2039 if (io_idx
) /* set VREF for mic */
2040 pinctl
|= stac92xx_get_vref(codec
, nid
);
2041 stac92xx_auto_set_pinctl(codec
, nid
, pinctl
);
2044 /* check the auto-mute again: we need to mute/unmute the speaker
2045 * appropriately according to the pin direction
2047 if (spec
->hp_detect
)
2048 codec
->patch_ops
.unsol_event(codec
, STAC_HP_EVENT
<< 26);
2053 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2055 static int stac92xx_clfe_switch_get(struct snd_kcontrol
*kcontrol
,
2056 struct snd_ctl_elem_value
*ucontrol
)
2058 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2059 struct sigmatel_spec
*spec
= codec
->spec
;
2061 ucontrol
->value
.integer
.value
[0] = spec
->clfe_swap
;
2065 static int stac92xx_clfe_switch_put(struct snd_kcontrol
*kcontrol
,
2066 struct snd_ctl_elem_value
*ucontrol
)
2068 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
2069 struct sigmatel_spec
*spec
= codec
->spec
;
2070 hda_nid_t nid
= kcontrol
->private_value
& 0xff;
2071 unsigned int val
= !!ucontrol
->value
.integer
.value
[0];
2073 if (spec
->clfe_swap
== val
)
2076 spec
->clfe_swap
= val
;
2078 snd_hda_codec_write_cache(codec
, nid
, 0, AC_VERB_SET_EAPD_BTLENABLE
,
2079 spec
->clfe_swap
? 0x4 : 0x0);
2084 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2085 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2088 .info = stac92xx_io_switch_info, \
2089 .get = stac92xx_io_switch_get, \
2090 .put = stac92xx_io_switch_put, \
2091 .private_value = xpval, \
2094 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2095 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2098 .info = stac92xx_clfe_switch_info, \
2099 .get = stac92xx_clfe_switch_get, \
2100 .put = stac92xx_clfe_switch_put, \
2101 .private_value = xpval, \
2105 STAC_CTL_WIDGET_VOL
,
2106 STAC_CTL_WIDGET_MUTE
,
2107 STAC_CTL_WIDGET_MONO_MUX
,
2108 STAC_CTL_WIDGET_IO_SWITCH
,
2109 STAC_CTL_WIDGET_CLFE_SWITCH
2112 static struct snd_kcontrol_new stac92xx_control_templates
[] = {
2113 HDA_CODEC_VOLUME(NULL
, 0, 0, 0),
2114 HDA_CODEC_MUTE(NULL
, 0, 0, 0),
2116 STAC_CODEC_IO_SWITCH(NULL
, 0),
2117 STAC_CODEC_CLFE_SWITCH(NULL
, 0),
2120 /* add dynamic controls */
2121 static int stac92xx_add_control(struct sigmatel_spec
*spec
, int type
, const char *name
, unsigned long val
)
2123 struct snd_kcontrol_new
*knew
;
2125 if (spec
->num_kctl_used
>= spec
->num_kctl_alloc
) {
2126 int num
= spec
->num_kctl_alloc
+ NUM_CONTROL_ALLOC
;
2128 knew
= kcalloc(num
+ 1, sizeof(*knew
), GFP_KERNEL
); /* array + terminator */
2131 if (spec
->kctl_alloc
) {
2132 memcpy(knew
, spec
->kctl_alloc
, sizeof(*knew
) * spec
->num_kctl_alloc
);
2133 kfree(spec
->kctl_alloc
);
2135 spec
->kctl_alloc
= knew
;
2136 spec
->num_kctl_alloc
= num
;
2139 knew
= &spec
->kctl_alloc
[spec
->num_kctl_used
];
2140 *knew
= stac92xx_control_templates
[type
];
2141 knew
->name
= kstrdup(name
, GFP_KERNEL
);
2144 knew
->private_value
= val
;
2145 spec
->num_kctl_used
++;
2149 /* flag inputs as additional dynamic lineouts */
2150 static int stac92xx_add_dyn_out_pins(struct hda_codec
*codec
, struct auto_pin_cfg
*cfg
)
2152 struct sigmatel_spec
*spec
= codec
->spec
;
2153 unsigned int wcaps
, wtype
;
2154 int i
, num_dacs
= 0;
2156 /* use the wcaps cache to count all DACs available for line-outs */
2157 for (i
= 0; i
< codec
->num_nodes
; i
++) {
2158 wcaps
= codec
->wcaps
[i
];
2159 wtype
= (wcaps
& AC_WCAP_TYPE
) >> AC_WCAP_TYPE_SHIFT
;
2161 if (wtype
== AC_WID_AUD_OUT
&& !(wcaps
& AC_WCAP_DIGITAL
))
2165 snd_printdd("%s: total dac count=%d\n", __func__
, num_dacs
);
2167 switch (cfg
->line_outs
) {
2169 /* add line-in as side */
2170 if (cfg
->input_pins
[AUTO_PIN_LINE
] && num_dacs
> 3) {
2171 cfg
->line_out_pins
[cfg
->line_outs
] =
2172 cfg
->input_pins
[AUTO_PIN_LINE
];
2173 spec
->line_switch
= 1;
2178 /* add line-in as clfe and mic as side */
2179 if (cfg
->input_pins
[AUTO_PIN_LINE
] && num_dacs
> 2) {
2180 cfg
->line_out_pins
[cfg
->line_outs
] =
2181 cfg
->input_pins
[AUTO_PIN_LINE
];
2182 spec
->line_switch
= 1;
2185 if (cfg
->input_pins
[AUTO_PIN_MIC
] && num_dacs
> 3) {
2186 cfg
->line_out_pins
[cfg
->line_outs
] =
2187 cfg
->input_pins
[AUTO_PIN_MIC
];
2188 spec
->mic_switch
= 1;
2193 /* add line-in as surr and mic as clfe */
2194 if (cfg
->input_pins
[AUTO_PIN_LINE
] && num_dacs
> 1) {
2195 cfg
->line_out_pins
[cfg
->line_outs
] =
2196 cfg
->input_pins
[AUTO_PIN_LINE
];
2197 spec
->line_switch
= 1;
2200 if (cfg
->input_pins
[AUTO_PIN_MIC
] && num_dacs
> 2) {
2201 cfg
->line_out_pins
[cfg
->line_outs
] =
2202 cfg
->input_pins
[AUTO_PIN_MIC
];
2203 spec
->mic_switch
= 1;
2213 static int is_in_dac_nids(struct sigmatel_spec
*spec
, hda_nid_t nid
)
2217 for (i
= 0; i
< spec
->multiout
.num_dacs
; i
++) {
2218 if (spec
->multiout
.dac_nids
[i
] == nid
)
2226 * Fill in the dac_nids table from the parsed pin configuration
2227 * This function only works when every pin in line_out_pins[]
2228 * contains atleast one DAC in its connection list. Some 92xx
2229 * codecs are not connected directly to a DAC, such as the 9200
2230 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2232 static int stac92xx_auto_fill_dac_nids(struct hda_codec
*codec
,
2233 struct auto_pin_cfg
*cfg
)
2235 struct sigmatel_spec
*spec
= codec
->spec
;
2236 int i
, j
, conn_len
= 0;
2237 hda_nid_t nid
, conn
[HDA_MAX_CONNECTIONS
];
2238 unsigned int wcaps
, wtype
;
2240 for (i
= 0; i
< cfg
->line_outs
; i
++) {
2241 nid
= cfg
->line_out_pins
[i
];
2242 conn_len
= snd_hda_get_connections(codec
, nid
, conn
,
2243 HDA_MAX_CONNECTIONS
);
2244 for (j
= 0; j
< conn_len
; j
++) {
2245 wcaps
= snd_hda_param_read(codec
, conn
[j
],
2246 AC_PAR_AUDIO_WIDGET_CAP
);
2247 wtype
= (wcaps
& AC_WCAP_TYPE
) >> AC_WCAP_TYPE_SHIFT
;
2248 if (wtype
!= AC_WID_AUD_OUT
||
2249 (wcaps
& AC_WCAP_DIGITAL
))
2251 /* conn[j] is a DAC routed to this line-out */
2252 if (!is_in_dac_nids(spec
, conn
[j
]))
2256 if (j
== conn_len
) {
2257 if (spec
->multiout
.num_dacs
> 0) {
2258 /* we have already working output pins,
2259 * so let's drop the broken ones again
2261 cfg
->line_outs
= spec
->multiout
.num_dacs
;
2264 /* error out, no available DAC found */
2266 "%s: No available DAC for pin 0x%x\n",
2271 spec
->multiout
.dac_nids
[i
] = conn
[j
];
2272 spec
->multiout
.num_dacs
++;
2274 /* select this DAC in the pin's input mux */
2275 snd_hda_codec_write_cache(codec
, nid
, 0,
2276 AC_VERB_SET_CONNECT_SEL
, j
);
2281 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2282 spec
->multiout
.num_dacs
,
2283 spec
->multiout
.dac_nids
[0],
2284 spec
->multiout
.dac_nids
[1],
2285 spec
->multiout
.dac_nids
[2],
2286 spec
->multiout
.dac_nids
[3],
2287 spec
->multiout
.dac_nids
[4]);
2291 /* create volume control/switch for the given prefx type */
2292 static int create_controls(struct sigmatel_spec
*spec
, const char *pfx
, hda_nid_t nid
, int chs
)
2297 sprintf(name
, "%s Playback Volume", pfx
);
2298 err
= stac92xx_add_control(spec
, STAC_CTL_WIDGET_VOL
, name
,
2299 HDA_COMPOSE_AMP_VAL(nid
, chs
, 0, HDA_OUTPUT
));
2302 sprintf(name
, "%s Playback Switch", pfx
);
2303 err
= stac92xx_add_control(spec
, STAC_CTL_WIDGET_MUTE
, name
,
2304 HDA_COMPOSE_AMP_VAL(nid
, chs
, 0, HDA_OUTPUT
));
2310 static int add_spec_dacs(struct sigmatel_spec
*spec
, hda_nid_t nid
)
2312 if (!spec
->multiout
.hp_nid
)
2313 spec
->multiout
.hp_nid
= nid
;
2314 else if (spec
->multiout
.num_dacs
> 4) {
2315 printk(KERN_WARNING
"stac92xx: No space for DAC 0x%x\n", nid
);
2318 spec
->multiout
.dac_nids
[spec
->multiout
.num_dacs
] = nid
;
2319 spec
->multiout
.num_dacs
++;
2324 static int check_in_dac_nids(struct sigmatel_spec
*spec
, hda_nid_t nid
)
2326 if (is_in_dac_nids(spec
, nid
))
2328 if (spec
->multiout
.hp_nid
== nid
)
2333 /* add playback controls from the parsed DAC table */
2334 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec
*codec
,
2335 const struct auto_pin_cfg
*cfg
)
2337 static const char *chname
[4] = {
2338 "Front", "Surround", NULL
/*CLFE*/, "Side"
2343 struct sigmatel_spec
*spec
= codec
->spec
;
2344 unsigned int wid_caps
, pincap
;
2347 for (i
= 0; i
< cfg
->line_outs
; i
++) {
2348 if (!spec
->multiout
.dac_nids
[i
])
2351 nid
= spec
->multiout
.dac_nids
[i
];
2355 err
= create_controls(spec
, "Center", nid
, 1);
2358 err
= create_controls(spec
, "LFE", nid
, 2);
2362 wid_caps
= get_wcaps(codec
, nid
);
2364 if (wid_caps
& AC_WCAP_LR_SWAP
) {
2365 err
= stac92xx_add_control(spec
,
2366 STAC_CTL_WIDGET_CLFE_SWITCH
,
2367 "Swap Center/LFE Playback Switch", nid
);
2374 err
= create_controls(spec
, chname
[i
], nid
, 3);
2380 if (spec
->line_switch
) {
2381 nid
= cfg
->input_pins
[AUTO_PIN_LINE
];
2382 pincap
= snd_hda_param_read(codec
, nid
,
2384 if (pincap
& AC_PINCAP_OUT
) {
2385 err
= stac92xx_add_control(spec
,
2386 STAC_CTL_WIDGET_IO_SWITCH
,
2387 "Line In as Output Switch", nid
<< 8);
2393 if (spec
->mic_switch
) {
2394 unsigned int def_conf
;
2395 unsigned int mic_pin
= AUTO_PIN_MIC
;
2397 nid
= cfg
->input_pins
[mic_pin
];
2398 def_conf
= snd_hda_codec_read(codec
, nid
, 0,
2399 AC_VERB_GET_CONFIG_DEFAULT
, 0);
2400 /* some laptops have an internal analog microphone
2401 * which can't be used as a output */
2402 if (get_defcfg_connect(def_conf
) != AC_JACK_PORT_FIXED
) {
2403 pincap
= snd_hda_param_read(codec
, nid
,
2405 if (pincap
& AC_PINCAP_OUT
) {
2406 err
= stac92xx_add_control(spec
,
2407 STAC_CTL_WIDGET_IO_SWITCH
,
2408 "Mic as Output Switch", (nid
<< 8) | 1);
2409 nid
= snd_hda_codec_read(codec
, nid
, 0,
2410 AC_VERB_GET_CONNECT_LIST
, 0) & 0xff;
2411 if (!check_in_dac_nids(spec
, nid
))
2412 add_spec_dacs(spec
, nid
);
2416 } else if (mic_pin
== AUTO_PIN_MIC
) {
2417 mic_pin
= AUTO_PIN_FRONT_MIC
;
2425 /* add playback controls for Speaker and HP outputs */
2426 static int stac92xx_auto_create_hp_ctls(struct hda_codec
*codec
,
2427 struct auto_pin_cfg
*cfg
)
2429 struct sigmatel_spec
*spec
= codec
->spec
;
2431 int i
, old_num_dacs
, err
;
2433 old_num_dacs
= spec
->multiout
.num_dacs
;
2434 for (i
= 0; i
< cfg
->hp_outs
; i
++) {
2435 unsigned int wid_caps
= get_wcaps(codec
, cfg
->hp_pins
[i
]);
2436 if (wid_caps
& AC_WCAP_UNSOL_CAP
)
2437 spec
->hp_detect
= 1;
2438 nid
= snd_hda_codec_read(codec
, cfg
->hp_pins
[i
], 0,
2439 AC_VERB_GET_CONNECT_LIST
, 0) & 0xff;
2440 if (check_in_dac_nids(spec
, nid
))
2444 add_spec_dacs(spec
, nid
);
2446 for (i
= 0; i
< cfg
->speaker_outs
; i
++) {
2447 nid
= snd_hda_codec_read(codec
, cfg
->speaker_pins
[i
], 0,
2448 AC_VERB_GET_CONNECT_LIST
, 0) & 0xff;
2449 if (check_in_dac_nids(spec
, nid
))
2453 add_spec_dacs(spec
, nid
);
2455 for (i
= 0; i
< cfg
->line_outs
; i
++) {
2456 nid
= snd_hda_codec_read(codec
, cfg
->line_out_pins
[i
], 0,
2457 AC_VERB_GET_CONNECT_LIST
, 0) & 0xff;
2458 if (check_in_dac_nids(spec
, nid
))
2462 add_spec_dacs(spec
, nid
);
2464 for (i
= old_num_dacs
; i
< spec
->multiout
.num_dacs
; i
++) {
2465 static const char *pfxs
[] = {
2466 "Speaker", "External Speaker", "Speaker2",
2468 err
= create_controls(spec
, pfxs
[i
- old_num_dacs
],
2469 spec
->multiout
.dac_nids
[i
], 3);
2473 if (spec
->multiout
.hp_nid
) {
2475 if (old_num_dacs
== spec
->multiout
.num_dacs
)
2479 err
= create_controls(spec
, pfx
, spec
->multiout
.hp_nid
, 3);
2487 /* labels for mono mux outputs */
2488 static const char *stac92xx_mono_labels
[3] = {
2489 "DAC0", "DAC1", "Mixer"
2492 /* create mono mux for mono out on capable codecs */
2493 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec
*codec
)
2495 struct sigmatel_spec
*spec
= codec
->spec
;
2496 struct hda_input_mux
*mono_mux
= &spec
->private_mono_mux
;
2498 hda_nid_t con_lst
[ARRAY_SIZE(stac92xx_mono_labels
)];
2500 num_cons
= snd_hda_get_connections(codec
,
2503 HDA_MAX_NUM_INPUTS
);
2504 if (!num_cons
|| num_cons
> ARRAY_SIZE(stac92xx_mono_labels
))
2507 for (i
= 0; i
< num_cons
; i
++) {
2508 mono_mux
->items
[mono_mux
->num_items
].label
=
2509 stac92xx_mono_labels
[i
];
2510 mono_mux
->items
[mono_mux
->num_items
].index
= i
;
2511 mono_mux
->num_items
++;
2514 return stac92xx_add_control(spec
, STAC_CTL_WIDGET_MONO_MUX
,
2515 "Mono Mux", spec
->mono_nid
);
2518 /* labels for dmic mux inputs */
2519 static const char *stac92xx_dmic_labels
[5] = {
2520 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
2521 "Digital Mic 3", "Digital Mic 4"
2524 /* create playback/capture controls for input pins on dmic capable codecs */
2525 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec
*codec
,
2526 const struct auto_pin_cfg
*cfg
)
2528 struct sigmatel_spec
*spec
= codec
->spec
;
2529 struct hda_input_mux
*dimux
= &spec
->private_dimux
;
2530 hda_nid_t con_lst
[HDA_MAX_NUM_INPUTS
];
2534 dimux
->items
[dimux
->num_items
].label
= stac92xx_dmic_labels
[0];
2535 dimux
->items
[dimux
->num_items
].index
= 0;
2538 for (i
= 0; i
< spec
->num_dmics
; i
++) {
2543 unsigned int def_conf
;
2545 def_conf
= snd_hda_codec_read(codec
,
2548 AC_VERB_GET_CONFIG_DEFAULT
,
2550 if (get_defcfg_connect(def_conf
) == AC_JACK_PORT_NONE
)
2553 nid
= spec
->dmic_nids
[i
];
2554 num_cons
= snd_hda_get_connections(codec
,
2557 HDA_MAX_NUM_INPUTS
);
2558 for (j
= 0; j
< num_cons
; j
++)
2559 if (con_lst
[j
] == nid
) {
2565 wcaps
= get_wcaps(codec
, nid
);
2567 if (wcaps
& AC_WCAP_OUT_AMP
) {
2568 sprintf(name
, "%s Capture Volume",
2569 stac92xx_dmic_labels
[dimux
->num_items
]);
2571 err
= stac92xx_add_control(spec
,
2572 STAC_CTL_WIDGET_VOL
,
2574 HDA_COMPOSE_AMP_VAL(nid
, 3, 0, HDA_OUTPUT
));
2579 dimux
->items
[dimux
->num_items
].label
=
2580 stac92xx_dmic_labels
[dimux
->num_items
];
2581 dimux
->items
[dimux
->num_items
].index
= index
;
2588 /* create playback/capture controls for input pins */
2589 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec
*codec
, const struct auto_pin_cfg
*cfg
)
2591 struct sigmatel_spec
*spec
= codec
->spec
;
2592 struct hda_input_mux
*imux
= &spec
->private_imux
;
2593 hda_nid_t con_lst
[HDA_MAX_NUM_INPUTS
];
2596 for (i
= 0; i
< AUTO_PIN_LAST
; i
++) {
2599 if (!cfg
->input_pins
[i
])
2602 for (j
= 0; j
< spec
->num_muxes
; j
++) {
2604 num_cons
= snd_hda_get_connections(codec
,
2607 HDA_MAX_NUM_INPUTS
);
2608 for (k
= 0; k
< num_cons
; k
++)
2609 if (con_lst
[k
] == cfg
->input_pins
[i
]) {
2616 imux
->items
[imux
->num_items
].label
= auto_pin_cfg_labels
[i
];
2617 imux
->items
[imux
->num_items
].index
= index
;
2621 if (imux
->num_items
) {
2623 * Set the current input for the muxes.
2624 * The STAC9221 has two input muxes with identical source
2625 * NID lists. Hopefully this won't get confused.
2627 for (i
= 0; i
< spec
->num_muxes
; i
++) {
2628 snd_hda_codec_write_cache(codec
, spec
->mux_nids
[i
], 0,
2629 AC_VERB_SET_CONNECT_SEL
,
2630 imux
->items
[0].index
);
2637 static void stac92xx_auto_init_multi_out(struct hda_codec
*codec
)
2639 struct sigmatel_spec
*spec
= codec
->spec
;
2642 for (i
= 0; i
< spec
->autocfg
.line_outs
; i
++) {
2643 hda_nid_t nid
= spec
->autocfg
.line_out_pins
[i
];
2644 stac92xx_auto_set_pinctl(codec
, nid
, AC_PINCTL_OUT_EN
);
2648 static void stac92xx_auto_init_hp_out(struct hda_codec
*codec
)
2650 struct sigmatel_spec
*spec
= codec
->spec
;
2653 for (i
= 0; i
< spec
->autocfg
.hp_outs
; i
++) {
2655 pin
= spec
->autocfg
.hp_pins
[i
];
2656 if (pin
) /* connect to front */
2657 stac92xx_auto_set_pinctl(codec
, pin
, AC_PINCTL_OUT_EN
| AC_PINCTL_HP_EN
);
2659 for (i
= 0; i
< spec
->autocfg
.speaker_outs
; i
++) {
2661 pin
= spec
->autocfg
.speaker_pins
[i
];
2662 if (pin
) /* connect to front */
2663 stac92xx_auto_set_pinctl(codec
, pin
, AC_PINCTL_OUT_EN
);
2667 static int stac92xx_parse_auto_config(struct hda_codec
*codec
, hda_nid_t dig_out
, hda_nid_t dig_in
)
2669 struct sigmatel_spec
*spec
= codec
->spec
;
2671 int hp_speaker_swap
= 0;
2673 if ((err
= snd_hda_parse_pin_def_config(codec
,
2675 spec
->dmic_nids
)) < 0)
2677 if (! spec
->autocfg
.line_outs
)
2678 return 0; /* can't find valid pin config */
2680 /* If we have no real line-out pin and multiple hp-outs, HPs should
2681 * be set up as multi-channel outputs.
2683 if (spec
->autocfg
.line_out_type
== AUTO_PIN_SPEAKER_OUT
&&
2684 spec
->autocfg
.hp_outs
> 1) {
2685 /* Copy hp_outs to line_outs, backup line_outs in
2686 * speaker_outs so that the following routines can handle
2687 * HP pins as primary outputs.
2689 memcpy(spec
->autocfg
.speaker_pins
, spec
->autocfg
.line_out_pins
,
2690 sizeof(spec
->autocfg
.line_out_pins
));
2691 spec
->autocfg
.speaker_outs
= spec
->autocfg
.line_outs
;
2692 memcpy(spec
->autocfg
.line_out_pins
, spec
->autocfg
.hp_pins
,
2693 sizeof(spec
->autocfg
.hp_pins
));
2694 spec
->autocfg
.line_outs
= spec
->autocfg
.hp_outs
;
2695 hp_speaker_swap
= 1;
2697 if (spec
->autocfg
.mono_out_pin
) {
2698 int dir
= (get_wcaps(codec
, spec
->autocfg
.mono_out_pin
)
2699 & AC_WCAP_OUT_AMP
) ? HDA_OUTPUT
: HDA_INPUT
;
2700 u32 caps
= query_amp_caps(codec
,
2701 spec
->autocfg
.mono_out_pin
, dir
);
2702 hda_nid_t conn_list
[1];
2704 /* get the mixer node and then the mono mux if it exists */
2705 if (snd_hda_get_connections(codec
,
2706 spec
->autocfg
.mono_out_pin
, conn_list
, 1) &&
2707 snd_hda_get_connections(codec
, conn_list
[0],
2710 int wcaps
= get_wcaps(codec
, conn_list
[0]);
2711 int wid_type
= (wcaps
& AC_WCAP_TYPE
)
2712 >> AC_WCAP_TYPE_SHIFT
;
2713 /* LR swap check, some stac925x have a mux that
2714 * changes the DACs output path instead of the
2717 if (wid_type
== AC_WID_AUD_SEL
&&
2718 !(wcaps
& AC_WCAP_LR_SWAP
))
2719 spec
->mono_nid
= conn_list
[0];
2721 /* all mono outs have a least a mute/unmute switch */
2722 err
= stac92xx_add_control(spec
, STAC_CTL_WIDGET_MUTE
,
2723 "Mono Playback Switch",
2724 HDA_COMPOSE_AMP_VAL(spec
->autocfg
.mono_out_pin
,
2728 /* check to see if there is volume support for the amp */
2729 if ((caps
& AC_AMPCAP_NUM_STEPS
) >> AC_AMPCAP_NUM_STEPS_SHIFT
) {
2730 err
= stac92xx_add_control(spec
, STAC_CTL_WIDGET_VOL
,
2731 "Mono Playback Volume",
2732 HDA_COMPOSE_AMP_VAL(spec
->autocfg
.mono_out_pin
,
2738 stac92xx_auto_set_pinctl(codec
, spec
->autocfg
.mono_out_pin
,
2742 if ((err
= stac92xx_add_dyn_out_pins(codec
, &spec
->autocfg
)) < 0)
2744 if (spec
->multiout
.num_dacs
== 0)
2745 if ((err
= stac92xx_auto_fill_dac_nids(codec
, &spec
->autocfg
)) < 0)
2748 err
= stac92xx_auto_create_multi_out_ctls(codec
, &spec
->autocfg
);
2753 if (hp_speaker_swap
== 1) {
2754 /* Restore the hp_outs and line_outs */
2755 memcpy(spec
->autocfg
.hp_pins
, spec
->autocfg
.line_out_pins
,
2756 sizeof(spec
->autocfg
.line_out_pins
));
2757 spec
->autocfg
.hp_outs
= spec
->autocfg
.line_outs
;
2758 memcpy(spec
->autocfg
.line_out_pins
, spec
->autocfg
.speaker_pins
,
2759 sizeof(spec
->autocfg
.speaker_pins
));
2760 spec
->autocfg
.line_outs
= spec
->autocfg
.speaker_outs
;
2761 memset(spec
->autocfg
.speaker_pins
, 0,
2762 sizeof(spec
->autocfg
.speaker_pins
));
2763 spec
->autocfg
.speaker_outs
= 0;
2766 err
= stac92xx_auto_create_hp_ctls(codec
, &spec
->autocfg
);
2771 err
= stac92xx_auto_create_analog_input_ctls(codec
, &spec
->autocfg
);
2776 if (spec
->mono_nid
> 0) {
2777 err
= stac92xx_auto_create_mono_output_ctls(codec
);
2782 if (spec
->num_dmics
> 0)
2783 if ((err
= stac92xx_auto_create_dmic_input_ctls(codec
,
2784 &spec
->autocfg
)) < 0)
2787 spec
->multiout
.max_channels
= spec
->multiout
.num_dacs
* 2;
2788 if (spec
->multiout
.max_channels
> 2)
2789 spec
->surr_switch
= 1;
2791 if (spec
->autocfg
.dig_out_pin
)
2792 spec
->multiout
.dig_out_nid
= dig_out
;
2793 if (spec
->autocfg
.dig_in_pin
)
2794 spec
->dig_in_nid
= dig_in
;
2796 if (spec
->kctl_alloc
)
2797 spec
->mixers
[spec
->num_mixers
++] = spec
->kctl_alloc
;
2799 spec
->input_mux
= &spec
->private_imux
;
2800 if (!spec
->dinput_mux
)
2801 spec
->dinput_mux
= &spec
->private_dimux
;
2802 spec
->mono_mux
= &spec
->private_mono_mux
;
2807 /* add playback controls for HP output */
2808 static int stac9200_auto_create_hp_ctls(struct hda_codec
*codec
,
2809 struct auto_pin_cfg
*cfg
)
2811 struct sigmatel_spec
*spec
= codec
->spec
;
2812 hda_nid_t pin
= cfg
->hp_pins
[0];
2813 unsigned int wid_caps
;
2818 wid_caps
= get_wcaps(codec
, pin
);
2819 if (wid_caps
& AC_WCAP_UNSOL_CAP
)
2820 spec
->hp_detect
= 1;
2825 /* add playback controls for LFE output */
2826 static int stac9200_auto_create_lfe_ctls(struct hda_codec
*codec
,
2827 struct auto_pin_cfg
*cfg
)
2829 struct sigmatel_spec
*spec
= codec
->spec
;
2831 hda_nid_t lfe_pin
= 0x0;
2835 * search speaker outs and line outs for a mono speaker pin
2836 * with an amp. If one is found, add LFE controls
2839 for (i
= 0; i
< spec
->autocfg
.speaker_outs
&& lfe_pin
== 0x0; i
++) {
2840 hda_nid_t pin
= spec
->autocfg
.speaker_pins
[i
];
2841 unsigned long wcaps
= get_wcaps(codec
, pin
);
2842 wcaps
&= (AC_WCAP_STEREO
| AC_WCAP_OUT_AMP
);
2843 if (wcaps
== AC_WCAP_OUT_AMP
)
2844 /* found a mono speaker with an amp, must be lfe */
2848 /* if speaker_outs is 0, then speakers may be in line_outs */
2849 if (lfe_pin
== 0 && spec
->autocfg
.speaker_outs
== 0) {
2850 for (i
= 0; i
< spec
->autocfg
.line_outs
&& lfe_pin
== 0x0; i
++) {
2851 hda_nid_t pin
= spec
->autocfg
.line_out_pins
[i
];
2853 cfg
= snd_hda_codec_read(codec
, pin
, 0,
2854 AC_VERB_GET_CONFIG_DEFAULT
,
2856 if (get_defcfg_device(cfg
) == AC_JACK_SPEAKER
) {
2857 unsigned long wcaps
= get_wcaps(codec
, pin
);
2858 wcaps
&= (AC_WCAP_STEREO
| AC_WCAP_OUT_AMP
);
2859 if (wcaps
== AC_WCAP_OUT_AMP
)
2860 /* found a mono speaker with an amp,
2868 err
= create_controls(spec
, "LFE", lfe_pin
, 1);
2876 static int stac9200_parse_auto_config(struct hda_codec
*codec
)
2878 struct sigmatel_spec
*spec
= codec
->spec
;
2881 if ((err
= snd_hda_parse_pin_def_config(codec
, &spec
->autocfg
, NULL
)) < 0)
2884 if ((err
= stac92xx_auto_create_analog_input_ctls(codec
, &spec
->autocfg
)) < 0)
2887 if ((err
= stac9200_auto_create_hp_ctls(codec
, &spec
->autocfg
)) < 0)
2890 if ((err
= stac9200_auto_create_lfe_ctls(codec
, &spec
->autocfg
)) < 0)
2893 if (spec
->autocfg
.dig_out_pin
)
2894 spec
->multiout
.dig_out_nid
= 0x05;
2895 if (spec
->autocfg
.dig_in_pin
)
2896 spec
->dig_in_nid
= 0x04;
2898 if (spec
->kctl_alloc
)
2899 spec
->mixers
[spec
->num_mixers
++] = spec
->kctl_alloc
;
2901 spec
->input_mux
= &spec
->private_imux
;
2902 spec
->dinput_mux
= &spec
->private_dimux
;
2908 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
2909 * funky external mute control using GPIO pins.
2912 static void stac_gpio_set(struct hda_codec
*codec
, unsigned int mask
,
2913 unsigned int dir_mask
, unsigned int data
)
2915 unsigned int gpiostate
, gpiomask
, gpiodir
;
2917 gpiostate
= snd_hda_codec_read(codec
, codec
->afg
, 0,
2918 AC_VERB_GET_GPIO_DATA
, 0);
2919 gpiostate
= (gpiostate
& ~dir_mask
) | (data
& dir_mask
);
2921 gpiomask
= snd_hda_codec_read(codec
, codec
->afg
, 0,
2922 AC_VERB_GET_GPIO_MASK
, 0);
2925 gpiodir
= snd_hda_codec_read(codec
, codec
->afg
, 0,
2926 AC_VERB_GET_GPIO_DIRECTION
, 0);
2927 gpiodir
|= dir_mask
;
2929 /* Configure GPIOx as CMOS */
2930 snd_hda_codec_write(codec
, codec
->afg
, 0, 0x7e7, 0);
2932 snd_hda_codec_write(codec
, codec
->afg
, 0,
2933 AC_VERB_SET_GPIO_MASK
, gpiomask
);
2934 snd_hda_codec_read(codec
, codec
->afg
, 0,
2935 AC_VERB_SET_GPIO_DIRECTION
, gpiodir
); /* sync */
2939 snd_hda_codec_read(codec
, codec
->afg
, 0,
2940 AC_VERB_SET_GPIO_DATA
, gpiostate
); /* sync */
2943 static void enable_pin_detect(struct hda_codec
*codec
, hda_nid_t nid
,
2946 if (get_wcaps(codec
, nid
) & AC_WCAP_UNSOL_CAP
)
2947 snd_hda_codec_write_cache(codec
, nid
, 0,
2948 AC_VERB_SET_UNSOLICITED_ENABLE
,
2949 (AC_USRSP_EN
| event
));
2952 static int is_nid_hp_pin(struct auto_pin_cfg
*cfg
, hda_nid_t nid
)
2955 for (i
= 0; i
< cfg
->hp_outs
; i
++)
2956 if (cfg
->hp_pins
[i
] == nid
)
2957 return 1; /* nid is a HP-Out */
2959 return 0; /* nid is not a HP-Out */
2962 static void stac92xx_power_down(struct hda_codec
*codec
)
2964 struct sigmatel_spec
*spec
= codec
->spec
;
2966 /* power down inactive DACs */
2968 for (dac
= spec
->dac_list
; *dac
; dac
++)
2969 if (!is_in_dac_nids(spec
, *dac
) &&
2970 spec
->multiout
.hp_nid
!= *dac
)
2971 snd_hda_codec_write_cache(codec
, *dac
, 0,
2972 AC_VERB_SET_POWER_STATE
, AC_PWRST_D3
);
2975 static int stac92xx_init(struct hda_codec
*codec
)
2977 struct sigmatel_spec
*spec
= codec
->spec
;
2978 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
2981 snd_hda_sequence_write(codec
, spec
->init
);
2984 if (spec
->hp_detect
) {
2985 /* Enable unsolicited responses on the HP widget */
2986 for (i
= 0; i
< cfg
->hp_outs
; i
++)
2987 enable_pin_detect(codec
, cfg
->hp_pins
[i
],
2989 /* force to enable the first line-out; the others are set up
2992 stac92xx_auto_set_pinctl(codec
, spec
->autocfg
.line_out_pins
[0],
2994 stac92xx_auto_init_hp_out(codec
);
2995 /* fake event to set up pins */
2996 codec
->patch_ops
.unsol_event(codec
, STAC_HP_EVENT
<< 26);
2998 stac92xx_auto_init_multi_out(codec
);
2999 stac92xx_auto_init_hp_out(codec
);
3001 for (i
= 0; i
< AUTO_PIN_LAST
; i
++) {
3002 hda_nid_t nid
= cfg
->input_pins
[i
];
3004 unsigned int pinctl
= AC_PINCTL_IN_EN
;
3005 if (i
== AUTO_PIN_MIC
|| i
== AUTO_PIN_FRONT_MIC
)
3006 pinctl
|= stac92xx_get_vref(codec
, nid
);
3007 stac92xx_auto_set_pinctl(codec
, nid
, pinctl
);
3010 for (i
= 0; i
< spec
->num_dmics
; i
++)
3011 stac92xx_auto_set_pinctl(codec
, spec
->dmic_nids
[i
],
3013 for (i
= 0; i
< spec
->num_pwrs
; i
++) {
3014 int event
= is_nid_hp_pin(cfg
, spec
->pwr_nids
[i
])
3015 ? STAC_HP_EVENT
: STAC_PWR_EVENT
;
3016 int pinctl
= snd_hda_codec_read(codec
, spec
->pwr_nids
[i
],
3017 0, AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
3018 /* outputs are only ports capable of power management
3019 * any attempts on powering down a input port cause the
3020 * referenced VREF to act quirky.
3022 if (pinctl
& AC_PINCTL_IN_EN
)
3024 enable_pin_detect(codec
, spec
->pwr_nids
[i
], event
| i
);
3025 codec
->patch_ops
.unsol_event(codec
, (event
| i
) << 26);
3028 stac92xx_power_down(codec
);
3029 if (cfg
->dig_out_pin
)
3030 stac92xx_auto_set_pinctl(codec
, cfg
->dig_out_pin
,
3032 if (cfg
->dig_in_pin
)
3033 stac92xx_auto_set_pinctl(codec
, cfg
->dig_in_pin
,
3036 stac_gpio_set(codec
, spec
->gpio_mask
,
3037 spec
->gpio_dir
, spec
->gpio_data
);
3042 static void stac92xx_free(struct hda_codec
*codec
)
3044 struct sigmatel_spec
*spec
= codec
->spec
;
3050 if (spec
->kctl_alloc
) {
3051 for (i
= 0; i
< spec
->num_kctl_used
; i
++)
3052 kfree(spec
->kctl_alloc
[i
].name
);
3053 kfree(spec
->kctl_alloc
);
3056 if (spec
->bios_pin_configs
)
3057 kfree(spec
->bios_pin_configs
);
3062 static void stac92xx_set_pinctl(struct hda_codec
*codec
, hda_nid_t nid
,
3065 unsigned int pin_ctl
= snd_hda_codec_read(codec
, nid
,
3066 0, AC_VERB_GET_PIN_WIDGET_CONTROL
, 0x00);
3068 if (pin_ctl
& AC_PINCTL_IN_EN
) {
3070 * we need to check the current set-up direction of
3071 * shared input pins since they can be switched via
3072 * "xxx as Output" mixer switch
3074 struct sigmatel_spec
*spec
= codec
->spec
;
3075 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
3076 if ((nid
== cfg
->input_pins
[AUTO_PIN_LINE
] &&
3077 spec
->line_switch
) ||
3078 (nid
== cfg
->input_pins
[AUTO_PIN_MIC
] &&
3083 /* if setting pin direction bits, clear the current
3084 direction bits first */
3085 if (flag
& (AC_PINCTL_IN_EN
| AC_PINCTL_OUT_EN
))
3086 pin_ctl
&= ~(AC_PINCTL_IN_EN
| AC_PINCTL_OUT_EN
);
3088 snd_hda_codec_write_cache(codec
, nid
, 0,
3089 AC_VERB_SET_PIN_WIDGET_CONTROL
,
3093 static void stac92xx_reset_pinctl(struct hda_codec
*codec
, hda_nid_t nid
,
3096 unsigned int pin_ctl
= snd_hda_codec_read(codec
, nid
,
3097 0, AC_VERB_GET_PIN_WIDGET_CONTROL
, 0x00);
3098 snd_hda_codec_write_cache(codec
, nid
, 0,
3099 AC_VERB_SET_PIN_WIDGET_CONTROL
,
3103 static int get_hp_pin_presence(struct hda_codec
*codec
, hda_nid_t nid
)
3107 if (snd_hda_codec_read(codec
, nid
, 0, AC_VERB_GET_PIN_SENSE
, 0x00)
3109 unsigned int pinctl
;
3110 pinctl
= snd_hda_codec_read(codec
, nid
, 0,
3111 AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
3112 if (pinctl
& AC_PINCTL_IN_EN
)
3113 return 0; /* mic- or line-input */
3115 return 1; /* HP-output */
3120 static void stac92xx_hp_detect(struct hda_codec
*codec
, unsigned int res
)
3122 struct sigmatel_spec
*spec
= codec
->spec
;
3123 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
3127 if (spec
->gpio_mute
)
3128 presence
= !(snd_hda_codec_read(codec
, codec
->afg
, 0,
3129 AC_VERB_GET_GPIO_DATA
, 0) & spec
->gpio_mute
);
3131 for (i
= 0; i
< cfg
->hp_outs
; i
++) {
3134 presence
= get_hp_pin_presence(codec
, cfg
->hp_pins
[i
]);
3138 /* disable lineouts, enable hp */
3139 for (i
= 0; i
< cfg
->line_outs
; i
++)
3140 stac92xx_reset_pinctl(codec
, cfg
->line_out_pins
[i
],
3142 for (i
= 0; i
< cfg
->speaker_outs
; i
++)
3143 stac92xx_reset_pinctl(codec
, cfg
->speaker_pins
[i
],
3146 /* enable lineouts, disable hp */
3147 for (i
= 0; i
< cfg
->line_outs
; i
++)
3148 stac92xx_set_pinctl(codec
, cfg
->line_out_pins
[i
],
3150 for (i
= 0; i
< cfg
->speaker_outs
; i
++)
3151 stac92xx_set_pinctl(codec
, cfg
->speaker_pins
[i
],
3156 static void stac92xx_pin_sense(struct hda_codec
*codec
, int idx
)
3158 struct sigmatel_spec
*spec
= codec
->spec
;
3159 hda_nid_t nid
= spec
->pwr_nids
[idx
];
3161 val
= snd_hda_codec_read(codec
, codec
->afg
, 0, 0x0fec, 0x0)
3163 presence
= get_hp_pin_presence(codec
, nid
);
3171 /* power down unused output ports */
3172 snd_hda_codec_write(codec
, codec
->afg
, 0, 0x7ec, val
);
3175 static void stac92xx_unsol_event(struct hda_codec
*codec
, unsigned int res
)
3177 struct sigmatel_spec
*spec
= codec
->spec
;
3178 int idx
= res
>> 26 & 0x0f;
3180 switch ((res
>> 26) & 0x30) {
3182 stac92xx_hp_detect(codec
, res
);
3184 case STAC_PWR_EVENT
:
3185 if (spec
->num_pwrs
> 0)
3186 stac92xx_pin_sense(codec
, idx
);
3190 #ifdef SND_HDA_NEEDS_RESUME
3191 static int stac92xx_resume(struct hda_codec
*codec
)
3193 struct sigmatel_spec
*spec
= codec
->spec
;
3195 stac92xx_set_config_regs(codec
);
3196 snd_hda_sequence_write(codec
, spec
->init
);
3197 stac_gpio_set(codec
, spec
->gpio_mask
,
3198 spec
->gpio_dir
, spec
->gpio_data
);
3199 snd_hda_codec_resume_amp(codec
);
3200 snd_hda_codec_resume_cache(codec
);
3201 /* power down inactive DACs */
3203 stac92xx_power_down(codec
);
3204 /* invoke unsolicited event to reset the HP state */
3205 if (spec
->hp_detect
)
3206 codec
->patch_ops
.unsol_event(codec
, STAC_HP_EVENT
<< 26);
3211 static struct hda_codec_ops stac92xx_patch_ops
= {
3212 .build_controls
= stac92xx_build_controls
,
3213 .build_pcms
= stac92xx_build_pcms
,
3214 .init
= stac92xx_init
,
3215 .free
= stac92xx_free
,
3216 .unsol_event
= stac92xx_unsol_event
,
3217 #ifdef SND_HDA_NEEDS_RESUME
3218 .resume
= stac92xx_resume
,
3222 static int patch_stac9200(struct hda_codec
*codec
)
3224 struct sigmatel_spec
*spec
;
3227 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
3232 spec
->num_pins
= ARRAY_SIZE(stac9200_pin_nids
);
3233 spec
->pin_nids
= stac9200_pin_nids
;
3234 spec
->board_config
= snd_hda_check_board_config(codec
, STAC_9200_MODELS
,
3237 if (spec
->board_config
< 0) {
3238 snd_printdd(KERN_INFO
"hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
3239 err
= stac92xx_save_bios_config_regs(codec
);
3241 stac92xx_free(codec
);
3244 spec
->pin_configs
= spec
->bios_pin_configs
;
3246 spec
->pin_configs
= stac9200_brd_tbl
[spec
->board_config
];
3247 stac92xx_set_config_regs(codec
);
3250 spec
->multiout
.max_channels
= 2;
3251 spec
->multiout
.num_dacs
= 1;
3252 spec
->multiout
.dac_nids
= stac9200_dac_nids
;
3253 spec
->adc_nids
= stac9200_adc_nids
;
3254 spec
->mux_nids
= stac9200_mux_nids
;
3255 spec
->num_muxes
= 1;
3256 spec
->num_dmics
= 0;
3260 if (spec
->board_config
== STAC_9200_GATEWAY
||
3261 spec
->board_config
== STAC_9200_OQO
)
3262 spec
->init
= stac9200_eapd_init
;
3264 spec
->init
= stac9200_core_init
;
3265 spec
->mixer
= stac9200_mixer
;
3267 err
= stac9200_parse_auto_config(codec
);
3269 stac92xx_free(codec
);
3273 codec
->patch_ops
= stac92xx_patch_ops
;
3278 static int patch_stac925x(struct hda_codec
*codec
)
3280 struct sigmatel_spec
*spec
;
3283 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
3288 spec
->num_pins
= ARRAY_SIZE(stac925x_pin_nids
);
3289 spec
->pin_nids
= stac925x_pin_nids
;
3290 spec
->board_config
= snd_hda_check_board_config(codec
, STAC_925x_MODELS
,
3294 if (spec
->board_config
< 0) {
3295 snd_printdd(KERN_INFO
"hda_codec: Unknown model for STAC925x,"
3296 "using BIOS defaults\n");
3297 err
= stac92xx_save_bios_config_regs(codec
);
3299 stac92xx_free(codec
);
3302 spec
->pin_configs
= spec
->bios_pin_configs
;
3303 } else if (stac925x_brd_tbl
[spec
->board_config
] != NULL
){
3304 spec
->pin_configs
= stac925x_brd_tbl
[spec
->board_config
];
3305 stac92xx_set_config_regs(codec
);
3308 spec
->multiout
.max_channels
= 2;
3309 spec
->multiout
.num_dacs
= 1;
3310 spec
->multiout
.dac_nids
= stac925x_dac_nids
;
3311 spec
->adc_nids
= stac925x_adc_nids
;
3312 spec
->mux_nids
= stac925x_mux_nids
;
3313 spec
->num_muxes
= 1;
3316 switch (codec
->vendor_id
) {
3317 case 0x83847632: /* STAC9202 */
3318 case 0x83847633: /* STAC9202D */
3319 case 0x83847636: /* STAC9251 */
3320 case 0x83847637: /* STAC9251D */
3321 spec
->num_dmics
= STAC925X_NUM_DMICS
;
3322 spec
->dmic_nids
= stac925x_dmic_nids
;
3323 spec
->num_dmuxes
= ARRAY_SIZE(stac925x_dmux_nids
);
3324 spec
->dmux_nids
= stac925x_dmux_nids
;
3327 spec
->num_dmics
= 0;
3331 spec
->init
= stac925x_core_init
;
3332 spec
->mixer
= stac925x_mixer
;
3334 err
= stac92xx_parse_auto_config(codec
, 0x8, 0x7);
3336 if (spec
->board_config
< 0) {
3337 printk(KERN_WARNING
"hda_codec: No auto-config is "
3338 "available, default to model=ref\n");
3339 spec
->board_config
= STAC_925x_REF
;
3345 stac92xx_free(codec
);
3349 codec
->patch_ops
= stac92xx_patch_ops
;
3354 static struct hda_input_mux stac92hd73xx_dmux
= {
3357 { "Analog Inputs", 0x0b },
3359 { "Digital Mic 1", 0x09 },
3360 { "Digital Mic 2", 0x0a },
3364 static int patch_stac92hd73xx(struct hda_codec
*codec
)
3366 struct sigmatel_spec
*spec
;
3367 hda_nid_t conn
[STAC92HD73_DAC_COUNT
+ 2];
3370 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
3375 spec
->num_pins
= ARRAY_SIZE(stac92hd73xx_pin_nids
);
3376 spec
->pin_nids
= stac92hd73xx_pin_nids
;
3377 spec
->board_config
= snd_hda_check_board_config(codec
,
3378 STAC_92HD73XX_MODELS
,
3379 stac92hd73xx_models
,
3380 stac92hd73xx_cfg_tbl
);
3382 if (spec
->board_config
< 0) {
3383 snd_printdd(KERN_INFO
"hda_codec: Unknown model for"
3384 " STAC92HD73XX, using BIOS defaults\n");
3385 err
= stac92xx_save_bios_config_regs(codec
);
3387 stac92xx_free(codec
);
3390 spec
->pin_configs
= spec
->bios_pin_configs
;
3392 spec
->pin_configs
= stac92hd73xx_brd_tbl
[spec
->board_config
];
3393 stac92xx_set_config_regs(codec
);
3396 spec
->multiout
.num_dacs
= snd_hda_get_connections(codec
, 0x0a,
3397 conn
, STAC92HD73_DAC_COUNT
+ 2) - 1;
3399 if (spec
->multiout
.num_dacs
< 0) {
3400 printk(KERN_WARNING
"hda_codec: Could not determine "
3401 "number of channels defaulting to DAC count\n");
3402 spec
->multiout
.num_dacs
= STAC92HD73_DAC_COUNT
;
3405 switch (spec
->multiout
.num_dacs
) {
3406 case 0x3: /* 6 Channel */
3407 spec
->mixer
= stac92hd73xx_6ch_mixer
;
3408 spec
->init
= stac92hd73xx_6ch_core_init
;
3410 case 0x4: /* 8 Channel */
3411 spec
->multiout
.hp_nid
= 0x18;
3412 spec
->mixer
= stac92hd73xx_8ch_mixer
;
3413 spec
->init
= stac92hd73xx_8ch_core_init
;
3415 case 0x5: /* 10 Channel */
3416 spec
->multiout
.hp_nid
= 0x19;
3417 spec
->mixer
= stac92hd73xx_10ch_mixer
;
3418 spec
->init
= stac92hd73xx_10ch_core_init
;
3421 spec
->multiout
.dac_nids
= stac92hd73xx_dac_nids
;
3422 spec
->aloopback_mask
= 0x01;
3423 spec
->aloopback_shift
= 8;
3425 spec
->mux_nids
= stac92hd73xx_mux_nids
;
3426 spec
->adc_nids
= stac92hd73xx_adc_nids
;
3427 spec
->dmic_nids
= stac92hd73xx_dmic_nids
;
3428 spec
->dmux_nids
= stac92hd73xx_dmux_nids
;
3430 spec
->num_muxes
= ARRAY_SIZE(stac92hd73xx_mux_nids
);
3431 spec
->num_adcs
= ARRAY_SIZE(stac92hd73xx_adc_nids
);
3432 spec
->num_dmuxes
= ARRAY_SIZE(stac92hd73xx_dmux_nids
);
3433 spec
->dinput_mux
= &stac92hd73xx_dmux
;
3434 /* GPIO0 High = Enable EAPD */
3435 spec
->gpio_mask
= spec
->gpio_dir
= 0x1;
3436 spec
->gpio_data
= 0x01;
3438 switch (spec
->board_config
) {
3440 switch (codec
->subsystem_id
) {
3441 case 0x1028025e: /* Analog Mics */
3443 stac92xx_set_config_reg(codec
, 0x0b, 0x90A70170);
3444 spec
->num_dmics
= 0;
3446 case 0x10280254: /* Digital Mics */
3450 stac92xx_set_config_reg(codec
, 0x13, 0x90A60160);
3451 spec
->num_dmics
= 1;
3453 case 0x10280256: /* Both */
3455 stac92xx_set_config_reg(codec
, 0x0b, 0x90A70170);
3456 stac92xx_set_config_reg(codec
, 0x13, 0x90A60160);
3457 spec
->num_dmics
= 1;
3462 spec
->num_dmics
= STAC92HD73XX_NUM_DMICS
;
3465 spec
->num_pwrs
= ARRAY_SIZE(stac92hd73xx_pwr_nids
);
3466 spec
->pwr_nids
= stac92hd73xx_pwr_nids
;
3468 err
= stac92xx_parse_auto_config(codec
, 0x22, 0x24);
3471 if (spec
->board_config
< 0) {
3472 printk(KERN_WARNING
"hda_codec: No auto-config is "
3473 "available, default to model=ref\n");
3474 spec
->board_config
= STAC_92HD73XX_REF
;
3481 stac92xx_free(codec
);
3485 codec
->patch_ops
= stac92xx_patch_ops
;
3490 static int patch_stac92hd71bxx(struct hda_codec
*codec
)
3492 struct sigmatel_spec
*spec
;
3495 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
3500 spec
->num_pins
= ARRAY_SIZE(stac92hd71bxx_pin_nids
);
3501 spec
->pin_nids
= stac92hd71bxx_pin_nids
;
3502 spec
->board_config
= snd_hda_check_board_config(codec
,
3503 STAC_92HD71BXX_MODELS
,
3504 stac92hd71bxx_models
,
3505 stac92hd71bxx_cfg_tbl
);
3507 if (spec
->board_config
< 0) {
3508 snd_printdd(KERN_INFO
"hda_codec: Unknown model for"
3509 " STAC92HD71BXX, using BIOS defaults\n");
3510 err
= stac92xx_save_bios_config_regs(codec
);
3512 stac92xx_free(codec
);
3515 spec
->pin_configs
= spec
->bios_pin_configs
;
3517 spec
->pin_configs
= stac92hd71bxx_brd_tbl
[spec
->board_config
];
3518 stac92xx_set_config_regs(codec
);
3521 switch (codec
->vendor_id
) {
3522 case 0x111d76b6: /* 4 Port without Analog Mixer */
3524 case 0x111d76b4: /* 6 Port without Analog Mixer */
3526 spec
->mixer
= stac92hd71bxx_mixer
;
3527 spec
->init
= stac92hd71bxx_core_init
;
3530 spec
->mixer
= stac92hd71bxx_analog_mixer
;
3531 spec
->init
= stac92hd71bxx_analog_core_init
;
3534 spec
->aloopback_mask
= 0x20;
3535 spec
->aloopback_shift
= 0;
3537 /* GPIO0 High = EAPD */
3538 spec
->gpio_mask
= spec
->gpio_dir
= spec
->gpio_data
= 0x1;
3540 spec
->mux_nids
= stac92hd71bxx_mux_nids
;
3541 spec
->adc_nids
= stac92hd71bxx_adc_nids
;
3542 spec
->dmic_nids
= stac92hd71bxx_dmic_nids
;
3543 spec
->dmux_nids
= stac92hd71bxx_dmux_nids
;
3545 spec
->num_muxes
= ARRAY_SIZE(stac92hd71bxx_mux_nids
);
3546 spec
->num_adcs
= ARRAY_SIZE(stac92hd71bxx_adc_nids
);
3547 spec
->num_dmics
= STAC92HD71BXX_NUM_DMICS
;
3548 spec
->num_dmuxes
= ARRAY_SIZE(stac92hd71bxx_dmux_nids
);
3550 spec
->num_pwrs
= ARRAY_SIZE(stac92hd71bxx_pwr_nids
);
3551 spec
->pwr_nids
= stac92hd71bxx_pwr_nids
;
3553 spec
->multiout
.num_dacs
= 1;
3554 spec
->multiout
.hp_nid
= 0x11;
3555 spec
->multiout
.dac_nids
= stac92hd71bxx_dac_nids
;
3557 err
= stac92xx_parse_auto_config(codec
, 0x21, 0x23);
3559 if (spec
->board_config
< 0) {
3560 printk(KERN_WARNING
"hda_codec: No auto-config is "
3561 "available, default to model=ref\n");
3562 spec
->board_config
= STAC_92HD71BXX_REF
;
3569 stac92xx_free(codec
);
3573 codec
->patch_ops
= stac92xx_patch_ops
;
3578 static int patch_stac922x(struct hda_codec
*codec
)
3580 struct sigmatel_spec
*spec
;
3583 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
3588 spec
->num_pins
= ARRAY_SIZE(stac922x_pin_nids
);
3589 spec
->pin_nids
= stac922x_pin_nids
;
3590 spec
->board_config
= snd_hda_check_board_config(codec
, STAC_922X_MODELS
,
3593 if (spec
->board_config
== STAC_INTEL_MAC_V3
) {
3594 spec
->gpio_mask
= spec
->gpio_dir
= 0x03;
3595 spec
->gpio_data
= 0x03;
3596 /* Intel Macs have all same PCI SSID, so we need to check
3597 * codec SSID to distinguish the exact models
3599 printk(KERN_INFO
"hda_codec: STAC922x, Apple subsys_id=%x\n", codec
->subsystem_id
);
3600 switch (codec
->subsystem_id
) {
3603 spec
->board_config
= STAC_INTEL_MAC_V1
;
3607 spec
->board_config
= STAC_INTEL_MAC_V2
;
3615 spec
->board_config
= STAC_INTEL_MAC_V3
;
3619 spec
->board_config
= STAC_INTEL_MAC_V4
;
3623 spec
->board_config
= STAC_INTEL_MAC_V5
;
3629 if (spec
->board_config
< 0) {
3630 snd_printdd(KERN_INFO
"hda_codec: Unknown model for STAC922x, "
3631 "using BIOS defaults\n");
3632 err
= stac92xx_save_bios_config_regs(codec
);
3634 stac92xx_free(codec
);
3637 spec
->pin_configs
= spec
->bios_pin_configs
;
3638 } else if (stac922x_brd_tbl
[spec
->board_config
] != NULL
) {
3639 spec
->pin_configs
= stac922x_brd_tbl
[spec
->board_config
];
3640 stac92xx_set_config_regs(codec
);
3643 spec
->adc_nids
= stac922x_adc_nids
;
3644 spec
->mux_nids
= stac922x_mux_nids
;
3645 spec
->num_muxes
= ARRAY_SIZE(stac922x_mux_nids
);
3646 spec
->num_adcs
= ARRAY_SIZE(stac922x_adc_nids
);
3647 spec
->num_dmics
= 0;
3650 spec
->init
= stac922x_core_init
;
3651 spec
->mixer
= stac922x_mixer
;
3653 spec
->multiout
.dac_nids
= spec
->dac_nids
;
3655 err
= stac92xx_parse_auto_config(codec
, 0x08, 0x09);
3657 if (spec
->board_config
< 0) {
3658 printk(KERN_WARNING
"hda_codec: No auto-config is "
3659 "available, default to model=ref\n");
3660 spec
->board_config
= STAC_D945_REF
;
3666 stac92xx_free(codec
);
3670 codec
->patch_ops
= stac92xx_patch_ops
;
3672 /* Fix Mux capture level; max to 2 */
3673 snd_hda_override_amp_caps(codec
, 0x12, HDA_OUTPUT
,
3674 (0 << AC_AMPCAP_OFFSET_SHIFT
) |
3675 (2 << AC_AMPCAP_NUM_STEPS_SHIFT
) |
3676 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT
) |
3677 (0 << AC_AMPCAP_MUTE_SHIFT
));
3682 static int patch_stac927x(struct hda_codec
*codec
)
3684 struct sigmatel_spec
*spec
;
3687 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
3692 spec
->num_pins
= ARRAY_SIZE(stac927x_pin_nids
);
3693 spec
->pin_nids
= stac927x_pin_nids
;
3694 spec
->board_config
= snd_hda_check_board_config(codec
, STAC_927X_MODELS
,
3698 if (spec
->board_config
< 0 || !stac927x_brd_tbl
[spec
->board_config
]) {
3699 if (spec
->board_config
< 0)
3700 snd_printdd(KERN_INFO
"hda_codec: Unknown model for"
3701 "STAC927x, using BIOS defaults\n");
3702 err
= stac92xx_save_bios_config_regs(codec
);
3704 stac92xx_free(codec
);
3707 spec
->pin_configs
= spec
->bios_pin_configs
;
3709 spec
->pin_configs
= stac927x_brd_tbl
[spec
->board_config
];
3710 stac92xx_set_config_regs(codec
);
3713 spec
->adc_nids
= stac927x_adc_nids
;
3714 spec
->num_adcs
= ARRAY_SIZE(stac927x_adc_nids
);
3715 spec
->mux_nids
= stac927x_mux_nids
;
3716 spec
->num_muxes
= ARRAY_SIZE(stac927x_mux_nids
);
3717 spec
->dac_list
= stac927x_dac_nids
;
3718 spec
->multiout
.dac_nids
= spec
->dac_nids
;
3720 switch (spec
->board_config
) {
3723 /* GPIO0 High = Enable EAPD */
3724 spec
->gpio_mask
= spec
->gpio_dir
= 0x01;
3725 spec
->gpio_data
= 0x01;
3726 spec
->num_dmics
= 0;
3728 spec
->init
= d965_core_init
;
3729 spec
->mixer
= stac927x_mixer
;
3731 case STAC_DELL_BIOS
:
3732 /* configure the analog microphone on some laptops */
3733 stac92xx_set_config_reg(codec
, 0x0c, 0x90a79130);
3734 /* correct the front output jack as a hp out */
3735 stac92xx_set_config_reg(codec
, 0x0f, 0x0227011f);
3736 /* correct the front input jack as a mic */
3737 stac92xx_set_config_reg(codec
, 0x0e, 0x02a79130);
3740 /* GPIO2 High = Enable EAPD */
3741 spec
->gpio_mask
= spec
->gpio_dir
= 0x04;
3742 spec
->gpio_data
= 0x04;
3743 spec
->dmic_nids
= stac927x_dmic_nids
;
3744 spec
->num_dmics
= STAC927X_NUM_DMICS
;
3746 spec
->init
= d965_core_init
;
3747 spec
->mixer
= stac927x_mixer
;
3748 spec
->dmux_nids
= stac927x_dmux_nids
;
3749 spec
->num_dmuxes
= ARRAY_SIZE(stac927x_dmux_nids
);
3752 /* GPIO0 High = Enable EAPD */
3753 spec
->gpio_mask
= spec
->gpio_dir
= 0x1;
3754 spec
->gpio_data
= 0x01;
3755 spec
->num_dmics
= 0;
3757 spec
->init
= stac927x_core_init
;
3758 spec
->mixer
= stac927x_mixer
;
3762 spec
->aloopback_mask
= 0x40;
3763 spec
->aloopback_shift
= 0;
3765 err
= stac92xx_parse_auto_config(codec
, 0x1e, 0x20);
3767 if (spec
->board_config
< 0) {
3768 printk(KERN_WARNING
"hda_codec: No auto-config is "
3769 "available, default to model=ref\n");
3770 spec
->board_config
= STAC_D965_REF
;
3776 stac92xx_free(codec
);
3780 codec
->patch_ops
= stac92xx_patch_ops
;
3784 * The STAC927x seem to require fairly long delays for certain
3785 * command sequences. With too short delays (even if the answer
3786 * is set to RIRB properly), it results in the silence output
3787 * on some hardwares like Dell.
3789 * The below flag enables the longer delay (see get_response
3792 codec
->bus
->needs_damn_long_delay
= 1;
3797 static int patch_stac9205(struct hda_codec
*codec
)
3799 struct sigmatel_spec
*spec
;
3802 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
3807 spec
->num_pins
= ARRAY_SIZE(stac9205_pin_nids
);
3808 spec
->pin_nids
= stac9205_pin_nids
;
3809 spec
->board_config
= snd_hda_check_board_config(codec
, STAC_9205_MODELS
,
3813 if (spec
->board_config
< 0) {
3814 snd_printdd(KERN_INFO
"hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
3815 err
= stac92xx_save_bios_config_regs(codec
);
3817 stac92xx_free(codec
);
3820 spec
->pin_configs
= spec
->bios_pin_configs
;
3822 spec
->pin_configs
= stac9205_brd_tbl
[spec
->board_config
];
3823 stac92xx_set_config_regs(codec
);
3826 spec
->adc_nids
= stac9205_adc_nids
;
3827 spec
->num_adcs
= ARRAY_SIZE(stac9205_adc_nids
);
3828 spec
->mux_nids
= stac9205_mux_nids
;
3829 spec
->num_muxes
= ARRAY_SIZE(stac9205_mux_nids
);
3830 spec
->dmic_nids
= stac9205_dmic_nids
;
3831 spec
->num_dmics
= STAC9205_NUM_DMICS
;
3832 spec
->dmux_nids
= stac9205_dmux_nids
;
3833 spec
->num_dmuxes
= ARRAY_SIZE(stac9205_dmux_nids
);
3836 spec
->init
= stac9205_core_init
;
3837 spec
->mixer
= stac9205_mixer
;
3839 spec
->aloopback_mask
= 0x40;
3840 spec
->aloopback_shift
= 0;
3841 spec
->multiout
.dac_nids
= spec
->dac_nids
;
3843 switch (spec
->board_config
){
3844 case STAC_9205_DELL_M43
:
3845 /* Enable SPDIF in/out */
3846 stac92xx_set_config_reg(codec
, 0x1f, 0x01441030);
3847 stac92xx_set_config_reg(codec
, 0x20, 0x1c410030);
3849 /* Enable unsol response for GPIO4/Dock HP connection */
3850 snd_hda_codec_write(codec
, codec
->afg
, 0,
3851 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK
, 0x10);
3852 snd_hda_codec_write_cache(codec
, codec
->afg
, 0,
3853 AC_VERB_SET_UNSOLICITED_ENABLE
,
3854 (AC_USRSP_EN
| STAC_HP_EVENT
));
3856 spec
->gpio_dir
= 0x0b;
3857 spec
->gpio_mask
= 0x1b;
3858 spec
->gpio_mute
= 0x10;
3859 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
3862 spec
->gpio_data
= 0x01;
3865 /* GPIO0 High = EAPD */
3866 spec
->gpio_mask
= spec
->gpio_dir
= 0x1;
3867 spec
->gpio_data
= 0x01;
3871 err
= stac92xx_parse_auto_config(codec
, 0x1f, 0x20);
3873 if (spec
->board_config
< 0) {
3874 printk(KERN_WARNING
"hda_codec: No auto-config is "
3875 "available, default to model=ref\n");
3876 spec
->board_config
= STAC_9205_REF
;
3882 stac92xx_free(codec
);
3886 codec
->patch_ops
= stac92xx_patch_ops
;
3895 /* static config for Sony VAIO FE550G and Sony VAIO AR */
3896 static hda_nid_t vaio_dacs
[] = { 0x2 };
3897 #define VAIO_HP_DAC 0x5
3898 static hda_nid_t vaio_adcs
[] = { 0x8 /*,0x6*/ };
3899 static hda_nid_t vaio_mux_nids
[] = { 0x15 };
3901 static struct hda_input_mux vaio_mux
= {
3904 /* { "HP", 0x0 }, */
3905 { "Mic Jack", 0x1 },
3906 { "Internal Mic", 0x2 },
3911 static struct hda_verb vaio_init
[] = {
3912 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
}, /* HP <- 0x2 */
3913 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE
, AC_USRSP_EN
| STAC_HP_EVENT
},
3914 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
}, /* Speaker <- 0x5 */
3915 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
}, /* Mic? (<- 0x2) */
3916 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
}, /* CD */
3917 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
}, /* Mic? */
3918 {0x15, AC_VERB_SET_CONNECT_SEL
, 0x1}, /* mic-sel: 0a,0d,14,02 */
3919 {0x02, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
}, /* HP */
3920 {0x05, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
}, /* Speaker */
3921 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3922 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3923 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
}, /* Mic-in -> 0x9 */
3927 static struct hda_verb vaio_ar_init
[] = {
3928 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
}, /* HP <- 0x2 */
3929 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
}, /* Speaker <- 0x5 */
3930 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
}, /* Mic? (<- 0x2) */
3931 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_IN
}, /* CD */
3932 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
3933 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_VREF80
}, /* Mic? */
3934 {0x15, AC_VERB_SET_CONNECT_SEL
, 0x1}, /* mic-sel: 0a,0d,14,02 */
3935 {0x02, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
}, /* HP */
3936 {0x05, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
}, /* Speaker */
3937 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
3938 {0x09, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
3939 {0x07, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
3940 {0x15, AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
}, /* Mic-in -> 0x9 */
3944 /* bind volumes of both NID 0x02 and 0x05 */
3945 static struct hda_bind_ctls vaio_bind_master_vol
= {
3946 .ops
= &snd_hda_bind_vol
,
3948 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT
),
3949 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT
),
3954 /* bind volumes of both NID 0x02 and 0x05 */
3955 static struct hda_bind_ctls vaio_bind_master_sw
= {
3956 .ops
= &snd_hda_bind_sw
,
3958 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT
),
3959 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT
),
3964 static struct snd_kcontrol_new vaio_mixer
[] = {
3965 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol
),
3966 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw
),
3967 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3968 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT
),
3969 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT
),
3971 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3972 .name
= "Capture Source",
3974 .info
= stac92xx_mux_enum_info
,
3975 .get
= stac92xx_mux_enum_get
,
3976 .put
= stac92xx_mux_enum_put
,
3981 static struct snd_kcontrol_new vaio_ar_mixer
[] = {
3982 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol
),
3983 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw
),
3984 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
3985 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT
),
3986 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT
),
3987 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
3988 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
3990 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
3991 .name
= "Capture Source",
3993 .info
= stac92xx_mux_enum_info
,
3994 .get
= stac92xx_mux_enum_get
,
3995 .put
= stac92xx_mux_enum_put
,
4000 static struct hda_codec_ops stac9872_patch_ops
= {
4001 .build_controls
= stac92xx_build_controls
,
4002 .build_pcms
= stac92xx_build_pcms
,
4003 .init
= stac92xx_init
,
4004 .free
= stac92xx_free
,
4005 #ifdef SND_HDA_NEEDS_RESUME
4006 .resume
= stac92xx_resume
,
4010 static int stac9872_vaio_init(struct hda_codec
*codec
)
4014 err
= stac92xx_init(codec
);
4017 if (codec
->patch_ops
.unsol_event
)
4018 codec
->patch_ops
.unsol_event(codec
, STAC_HP_EVENT
<< 26);
4022 static void stac9872_vaio_hp_detect(struct hda_codec
*codec
, unsigned int res
)
4024 if (get_hp_pin_presence(codec
, 0x0a)) {
4025 stac92xx_reset_pinctl(codec
, 0x0f, AC_PINCTL_OUT_EN
);
4026 stac92xx_set_pinctl(codec
, 0x0a, AC_PINCTL_OUT_EN
);
4028 stac92xx_reset_pinctl(codec
, 0x0a, AC_PINCTL_OUT_EN
);
4029 stac92xx_set_pinctl(codec
, 0x0f, AC_PINCTL_OUT_EN
);
4033 static void stac9872_vaio_unsol_event(struct hda_codec
*codec
, unsigned int res
)
4035 switch (res
>> 26) {
4037 stac9872_vaio_hp_detect(codec
, res
);
4042 static struct hda_codec_ops stac9872_vaio_patch_ops
= {
4043 .build_controls
= stac92xx_build_controls
,
4044 .build_pcms
= stac92xx_build_pcms
,
4045 .init
= stac9872_vaio_init
,
4046 .free
= stac92xx_free
,
4047 .unsol_event
= stac9872_vaio_unsol_event
,
4049 .resume
= stac92xx_resume
,
4053 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
4055 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
4057 /* Unknown. id=0x83847661 and subsys=0x104D1200. */
4059 /* AR Series. id=0x83847664 and subsys=104D1300 */
4064 static const char *stac9872_models
[STAC_9872_MODELS
] = {
4065 [CXD9872RD_VAIO
] = "vaio",
4066 [CXD9872AKD_VAIO
] = "vaio-ar",
4069 static struct snd_pci_quirk stac9872_cfg_tbl
[] = {
4070 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO
),
4071 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO
),
4072 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO
),
4073 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO
),
4077 static int patch_stac9872(struct hda_codec
*codec
)
4079 struct sigmatel_spec
*spec
;
4082 board_config
= snd_hda_check_board_config(codec
, STAC_9872_MODELS
,
4085 if (board_config
< 0)
4086 /* unknown config, let generic-parser do its job... */
4087 return snd_hda_parse_generic_codec(codec
);
4089 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
4094 switch (board_config
) {
4095 case CXD9872RD_VAIO
:
4096 case STAC9872AK_VAIO
:
4097 case STAC9872K_VAIO
:
4098 spec
->mixer
= vaio_mixer
;
4099 spec
->init
= vaio_init
;
4100 spec
->multiout
.max_channels
= 2;
4101 spec
->multiout
.num_dacs
= ARRAY_SIZE(vaio_dacs
);
4102 spec
->multiout
.dac_nids
= vaio_dacs
;
4103 spec
->multiout
.hp_nid
= VAIO_HP_DAC
;
4104 spec
->num_adcs
= ARRAY_SIZE(vaio_adcs
);
4105 spec
->adc_nids
= vaio_adcs
;
4107 spec
->input_mux
= &vaio_mux
;
4108 spec
->mux_nids
= vaio_mux_nids
;
4109 codec
->patch_ops
= stac9872_vaio_patch_ops
;
4112 case CXD9872AKD_VAIO
:
4113 spec
->mixer
= vaio_ar_mixer
;
4114 spec
->init
= vaio_ar_init
;
4115 spec
->multiout
.max_channels
= 2;
4116 spec
->multiout
.num_dacs
= ARRAY_SIZE(vaio_dacs
);
4117 spec
->multiout
.dac_nids
= vaio_dacs
;
4118 spec
->multiout
.hp_nid
= VAIO_HP_DAC
;
4119 spec
->num_adcs
= ARRAY_SIZE(vaio_adcs
);
4121 spec
->adc_nids
= vaio_adcs
;
4122 spec
->input_mux
= &vaio_mux
;
4123 spec
->mux_nids
= vaio_mux_nids
;
4124 codec
->patch_ops
= stac9872_patch_ops
;
4135 struct hda_codec_preset snd_hda_preset_sigmatel
[] = {
4136 { .id
= 0x83847690, .name
= "STAC9200", .patch
= patch_stac9200
},
4137 { .id
= 0x83847882, .name
= "STAC9220 A1", .patch
= patch_stac922x
},
4138 { .id
= 0x83847680, .name
= "STAC9221 A1", .patch
= patch_stac922x
},
4139 { .id
= 0x83847880, .name
= "STAC9220 A2", .patch
= patch_stac922x
},
4140 { .id
= 0x83847681, .name
= "STAC9220D/9223D A2", .patch
= patch_stac922x
},
4141 { .id
= 0x83847682, .name
= "STAC9221 A2", .patch
= patch_stac922x
},
4142 { .id
= 0x83847683, .name
= "STAC9221D A2", .patch
= patch_stac922x
},
4143 { .id
= 0x83847618, .name
= "STAC9227", .patch
= patch_stac927x
},
4144 { .id
= 0x83847619, .name
= "STAC9227", .patch
= patch_stac927x
},
4145 { .id
= 0x83847616, .name
= "STAC9228", .patch
= patch_stac927x
},
4146 { .id
= 0x83847617, .name
= "STAC9228", .patch
= patch_stac927x
},
4147 { .id
= 0x83847614, .name
= "STAC9229", .patch
= patch_stac927x
},
4148 { .id
= 0x83847615, .name
= "STAC9229", .patch
= patch_stac927x
},
4149 { .id
= 0x83847620, .name
= "STAC9274", .patch
= patch_stac927x
},
4150 { .id
= 0x83847621, .name
= "STAC9274D", .patch
= patch_stac927x
},
4151 { .id
= 0x83847622, .name
= "STAC9273X", .patch
= patch_stac927x
},
4152 { .id
= 0x83847623, .name
= "STAC9273D", .patch
= patch_stac927x
},
4153 { .id
= 0x83847624, .name
= "STAC9272X", .patch
= patch_stac927x
},
4154 { .id
= 0x83847625, .name
= "STAC9272D", .patch
= patch_stac927x
},
4155 { .id
= 0x83847626, .name
= "STAC9271X", .patch
= patch_stac927x
},
4156 { .id
= 0x83847627, .name
= "STAC9271D", .patch
= patch_stac927x
},
4157 { .id
= 0x83847628, .name
= "STAC9274X5NH", .patch
= patch_stac927x
},
4158 { .id
= 0x83847629, .name
= "STAC9274D5NH", .patch
= patch_stac927x
},
4159 { .id
= 0x83847632, .name
= "STAC9202", .patch
= patch_stac925x
},
4160 { .id
= 0x83847633, .name
= "STAC9202D", .patch
= patch_stac925x
},
4161 { .id
= 0x83847634, .name
= "STAC9250", .patch
= patch_stac925x
},
4162 { .id
= 0x83847635, .name
= "STAC9250D", .patch
= patch_stac925x
},
4163 { .id
= 0x83847636, .name
= "STAC9251", .patch
= patch_stac925x
},
4164 { .id
= 0x83847637, .name
= "STAC9250D", .patch
= patch_stac925x
},
4165 /* The following does not take into account .id=0x83847661 when subsys =
4166 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
4167 * currently not fully supported.
4169 { .id
= 0x83847661, .name
= "CXD9872RD/K", .patch
= patch_stac9872
},
4170 { .id
= 0x83847662, .name
= "STAC9872AK", .patch
= patch_stac9872
},
4171 { .id
= 0x83847664, .name
= "CXD9872AKD", .patch
= patch_stac9872
},
4172 { .id
= 0x838476a0, .name
= "STAC9205", .patch
= patch_stac9205
},
4173 { .id
= 0x838476a1, .name
= "STAC9205D", .patch
= patch_stac9205
},
4174 { .id
= 0x838476a2, .name
= "STAC9204", .patch
= patch_stac9205
},
4175 { .id
= 0x838476a3, .name
= "STAC9204D", .patch
= patch_stac9205
},
4176 { .id
= 0x838476a4, .name
= "STAC9255", .patch
= patch_stac9205
},
4177 { .id
= 0x838476a5, .name
= "STAC9255D", .patch
= patch_stac9205
},
4178 { .id
= 0x838476a6, .name
= "STAC9254", .patch
= patch_stac9205
},
4179 { .id
= 0x838476a7, .name
= "STAC9254D", .patch
= patch_stac9205
},
4180 { .id
= 0x111d7674, .name
= "92HD73D1X5", .patch
= patch_stac92hd73xx
},
4181 { .id
= 0x111d7675, .name
= "92HD73C1X5", .patch
= patch_stac92hd73xx
},
4182 { .id
= 0x111d7676, .name
= "92HD73E1X5", .patch
= patch_stac92hd73xx
},
4183 { .id
= 0x111d7608, .name
= "92HD71BXX", .patch
= patch_stac92hd71bxx
},
4184 { .id
= 0x111d76b0, .name
= "92HD71B8X", .patch
= patch_stac92hd71bxx
},
4185 { .id
= 0x111d76b1, .name
= "92HD71B8X", .patch
= patch_stac92hd71bxx
},
4186 { .id
= 0x111d76b2, .name
= "92HD71B7X", .patch
= patch_stac92hd71bxx
},
4187 { .id
= 0x111d76b3, .name
= "92HD71B7X", .patch
= patch_stac92hd71bxx
},
4188 { .id
= 0x111d76b4, .name
= "92HD71B6X", .patch
= patch_stac92hd71bxx
},
4189 { .id
= 0x111d76b5, .name
= "92HD71B6X", .patch
= patch_stac92hd71bxx
},
4190 { .id
= 0x111d76b6, .name
= "92HD71B5X", .patch
= patch_stac92hd71bxx
},
4191 { .id
= 0x111d76b7, .name
= "92HD71B5X", .patch
= patch_stac92hd71bxx
},