ALSA: hda: Use STAC_DELL_M6_BOTH quirk for Dell Studio 1558
[kernel.git] / sound / pci / hda / patch_sigmatel.c
1 /*
2  * Universal Interface for Intel High Definition Audio Codec
3  *
4  * HD audio interface patch for SigmaTel STAC92xx
5  *
6  * Copyright (c) 2005 Embedded Alley Solutions, Inc.
7  * Matt Porter <mporter@embeddedalley.com>
8  *
9  * Based on patch_cmedia.c and patch_realtek.c
10  * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
11  *
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.
16  *
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.
21  *
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
25  */
26
27 #include <linux/init.h>
28 #include <linux/delay.h>
29 #include <linux/slab.h>
30 #include <linux/pci.h>
31 #include <linux/dmi.h>
32 #include <sound/core.h>
33 #include <sound/asoundef.h>
34 #include <sound/jack.h>
35 #include "hda_codec.h"
36 #include "hda_local.h"
37 #include "hda_beep.h"
38
39 enum {
40         STAC_VREF_EVENT = 1,
41         STAC_INSERT_EVENT,
42         STAC_PWR_EVENT,
43         STAC_HP_EVENT,
44         STAC_LO_EVENT,
45         STAC_MIC_EVENT,
46 };
47
48 enum {
49         STAC_AUTO,
50         STAC_REF,
51         STAC_9200_OQO,
52         STAC_9200_DELL_D21,
53         STAC_9200_DELL_D22,
54         STAC_9200_DELL_D23,
55         STAC_9200_DELL_M21,
56         STAC_9200_DELL_M22,
57         STAC_9200_DELL_M23,
58         STAC_9200_DELL_M24,
59         STAC_9200_DELL_M25,
60         STAC_9200_DELL_M26,
61         STAC_9200_DELL_M27,
62         STAC_9200_M4,
63         STAC_9200_M4_2,
64         STAC_9200_PANASONIC,
65         STAC_9200_MODELS
66 };
67
68 enum {
69         STAC_9205_AUTO,
70         STAC_9205_REF,
71         STAC_9205_DELL_M42,
72         STAC_9205_DELL_M43,
73         STAC_9205_DELL_M44,
74         STAC_9205_EAPD,
75         STAC_9205_MODELS
76 };
77
78 enum {
79         STAC_92HD73XX_AUTO,
80         STAC_92HD73XX_NO_JD, /* no jack-detection */
81         STAC_92HD73XX_REF,
82         STAC_92HD73XX_INTEL,
83         STAC_DELL_M6_AMIC,
84         STAC_DELL_M6_DMIC,
85         STAC_DELL_M6_BOTH,
86         STAC_DELL_EQ,
87         STAC_ALIENWARE_M17X,
88         STAC_92HD73XX_MODELS
89 };
90
91 enum {
92         STAC_92HD83XXX_AUTO,
93         STAC_92HD83XXX_REF,
94         STAC_92HD83XXX_PWR_REF,
95         STAC_DELL_S14,
96         STAC_92HD83XXX_HP,
97         STAC_92HD83XXX_MODELS
98 };
99
100 enum {
101         STAC_92HD71BXX_AUTO,
102         STAC_92HD71BXX_REF,
103         STAC_DELL_M4_1,
104         STAC_DELL_M4_2,
105         STAC_DELL_M4_3,
106         STAC_HP_M4,
107         STAC_HP_DV5,
108         STAC_HP_HDX,
109         STAC_HP_DV4_1222NR,
110         STAC_92HD71BXX_MODELS
111 };
112
113 enum {
114         STAC_925x_AUTO,
115         STAC_925x_REF,
116         STAC_M1,
117         STAC_M1_2,
118         STAC_M2,
119         STAC_M2_2,
120         STAC_M3,
121         STAC_M5,
122         STAC_M6,
123         STAC_925x_MODELS
124 };
125
126 enum {
127         STAC_922X_AUTO,
128         STAC_D945_REF,
129         STAC_D945GTP3,
130         STAC_D945GTP5,
131         STAC_INTEL_MAC_V1,
132         STAC_INTEL_MAC_V2,
133         STAC_INTEL_MAC_V3,
134         STAC_INTEL_MAC_V4,
135         STAC_INTEL_MAC_V5,
136         STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
137                               * is given, one of the above models will be
138                               * chosen according to the subsystem id. */
139         /* for backward compatibility */
140         STAC_MACMINI,
141         STAC_MACBOOK,
142         STAC_MACBOOK_PRO_V1,
143         STAC_MACBOOK_PRO_V2,
144         STAC_IMAC_INTEL,
145         STAC_IMAC_INTEL_20,
146         STAC_ECS_202,
147         STAC_922X_DELL_D81,
148         STAC_922X_DELL_D82,
149         STAC_922X_DELL_M81,
150         STAC_922X_DELL_M82,
151         STAC_922X_MODELS
152 };
153
154 enum {
155         STAC_927X_AUTO,
156         STAC_D965_REF_NO_JD, /* no jack-detection */
157         STAC_D965_REF,
158         STAC_D965_3ST,
159         STAC_D965_5ST,
160         STAC_D965_5ST_NO_FP,
161         STAC_DELL_3ST,
162         STAC_DELL_BIOS,
163         STAC_927X_VOLKNOB,
164         STAC_927X_MODELS
165 };
166
167 enum {
168         STAC_9872_AUTO,
169         STAC_9872_VAIO,
170         STAC_9872_MODELS
171 };
172
173 struct sigmatel_event {
174         hda_nid_t nid;
175         unsigned char type;
176         unsigned char tag;
177         int data;
178 };
179
180 struct sigmatel_jack {
181         hda_nid_t nid;
182         int type;
183         struct snd_jack *jack;
184 };
185
186 struct sigmatel_mic_route {
187         hda_nid_t pin;
188         signed char mux_idx;
189         signed char dmux_idx;
190 };
191
192 struct sigmatel_spec {
193         struct snd_kcontrol_new *mixers[4];
194         unsigned int num_mixers;
195
196         int board_config;
197         unsigned int eapd_switch: 1;
198         unsigned int surr_switch: 1;
199         unsigned int alt_switch: 1;
200         unsigned int hp_detect: 1;
201         unsigned int spdif_mute: 1;
202         unsigned int check_volume_offset:1;
203         unsigned int auto_mic:1;
204
205         /* gpio lines */
206         unsigned int eapd_mask;
207         unsigned int gpio_mask;
208         unsigned int gpio_dir;
209         unsigned int gpio_data;
210         unsigned int gpio_mute;
211         unsigned int gpio_led;
212         unsigned int gpio_led_polarity;
213
214         /* stream */
215         unsigned int stream_delay;
216
217         /* analog loopback */
218         struct snd_kcontrol_new *aloopback_ctl;
219         unsigned char aloopback_mask;
220         unsigned char aloopback_shift;
221
222         /* power management */
223         unsigned int num_pwrs;
224         unsigned int *pwr_mapping;
225         hda_nid_t *pwr_nids;
226         hda_nid_t *dac_list;
227
228         /* jack detection */
229         struct snd_array jacks;
230
231         /* events */
232         struct snd_array events;
233
234         /* playback */
235         struct hda_input_mux *mono_mux;
236         unsigned int cur_mmux;
237         struct hda_multi_out multiout;
238         hda_nid_t dac_nids[5];
239         hda_nid_t hp_dacs[5];
240         hda_nid_t speaker_dacs[5];
241
242         int volume_offset;
243
244         /* capture */
245         hda_nid_t *adc_nids;
246         unsigned int num_adcs;
247         hda_nid_t *mux_nids;
248         unsigned int num_muxes;
249         hda_nid_t *dmic_nids;
250         unsigned int num_dmics;
251         hda_nid_t *dmux_nids;
252         unsigned int num_dmuxes;
253         hda_nid_t *smux_nids;
254         unsigned int num_smuxes;
255         unsigned int num_analog_muxes;
256
257         unsigned long *capvols; /* amp-volume attr: HDA_COMPOSE_AMP_VAL() */
258         unsigned long *capsws; /* amp-mute attr: HDA_COMPOSE_AMP_VAL() */
259         unsigned int num_caps; /* number of capture volume/switch elements */
260
261         struct sigmatel_mic_route ext_mic;
262         struct sigmatel_mic_route int_mic;
263
264         const char **spdif_labels;
265
266         hda_nid_t dig_in_nid;
267         hda_nid_t mono_nid;
268         hda_nid_t anabeep_nid;
269         hda_nid_t digbeep_nid;
270
271         /* pin widgets */
272         hda_nid_t *pin_nids;
273         unsigned int num_pins;
274
275         /* codec specific stuff */
276         struct hda_verb *init;
277         struct snd_kcontrol_new *mixer;
278
279         /* capture source */
280         struct hda_input_mux *dinput_mux;
281         unsigned int cur_dmux[2];
282         struct hda_input_mux *input_mux;
283         unsigned int cur_mux[3];
284         struct hda_input_mux *sinput_mux;
285         unsigned int cur_smux[2];
286         unsigned int cur_amux;
287         hda_nid_t *amp_nids;
288         unsigned int powerdown_adcs;
289
290         /* i/o switches */
291         unsigned int io_switch[2];
292         unsigned int clfe_swap;
293         hda_nid_t line_switch;  /* shared line-in for input and output */
294         hda_nid_t mic_switch;   /* shared mic-in for input and output */
295         hda_nid_t hp_switch; /* NID of HP as line-out */
296         unsigned int aloopback;
297
298         struct hda_pcm pcm_rec[2];      /* PCM information */
299
300         /* dynamic controls and input_mux */
301         struct auto_pin_cfg autocfg;
302         struct snd_array kctls;
303         struct hda_input_mux private_dimux;
304         struct hda_input_mux private_imux;
305         struct hda_input_mux private_smux;
306         struct hda_input_mux private_mono_mux;
307 };
308
309 static hda_nid_t stac9200_adc_nids[1] = {
310         0x03,
311 };
312
313 static hda_nid_t stac9200_mux_nids[1] = {
314         0x0c,
315 };
316
317 static hda_nid_t stac9200_dac_nids[1] = {
318         0x02,
319 };
320
321 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
322         0x0a, 0x0b, 0x0c, 0xd, 0x0e,
323         0x0f, 0x10, 0x11
324 };
325
326 static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
327         0x26, 0,
328 };
329
330 static hda_nid_t stac92hd73xx_adc_nids[2] = {
331         0x1a, 0x1b
332 };
333
334 #define STAC92HD73XX_NUM_DMICS  2
335 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
336         0x13, 0x14, 0
337 };
338
339 #define STAC92HD73_DAC_COUNT 5
340
341 static hda_nid_t stac92hd73xx_mux_nids[2] = {
342         0x20, 0x21,
343 };
344
345 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
346         0x20, 0x21,
347 };
348
349 static hda_nid_t stac92hd73xx_smux_nids[2] = {
350         0x22, 0x23,
351 };
352
353 #define STAC92HD73XX_NUM_CAPS   2
354 static unsigned long stac92hd73xx_capvols[] = {
355         HDA_COMPOSE_AMP_VAL(0x20, 3, 0, HDA_OUTPUT),
356         HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
357 };
358 #define stac92hd73xx_capsws     stac92hd73xx_capvols
359
360 #define STAC92HD83_DAC_COUNT 3
361
362 static hda_nid_t stac92hd83xxx_mux_nids[2] = {
363         0x17, 0x18,
364 };
365
366 static hda_nid_t stac92hd83xxx_adc_nids[2] = {
367         0x15, 0x16,
368 };
369
370 static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
371         0xa, 0xb, 0xd, 0xe,
372 };
373
374 static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
375         0x1e, 0,
376 };
377
378 static unsigned int stac92hd83xxx_pwr_mapping[4] = {
379         0x03, 0x0c, 0x20, 0x40,
380 };
381
382 #define STAC92HD83XXX_NUM_CAPS  2
383 static unsigned long stac92hd83xxx_capvols[] = {
384         HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
385         HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_OUTPUT),
386 };
387 #define stac92hd83xxx_capsws    stac92hd83xxx_capvols
388
389 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
390         0x0a, 0x0d, 0x0f
391 };
392
393 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
394         0x12, 0x13,
395 };
396
397 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
398         0x1a, 0x1b
399 };
400
401 static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
402         0x1c, 0x1d,
403 };
404
405 static hda_nid_t stac92hd71bxx_smux_nids[2] = {
406         0x24, 0x25,
407 };
408
409 #define STAC92HD71BXX_NUM_DMICS 2
410 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
411         0x18, 0x19, 0
412 };
413
414 static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
415         0x22, 0
416 };
417
418 #define STAC92HD71BXX_NUM_CAPS          2
419 static unsigned long stac92hd71bxx_capvols[] = {
420         HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
421         HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
422 };
423 #define stac92hd71bxx_capsws    stac92hd71bxx_capvols
424
425 static hda_nid_t stac925x_adc_nids[1] = {
426         0x03,
427 };
428
429 static hda_nid_t stac925x_mux_nids[1] = {
430         0x0f,
431 };
432
433 static hda_nid_t stac925x_dac_nids[1] = {
434         0x02,
435 };
436
437 #define STAC925X_NUM_DMICS      1
438 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
439         0x15, 0
440 };
441
442 static hda_nid_t stac925x_dmux_nids[1] = {
443         0x14,
444 };
445
446 static unsigned long stac925x_capvols[] = {
447         HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
448 };
449 static unsigned long stac925x_capsws[] = {
450         HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
451 };
452
453 static hda_nid_t stac922x_adc_nids[2] = {
454         0x06, 0x07,
455 };
456
457 static hda_nid_t stac922x_mux_nids[2] = {
458         0x12, 0x13,
459 };
460
461 #define STAC922X_NUM_CAPS       2
462 static unsigned long stac922x_capvols[] = {
463         HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_INPUT),
464         HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
465 };
466 #define stac922x_capsws         stac922x_capvols
467
468 static hda_nid_t stac927x_slave_dig_outs[2] = {
469         0x1f, 0,
470 };
471
472 static hda_nid_t stac927x_adc_nids[3] = {
473         0x07, 0x08, 0x09
474 };
475
476 static hda_nid_t stac927x_mux_nids[3] = {
477         0x15, 0x16, 0x17
478 };
479
480 static hda_nid_t stac927x_smux_nids[1] = {
481         0x21,
482 };
483
484 static hda_nid_t stac927x_dac_nids[6] = {
485         0x02, 0x03, 0x04, 0x05, 0x06, 0
486 };
487
488 static hda_nid_t stac927x_dmux_nids[1] = {
489         0x1b,
490 };
491
492 #define STAC927X_NUM_DMICS 2
493 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
494         0x13, 0x14, 0
495 };
496
497 #define STAC927X_NUM_CAPS       3
498 static unsigned long stac927x_capvols[] = {
499         HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
500         HDA_COMPOSE_AMP_VAL(0x19, 3, 0, HDA_INPUT),
501         HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_INPUT),
502 };
503 static unsigned long stac927x_capsws[] = {
504         HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
505         HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
506         HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
507 };
508
509 static const char *stac927x_spdif_labels[5] = {
510         "Digital Playback", "ADAT", "Analog Mux 1",
511         "Analog Mux 2", "Analog Mux 3"
512 };
513
514 static hda_nid_t stac9205_adc_nids[2] = {
515         0x12, 0x13
516 };
517
518 static hda_nid_t stac9205_mux_nids[2] = {
519         0x19, 0x1a
520 };
521
522 static hda_nid_t stac9205_dmux_nids[1] = {
523         0x1d,
524 };
525
526 static hda_nid_t stac9205_smux_nids[1] = {
527         0x21,
528 };
529
530 #define STAC9205_NUM_DMICS      2
531 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
532         0x17, 0x18, 0
533 };
534
535 #define STAC9205_NUM_CAPS       2
536 static unsigned long stac9205_capvols[] = {
537         HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_INPUT),
538         HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_INPUT),
539 };
540 static unsigned long stac9205_capsws[] = {
541         HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
542         HDA_COMPOSE_AMP_VAL(0x1e, 3, 0, HDA_OUTPUT),
543 };
544
545 static hda_nid_t stac9200_pin_nids[8] = {
546         0x08, 0x09, 0x0d, 0x0e, 
547         0x0f, 0x10, 0x11, 0x12,
548 };
549
550 static hda_nid_t stac925x_pin_nids[8] = {
551         0x07, 0x08, 0x0a, 0x0b, 
552         0x0c, 0x0d, 0x10, 0x11,
553 };
554
555 static hda_nid_t stac922x_pin_nids[10] = {
556         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
557         0x0f, 0x10, 0x11, 0x15, 0x1b,
558 };
559
560 static hda_nid_t stac92hd73xx_pin_nids[13] = {
561         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
562         0x0f, 0x10, 0x11, 0x12, 0x13,
563         0x14, 0x22, 0x23
564 };
565
566 static hda_nid_t stac92hd83xxx_pin_nids[10] = {
567         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
568         0x0f, 0x10, 0x11, 0x1f, 0x20,
569 };
570
571 static hda_nid_t stac92hd88xxx_pin_nids[10] = {
572         0x0a, 0x0b, 0x0c, 0x0d,
573         0x0f, 0x11, 0x1f, 0x20,
574 };
575
576 #define STAC92HD71BXX_NUM_PINS 13
577 static hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
578         0x0a, 0x0b, 0x0c, 0x0d, 0x00,
579         0x00, 0x14, 0x18, 0x19, 0x1e,
580         0x1f, 0x20, 0x27
581 };
582 static hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
583         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
584         0x0f, 0x14, 0x18, 0x19, 0x1e,
585         0x1f, 0x20, 0x27
586 };
587
588 static hda_nid_t stac927x_pin_nids[14] = {
589         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
590         0x0f, 0x10, 0x11, 0x12, 0x13,
591         0x14, 0x21, 0x22, 0x23,
592 };
593
594 static hda_nid_t stac9205_pin_nids[12] = {
595         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
596         0x0f, 0x14, 0x16, 0x17, 0x18,
597         0x21, 0x22,
598 };
599
600 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
601                                    struct snd_ctl_elem_info *uinfo)
602 {
603         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
604         struct sigmatel_spec *spec = codec->spec;
605         return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
606 }
607
608 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
609                                   struct snd_ctl_elem_value *ucontrol)
610 {
611         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
612         struct sigmatel_spec *spec = codec->spec;
613         unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
614
615         ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
616         return 0;
617 }
618
619 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
620                                   struct snd_ctl_elem_value *ucontrol)
621 {
622         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
623         struct sigmatel_spec *spec = codec->spec;
624         unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
625
626         return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
627                         spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
628 }
629
630 static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
631                                    struct snd_ctl_elem_info *uinfo)
632 {
633         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
634         struct sigmatel_spec *spec = codec->spec;
635         return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
636 }
637
638 static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
639                                   struct snd_ctl_elem_value *ucontrol)
640 {
641         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
642         struct sigmatel_spec *spec = codec->spec;
643         unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
644
645         ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
646         return 0;
647 }
648
649 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
650                                   struct snd_ctl_elem_value *ucontrol)
651 {
652         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
653         struct sigmatel_spec *spec = codec->spec;
654         struct hda_input_mux *smux = &spec->private_smux;
655         unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
656         int err, val;
657         hda_nid_t nid;
658
659         err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
660                         spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
661         if (err < 0)
662                 return err;
663
664         if (spec->spdif_mute) {
665                 if (smux_idx == 0)
666                         nid = spec->multiout.dig_out_nid;
667                 else
668                         nid = codec->slave_dig_outs[smux_idx - 1];
669                 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
670                         val = HDA_AMP_MUTE;
671                 else
672                         val = 0;
673                 /* un/mute SPDIF out */
674                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
675                                          HDA_AMP_MUTE, val);
676         }
677         return 0;
678 }
679
680 static unsigned int stac92xx_vref_set(struct hda_codec *codec,
681                                         hda_nid_t nid, unsigned int new_vref)
682 {
683         int error;
684         unsigned int pincfg;
685         pincfg = snd_hda_codec_read(codec, nid, 0,
686                                 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
687
688         pincfg &= 0xff;
689         pincfg &= ~(AC_PINCTL_VREFEN | AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
690         pincfg |= new_vref;
691
692         if (new_vref == AC_PINCTL_VREF_HIZ)
693                 pincfg |= AC_PINCTL_OUT_EN;
694         else
695                 pincfg |= AC_PINCTL_IN_EN;
696
697         error = snd_hda_codec_write_cache(codec, nid, 0,
698                                         AC_VERB_SET_PIN_WIDGET_CONTROL, pincfg);
699         if (error < 0)
700                 return error;
701         else
702                 return 1;
703 }
704
705 static unsigned int stac92xx_vref_get(struct hda_codec *codec, hda_nid_t nid)
706 {
707         unsigned int vref;
708         vref = snd_hda_codec_read(codec, nid, 0,
709                                 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
710         vref &= AC_PINCTL_VREFEN;
711         return vref;
712 }
713
714 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
715 {
716         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
717         struct sigmatel_spec *spec = codec->spec;
718         return snd_hda_input_mux_info(spec->input_mux, uinfo);
719 }
720
721 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
722 {
723         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
724         struct sigmatel_spec *spec = codec->spec;
725         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
726
727         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
728         return 0;
729 }
730
731 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
732 {
733         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
734         struct sigmatel_spec *spec = codec->spec;
735         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
736         const struct hda_input_mux *imux = spec->input_mux;
737         unsigned int idx, prev_idx;
738
739         idx = ucontrol->value.enumerated.item[0];
740         if (idx >= imux->num_items)
741                 idx = imux->num_items - 1;
742         prev_idx = spec->cur_mux[adc_idx];
743         if (prev_idx == idx)
744                 return 0;
745         if (idx < spec->num_analog_muxes) {
746                 snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0,
747                                           AC_VERB_SET_CONNECT_SEL,
748                                           imux->items[idx].index);
749                 if (prev_idx >= spec->num_analog_muxes) {
750                         imux = spec->dinput_mux;
751                         /* 0 = analog */
752                         snd_hda_codec_write_cache(codec,
753                                                   spec->dmux_nids[adc_idx], 0,
754                                                   AC_VERB_SET_CONNECT_SEL,
755                                                   imux->items[0].index);
756                 }
757         } else {
758                 imux = spec->dinput_mux;
759                 snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0,
760                                           AC_VERB_SET_CONNECT_SEL,
761                                           imux->items[idx - 1].index);
762         }
763         spec->cur_mux[adc_idx] = idx;
764         return 1;
765 }
766
767 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
768         struct snd_ctl_elem_info *uinfo)
769 {
770         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
771         struct sigmatel_spec *spec = codec->spec;
772         return snd_hda_input_mux_info(spec->mono_mux, uinfo);
773 }
774
775 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
776         struct snd_ctl_elem_value *ucontrol)
777 {
778         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
779         struct sigmatel_spec *spec = codec->spec;
780
781         ucontrol->value.enumerated.item[0] = spec->cur_mmux;
782         return 0;
783 }
784
785 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
786         struct snd_ctl_elem_value *ucontrol)
787 {
788         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
789         struct sigmatel_spec *spec = codec->spec;
790
791         return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
792                                      spec->mono_nid, &spec->cur_mmux);
793 }
794
795 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
796
797 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
798         struct snd_ctl_elem_value *ucontrol)
799 {
800         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
801         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
802         struct sigmatel_spec *spec = codec->spec;
803
804         ucontrol->value.integer.value[0] = !!(spec->aloopback &
805                                               (spec->aloopback_mask << idx));
806         return 0;
807 }
808
809 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
810                 struct snd_ctl_elem_value *ucontrol)
811 {
812         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
813         struct sigmatel_spec *spec = codec->spec;
814         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
815         unsigned int dac_mode;
816         unsigned int val, idx_val;
817
818         idx_val = spec->aloopback_mask << idx;
819         if (ucontrol->value.integer.value[0])
820                 val = spec->aloopback | idx_val;
821         else
822                 val = spec->aloopback & ~idx_val;
823         if (spec->aloopback == val)
824                 return 0;
825
826         spec->aloopback = val;
827
828         /* Only return the bits defined by the shift value of the
829          * first two bytes of the mask
830          */
831         dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
832                                       kcontrol->private_value & 0xFFFF, 0x0);
833         dac_mode >>= spec->aloopback_shift;
834
835         if (spec->aloopback & idx_val) {
836                 snd_hda_power_up(codec);
837                 dac_mode |= idx_val;
838         } else {
839                 snd_hda_power_down(codec);
840                 dac_mode &= ~idx_val;
841         }
842
843         snd_hda_codec_write_cache(codec, codec->afg, 0,
844                 kcontrol->private_value >> 16, dac_mode);
845
846         return 1;
847 }
848
849 static struct hda_verb stac9200_core_init[] = {
850         /* set dac0mux for dac converter */
851         { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
852         {}
853 };
854
855 static struct hda_verb stac9200_eapd_init[] = {
856         /* set dac0mux for dac converter */
857         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
858         {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
859         {}
860 };
861
862 static struct hda_verb dell_eq_core_init[] = {
863         /* set master volume to max value without distortion
864          * and direct control */
865         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
866         {}
867 };
868
869 static struct hda_verb stac92hd73xx_core_init[] = {
870         /* set master volume and direct control */
871         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
872         {}
873 };
874
875 static struct hda_verb stac92hd83xxx_core_init[] = {
876         /* power state controls amps */
877         { 0x01, AC_VERB_SET_EAPD, 1 << 2},
878         {}
879 };
880
881 static struct hda_verb stac92hd71bxx_core_init[] = {
882         /* set master volume and direct control */
883         { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
884         {}
885 };
886
887 static struct hda_verb stac92hd71bxx_unmute_core_init[] = {
888         /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
889         { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
890         { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
891         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
892         {}
893 };
894
895 static struct hda_verb stac925x_core_init[] = {
896         /* set dac0mux for dac converter */
897         { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
898         /* mute the master volume */
899         { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
900         {}
901 };
902
903 static struct hda_verb stac922x_core_init[] = {
904         /* set master volume and direct control */      
905         { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
906         {}
907 };
908
909 static struct hda_verb d965_core_init[] = {
910         /* set master volume and direct control */      
911         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
912         /* unmute node 0x1b */
913         { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
914         /* select node 0x03 as DAC */   
915         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
916         {}
917 };
918
919 static struct hda_verb dell_3st_core_init[] = {
920         /* don't set delta bit */
921         {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
922         /* unmute node 0x1b */
923         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
924         /* select node 0x03 as DAC */
925         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
926         {}
927 };
928
929 static struct hda_verb stac927x_core_init[] = {
930         /* set master volume and direct control */      
931         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
932         /* enable analog pc beep path */
933         { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
934         {}
935 };
936
937 static struct hda_verb stac927x_volknob_core_init[] = {
938         /* don't set delta bit */
939         {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
940         /* enable analog pc beep path */
941         {0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
942         {}
943 };
944
945 static struct hda_verb stac9205_core_init[] = {
946         /* set master volume and direct control */      
947         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
948         /* enable analog pc beep path */
949         { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
950         {}
951 };
952
953 #define STAC_MONO_MUX \
954         { \
955                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
956                 .name = "Mono Mux", \
957                 .count = 1, \
958                 .info = stac92xx_mono_mux_enum_info, \
959                 .get = stac92xx_mono_mux_enum_get, \
960                 .put = stac92xx_mono_mux_enum_put, \
961         }
962
963 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
964         { \
965                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
966                 .name  = "Analog Loopback", \
967                 .count = cnt, \
968                 .info  = stac92xx_aloopback_info, \
969                 .get   = stac92xx_aloopback_get, \
970                 .put   = stac92xx_aloopback_put, \
971                 .private_value = verb_read | (verb_write << 16), \
972         }
973
974 #define DC_BIAS(xname, idx, nid) \
975         { \
976                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
977                 .name = xname, \
978                 .index = idx, \
979                 .info = stac92xx_dc_bias_info, \
980                 .get = stac92xx_dc_bias_get, \
981                 .put = stac92xx_dc_bias_put, \
982                 .private_value = nid, \
983         }
984
985 static struct snd_kcontrol_new stac9200_mixer[] = {
986         HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
987         HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
988         HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
989         HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
990         { } /* end */
991 };
992
993 static struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
994         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
995         {}
996 };
997
998 static struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = {
999         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1000         {}
1001 };
1002
1003 static struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
1004         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1005         {}
1006 };
1007
1008
1009 static struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
1010         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
1011 };
1012
1013 static struct snd_kcontrol_new stac925x_mixer[] = {
1014         HDA_CODEC_VOLUME("Master Playback Volume", 0x0e, 0, HDA_OUTPUT),
1015         HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
1016         { } /* end */
1017 };
1018
1019 static struct snd_kcontrol_new stac9205_loopback[] = {
1020         STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1021         {}
1022 };
1023
1024 static struct snd_kcontrol_new stac927x_loopback[] = {
1025         STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1026         {}
1027 };
1028
1029 static struct snd_kcontrol_new stac_dmux_mixer = {
1030         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1031         .name = "Digital Input Source",
1032         /* count set later */
1033         .info = stac92xx_dmux_enum_info,
1034         .get = stac92xx_dmux_enum_get,
1035         .put = stac92xx_dmux_enum_put,
1036 };
1037
1038 static struct snd_kcontrol_new stac_smux_mixer = {
1039         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1040         .name = "IEC958 Playback Source",
1041         /* count set later */
1042         .info = stac92xx_smux_enum_info,
1043         .get = stac92xx_smux_enum_get,
1044         .put = stac92xx_smux_enum_put,
1045 };
1046
1047 static const char *slave_vols[] = {
1048         "Front Playback Volume",
1049         "Surround Playback Volume",
1050         "Center Playback Volume",
1051         "LFE Playback Volume",
1052         "Side Playback Volume",
1053         "Headphone Playback Volume",
1054         "Speaker Playback Volume",
1055         NULL
1056 };
1057
1058 static const char *slave_sws[] = {
1059         "Front Playback Switch",
1060         "Surround Playback Switch",
1061         "Center Playback Switch",
1062         "LFE Playback Switch",
1063         "Side Playback Switch",
1064         "Headphone Playback Switch",
1065         "Speaker Playback Switch",
1066         "IEC958 Playback Switch",
1067         NULL
1068 };
1069
1070 static void stac92xx_free_kctls(struct hda_codec *codec);
1071 static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
1072
1073 static int stac92xx_build_controls(struct hda_codec *codec)
1074 {
1075         struct sigmatel_spec *spec = codec->spec;
1076         struct auto_pin_cfg *cfg = &spec->autocfg;
1077         hda_nid_t nid;
1078         int err;
1079         int i;
1080
1081         if (spec->mixer) {
1082                 err = snd_hda_add_new_ctls(codec, spec->mixer);
1083                 if (err < 0)
1084                         return err;
1085         }
1086
1087         for (i = 0; i < spec->num_mixers; i++) {
1088                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1089                 if (err < 0)
1090                         return err;
1091         }
1092         if (!spec->auto_mic && spec->num_dmuxes > 0 &&
1093             snd_hda_get_bool_hint(codec, "separate_dmux") == 1) {
1094                 stac_dmux_mixer.count = spec->num_dmuxes;
1095                 err = snd_hda_ctl_add(codec, 0,
1096                                   snd_ctl_new1(&stac_dmux_mixer, codec));
1097                 if (err < 0)
1098                         return err;
1099         }
1100         if (spec->num_smuxes > 0) {
1101                 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1102                 struct hda_input_mux *smux = &spec->private_smux;
1103                 /* check for mute support on SPDIF out */
1104                 if (wcaps & AC_WCAP_OUT_AMP) {
1105                         smux->items[smux->num_items].label = "Off";
1106                         smux->items[smux->num_items].index = 0;
1107                         smux->num_items++;
1108                         spec->spdif_mute = 1;
1109                 }
1110                 stac_smux_mixer.count = spec->num_smuxes;
1111                 err = snd_hda_ctl_add(codec, 0,
1112                                   snd_ctl_new1(&stac_smux_mixer, codec));
1113                 if (err < 0)
1114                         return err;
1115         }
1116
1117         if (spec->multiout.dig_out_nid) {
1118                 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1119                 if (err < 0)
1120                         return err;
1121                 err = snd_hda_create_spdif_share_sw(codec,
1122                                                     &spec->multiout);
1123                 if (err < 0)
1124                         return err;
1125                 spec->multiout.share_spdif = 1;
1126         }
1127         if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1128                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1129                 if (err < 0)
1130                         return err;
1131         }
1132
1133         /* if we have no master control, let's create it */
1134         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1135                 unsigned int vmaster_tlv[4];
1136                 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1137                                         HDA_OUTPUT, vmaster_tlv);
1138                 /* correct volume offset */
1139                 vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
1140                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1141                                           vmaster_tlv, slave_vols);
1142                 if (err < 0)
1143                         return err;
1144         }
1145         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1146                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1147                                           NULL, slave_sws);
1148                 if (err < 0)
1149                         return err;
1150         }
1151
1152         if (spec->aloopback_ctl &&
1153             snd_hda_get_bool_hint(codec, "loopback") == 1) {
1154                 err = snd_hda_add_new_ctls(codec, spec->aloopback_ctl);
1155                 if (err < 0)
1156                         return err;
1157         }
1158
1159         stac92xx_free_kctls(codec); /* no longer needed */
1160
1161         /* create jack input elements */
1162         if (spec->hp_detect) {
1163                 for (i = 0; i < cfg->hp_outs; i++) {
1164                         int type = SND_JACK_HEADPHONE;
1165                         nid = cfg->hp_pins[i];
1166                         /* jack detection */
1167                         if (cfg->hp_outs == i)
1168                                 type |= SND_JACK_LINEOUT;
1169                         err = stac92xx_add_jack(codec, nid, type);
1170                         if (err < 0)
1171                                 return err;
1172                 }
1173         }
1174         for (i = 0; i < cfg->line_outs; i++) {
1175                 err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
1176                                         SND_JACK_LINEOUT);
1177                 if (err < 0)
1178                         return err;
1179         }
1180         for (i = 0; i < AUTO_PIN_LAST; i++) {
1181                 nid = cfg->input_pins[i];
1182                 if (nid) {
1183                         err = stac92xx_add_jack(codec, nid,
1184                                                 SND_JACK_MICROPHONE);
1185                         if (err < 0)
1186                                 return err;
1187                 }
1188         }
1189
1190         return 0;       
1191 }
1192
1193 static unsigned int ref9200_pin_configs[8] = {
1194         0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1195         0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1196 };
1197
1198 static unsigned int gateway9200_m4_pin_configs[8] = {
1199         0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1200         0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1201 };
1202 static unsigned int gateway9200_m4_2_pin_configs[8] = {
1203         0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1204         0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1205 };
1206
1207 /*
1208     STAC 9200 pin configs for
1209     102801A8
1210     102801DE
1211     102801E8
1212 */
1213 static unsigned int dell9200_d21_pin_configs[8] = {
1214         0x400001f0, 0x400001f1, 0x02214030, 0x01014010, 
1215         0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1216 };
1217
1218 /* 
1219     STAC 9200 pin configs for
1220     102801C0
1221     102801C1
1222 */
1223 static unsigned int dell9200_d22_pin_configs[8] = {
1224         0x400001f0, 0x400001f1, 0x0221401f, 0x01014010, 
1225         0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1226 };
1227
1228 /* 
1229     STAC 9200 pin configs for
1230     102801C4 (Dell Dimension E310)
1231     102801C5
1232     102801C7
1233     102801D9
1234     102801DA
1235     102801E3
1236 */
1237 static unsigned int dell9200_d23_pin_configs[8] = {
1238         0x400001f0, 0x400001f1, 0x0221401f, 0x01014010, 
1239         0x01813020, 0x01a19021, 0x90100140, 0x400001f2, 
1240 };
1241
1242
1243 /* 
1244     STAC 9200-32 pin configs for
1245     102801B5 (Dell Inspiron 630m)
1246     102801D8 (Dell Inspiron 640m)
1247 */
1248 static unsigned int dell9200_m21_pin_configs[8] = {
1249         0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1250         0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1251 };
1252
1253 /* 
1254     STAC 9200-32 pin configs for
1255     102801C2 (Dell Latitude D620)
1256     102801C8 
1257     102801CC (Dell Latitude D820)
1258     102801D4 
1259     102801D6 
1260 */
1261 static unsigned int dell9200_m22_pin_configs[8] = {
1262         0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310, 
1263         0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1264 };
1265
1266 /* 
1267     STAC 9200-32 pin configs for
1268     102801CE (Dell XPS M1710)
1269     102801CF (Dell Precision M90)
1270 */
1271 static unsigned int dell9200_m23_pin_configs[8] = {
1272         0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1273         0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1274 };
1275
1276 /*
1277     STAC 9200-32 pin configs for 
1278     102801C9
1279     102801CA
1280     102801CB (Dell Latitude 120L)
1281     102801D3
1282 */
1283 static unsigned int dell9200_m24_pin_configs[8] = {
1284         0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310, 
1285         0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe, 
1286 };
1287
1288 /*
1289     STAC 9200-32 pin configs for
1290     102801BD (Dell Inspiron E1505n)
1291     102801EE
1292     102801EF
1293 */
1294 static unsigned int dell9200_m25_pin_configs[8] = {
1295         0x40c003fa, 0x01441340, 0x0421121f, 0x90170310, 
1296         0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1297 };
1298
1299 /*
1300     STAC 9200-32 pin configs for
1301     102801F5 (Dell Inspiron 1501)
1302     102801F6
1303 */
1304 static unsigned int dell9200_m26_pin_configs[8] = {
1305         0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310, 
1306         0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1307 };
1308
1309 /*
1310     STAC 9200-32
1311     102801CD (Dell Inspiron E1705/9400)
1312 */
1313 static unsigned int dell9200_m27_pin_configs[8] = {
1314         0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1315         0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1316 };
1317
1318 static unsigned int oqo9200_pin_configs[8] = {
1319         0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1320         0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1321 };
1322
1323
1324 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1325         [STAC_REF] = ref9200_pin_configs,
1326         [STAC_9200_OQO] = oqo9200_pin_configs,
1327         [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1328         [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1329         [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1330         [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1331         [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1332         [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1333         [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1334         [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1335         [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1336         [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1337         [STAC_9200_M4] = gateway9200_m4_pin_configs,
1338         [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1339         [STAC_9200_PANASONIC] = ref9200_pin_configs,
1340 };
1341
1342 static const char *stac9200_models[STAC_9200_MODELS] = {
1343         [STAC_AUTO] = "auto",
1344         [STAC_REF] = "ref",
1345         [STAC_9200_OQO] = "oqo",
1346         [STAC_9200_DELL_D21] = "dell-d21",
1347         [STAC_9200_DELL_D22] = "dell-d22",
1348         [STAC_9200_DELL_D23] = "dell-d23",
1349         [STAC_9200_DELL_M21] = "dell-m21",
1350         [STAC_9200_DELL_M22] = "dell-m22",
1351         [STAC_9200_DELL_M23] = "dell-m23",
1352         [STAC_9200_DELL_M24] = "dell-m24",
1353         [STAC_9200_DELL_M25] = "dell-m25",
1354         [STAC_9200_DELL_M26] = "dell-m26",
1355         [STAC_9200_DELL_M27] = "dell-m27",
1356         [STAC_9200_M4] = "gateway-m4",
1357         [STAC_9200_M4_2] = "gateway-m4-2",
1358         [STAC_9200_PANASONIC] = "panasonic",
1359 };
1360
1361 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1362         /* SigmaTel reference board */
1363         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1364                       "DFI LanParty", STAC_REF),
1365         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1366                       "DFI LanParty", STAC_REF),
1367         /* Dell laptops have BIOS problem */
1368         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1369                       "unknown Dell", STAC_9200_DELL_D21),
1370         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1371                       "Dell Inspiron 630m", STAC_9200_DELL_M21),
1372         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1373                       "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1374         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1375                       "unknown Dell", STAC_9200_DELL_D22),
1376         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1377                       "unknown Dell", STAC_9200_DELL_D22),
1378         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1379                       "Dell Latitude D620", STAC_9200_DELL_M22),
1380         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1381                       "unknown Dell", STAC_9200_DELL_D23),
1382         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1383                       "unknown Dell", STAC_9200_DELL_D23),
1384         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1385                       "unknown Dell", STAC_9200_DELL_M22),
1386         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1387                       "unknown Dell", STAC_9200_DELL_M24),
1388         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1389                       "unknown Dell", STAC_9200_DELL_M24),
1390         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1391                       "Dell Latitude 120L", STAC_9200_DELL_M24),
1392         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1393                       "Dell Latitude D820", STAC_9200_DELL_M22),
1394         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1395                       "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1396         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1397                       "Dell XPS M1710", STAC_9200_DELL_M23),
1398         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1399                       "Dell Precision M90", STAC_9200_DELL_M23),
1400         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1401                       "unknown Dell", STAC_9200_DELL_M22),
1402         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1403                       "unknown Dell", STAC_9200_DELL_M22),
1404         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1405                       "unknown Dell", STAC_9200_DELL_M22),
1406         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1407                       "Dell Inspiron 640m", STAC_9200_DELL_M21),
1408         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1409                       "unknown Dell", STAC_9200_DELL_D23),
1410         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1411                       "unknown Dell", STAC_9200_DELL_D23),
1412         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1413                       "unknown Dell", STAC_9200_DELL_D21),
1414         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1415                       "unknown Dell", STAC_9200_DELL_D23),
1416         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1417                       "unknown Dell", STAC_9200_DELL_D21),
1418         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1419                       "unknown Dell", STAC_9200_DELL_M25),
1420         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1421                       "unknown Dell", STAC_9200_DELL_M25),
1422         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1423                       "Dell Inspiron 1501", STAC_9200_DELL_M26),
1424         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1425                       "unknown Dell", STAC_9200_DELL_M26),
1426         /* Panasonic */
1427         SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1428         /* Gateway machines needs EAPD to be set on resume */
1429         SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1430         SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1431         SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1432         /* OQO Mobile */
1433         SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1434         {} /* terminator */
1435 };
1436
1437 static unsigned int ref925x_pin_configs[8] = {
1438         0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1439         0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1440 };
1441
1442 static unsigned int stac925xM1_pin_configs[8] = {
1443         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1444         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1445 };
1446
1447 static unsigned int stac925xM1_2_pin_configs[8] = {
1448         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1449         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1450 };
1451
1452 static unsigned int stac925xM2_pin_configs[8] = {
1453         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1454         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1455 };
1456
1457 static unsigned int stac925xM2_2_pin_configs[8] = {
1458         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1459         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1460 };
1461
1462 static unsigned int stac925xM3_pin_configs[8] = {
1463         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1464         0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1465 };
1466
1467 static unsigned int stac925xM5_pin_configs[8] = {
1468         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1469         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1470 };
1471
1472 static unsigned int stac925xM6_pin_configs[8] = {
1473         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1474         0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1475 };
1476
1477 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1478         [STAC_REF] = ref925x_pin_configs,
1479         [STAC_M1] = stac925xM1_pin_configs,
1480         [STAC_M1_2] = stac925xM1_2_pin_configs,
1481         [STAC_M2] = stac925xM2_pin_configs,
1482         [STAC_M2_2] = stac925xM2_2_pin_configs,
1483         [STAC_M3] = stac925xM3_pin_configs,
1484         [STAC_M5] = stac925xM5_pin_configs,
1485         [STAC_M6] = stac925xM6_pin_configs,
1486 };
1487
1488 static const char *stac925x_models[STAC_925x_MODELS] = {
1489         [STAC_925x_AUTO] = "auto",
1490         [STAC_REF] = "ref",
1491         [STAC_M1] = "m1",
1492         [STAC_M1_2] = "m1-2",
1493         [STAC_M2] = "m2",
1494         [STAC_M2_2] = "m2-2",
1495         [STAC_M3] = "m3",
1496         [STAC_M5] = "m5",
1497         [STAC_M6] = "m6",
1498 };
1499
1500 static struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1501         SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1502         SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1503         SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1504         SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1505         SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1506         /* Not sure about the brand name for those */
1507         SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1508         SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1509         SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1510         SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1511         {} /* terminator */
1512 };
1513
1514 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1515         /* SigmaTel reference board */
1516         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1517         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
1518         SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1519
1520         /* Default table for unknown ID */
1521         SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1522
1523         {} /* terminator */
1524 };
1525
1526 static unsigned int ref92hd73xx_pin_configs[13] = {
1527         0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1528         0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1529         0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1530         0x01452050,
1531 };
1532
1533 static unsigned int dell_m6_pin_configs[13] = {
1534         0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1535         0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1536         0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1537         0x4f0000f0,
1538 };
1539
1540 static unsigned int alienware_m17x_pin_configs[13] = {
1541         0x0321101f, 0x0321101f, 0x03a11020, 0x03014020,
1542         0x90170110, 0x4f0000f0, 0x4f0000f0, 0x4f0000f0,
1543         0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1544         0x904601b0,
1545 };
1546
1547 static unsigned int intel_dg45id_pin_configs[14] = {
1548         0x02214230, 0x02A19240, 0x01013214, 0x01014210,
1549         0x01A19250, 0x01011212, 0x01016211, 0x40f000f0,
1550         0x40f000f0, 0x40f000f0, 0x40f000f0, 0x014510A0,
1551         0x074510B0, 0x40f000f0
1552 };
1553
1554 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1555         [STAC_92HD73XX_REF]     = ref92hd73xx_pin_configs,
1556         [STAC_DELL_M6_AMIC]     = dell_m6_pin_configs,
1557         [STAC_DELL_M6_DMIC]     = dell_m6_pin_configs,
1558         [STAC_DELL_M6_BOTH]     = dell_m6_pin_configs,
1559         [STAC_DELL_EQ]  = dell_m6_pin_configs,
1560         [STAC_ALIENWARE_M17X]   = alienware_m17x_pin_configs,
1561         [STAC_92HD73XX_INTEL]   = intel_dg45id_pin_configs,
1562 };
1563
1564 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1565         [STAC_92HD73XX_AUTO] = "auto",
1566         [STAC_92HD73XX_NO_JD] = "no-jd",
1567         [STAC_92HD73XX_REF] = "ref",
1568         [STAC_92HD73XX_INTEL] = "intel",
1569         [STAC_DELL_M6_AMIC] = "dell-m6-amic",
1570         [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1571         [STAC_DELL_M6_BOTH] = "dell-m6",
1572         [STAC_DELL_EQ] = "dell-eq",
1573         [STAC_ALIENWARE_M17X] = "alienware",
1574 };
1575
1576 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1577         /* SigmaTel reference board */
1578         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1579                                 "DFI LanParty", STAC_92HD73XX_REF),
1580         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1581                                 "DFI LanParty", STAC_92HD73XX_REF),
1582         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
1583                                 "Intel DG45ID", STAC_92HD73XX_INTEL),
1584         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
1585                                 "Intel DG45FC", STAC_92HD73XX_INTEL),
1586         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1587                                 "Dell Studio 1535", STAC_DELL_M6_DMIC),
1588         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1589                                 "unknown Dell", STAC_DELL_M6_DMIC),
1590         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1591                                 "unknown Dell", STAC_DELL_M6_BOTH),
1592         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1593                                 "unknown Dell", STAC_DELL_M6_BOTH),
1594         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1595                                 "unknown Dell", STAC_DELL_M6_AMIC),
1596         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1597                                 "unknown Dell", STAC_DELL_M6_AMIC),
1598         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1599                                 "unknown Dell", STAC_DELL_M6_DMIC),
1600         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1601                                 "unknown Dell", STAC_DELL_M6_DMIC),
1602         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1603                                 "Dell Studio 1537", STAC_DELL_M6_DMIC),
1604         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1605                                 "Dell Studio 17", STAC_DELL_M6_DMIC),
1606         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
1607                                 "Dell Studio 1555", STAC_DELL_M6_DMIC),
1608         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd,
1609                                 "Dell Studio 1557", STAC_DELL_M6_DMIC),
1610         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe,
1611                                 "Dell Studio XPS 1645", STAC_DELL_M6_BOTH),
1612         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413,
1613                                 "Dell Studio 1558", STAC_DELL_M6_BOTH),
1614         {} /* terminator */
1615 };
1616
1617 static struct snd_pci_quirk stac92hd73xx_codec_id_cfg_tbl[] = {
1618         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1,
1619                       "Alienware M17x", STAC_ALIENWARE_M17X),
1620         {} /* terminator */
1621 };
1622
1623 static unsigned int ref92hd83xxx_pin_configs[10] = {
1624         0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1625         0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1626         0x01451160, 0x98560170,
1627 };
1628
1629 static unsigned int dell_s14_pin_configs[10] = {
1630         0x0221403f, 0x0221101f, 0x02a19020, 0x90170110,
1631         0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a60160,
1632         0x40f000f0, 0x40f000f0,
1633 };
1634
1635 static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1636         [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1637         [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
1638         [STAC_DELL_S14] = dell_s14_pin_configs,
1639 };
1640
1641 static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1642         [STAC_92HD83XXX_AUTO] = "auto",
1643         [STAC_92HD83XXX_REF] = "ref",
1644         [STAC_92HD83XXX_PWR_REF] = "mic-ref",
1645         [STAC_DELL_S14] = "dell-s14",
1646         [STAC_92HD83XXX_HP] = "hp",
1647 };
1648
1649 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1650         /* SigmaTel reference board */
1651         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1652                       "DFI LanParty", STAC_92HD83XXX_REF),
1653         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1654                       "DFI LanParty", STAC_92HD83XXX_REF),
1655         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
1656                       "unknown Dell", STAC_DELL_S14),
1657         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x3600,
1658                       "HP", STAC_92HD83XXX_HP),
1659         {} /* terminator */
1660 };
1661
1662 static unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1663         0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1664         0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1665         0x90a000f0, 0x01452050, 0x01452050, 0x00000000,
1666         0x00000000
1667 };
1668
1669 static unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1670         0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1671         0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1672         0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000,
1673         0x00000000
1674 };
1675
1676 static unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1677         0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1678         0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1679         0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1680         0x00000000
1681 };
1682
1683 static unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1684         0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1685         0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1686         0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1687         0x00000000
1688 };
1689
1690 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1691         [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1692         [STAC_DELL_M4_1]        = dell_m4_1_pin_configs,
1693         [STAC_DELL_M4_2]        = dell_m4_2_pin_configs,
1694         [STAC_DELL_M4_3]        = dell_m4_3_pin_configs,
1695         [STAC_HP_M4]            = NULL,
1696         [STAC_HP_DV5]           = NULL,
1697         [STAC_HP_HDX]           = NULL,
1698         [STAC_HP_DV4_1222NR]    = NULL,
1699 };
1700
1701 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1702         [STAC_92HD71BXX_AUTO] = "auto",
1703         [STAC_92HD71BXX_REF] = "ref",
1704         [STAC_DELL_M4_1] = "dell-m4-1",
1705         [STAC_DELL_M4_2] = "dell-m4-2",
1706         [STAC_DELL_M4_3] = "dell-m4-3",
1707         [STAC_HP_M4] = "hp-m4",
1708         [STAC_HP_DV5] = "hp-dv5",
1709         [STAC_HP_HDX] = "hp-hdx",
1710         [STAC_HP_DV4_1222NR] = "hp-dv4-1222nr",
1711 };
1712
1713 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1714         /* SigmaTel reference board */
1715         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1716                       "DFI LanParty", STAC_92HD71BXX_REF),
1717         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1718                       "DFI LanParty", STAC_92HD71BXX_REF),
1719         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb,
1720                       "HP dv4-1222nr", STAC_HP_DV4_1222NR),
1721         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720,
1722                           "HP", STAC_HP_DV5),
1723         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
1724                       "HP", STAC_HP_DV5),
1725         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
1726                       "HP dv4-7", STAC_HP_DV5),
1727         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
1728                       "HP dv4-7", STAC_HP_DV5),
1729         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
1730                       "HP HDX", STAC_HP_HDX),  /* HDX18 */
1731         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1732                       "HP mini 1000", STAC_HP_M4),
1733         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
1734                       "HP HDX", STAC_HP_HDX),  /* HDX16 */
1735         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
1736                       "HP dv6", STAC_HP_DV5),
1737         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061,
1738                       "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */
1739         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
1740                       "HP", STAC_HP_DV5),
1741         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1742                                 "unknown Dell", STAC_DELL_M4_1),
1743         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1744                                 "unknown Dell", STAC_DELL_M4_1),
1745         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1746                                 "unknown Dell", STAC_DELL_M4_1),
1747         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1748                                 "unknown Dell", STAC_DELL_M4_1),
1749         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1750                                 "unknown Dell", STAC_DELL_M4_1),
1751         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1752                                 "unknown Dell", STAC_DELL_M4_1),
1753         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1754                                 "unknown Dell", STAC_DELL_M4_1),
1755         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1756                                 "unknown Dell", STAC_DELL_M4_2),
1757         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1758                                 "unknown Dell", STAC_DELL_M4_2),
1759         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1760                                 "unknown Dell", STAC_DELL_M4_2),
1761         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1762                                 "unknown Dell", STAC_DELL_M4_2),
1763         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1764                                 "unknown Dell", STAC_DELL_M4_3),
1765         {} /* terminator */
1766 };
1767
1768 static unsigned int ref922x_pin_configs[10] = {
1769         0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1770         0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1771         0x40000100, 0x40000100,
1772 };
1773
1774 /*
1775     STAC 922X pin configs for
1776     102801A7
1777     102801AB
1778     102801A9
1779     102801D1
1780     102801D2
1781 */
1782 static unsigned int dell_922x_d81_pin_configs[10] = {
1783         0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1784         0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1785         0x01813122, 0x400001f2,
1786 };
1787
1788 /*
1789     STAC 922X pin configs for
1790     102801AC
1791     102801D0
1792 */
1793 static unsigned int dell_922x_d82_pin_configs[10] = {
1794         0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1795         0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1796         0x01813122, 0x400001f1,
1797 };
1798
1799 /*
1800     STAC 922X pin configs for
1801     102801BF
1802 */
1803 static unsigned int dell_922x_m81_pin_configs[10] = {
1804         0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1805         0x03a11050, 0x01116221, 0x90a70330, 0x01452340, 
1806         0x40C003f1, 0x405003f0,
1807 };
1808
1809 /*
1810     STAC 9221 A1 pin configs for
1811     102801D7 (Dell XPS M1210)
1812 */
1813 static unsigned int dell_922x_m82_pin_configs[10] = {
1814         0x02211211, 0x408103ff, 0x02a1123e, 0x90100310, 
1815         0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2, 
1816         0x508003f3, 0x405003f4, 
1817 };
1818
1819 static unsigned int d945gtp3_pin_configs[10] = {
1820         0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1821         0x40000100, 0x40000100, 0x40000100, 0x40000100,
1822         0x02a19120, 0x40000100,
1823 };
1824
1825 static unsigned int d945gtp5_pin_configs[10] = {
1826         0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1827         0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1828         0x02a19320, 0x40000100,
1829 };
1830
1831 static unsigned int intel_mac_v1_pin_configs[10] = {
1832         0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1833         0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1834         0x400000fc, 0x400000fb,
1835 };
1836
1837 static unsigned int intel_mac_v2_pin_configs[10] = {
1838         0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1839         0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1840         0x400000fc, 0x400000fb,
1841 };
1842
1843 static unsigned int intel_mac_v3_pin_configs[10] = {
1844         0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1845         0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1846         0x400000fc, 0x400000fb,
1847 };
1848
1849 static unsigned int intel_mac_v4_pin_configs[10] = {
1850         0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1851         0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1852         0x400000fc, 0x400000fb,
1853 };
1854
1855 static unsigned int intel_mac_v5_pin_configs[10] = {
1856         0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1857         0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1858         0x400000fc, 0x400000fb,
1859 };
1860
1861 static unsigned int ecs202_pin_configs[10] = {
1862         0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1863         0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1864         0x9037012e, 0x40e000f2,
1865 };
1866
1867 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1868         [STAC_D945_REF] = ref922x_pin_configs,
1869         [STAC_D945GTP3] = d945gtp3_pin_configs,
1870         [STAC_D945GTP5] = d945gtp5_pin_configs,
1871         [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1872         [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1873         [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1874         [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1875         [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1876         [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1877         /* for backward compatibility */
1878         [STAC_MACMINI] = intel_mac_v3_pin_configs,
1879         [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1880         [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1881         [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1882         [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1883         [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1884         [STAC_ECS_202] = ecs202_pin_configs,
1885         [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1886         [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,       
1887         [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1888         [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,       
1889 };
1890
1891 static const char *stac922x_models[STAC_922X_MODELS] = {
1892         [STAC_922X_AUTO] = "auto",
1893         [STAC_D945_REF] = "ref",
1894         [STAC_D945GTP5] = "5stack",
1895         [STAC_D945GTP3] = "3stack",
1896         [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1897         [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1898         [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1899         [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1900         [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1901         [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1902         /* for backward compatibility */
1903         [STAC_MACMINI]  = "macmini",
1904         [STAC_MACBOOK]  = "macbook",
1905         [STAC_MACBOOK_PRO_V1]   = "macbook-pro-v1",
1906         [STAC_MACBOOK_PRO_V2]   = "macbook-pro",
1907         [STAC_IMAC_INTEL] = "imac-intel",
1908         [STAC_IMAC_INTEL_20] = "imac-intel-20",
1909         [STAC_ECS_202] = "ecs202",
1910         [STAC_922X_DELL_D81] = "dell-d81",
1911         [STAC_922X_DELL_D82] = "dell-d82",
1912         [STAC_922X_DELL_M81] = "dell-m81",
1913         [STAC_922X_DELL_M82] = "dell-m82",
1914 };
1915
1916 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1917         /* SigmaTel reference board */
1918         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1919                       "DFI LanParty", STAC_D945_REF),
1920         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1921                       "DFI LanParty", STAC_D945_REF),
1922         /* Intel 945G based systems */
1923         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1924                       "Intel D945G", STAC_D945GTP3),
1925         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1926                       "Intel D945G", STAC_D945GTP3),
1927         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1928                       "Intel D945G", STAC_D945GTP3),
1929         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1930                       "Intel D945G", STAC_D945GTP3),
1931         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1932                       "Intel D945G", STAC_D945GTP3),
1933         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1934                       "Intel D945G", STAC_D945GTP3),
1935         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1936                       "Intel D945G", STAC_D945GTP3),
1937         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1938                       "Intel D945G", STAC_D945GTP3),
1939         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1940                       "Intel D945G", STAC_D945GTP3),
1941         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1942                       "Intel D945G", STAC_D945GTP3),
1943         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1944                       "Intel D945G", STAC_D945GTP3),
1945         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1946                       "Intel D945G", STAC_D945GTP3),
1947         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1948                       "Intel D945G", STAC_D945GTP3),
1949         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1950                       "Intel D945G", STAC_D945GTP3),
1951         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1952                       "Intel D945G", STAC_D945GTP3),
1953         /* Intel D945G 5-stack systems */
1954         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1955                       "Intel D945G", STAC_D945GTP5),
1956         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1957                       "Intel D945G", STAC_D945GTP5),
1958         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1959                       "Intel D945G", STAC_D945GTP5),
1960         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1961                       "Intel D945G", STAC_D945GTP5),
1962         /* Intel 945P based systems */
1963         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1964                       "Intel D945P", STAC_D945GTP3),
1965         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1966                       "Intel D945P", STAC_D945GTP3),
1967         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1968                       "Intel D945P", STAC_D945GTP3),
1969         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1970                       "Intel D945P", STAC_D945GTP3),
1971         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1972                       "Intel D945P", STAC_D945GTP3),
1973         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1974                       "Intel D945P", STAC_D945GTP5),
1975         /* other intel */
1976         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
1977                       "Intel D945", STAC_D945_REF),
1978         /* other systems  */
1979         /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
1980         SND_PCI_QUIRK(0x8384, 0x7680,
1981                       "Mac", STAC_INTEL_MAC_AUTO),
1982         /* Dell systems  */
1983         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1984                       "unknown Dell", STAC_922X_DELL_D81),
1985         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1986                       "unknown Dell", STAC_922X_DELL_D81),
1987         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1988                       "unknown Dell", STAC_922X_DELL_D81),
1989         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1990                       "unknown Dell", STAC_922X_DELL_D82),
1991         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1992                       "unknown Dell", STAC_922X_DELL_M81),
1993         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1994                       "unknown Dell", STAC_922X_DELL_D82),
1995         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1996                       "unknown Dell", STAC_922X_DELL_D81),
1997         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1998                       "unknown Dell", STAC_922X_DELL_D81),
1999         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
2000                       "Dell XPS M1210", STAC_922X_DELL_M82),
2001         /* ECS/PC Chips boards */
2002         SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
2003                       "ECS/PC chips", STAC_ECS_202),
2004         {} /* terminator */
2005 };
2006
2007 static unsigned int ref927x_pin_configs[14] = {
2008         0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2009         0x01a19040, 0x01011012, 0x01016011, 0x0101201f, 
2010         0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2011         0x01c42190, 0x40000100,
2012 };
2013
2014 static unsigned int d965_3st_pin_configs[14] = {
2015         0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2016         0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2017         0x40000100, 0x40000100, 0x40000100, 0x40000100,
2018         0x40000100, 0x40000100
2019 };
2020
2021 static unsigned int d965_5st_pin_configs[14] = {
2022         0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2023         0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2024         0x40000100, 0x40000100, 0x40000100, 0x01442070,
2025         0x40000100, 0x40000100
2026 };
2027
2028 static unsigned int d965_5st_no_fp_pin_configs[14] = {
2029         0x40000100, 0x40000100, 0x0181304e, 0x01014010,
2030         0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2031         0x40000100, 0x40000100, 0x40000100, 0x01442070,
2032         0x40000100, 0x40000100
2033 };
2034
2035 static unsigned int dell_3st_pin_configs[14] = {
2036         0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2037         0x01111212, 0x01116211, 0x01813050, 0x01112214,
2038         0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2039         0x40c003fc, 0x40000100
2040 };
2041
2042 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2043         [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2044         [STAC_D965_REF]  = ref927x_pin_configs,
2045         [STAC_D965_3ST]  = d965_3st_pin_configs,
2046         [STAC_D965_5ST]  = d965_5st_pin_configs,
2047         [STAC_D965_5ST_NO_FP]  = d965_5st_no_fp_pin_configs,
2048         [STAC_DELL_3ST]  = dell_3st_pin_configs,
2049         [STAC_DELL_BIOS] = NULL,
2050         [STAC_927X_VOLKNOB] = NULL,
2051 };
2052
2053 static const char *stac927x_models[STAC_927X_MODELS] = {
2054         [STAC_927X_AUTO]        = "auto",
2055         [STAC_D965_REF_NO_JD]   = "ref-no-jd",
2056         [STAC_D965_REF]         = "ref",
2057         [STAC_D965_3ST]         = "3stack",
2058         [STAC_D965_5ST]         = "5stack",
2059         [STAC_D965_5ST_NO_FP]   = "5stack-no-fp",
2060         [STAC_DELL_3ST]         = "dell-3stack",
2061         [STAC_DELL_BIOS]        = "dell-bios",
2062         [STAC_927X_VOLKNOB]     = "volknob",
2063 };
2064
2065 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2066         /* SigmaTel reference board */
2067         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2068                       "DFI LanParty", STAC_D965_REF),
2069         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2070                       "DFI LanParty", STAC_D965_REF),
2071          /* Intel 946 based systems */
2072         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2073         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2074         /* 965 based 3 stack systems */
2075         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
2076                            "Intel D965", STAC_D965_3ST),
2077         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
2078                            "Intel D965", STAC_D965_3ST),
2079         /* Dell 3 stack systems */
2080         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
2081         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2082         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01ed, "Dell     ", STAC_DELL_3ST),
2083         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f4, "Dell     ", STAC_DELL_3ST),
2084         /* Dell 3 stack systems with verb table in BIOS */
2085         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2086         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0227, "Dell Vostro 1400  ", STAC_DELL_BIOS),
2087         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022e, "Dell     ", STAC_DELL_BIOS),
2088         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
2089         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0242, "Dell     ", STAC_DELL_BIOS),
2090         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0243, "Dell     ", STAC_DELL_BIOS),
2091         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x02ff, "Dell     ", STAC_DELL_BIOS),
2092         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2093         /* 965 based 5 stack systems */
2094         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
2095                            "Intel D965", STAC_D965_5ST),
2096         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
2097                            "Intel D965", STAC_D965_5ST),
2098         /* volume-knob fixes */
2099         SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB),
2100         {} /* terminator */
2101 };
2102
2103 static unsigned int ref9205_pin_configs[12] = {
2104         0x40000100, 0x40000100, 0x01016011, 0x01014010,
2105         0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2106         0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2107 };
2108
2109 /*
2110     STAC 9205 pin configs for
2111     102801F1
2112     102801F2
2113     102801FC
2114     102801FD
2115     10280204
2116     1028021F
2117     10280228 (Dell Vostro 1500)
2118     10280229 (Dell Vostro 1700)
2119 */
2120 static unsigned int dell_9205_m42_pin_configs[12] = {
2121         0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2122         0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2123         0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2124 };
2125
2126 /*
2127     STAC 9205 pin configs for
2128     102801F9
2129     102801FA
2130     102801FE
2131     102801FF (Dell Precision M4300)
2132     10280206
2133     10280200
2134     10280201
2135 */
2136 static unsigned int dell_9205_m43_pin_configs[12] = {
2137         0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2138         0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2139         0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2140 };
2141
2142 static unsigned int dell_9205_m44_pin_configs[12] = {
2143         0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2144         0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2145         0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2146 };
2147
2148 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2149         [STAC_9205_REF] = ref9205_pin_configs,
2150         [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2151         [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2152         [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2153         [STAC_9205_EAPD] = NULL,
2154 };
2155
2156 static const char *stac9205_models[STAC_9205_MODELS] = {
2157         [STAC_9205_AUTO] = "auto",
2158         [STAC_9205_REF] = "ref",
2159         [STAC_9205_DELL_M42] = "dell-m42",
2160         [STAC_9205_DELL_M43] = "dell-m43",
2161         [STAC_9205_DELL_M44] = "dell-m44",
2162         [STAC_9205_EAPD] = "eapd",
2163 };
2164
2165 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
2166         /* SigmaTel reference board */
2167         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2168                       "DFI LanParty", STAC_9205_REF),
2169         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
2170                       "SigmaTel", STAC_9205_REF),
2171         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2172                       "DFI LanParty", STAC_9205_REF),
2173         /* Dell */
2174         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2175                       "unknown Dell", STAC_9205_DELL_M42),
2176         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2177                       "unknown Dell", STAC_9205_DELL_M42),
2178         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2179                       "Dell Precision", STAC_9205_DELL_M43),
2180         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2181                       "Dell Precision", STAC_9205_DELL_M43),
2182         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2183                       "Dell Precision", STAC_9205_DELL_M43),
2184         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2185                       "unknown Dell", STAC_9205_DELL_M42),
2186         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2187                       "unknown Dell", STAC_9205_DELL_M42),
2188         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2189                       "Dell Precision", STAC_9205_DELL_M43),
2190         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2191                       "Dell Precision M4300", STAC_9205_DELL_M43),
2192         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2193                       "unknown Dell", STAC_9205_DELL_M42),
2194         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2195                       "Dell Precision", STAC_9205_DELL_M43),
2196         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2197                       "Dell Precision", STAC_9205_DELL_M43),
2198         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2199                       "Dell Precision", STAC_9205_DELL_M43),
2200         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2201                       "Dell Inspiron", STAC_9205_DELL_M44),
2202         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2203                       "Dell Vostro 1500", STAC_9205_DELL_M42),
2204         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229,
2205                       "Dell Vostro 1700", STAC_9205_DELL_M42),
2206         /* Gateway */
2207         SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
2208         SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
2209         {} /* terminator */
2210 };
2211
2212 static void stac92xx_set_config_regs(struct hda_codec *codec,
2213                                      unsigned int *pincfgs)
2214 {
2215         int i;
2216         struct sigmatel_spec *spec = codec->spec;
2217
2218         if (!pincfgs)
2219                 return;
2220
2221         for (i = 0; i < spec->num_pins; i++)
2222                 if (spec->pin_nids[i] && pincfgs[i])
2223                         snd_hda_codec_set_pincfg(codec, spec->pin_nids[i],
2224                                                  pincfgs[i]);
2225 }
2226
2227 /*
2228  * Analog playback callbacks
2229  */
2230 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2231                                       struct hda_codec *codec,
2232                                       struct snd_pcm_substream *substream)
2233 {
2234         struct sigmatel_spec *spec = codec->spec;
2235         if (spec->stream_delay)
2236                 msleep(spec->stream_delay);
2237         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2238                                              hinfo);
2239 }
2240
2241 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2242                                          struct hda_codec *codec,
2243                                          unsigned int stream_tag,
2244                                          unsigned int format,
2245                                          struct snd_pcm_substream *substream)
2246 {
2247         struct sigmatel_spec *spec = codec->spec;
2248         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2249 }
2250
2251 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2252                                         struct hda_codec *codec,
2253                                         struct snd_pcm_substream *substream)
2254 {
2255         struct sigmatel_spec *spec = codec->spec;
2256         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2257 }
2258
2259 /*
2260  * Digital playback callbacks
2261  */
2262 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2263                                           struct hda_codec *codec,
2264                                           struct snd_pcm_substream *substream)
2265 {
2266         struct sigmatel_spec *spec = codec->spec;
2267         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2268 }
2269
2270 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2271                                            struct hda_codec *codec,
2272                                            struct snd_pcm_substream *substream)
2273 {
2274         struct sigmatel_spec *spec = codec->spec;
2275         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2276 }
2277
2278 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2279                                          struct hda_codec *codec,
2280                                          unsigned int stream_tag,
2281                                          unsigned int format,
2282                                          struct snd_pcm_substream *substream)
2283 {
2284         struct sigmatel_spec *spec = codec->spec;
2285         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2286                                              stream_tag, format, substream);
2287 }
2288
2289 static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2290                                         struct hda_codec *codec,
2291                                         struct snd_pcm_substream *substream)
2292 {
2293         struct sigmatel_spec *spec = codec->spec;
2294         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2295 }
2296
2297
2298 /*
2299  * Analog capture callbacks
2300  */
2301 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2302                                         struct hda_codec *codec,
2303                                         unsigned int stream_tag,
2304                                         unsigned int format,
2305                                         struct snd_pcm_substream *substream)
2306 {
2307         struct sigmatel_spec *spec = codec->spec;
2308         hda_nid_t nid = spec->adc_nids[substream->number];
2309
2310         if (spec->powerdown_adcs) {
2311                 msleep(40);
2312                 snd_hda_codec_write(codec, nid, 0,
2313                         AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2314         }
2315         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2316         return 0;
2317 }
2318
2319 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2320                                         struct hda_codec *codec,
2321                                         struct snd_pcm_substream *substream)
2322 {
2323         struct sigmatel_spec *spec = codec->spec;
2324         hda_nid_t nid = spec->adc_nids[substream->number];
2325
2326         snd_hda_codec_cleanup_stream(codec, nid);
2327         if (spec->powerdown_adcs)
2328                 snd_hda_codec_write(codec, nid, 0,
2329                         AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2330         return 0;
2331 }
2332
2333 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2334         .substreams = 1,
2335         .channels_min = 2,
2336         .channels_max = 2,
2337         /* NID is set in stac92xx_build_pcms */
2338         .ops = {
2339                 .open = stac92xx_dig_playback_pcm_open,
2340                 .close = stac92xx_dig_playback_pcm_close,
2341                 .prepare = stac92xx_dig_playback_pcm_prepare,
2342                 .cleanup = stac92xx_dig_playback_pcm_cleanup
2343         },
2344 };
2345
2346 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2347         .substreams = 1,
2348         .channels_min = 2,
2349         .channels_max = 2,
2350         /* NID is set in stac92xx_build_pcms */
2351 };
2352
2353 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2354         .substreams = 1,
2355         .channels_min = 2,
2356         .channels_max = 8,
2357         .nid = 0x02, /* NID to query formats and rates */
2358         .ops = {
2359                 .open = stac92xx_playback_pcm_open,
2360                 .prepare = stac92xx_playback_pcm_prepare,
2361                 .cleanup = stac92xx_playback_pcm_cleanup
2362         },
2363 };
2364
2365 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2366         .substreams = 1,
2367         .channels_min = 2,
2368         .channels_max = 2,
2369         .nid = 0x06, /* NID to query formats and rates */
2370         .ops = {
2371                 .open = stac92xx_playback_pcm_open,
2372                 .prepare = stac92xx_playback_pcm_prepare,
2373                 .cleanup = stac92xx_playback_pcm_cleanup
2374         },
2375 };
2376
2377 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2378         .channels_min = 2,
2379         .channels_max = 2,
2380         /* NID + .substreams is set in stac92xx_build_pcms */
2381         .ops = {
2382                 .prepare = stac92xx_capture_pcm_prepare,
2383                 .cleanup = stac92xx_capture_pcm_cleanup
2384         },
2385 };
2386
2387 static int stac92xx_build_pcms(struct hda_codec *codec)
2388 {
2389         struct sigmatel_spec *spec = codec->spec;
2390         struct hda_pcm *info = spec->pcm_rec;
2391
2392         codec->num_pcms = 1;
2393         codec->pcm_info = info;
2394
2395         info->name = "STAC92xx Analog";
2396         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2397         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2398                 spec->multiout.dac_nids[0];
2399         info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2400         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2401         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2402
2403         if (spec->alt_switch) {
2404                 codec->num_pcms++;
2405                 info++;
2406                 info->name = "STAC92xx Analog Alt";
2407                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2408         }
2409
2410         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2411                 codec->num_pcms++;
2412                 info++;
2413                 info->name = "STAC92xx Digital";
2414                 info->pcm_type = spec->autocfg.dig_out_type[0];
2415                 if (spec->multiout.dig_out_nid) {
2416                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2417                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2418                 }
2419                 if (spec->dig_in_nid) {
2420                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2421                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2422                 }
2423         }
2424
2425         return 0;
2426 }
2427
2428 static unsigned int stac92xx_get_default_vref(struct hda_codec *codec,
2429                                         hda_nid_t nid)
2430 {
2431         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2432         pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2433         if (pincap & AC_PINCAP_VREF_100)
2434                 return AC_PINCTL_VREF_100;
2435         if (pincap & AC_PINCAP_VREF_80)
2436                 return AC_PINCTL_VREF_80;
2437         if (pincap & AC_PINCAP_VREF_50)
2438                 return AC_PINCTL_VREF_50;
2439         if (pincap & AC_PINCAP_VREF_GRD)
2440                 return AC_PINCTL_VREF_GRD;
2441         return 0;
2442 }
2443
2444 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2445
2446 {
2447         snd_hda_codec_write_cache(codec, nid, 0,
2448                                   AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2449 }
2450
2451 #define stac92xx_hp_switch_info         snd_ctl_boolean_mono_info
2452
2453 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2454                         struct snd_ctl_elem_value *ucontrol)
2455 {
2456         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2457         struct sigmatel_spec *spec = codec->spec;
2458
2459         ucontrol->value.integer.value[0] = !!spec->hp_switch;
2460         return 0;
2461 }
2462
2463 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid);
2464
2465 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2466                         struct snd_ctl_elem_value *ucontrol)
2467 {
2468         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2469         struct sigmatel_spec *spec = codec->spec;
2470         int nid = kcontrol->private_value;
2471  
2472         spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2473
2474         /* check to be sure that the ports are upto date with
2475          * switch changes
2476          */
2477         stac_issue_unsol_event(codec, nid);
2478
2479         return 1;
2480 }
2481
2482 static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol,
2483                                 struct snd_ctl_elem_info *uinfo)
2484 {
2485         int i;
2486         static char *texts[] = {
2487                 "Mic In", "Line In", "Line Out"
2488         };
2489
2490         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2491         struct sigmatel_spec *spec = codec->spec;
2492         hda_nid_t nid = kcontrol->private_value;
2493
2494         if (nid == spec->mic_switch || nid == spec->line_switch)
2495                 i = 3;
2496         else
2497                 i = 2;
2498
2499         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2500         uinfo->value.enumerated.items = i;
2501         uinfo->count = 1;
2502         if (uinfo->value.enumerated.item >= i)
2503                 uinfo->value.enumerated.item = i-1;
2504         strcpy(uinfo->value.enumerated.name,
2505                 texts[uinfo->value.enumerated.item]);
2506
2507         return 0;
2508 }
2509
2510 static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol,
2511                                 struct snd_ctl_elem_value *ucontrol)
2512 {
2513         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2514         hda_nid_t nid = kcontrol->private_value;
2515         unsigned int vref = stac92xx_vref_get(codec, nid);
2516
2517         if (vref == stac92xx_get_default_vref(codec, nid))
2518                 ucontrol->value.enumerated.item[0] = 0;
2519         else if (vref == AC_PINCTL_VREF_GRD)
2520                 ucontrol->value.enumerated.item[0] = 1;
2521         else if (vref == AC_PINCTL_VREF_HIZ)
2522                 ucontrol->value.enumerated.item[0] = 2;
2523
2524         return 0;
2525 }
2526
2527 static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol,
2528                                 struct snd_ctl_elem_value *ucontrol)
2529 {
2530         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2531         unsigned int new_vref = 0;
2532         int error;
2533         hda_nid_t nid = kcontrol->private_value;
2534
2535         if (ucontrol->value.enumerated.item[0] == 0)
2536                 new_vref = stac92xx_get_default_vref(codec, nid);
2537         else if (ucontrol->value.enumerated.item[0] == 1)
2538                 new_vref = AC_PINCTL_VREF_GRD;
2539         else if (ucontrol->value.enumerated.item[0] == 2)
2540                 new_vref = AC_PINCTL_VREF_HIZ;
2541         else
2542                 return 0;
2543
2544         if (new_vref != stac92xx_vref_get(codec, nid)) {
2545                 error = stac92xx_vref_set(codec, nid, new_vref);
2546                 return error;
2547         }
2548
2549         return 0;
2550 }
2551
2552 static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol,
2553                                 struct snd_ctl_elem_info *uinfo)
2554 {
2555         static char *texts[2];
2556         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2557         struct sigmatel_spec *spec = codec->spec;
2558
2559         if (kcontrol->private_value == spec->line_switch)
2560                 texts[0] = "Line In";
2561         else
2562                 texts[0] = "Mic In";
2563         texts[1] = "Line Out";
2564         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2565         uinfo->value.enumerated.items = 2;
2566         uinfo->count = 1;
2567
2568         if (uinfo->value.enumerated.item >= 2)
2569                 uinfo->value.enumerated.item = 1;
2570         strcpy(uinfo->value.enumerated.name,
2571                 texts[uinfo->value.enumerated.item]);
2572
2573         return 0;
2574 }
2575
2576 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2577 {
2578         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2579         struct sigmatel_spec *spec = codec->spec;
2580         hda_nid_t nid = kcontrol->private_value;
2581         int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2582
2583         ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx];
2584         return 0;
2585 }
2586
2587 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2588 {
2589         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2590         struct sigmatel_spec *spec = codec->spec;
2591         hda_nid_t nid = kcontrol->private_value;
2592         int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2593         unsigned short val = !!ucontrol->value.enumerated.item[0];
2594
2595         spec->io_switch[io_idx] = val;
2596
2597         if (val)
2598                 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2599         else {
2600                 unsigned int pinctl = AC_PINCTL_IN_EN;
2601                 if (io_idx) /* set VREF for mic */
2602                         pinctl |= stac92xx_get_default_vref(codec, nid);
2603                 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2604         }
2605
2606         /* check the auto-mute again: we need to mute/unmute the speaker
2607          * appropriately according to the pin direction
2608          */
2609         if (spec->hp_detect)
2610                 stac_issue_unsol_event(codec, nid);
2611
2612         return 1;
2613 }
2614
2615 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2616
2617 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2618                 struct snd_ctl_elem_value *ucontrol)
2619 {
2620         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2621         struct sigmatel_spec *spec = codec->spec;
2622
2623         ucontrol->value.integer.value[0] = spec->clfe_swap;
2624         return 0;
2625 }
2626
2627 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2628                 struct snd_ctl_elem_value *ucontrol)
2629 {
2630         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2631         struct sigmatel_spec *spec = codec->spec;
2632         hda_nid_t nid = kcontrol->private_value & 0xff;
2633         unsigned int val = !!ucontrol->value.integer.value[0];
2634
2635         if (spec->clfe_swap == val)
2636                 return 0;
2637
2638         spec->clfe_swap = val;
2639
2640         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2641                 spec->clfe_swap ? 0x4 : 0x0);
2642
2643         return 1;
2644 }
2645
2646 #define STAC_CODEC_HP_SWITCH(xname) \
2647         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2648           .name = xname, \
2649           .index = 0, \
2650           .info = stac92xx_hp_switch_info, \
2651           .get = stac92xx_hp_switch_get, \
2652           .put = stac92xx_hp_switch_put, \
2653         }
2654
2655 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2656         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2657           .name = xname, \
2658           .index = 0, \
2659           .info = stac92xx_io_switch_info, \
2660           .get = stac92xx_io_switch_get, \
2661           .put = stac92xx_io_switch_put, \
2662           .private_value = xpval, \
2663         }
2664
2665 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2666         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2667           .name = xname, \
2668           .index = 0, \
2669           .info = stac92xx_clfe_switch_info, \
2670           .get = stac92xx_clfe_switch_get, \
2671           .put = stac92xx_clfe_switch_put, \
2672           .private_value = xpval, \
2673         }
2674
2675 enum {
2676         STAC_CTL_WIDGET_VOL,
2677         STAC_CTL_WIDGET_MUTE,
2678         STAC_CTL_WIDGET_MUTE_BEEP,
2679         STAC_CTL_WIDGET_MONO_MUX,
2680         STAC_CTL_WIDGET_HP_SWITCH,
2681         STAC_CTL_WIDGET_IO_SWITCH,
2682         STAC_CTL_WIDGET_CLFE_SWITCH,
2683         STAC_CTL_WIDGET_DC_BIAS
2684 };
2685
2686 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2687         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2688         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2689         HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0),
2690         STAC_MONO_MUX,
2691         STAC_CODEC_HP_SWITCH(NULL),
2692         STAC_CODEC_IO_SWITCH(NULL, 0),
2693         STAC_CODEC_CLFE_SWITCH(NULL, 0),
2694         DC_BIAS(NULL, 0, 0),
2695 };
2696
2697 /* add dynamic controls */
2698 static struct snd_kcontrol_new *
2699 stac_control_new(struct sigmatel_spec *spec,
2700                  struct snd_kcontrol_new *ktemp,
2701                  const char *name,
2702                  unsigned int subdev)
2703 {
2704         struct snd_kcontrol_new *knew;
2705
2706         snd_array_init(&spec->kctls, sizeof(*knew), 32);
2707         knew = snd_array_new(&spec->kctls);
2708         if (!knew)
2709                 return NULL;
2710         *knew = *ktemp;
2711         knew->name = kstrdup(name, GFP_KERNEL);
2712         if (!knew->name) {
2713                 /* roolback */
2714                 memset(knew, 0, sizeof(*knew));
2715                 spec->kctls.alloced--;
2716                 return NULL;
2717         }
2718         knew->subdevice = subdev;
2719         return knew;
2720 }
2721
2722 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2723                                      struct snd_kcontrol_new *ktemp,
2724                                      int idx, const char *name,
2725                                      unsigned long val)
2726 {
2727         struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name,
2728                                                          HDA_SUBDEV_AMP_FLAG);
2729         if (!knew)
2730                 return -ENOMEM;
2731         knew->index = idx;
2732         knew->private_value = val;
2733         return 0;
2734 }
2735
2736 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2737                                            int type, int idx, const char *name,
2738                                            unsigned long val)
2739 {
2740         return stac92xx_add_control_temp(spec,
2741                                          &stac92xx_control_templates[type],
2742                                          idx, name, val);
2743 }
2744
2745
2746 /* add dynamic controls */
2747 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2748                                        const char *name, unsigned long val)
2749 {
2750         return stac92xx_add_control_idx(spec, type, 0, name, val);
2751 }
2752
2753 static struct snd_kcontrol_new stac_input_src_temp = {
2754         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2755         .name = "Input Source",
2756         .info = stac92xx_mux_enum_info,
2757         .get = stac92xx_mux_enum_get,
2758         .put = stac92xx_mux_enum_put,
2759 };
2760
2761 static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
2762                                                 hda_nid_t nid, int idx)
2763 {
2764         int def_conf = snd_hda_codec_get_pincfg(codec, nid);
2765         int control = 0;
2766         struct sigmatel_spec *spec = codec->spec;
2767         char name[22];
2768
2769         if (!((get_defcfg_connect(def_conf)) & AC_JACK_PORT_FIXED)) {
2770                 if (stac92xx_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
2771                         && nid == spec->line_switch)
2772                         control = STAC_CTL_WIDGET_IO_SWITCH;
2773                 else if (snd_hda_query_pin_caps(codec, nid)
2774                         & (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT))
2775                         control = STAC_CTL_WIDGET_DC_BIAS;
2776                 else if (nid == spec->mic_switch)
2777                         control = STAC_CTL_WIDGET_IO_SWITCH;
2778         }
2779
2780         if (control) {
2781                 strcpy(name, auto_pin_cfg_labels[idx]);
2782                 return stac92xx_add_control(codec->spec, control,
2783                                         strcat(name, " Jack Mode"), nid);
2784         }
2785
2786         return 0;
2787 }
2788
2789 static int stac92xx_add_input_source(struct sigmatel_spec *spec)
2790 {
2791         struct snd_kcontrol_new *knew;
2792         struct hda_input_mux *imux = &spec->private_imux;
2793
2794         if (spec->auto_mic)
2795                 return 0; /* no need for input source */
2796         if (!spec->num_adcs || imux->num_items <= 1)
2797                 return 0; /* no need for input source control */
2798         knew = stac_control_new(spec, &stac_input_src_temp,
2799                                 stac_input_src_temp.name, 0);
2800         if (!knew)
2801                 return -ENOMEM;
2802         knew->count = spec->num_adcs;
2803         return 0;
2804 }
2805
2806 /* check whether the line-input can be used as line-out */
2807 static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2808 {
2809         struct sigmatel_spec *spec = codec->spec;
2810         struct auto_pin_cfg *cfg = &spec->autocfg;
2811         hda_nid_t nid;
2812         unsigned int pincap;
2813
2814         if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2815                 return 0;
2816         nid = cfg->input_pins[AUTO_PIN_LINE];
2817         pincap = snd_hda_query_pin_caps(codec, nid);
2818         if (pincap & AC_PINCAP_OUT)
2819                 return nid;
2820         return 0;
2821 }
2822
2823 /* check whether the mic-input can be used as line-out */
2824 static hda_nid_t check_mic_out_switch(struct hda_codec *codec)
2825 {
2826         struct sigmatel_spec *spec = codec->spec;
2827         struct auto_pin_cfg *cfg = &spec->autocfg;
2828         unsigned int def_conf, pincap;
2829         unsigned int mic_pin;
2830
2831         if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2832                 return 0;
2833         mic_pin = AUTO_PIN_MIC;
2834         for (;;) {
2835                 hda_nid_t nid = cfg->input_pins[mic_pin];
2836                 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2837                 /* some laptops have an internal analog microphone
2838                  * which can't be used as a output */
2839                 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2840                         pincap = snd_hda_query_pin_caps(codec, nid);
2841                         if (pincap & AC_PINCAP_OUT)
2842                                 return nid;
2843                 }
2844                 if (mic_pin == AUTO_PIN_MIC)
2845                         mic_pin = AUTO_PIN_FRONT_MIC;
2846                 else
2847                         break;
2848         }
2849         return 0;
2850 }
2851
2852 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2853 {
2854         int i;
2855         
2856         for (i = 0; i < spec->multiout.num_dacs; i++) {
2857                 if (spec->multiout.dac_nids[i] == nid)
2858                         return 1;
2859         }
2860
2861         return 0;
2862 }
2863
2864 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2865 {
2866         int i;
2867         if (is_in_dac_nids(spec, nid))
2868                 return 1;
2869         for (i = 0; i < spec->autocfg.hp_outs; i++)
2870                 if (spec->hp_dacs[i] == nid)
2871                         return 1;
2872         for (i = 0; i < spec->autocfg.speaker_outs; i++)
2873                 if (spec->speaker_dacs[i] == nid)
2874                         return 1;
2875         return 0;
2876 }
2877
2878 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2879 {
2880         struct sigmatel_spec *spec = codec->spec;
2881         int j, conn_len;
2882         hda_nid_t conn[HDA_MAX_CONNECTIONS];
2883         unsigned int wcaps, wtype;
2884
2885         conn_len = snd_hda_get_connections(codec, nid, conn,
2886                                            HDA_MAX_CONNECTIONS);
2887         /* 92HD88: trace back up the link of nids to find the DAC */
2888         while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0]))
2889                                         != AC_WID_AUD_OUT)) {
2890                 nid = conn[0];
2891                 conn_len = snd_hda_get_connections(codec, nid, conn,
2892                         HDA_MAX_CONNECTIONS);
2893         }
2894         for (j = 0; j < conn_len; j++) {
2895                 wcaps = get_wcaps(codec, conn[j]);
2896                 wtype = get_wcaps_type(wcaps);
2897                 /* we check only analog outputs */
2898                 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2899                         continue;
2900                 /* if this route has a free DAC, assign it */
2901                 if (!check_all_dac_nids(spec, conn[j])) {
2902                         if (conn_len > 1) {
2903                                 /* select this DAC in the pin's input mux */
2904                                 snd_hda_codec_write_cache(codec, nid, 0,
2905                                                   AC_VERB_SET_CONNECT_SEL, j);
2906                         }
2907                         return conn[j];
2908                 }
2909         }
2910         /* if all DACs are already assigned, connect to the primary DAC */
2911         if (conn_len > 1) {
2912                 for (j = 0; j < conn_len; j++) {
2913                         if (conn[j] == spec->multiout.dac_nids[0]) {
2914                                 snd_hda_codec_write_cache(codec, nid, 0,
2915                                                   AC_VERB_SET_CONNECT_SEL, j);
2916                                 break;
2917                         }
2918                 }
2919         }
2920         return 0;
2921 }
2922
2923 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2924 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2925
2926 /*
2927  * Fill in the dac_nids table from the parsed pin configuration
2928  * This function only works when every pin in line_out_pins[]
2929  * contains atleast one DAC in its connection list. Some 92xx
2930  * codecs are not connected directly to a DAC, such as the 9200
2931  * and 9202/925x. For those, dac_nids[] must be hard-coded.
2932  */
2933 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2934 {
2935         struct sigmatel_spec *spec = codec->spec;
2936         struct auto_pin_cfg *cfg = &spec->autocfg;
2937         int i;
2938         hda_nid_t nid, dac;
2939         
2940         for (i = 0; i < cfg->line_outs; i++) {
2941                 nid = cfg->line_out_pins[i];
2942                 dac = get_unassigned_dac(codec, nid);
2943                 if (!dac) {
2944                         if (spec->multiout.num_dacs > 0) {
2945                                 /* we have already working output pins,
2946                                  * so let's drop the broken ones again
2947                                  */
2948                                 cfg->line_outs = spec->multiout.num_dacs;
2949                                 break;
2950                         }
2951                         /* error out, no available DAC found */
2952                         snd_printk(KERN_ERR
2953                                    "%s: No available DAC for pin 0x%x\n",
2954                                    __func__, nid);
2955                         return -ENODEV;
2956                 }
2957                 add_spec_dacs(spec, dac);
2958         }
2959
2960         for (i = 0; i < cfg->hp_outs; i++) {
2961                 nid = cfg->hp_pins[i];
2962                 dac = get_unassigned_dac(codec, nid);
2963                 if (dac) {
2964                         if (!spec->multiout.hp_nid)
2965                                 spec->multiout.hp_nid = dac;
2966                         else
2967                                 add_spec_extra_dacs(spec, dac);
2968                 }
2969                 spec->hp_dacs[i] = dac;
2970         }
2971
2972         for (i = 0; i < cfg->speaker_outs; i++) {
2973                 nid = cfg->speaker_pins[i];
2974                 dac = get_unassigned_dac(codec, nid);
2975                 if (dac)
2976                         add_spec_extra_dacs(spec, dac);
2977                 spec->speaker_dacs[i] = dac;
2978         }
2979
2980         /* add line-in as output */
2981         nid = check_line_out_switch(codec);
2982         if (nid) {
2983                 dac = get_unassigned_dac(codec, nid);
2984                 if (dac) {
2985                         snd_printdd("STAC: Add line-in 0x%x as output %d\n",
2986                                     nid, cfg->line_outs);
2987                         cfg->line_out_pins[cfg->line_outs] = nid;
2988                         cfg->line_outs++;
2989                         spec->line_switch = nid;
2990                         add_spec_dacs(spec, dac);
2991                 }
2992         }
2993         /* add mic as output */
2994         nid = check_mic_out_switch(codec);
2995         if (nid) {
2996                 dac = get_unassigned_dac(codec, nid);
2997                 if (dac) {
2998                         snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
2999                                     nid, cfg->line_outs);
3000                         cfg->line_out_pins[cfg->line_outs] = nid;
3001                         cfg->line_outs++;
3002                         spec->mic_switch = nid;
3003                         add_spec_dacs(spec, dac);
3004                 }
3005         }
3006
3007         snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3008                    spec->multiout.num_dacs,
3009                    spec->multiout.dac_nids[0],
3010                    spec->multiout.dac_nids[1],
3011                    spec->multiout.dac_nids[2],
3012                    spec->multiout.dac_nids[3],
3013                    spec->multiout.dac_nids[4]);
3014
3015         return 0;
3016 }
3017
3018 /* create volume control/switch for the given prefx type */
3019 static int create_controls_idx(struct hda_codec *codec, const char *pfx,
3020                                int idx, hda_nid_t nid, int chs)
3021 {
3022         struct sigmatel_spec *spec = codec->spec;
3023         char name[32];
3024         int err;
3025
3026         if (!spec->check_volume_offset) {
3027                 unsigned int caps, step, nums, db_scale;
3028                 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3029                 step = (caps & AC_AMPCAP_STEP_SIZE) >>
3030                         AC_AMPCAP_STEP_SIZE_SHIFT;
3031                 step = (step + 1) * 25; /* in .01dB unit */
3032                 nums = (caps & AC_AMPCAP_NUM_STEPS) >>
3033                         AC_AMPCAP_NUM_STEPS_SHIFT;
3034                 db_scale = nums * step;
3035                 /* if dB scale is over -64dB, and finer enough,
3036                  * let's reduce it to half
3037                  */
3038                 if (db_scale > 6400 && nums >= 0x1f)
3039                         spec->volume_offset = nums / 2;
3040                 spec->check_volume_offset = 1;
3041         }
3042
3043         sprintf(name, "%s Playback Volume", pfx);
3044         err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
3045                 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3046                                         spec->volume_offset));
3047         if (err < 0)
3048                 return err;
3049         sprintf(name, "%s Playback Switch", pfx);
3050         err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
3051                                    HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3052         if (err < 0)
3053                 return err;
3054         return 0;
3055 }
3056
3057 #define create_controls(codec, pfx, nid, chs) \
3058         create_controls_idx(codec, pfx, 0, nid, chs)
3059
3060 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3061 {
3062         if (spec->multiout.num_dacs > 4) {
3063                 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3064                 return 1;
3065         } else {
3066                 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
3067                 spec->multiout.num_dacs++;
3068         }
3069         return 0;
3070 }
3071
3072 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3073 {
3074         int i;
3075         for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3076                 if (!spec->multiout.extra_out_nid[i]) {
3077                         spec->multiout.extra_out_nid[i] = nid;
3078                         return 0;
3079                 }
3080         }
3081         printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3082         return 1;
3083 }
3084
3085 /* Create output controls
3086  * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
3087  */
3088 static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
3089                                  const hda_nid_t *pins,
3090                                  const hda_nid_t *dac_nids,
3091                                  int type)
3092 {
3093         struct sigmatel_spec *spec = codec->spec;
3094         static const char *chname[4] = {
3095                 "Front", "Surround", NULL /*CLFE*/, "Side"
3096         };
3097         hda_nid_t nid;
3098         int i, err;
3099         unsigned int wid_caps;
3100
3101         for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
3102                 if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3103                         wid_caps = get_wcaps(codec, pins[i]);
3104                         if (wid_caps & AC_WCAP_UNSOL_CAP)
3105                                 spec->hp_detect = 1;
3106                 }
3107                 nid = dac_nids[i];
3108                 if (!nid)
3109                         continue;
3110                 if (type != AUTO_PIN_HP_OUT && i == 2) {
3111                         /* Center/LFE */
3112                         err = create_controls(codec, "Center", nid, 1);
3113                         if (err < 0)
3114                                 return err;
3115                         err = create_controls(codec, "LFE", nid, 2);
3116                         if (err < 0)
3117                                 return err;
3118
3119                         wid_caps = get_wcaps(codec, nid);
3120
3121                         if (wid_caps & AC_WCAP_LR_SWAP) {
3122                                 err = stac92xx_add_control(spec,
3123                                         STAC_CTL_WIDGET_CLFE_SWITCH,
3124                                         "Swap Center/LFE Playback Switch", nid);
3125
3126                                 if (err < 0)
3127                                         return err;
3128                         }
3129
3130                 } else {
3131                         const char *name;
3132                         int idx;
3133                         switch (type) {
3134                         case AUTO_PIN_HP_OUT:
3135                                 name = "Headphone";
3136                                 idx = i;
3137                                 break;
3138                         case AUTO_PIN_SPEAKER_OUT:
3139                                 name = "Speaker";
3140                                 idx = i;
3141                                 break;
3142                         default:
3143                                 name = chname[i];
3144                                 idx = 0;
3145                                 break;
3146                         }
3147                         err = create_controls_idx(codec, name, idx, nid, 3);
3148                         if (err < 0)
3149                                 return err;
3150                 }
3151         }
3152         return 0;
3153 }
3154
3155 static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol,
3156                                     unsigned long sw, int idx)
3157 {
3158         int err;
3159         err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx,
3160                                        "Capture Volume", vol);
3161         if (err < 0)
3162                 return err;
3163         err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_MUTE, idx,
3164                                        "Capture Switch", sw);
3165         if (err < 0)
3166                 return err;
3167         return 0;
3168 }
3169
3170 /* add playback controls from the parsed DAC table */
3171 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3172                                                const struct auto_pin_cfg *cfg)
3173 {
3174         struct sigmatel_spec *spec = codec->spec;
3175         hda_nid_t nid;
3176         int err;
3177         int idx;
3178
3179         err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
3180                                     spec->multiout.dac_nids,
3181                                     cfg->line_out_type);
3182         if (err < 0)
3183                 return err;
3184
3185         if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3186                 err = stac92xx_add_control(spec,
3187                         STAC_CTL_WIDGET_HP_SWITCH,
3188                         "Headphone as Line Out Switch",
3189                         cfg->hp_pins[cfg->hp_outs - 1]);
3190                 if (err < 0)
3191                         return err;
3192         }
3193
3194         for (idx = AUTO_PIN_MIC; idx <= AUTO_PIN_FRONT_LINE; idx++) {
3195                 nid = cfg->input_pins[idx];
3196                 if (nid) {
3197                         err = stac92xx_add_jack_mode_control(codec, nid, idx);
3198                         if (err < 0)
3199                                 return err;
3200                 }
3201         }
3202
3203         return 0;
3204 }
3205
3206 /* add playback controls for Speaker and HP outputs */
3207 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3208                                         struct auto_pin_cfg *cfg)
3209 {
3210         struct sigmatel_spec *spec = codec->spec;
3211         int err;
3212
3213         err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
3214                                     spec->hp_dacs, AUTO_PIN_HP_OUT);
3215         if (err < 0)
3216                 return err;
3217
3218         err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
3219                                     spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
3220         if (err < 0)
3221                 return err;
3222
3223         return 0;
3224 }
3225
3226 /* labels for mono mux outputs */
3227 static const char *stac92xx_mono_labels[4] = {
3228         "DAC0", "DAC1", "Mixer", "DAC2"
3229 };
3230
3231 /* create mono mux for mono out on capable codecs */
3232 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3233 {
3234         struct sigmatel_spec *spec = codec->spec;
3235         struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3236         int i, num_cons;
3237         hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3238
3239         num_cons = snd_hda_get_connections(codec,
3240                                 spec->mono_nid,
3241                                 con_lst,
3242                                 HDA_MAX_NUM_INPUTS);
3243         if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3244                 return -EINVAL;
3245
3246         for (i = 0; i < num_cons; i++) {
3247                 mono_mux->items[mono_mux->num_items].label =
3248                                         stac92xx_mono_labels[i];
3249                 mono_mux->items[mono_mux->num_items].index = i;
3250                 mono_mux->num_items++;
3251         }
3252
3253         return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3254                                 "Mono Mux", spec->mono_nid);
3255 }
3256
3257 /* create PC beep volume controls */
3258 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3259                                                 hda_nid_t nid)
3260 {
3261         struct sigmatel_spec *spec = codec->spec;
3262         u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3263         int err, type = STAC_CTL_WIDGET_MUTE_BEEP;
3264
3265         if (spec->anabeep_nid == nid)
3266                 type = STAC_CTL_WIDGET_MUTE;
3267
3268         /* check for mute support for the the amp */
3269         if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3270                 err = stac92xx_add_control(spec, type,
3271                         "Beep Playback Switch",
3272                         HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3273                         if (err < 0)
3274                                 return err;
3275         }
3276
3277         /* check to see if there is volume support for the amp */
3278         if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3279                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3280                         "Beep Playback Volume",
3281                         HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3282                         if (err < 0)
3283                                 return err;
3284         }
3285         return 0;
3286 }
3287
3288 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3289 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3290
3291 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3292                                         struct snd_ctl_elem_value *ucontrol)
3293 {
3294         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3295         ucontrol->value.integer.value[0] = codec->beep->enabled;
3296         return 0;
3297 }
3298
3299 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3300                                         struct snd_ctl_elem_value *ucontrol)
3301 {
3302         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3303         return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
3304 }
3305
3306 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3307         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3308         .info = stac92xx_dig_beep_switch_info,
3309         .get = stac92xx_dig_beep_switch_get,
3310         .put = stac92xx_dig_beep_switch_put,
3311 };
3312
3313 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3314 {
3315         return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3316                                          0, "Beep Playback Switch", 0);
3317 }
3318 #endif
3319
3320 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3321 {
3322         struct sigmatel_spec *spec = codec->spec;
3323         int i, j, err = 0;
3324
3325         for (i = 0; i < spec->num_muxes; i++) {
3326                 hda_nid_t nid;
3327                 unsigned int wcaps;
3328                 unsigned long val;
3329
3330                 nid = spec->mux_nids[i];
3331                 wcaps = get_wcaps(codec, nid);
3332                 if (!(wcaps & AC_WCAP_OUT_AMP))
3333                         continue;
3334
3335                 /* check whether already the same control was created as
3336                  * normal Capture Volume.
3337                  */
3338                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3339                 for (j = 0; j < spec->num_caps; j++) {
3340                         if (spec->capvols[j] == val)
3341                                 break;
3342                 }
3343                 if (j < spec->num_caps)
3344                         continue;
3345
3346                 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i,
3347                                                "Mux Capture Volume", val);
3348                 if (err < 0)
3349                         return err;
3350         }
3351         return 0;
3352 };
3353
3354 static const char *stac92xx_spdif_labels[3] = {
3355         "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3356 };
3357
3358 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3359 {
3360         struct sigmatel_spec *spec = codec->spec;
3361         struct hda_input_mux *spdif_mux = &spec->private_smux;
3362         const char **labels = spec->spdif_labels;
3363         int i, num_cons;
3364         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3365
3366         num_cons = snd_hda_get_connections(codec,
3367                                 spec->smux_nids[0],
3368                                 con_lst,
3369                                 HDA_MAX_NUM_INPUTS);
3370         if (num_cons <= 0)
3371                 return -EINVAL;
3372
3373         if (!labels)
3374                 labels = stac92xx_spdif_labels;
3375
3376         for (i = 0; i < num_cons; i++) {
3377                 spdif_mux->items[spdif_mux->num_items].label = labels[i];
3378                 spdif_mux->items[spdif_mux->num_items].index = i;
3379                 spdif_mux->num_items++;
3380         }
3381
3382         return 0;
3383 }
3384
3385 /* labels for dmic mux inputs */
3386 static const char *stac92xx_dmic_labels[5] = {
3387         "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3388         "Digital Mic 3", "Digital Mic 4"
3389 };
3390
3391 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
3392                                 hda_nid_t nid)
3393 {
3394         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3395         int i, nums;
3396
3397         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3398         for (i = 0; i < nums; i++)
3399                 if (conn[i] == nid)
3400                         return i;
3401         return -1;
3402 }
3403
3404 /* create a volume assigned to the given pin (only if supported) */
3405 /* return 1 if the volume control is created */
3406 static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
3407                                    const char *label, int direction)
3408 {
3409         unsigned int caps, nums;
3410         char name[32];
3411         int err;
3412
3413         if (direction == HDA_OUTPUT)
3414                 caps = AC_WCAP_OUT_AMP;
3415         else
3416                 caps = AC_WCAP_IN_AMP;
3417         if (!(get_wcaps(codec, nid) & caps))