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