]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - sound/pci/hda/patch_sigmatel.c
852dae91edb1ce9dc92bc93f166d1640da4d7820
[~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) {
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, mic_type;
2856
2857         *dac = 0;
2858         if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2859                 return 0;
2860         mic_type = AUTO_PIN_MIC;
2861  again:
2862         for (i = 0; i < cfg->num_inputs; i++) {
2863                 hda_nid_t nid = cfg->inputs[i].pin;
2864                 if (cfg->inputs[i].type != mic_type)
2865                         continue;
2866                 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2867                 /* some laptops have an internal analog microphone
2868                  * which can't be used as a output */
2869                 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2870                         pincap = snd_hda_query_pin_caps(codec, nid);
2871                         if (pincap & AC_PINCAP_OUT) {
2872                                 *dac = get_unassigned_dac(codec, nid);
2873                                 if (*dac)
2874                                         return nid;
2875                         }
2876                 }
2877         }
2878         if (mic_type == AUTO_PIN_MIC) {
2879                 mic_type = AUTO_PIN_FRONT_MIC;
2880                 goto again;
2881         }
2882         return 0;
2883 }
2884
2885 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2886 {
2887         int i;
2888         
2889         for (i = 0; i < spec->multiout.num_dacs; i++) {
2890                 if (spec->multiout.dac_nids[i] == nid)
2891                         return 1;
2892         }
2893
2894         return 0;
2895 }
2896
2897 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2898 {
2899         int i;
2900         if (is_in_dac_nids(spec, nid))
2901                 return 1;
2902         for (i = 0; i < spec->autocfg.hp_outs; i++)
2903                 if (spec->hp_dacs[i] == nid)
2904                         return 1;
2905         for (i = 0; i < spec->autocfg.speaker_outs; i++)
2906                 if (spec->speaker_dacs[i] == nid)
2907                         return 1;
2908         return 0;
2909 }
2910
2911 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2912 {
2913         struct sigmatel_spec *spec = codec->spec;
2914         int j, conn_len;
2915         hda_nid_t conn[HDA_MAX_CONNECTIONS];
2916         unsigned int wcaps, wtype;
2917
2918         conn_len = snd_hda_get_connections(codec, nid, conn,
2919                                            HDA_MAX_CONNECTIONS);
2920         /* 92HD88: trace back up the link of nids to find the DAC */
2921         while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0]))
2922                                         != AC_WID_AUD_OUT)) {
2923                 nid = conn[0];
2924                 conn_len = snd_hda_get_connections(codec, nid, conn,
2925                         HDA_MAX_CONNECTIONS);
2926         }
2927         for (j = 0; j < conn_len; j++) {
2928                 wcaps = get_wcaps(codec, conn[j]);
2929                 wtype = get_wcaps_type(wcaps);
2930                 /* we check only analog outputs */
2931                 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2932                         continue;
2933                 /* if this route has a free DAC, assign it */
2934                 if (!check_all_dac_nids(spec, conn[j])) {
2935                         if (conn_len > 1) {
2936                                 /* select this DAC in the pin's input mux */
2937                                 snd_hda_codec_write_cache(codec, nid, 0,
2938                                                   AC_VERB_SET_CONNECT_SEL, j);
2939                         }
2940                         return conn[j];
2941                 }
2942         }
2943         /* if all DACs are already assigned, connect to the primary DAC */
2944         if (conn_len > 1) {
2945                 for (j = 0; j < conn_len; j++) {
2946                         if (conn[j] == spec->multiout.dac_nids[0]) {
2947                                 snd_hda_codec_write_cache(codec, nid, 0,
2948                                                   AC_VERB_SET_CONNECT_SEL, j);
2949                                 break;
2950                         }
2951                 }
2952         }
2953         return 0;
2954 }
2955
2956 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2957 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2958
2959 /*
2960  * Fill in the dac_nids table from the parsed pin configuration
2961  * This function only works when every pin in line_out_pins[]
2962  * contains atleast one DAC in its connection list. Some 92xx
2963  * codecs are not connected directly to a DAC, such as the 9200
2964  * and 9202/925x. For those, dac_nids[] must be hard-coded.
2965  */
2966 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2967 {
2968         struct sigmatel_spec *spec = codec->spec;
2969         struct auto_pin_cfg *cfg = &spec->autocfg;
2970         int i;
2971         hda_nid_t nid, dac;
2972         
2973         for (i = 0; i < cfg->line_outs; i++) {
2974                 nid = cfg->line_out_pins[i];
2975                 dac = get_unassigned_dac(codec, nid);
2976                 if (!dac) {
2977                         if (spec->multiout.num_dacs > 0) {
2978                                 /* we have already working output pins,
2979                                  * so let's drop the broken ones again
2980                                  */
2981                                 cfg->line_outs = spec->multiout.num_dacs;
2982                                 break;
2983                         }
2984                         /* error out, no available DAC found */
2985                         snd_printk(KERN_ERR
2986                                    "%s: No available DAC for pin 0x%x\n",
2987                                    __func__, nid);
2988                         return -ENODEV;
2989                 }
2990                 add_spec_dacs(spec, dac);
2991         }
2992
2993         for (i = 0; i < cfg->hp_outs; i++) {
2994                 nid = cfg->hp_pins[i];
2995                 dac = get_unassigned_dac(codec, nid);
2996                 if (dac) {
2997                         if (!spec->multiout.hp_nid)
2998                                 spec->multiout.hp_nid = dac;
2999                         else
3000                                 add_spec_extra_dacs(spec, dac);
3001                 }
3002                 spec->hp_dacs[i] = dac;
3003         }
3004
3005         for (i = 0; i < cfg->speaker_outs; i++) {
3006                 nid = cfg->speaker_pins[i];
3007                 dac = get_unassigned_dac(codec, nid);
3008                 if (dac)
3009                         add_spec_extra_dacs(spec, dac);
3010                 spec->speaker_dacs[i] = dac;
3011         }
3012
3013         /* add line-in as output */
3014         nid = check_line_out_switch(codec);
3015         if (nid) {
3016                 dac = get_unassigned_dac(codec, nid);
3017                 if (dac) {
3018                         snd_printdd("STAC: Add line-in 0x%x as output %d\n",
3019                                     nid, cfg->line_outs);
3020                         cfg->line_out_pins[cfg->line_outs] = nid;
3021                         cfg->line_outs++;
3022                         spec->line_switch = nid;
3023                         add_spec_dacs(spec, dac);
3024                 }
3025         }
3026         /* add mic as output */
3027         nid = check_mic_out_switch(codec, &dac);
3028         if (nid && dac) {
3029                 snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
3030                             nid, cfg->line_outs);
3031                 cfg->line_out_pins[cfg->line_outs] = nid;
3032                 cfg->line_outs++;
3033                 spec->mic_switch = nid;
3034                 add_spec_dacs(spec, dac);
3035         }
3036
3037         snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3038                    spec->multiout.num_dacs,
3039                    spec->multiout.dac_nids[0],
3040                    spec->multiout.dac_nids[1],
3041                    spec->multiout.dac_nids[2],
3042                    spec->multiout.dac_nids[3],
3043                    spec->multiout.dac_nids[4]);
3044
3045         return 0;
3046 }
3047
3048 /* create volume control/switch for the given prefx type */
3049 static int create_controls_idx(struct hda_codec *codec, const char *pfx,
3050                                int idx, hda_nid_t nid, int chs)
3051 {
3052         struct sigmatel_spec *spec = codec->spec;
3053         char name[32];
3054         int err;
3055
3056         if (!spec->check_volume_offset) {
3057                 unsigned int caps, step, nums, db_scale;
3058                 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3059                 step = (caps & AC_AMPCAP_STEP_SIZE) >>
3060                         AC_AMPCAP_STEP_SIZE_SHIFT;
3061                 step = (step + 1) * 25; /* in .01dB unit */
3062                 nums = (caps & AC_AMPCAP_NUM_STEPS) >>
3063                         AC_AMPCAP_NUM_STEPS_SHIFT;
3064                 db_scale = nums * step;
3065                 /* if dB scale is over -64dB, and finer enough,
3066                  * let's reduce it to half
3067                  */
3068                 if (db_scale > 6400 && nums >= 0x1f)
3069                         spec->volume_offset = nums / 2;
3070                 spec->check_volume_offset = 1;
3071         }
3072
3073         sprintf(name, "%s Playback Volume", pfx);
3074         err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
3075                 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3076                                         spec->volume_offset));
3077         if (err < 0)
3078                 return err;
3079         sprintf(name, "%s Playback Switch", pfx);
3080         err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
3081                                    HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3082         if (err < 0)
3083                 return err;
3084         return 0;
3085 }
3086
3087 #define create_controls(codec, pfx, nid, chs) \
3088         create_controls_idx(codec, pfx, 0, nid, chs)
3089
3090 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3091 {
3092         if (spec->multiout.num_dacs > 4) {
3093                 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3094                 return 1;
3095         } else {
3096                 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
3097                 spec->multiout.num_dacs++;
3098         }
3099         return 0;
3100 }
3101
3102 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3103 {
3104         int i;
3105         for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3106                 if (!spec->multiout.extra_out_nid[i]) {
3107                         spec->multiout.extra_out_nid[i] = nid;
3108                         return 0;
3109                 }
3110         }
3111         printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3112         return 1;
3113 }
3114
3115 /* Create output controls
3116  * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
3117  */
3118 static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
3119                                  const hda_nid_t *pins,
3120                                  const hda_nid_t *dac_nids,
3121                                  int type)
3122 {
3123         struct sigmatel_spec *spec = codec->spec;
3124         static const char *chname[4] = {
3125                 "Front", "Surround", NULL /*CLFE*/, "Side"
3126         };
3127         hda_nid_t nid;
3128         int i, err;
3129         unsigned int wid_caps;
3130
3131         for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
3132                 if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3133                         wid_caps = get_wcaps(codec, pins[i]);
3134                         if (wid_caps & AC_WCAP_UNSOL_CAP)
3135                                 spec->hp_detect = 1;
3136                 }
3137                 nid = dac_nids[i];
3138                 if (!nid)
3139                         continue;
3140                 if (type != AUTO_PIN_HP_OUT && i == 2) {
3141                         /* Center/LFE */
3142                         err = create_controls(codec, "Center", nid, 1);
3143                         if (err < 0)
3144                                 return err;
3145                         err = create_controls(codec, "LFE", nid, 2);
3146                         if (err < 0)
3147                                 return err;
3148
3149                         wid_caps = get_wcaps(codec, nid);
3150
3151                         if (wid_caps & AC_WCAP_LR_SWAP) {
3152                                 err = stac92xx_add_control(spec,
3153                                         STAC_CTL_WIDGET_CLFE_SWITCH,
3154                                         "Swap Center/LFE Playback Switch", nid);
3155
3156                                 if (err < 0)
3157                                         return err;
3158                         }
3159
3160                 } else {
3161                         const char *name;
3162                         int idx;
3163                         switch (type) {
3164                         case AUTO_PIN_HP_OUT:
3165                                 name = "Headphone";
3166                                 idx = i;
3167                                 break;
3168                         case AUTO_PIN_SPEAKER_OUT:
3169                                 name = "Speaker";
3170                                 idx = i;
3171                                 break;
3172                         default:
3173                                 name = chname[i];
3174                                 idx = 0;
3175                                 break;
3176                         }
3177                         err = create_controls_idx(codec, name, idx, nid, 3);
3178                         if (err < 0)
3179                                 return err;
3180                 }
3181         }
3182         return 0;
3183 }
3184
3185 static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol,
3186                                     unsigned long sw, int idx)
3187 {
3188         int err;
3189         err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx,
3190                                        "Capture Volume", vol);
3191         if (err < 0)
3192                 return err;
3193         err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_MUTE, idx,
3194                                        "Capture Switch", sw);
3195         if (err < 0)
3196                 return err;
3197         return 0;
3198 }
3199
3200 /* add playback controls from the parsed DAC table */
3201 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3202                                                const struct auto_pin_cfg *cfg)
3203 {
3204         struct sigmatel_spec *spec = codec->spec;
3205         hda_nid_t nid;
3206         int err;
3207         int idx;
3208
3209         err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
3210                                     spec->multiout.dac_nids,
3211                                     cfg->line_out_type);
3212         if (err < 0)
3213                 return err;
3214
3215         if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3216                 err = stac92xx_add_control(spec,
3217                         STAC_CTL_WIDGET_HP_SWITCH,
3218                         "Headphone as Line Out Switch",
3219                         cfg->hp_pins[cfg->hp_outs - 1]);
3220                 if (err < 0)
3221                         return err;
3222         }
3223
3224         for (idx = 0; idx < cfg->num_inputs; idx++) {
3225                 if (cfg->inputs[idx].type > AUTO_PIN_FRONT_LINE)
3226                         break;
3227                 nid = cfg->inputs[idx].pin;
3228                 err = stac92xx_add_jack_mode_control(codec, nid, idx);
3229                 if (err < 0)
3230                         return err;
3231         }
3232
3233         return 0;
3234 }
3235
3236 /* add playback controls for Speaker and HP outputs */
3237 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3238                                         struct auto_pin_cfg *cfg)
3239 {
3240         struct sigmatel_spec *spec = codec->spec;
3241         int err;
3242
3243         err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
3244                                     spec->hp_dacs, AUTO_PIN_HP_OUT);
3245         if (err < 0)
3246                 return err;
3247
3248         err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
3249                                     spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
3250         if (err < 0)
3251                 return err;
3252
3253         return 0;
3254 }
3255
3256 /* labels for mono mux outputs */
3257 static const char *stac92xx_mono_labels[4] = {
3258         "DAC0", "DAC1", "Mixer", "DAC2"
3259 };
3260
3261 /* create mono mux for mono out on capable codecs */
3262 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3263 {
3264         struct sigmatel_spec *spec = codec->spec;
3265         struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3266         int i, num_cons;
3267         hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3268
3269         num_cons = snd_hda_get_connections(codec,
3270                                 spec->mono_nid,
3271                                 con_lst,
3272                                 HDA_MAX_NUM_INPUTS);
3273         if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3274                 return -EINVAL;
3275
3276         for (i = 0; i < num_cons; i++) {
3277                 strcpy(mono_mux->items[mono_mux->num_items].label,
3278                        stac92xx_mono_labels[i]);
3279                 mono_mux->items[mono_mux->num_items].index = i;
3280                 mono_mux->num_items++;
3281         }
3282
3283         return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3284                                 "Mono Mux", spec->mono_nid);
3285 }
3286
3287 /* create PC beep volume controls */
3288 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3289                                                 hda_nid_t nid)
3290 {
3291         struct sigmatel_spec *spec = codec->spec;
3292         u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3293         int err, type = STAC_CTL_WIDGET_MUTE_BEEP;
3294
3295         if (spec->anabeep_nid == nid)
3296                 type = STAC_CTL_WIDGET_MUTE;
3297
3298         /* check for mute support for the the amp */
3299         if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3300                 err = stac92xx_add_control(spec, type,
3301                         "Beep Playback Switch",
3302                         HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3303                         if (err < 0)
3304                                 return err;
3305         }
3306
3307         /* check to see if there is volume support for the amp */
3308         if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3309                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3310                         "Beep Playback Volume",
3311                         HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3312                         if (err < 0)
3313                                 return err;
3314         }
3315         return 0;
3316 }
3317
3318 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3319 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3320
3321 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3322                                         struct snd_ctl_elem_value *ucontrol)
3323 {
3324         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3325         ucontrol->value.integer.value[0] = codec->beep->enabled;
3326         return 0;
3327 }
3328
3329 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3330                                         struct snd_ctl_elem_value *ucontrol)
3331 {
3332         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3333         return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
3334 }
3335
3336 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3337         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3338         .info = stac92xx_dig_beep_switch_info,
3339         .get = stac92xx_dig_beep_switch_get,
3340         .put = stac92xx_dig_beep_switch_put,
3341 };
3342
3343 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3344 {
3345         return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3346                                          0, "Beep Playback Switch", 0);
3347 }
3348 #endif
3349
3350 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3351 {
3352         struct sigmatel_spec *spec = codec->spec;
3353         int i, j, err = 0;
3354
3355         for (i = 0; i < spec->num_muxes; i++) {
3356                 hda_nid_t nid;
3357                 unsigned int wcaps;
3358                 unsigned long val;
3359
3360                 nid = spec->mux_nids[i];
3361                 wcaps = get_wcaps(codec, nid);
3362                 if (!(wcaps & AC_WCAP_OUT_AMP))
3363                         continue;
3364
3365                 /* check whether already the same control was created as
3366                  * normal Capture Volume.
3367                  */
3368                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3369                 for (j = 0; j < spec->num_caps; j++) {
3370                         if (spec->capvols[j] == val)
3371                                 break;
3372                 }
3373                 if (j < spec->num_caps)
3374                         continue;
3375
3376                 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i,
3377                                                "Mux Capture Volume", val);
3378                 if (err < 0)
3379                         return err;
3380         }
3381         return 0;
3382 };
3383
3384 static const char *stac92xx_spdif_labels[3] = {
3385         "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3386 };
3387
3388 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3389 {
3390         struct sigmatel_spec *spec = codec->spec;
3391         struct hda_input_mux *spdif_mux = &spec->private_smux;
3392         const char **labels = spec->spdif_labels;
3393         int i, num_cons;
3394         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3395
3396         num_cons = snd_hda_get_connections(codec,
3397                                 spec->smux_nids[0],
3398                                 con_lst,
3399                                 HDA_MAX_NUM_INPUTS);
3400         if (num_cons <= 0)
3401                 return -EINVAL;
3402
3403         if (!labels)
3404                 labels = stac92xx_spdif_labels;
3405
3406         for (i = 0; i < num_cons; i++) {
3407                 strcpy(spdif_mux->items[spdif_mux->num_items].label, labels[i]);
3408                 spdif_mux->items[spdif_mux->num_items].index = i;
3409                 spdif_mux->num_items++;
3410         }
3411
3412         return 0;
3413 }
3414
3415 /* labels for dmic mux inputs */
3416 static const char *stac92xx_dmic_labels[5] = {
3417         "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3418         "Digital Mic 3", "Digital Mic 4"
3419 };
3420
3421 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
3422                                 hda_nid_t nid)
3423 {
3424         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3425         int i, nums;
3426
3427         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3428         for (i = 0; i < nums; i++)
3429                 if (conn[i] == nid)
3430                         return i;
3431         return -1;
3432 }
3433
3434 /* create a volume assigned to the given pin (only if supported) */
3435 /* return 1 if the volume control is created */
3436 static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
3437                                    const char *label, int idx, int direction)
3438 {
3439         unsigned int caps, nums;
3440         char name[32];
3441         int err;
3442
3443         if (direction == HDA_OUTPUT)
3444                 caps = AC_WCAP_OUT_AMP;
3445         else
3446                 caps = AC_WCAP_IN_AMP;
3447         if (!(get_wcaps(codec, nid) & caps))
3448                 return 0;
3449         caps = query_amp_caps(codec, nid, direction);
3450         nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
3451         if (!nums)
3452                 return 0;
3453         snprintf(name, sizeof(name), "%s Capture Volume", label);
3454         err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, name,
3455                                        HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction));
3456         if (err < 0)
3457                 return err;
3458         return 1;
3459 }
3460
3461 static const char *get_input_src_label(struct hda_codec *codec, hda_nid_t nid)
3462 {
3463         unsigned int def_conf;
3464
3465         def_conf = snd_hda_codec_get_pincfg(codec, nid);
3466
3467         switch (get_defcfg_device(def_conf)) {
3468         case AC_JACK_MIC_IN:
3469                 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_FIXED ||
3470                                 ((get_defcfg_location(def_conf) & 0xf0)
3471                                                 == AC_JACK_LOC_INTERNAL))
3472                         return "Internal Mic";
3473                 if ((get_defcfg_location(def_conf) & 0xf0)
3474                                                 == AC_JACK_LOC_SEPARATE)
3475                         return "Dock Mic";
3476                 if (get_defcfg_location(def_conf) == AC_JACK_LOC_REAR)
3477                         return "Rear Mic";
3478                 return "Mic";
3479         case AC_JACK_LINE_IN:
3480                 if ((get_defcfg_location(def_conf) & 0xf0)
3481                                                 == AC_JACK_LOC_SEPARATE)
3482                         return "Dock Line";
3483                 return "Line";
3484         case AC_JACK_AUX:
3485                 return "Aux";
3486         case AC_JACK_CD:
3487                 return "CD";
3488         case AC_JACK_SPDIF_IN:
3489                 return "SPDIF In";
3490         case AC_JACK_DIG_OTHER_IN:
3491                 return "Digital In";
3492         }
3493
3494         snd_printd("invalid inp pin %02x device config %08x", nid, def_conf);
3495         return NULL;
3496 }
3497
3498 static const char *get_unique_inp_src_label(struct hda_codec *codec,
3499                                 hda_nid_t nid)
3500 {
3501         int i, n;
3502         const char *label;
3503         struct sigmatel_spec *spec = codec->spec;
3504         struct hda_input_mux *imux = &spec->private_imux;
3505         struct hda_input_mux *dimux = &spec->private_dimux;
3506         struct unique_input_names *unames = &spec->private_u_inp_names;
3507
3508         label = get_input_src_label(codec, nid);
3509         n = 0;
3510
3511         for (i = 0; i < imux->num_items; i++) {
3512                 if (!strncmp(label, imux->items[i].label, strlen(label)))
3513                         n++;
3514         }
3515         if (snd_hda_get_bool_hint(codec, "separate_dmux") == 1) {
3516                 for (i = 0; i < dimux->num_items; i++) {
3517                         if (!strncmp(label, dimux->items[i].label,
3518                                         strlen(label)))
3519                                 n++;
3520                 }
3521         }
3522         if (n > 0 && unames->num < HDA_MAX_NUM_INPUTS) {
3523                 sprintf(&unames->uname[unames->num][0], "%.28s %d", label, n);
3524                 label = &unames->uname[unames->num][0];
3525                 unames->num++;
3526         }
3527
3528         return label;
3529 }
3530
3531 /* create playback/capture controls for input pins on dmic capable codecs */
3532 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3533                                                 const struct auto_pin_cfg *cfg)
3534 {
3535         struct sigmatel_spec *spec = codec->spec;
3536         struct hda_input_mux *imux = &spec->private_imux;
3537         struct hda_input_mux *dimux = &spec->private_dimux;
3538         int err, i;
3539         unsigned int def_conf;
3540
3541         strcpy(dimux->items[dimux->num_items].label, stac92xx_dmic_labels[0]);
3542         dimux->items[dimux->num_items].index = 0;
3543         dimux->num_items++;
3544
3545         for (i = 0; i < spec->num_dmics; i++) {
3546                 hda_nid_t nid;
3547                 int index;
3548                 const char *label;
3549
3550                 nid = spec->dmic_nids[i];
3551                 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
3552                         continue;
3553                 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3554                 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3555                         continue;
3556
3557                 index = get_connection_index(codec, spec->dmux_nids[0], nid);
3558                 if (index < 0)
3559                         continue;
3560
3561                 label = get_unique_inp_src_label(codec, nid);
3562                 if (label == NULL)
3563                         return -EINVAL;
3564
3565                 err = create_elem_capture_vol(codec, nid, label, 0, HDA_INPUT);
3566                 if (err < 0)
3567                         return err;
3568                 if (!err) {
3569                         err = create_elem_capture_vol(codec, nid, label, 0,
3570                                                       HDA_OUTPUT);
3571                         if (err < 0)
3572                                 return err;
3573                 }
3574
3575                 strcpy(dimux->items[dimux->num_items].label, label);
3576                 dimux->items[dimux->num_items].index = index;
3577                 dimux->num_items++;
3578                 if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1) {
3579                         strcpy(imux->items[imux->num_items].label, label);
3580                         imux->items[imux->num_items].index = index;
3581                         imux->num_items++;
3582                 }
3583         }
3584
3585         return 0;
3586 }
3587
3588 static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid,
3589                          hda_nid_t *fixed, hda_nid_t *ext)
3590 {
3591         unsigned int cfg;
3592
3593         if (!nid)
3594                 return 0;
3595         cfg = snd_hda_codec_get_pincfg(codec, nid);
3596         switch (get_defcfg_connect(cfg)) {
3597         case AC_JACK_PORT_FIXED:
3598                 if (*fixed)
3599                         return 1; /* already occupied */
3600                 *fixed = nid;
3601                 break;
3602         case AC_JACK_PORT_COMPLEX:
3603                 if (*ext)
3604                         return 1; /* already occupied */
3605                 *ext = nid;
3606                 break;
3607         }
3608         return 0;
3609 }
3610
3611 static int set_mic_route(struct hda_codec *codec,
3612                          struct sigmatel_mic_route *mic,
3613                          hda_nid_t pin)
3614 {
3615         struct sigmatel_spec *spec = codec->spec;
3616         struct auto_pin_cfg *cfg = &spec->autocfg;
3617         int i;
3618
3619         mic->pin = pin;
3620         for (i = 0; i < cfg->num_inputs; i++) {
3621                 if (pin == cfg->inputs[i].pin)
3622                         break;
3623         }
3624         if (i < cfg->num_inputs && cfg->inputs[i].type <= AUTO_PIN_FRONT_MIC) {
3625                 /* analog pin */
3626                 i = get_connection_index(codec, spec->mux_nids[0], pin);
3627                 if (i < 0)
3628                         return -1;
3629                 mic->mux_idx = i;
3630                 mic->dmux_idx = -1;
3631                 if (spec->dmux_nids)
3632                         mic->dmux_idx = get_connection_index(codec,
3633                                                              spec->dmux_nids[0],
3634                                                              spec->mux_nids[0]);
3635         }  else if (spec->dmux_nids) {
3636                 /* digital pin */
3637                 i = get_connection_index(codec, spec->dmux_nids[0], pin);
3638                 if (i < 0)
3639                         return -1;
3640                 mic->dmux_idx = i;
3641                 mic->mux_idx = -1;
3642                 if (spec->mux_nids)
3643                         mic->mux_idx = get_connection_index(codec,
3644                                                             spec->mux_nids[0],
3645                                                             spec->dmux_nids[0]);
3646         }
3647         return 0;
3648 }
3649
3650 /* return non-zero if the device is for automatic mic switch */
3651 static int stac_check_auto_mic(struct hda_codec *codec)
3652 {
3653         struct sigmatel_spec *spec = codec->spec;
3654         struct auto_pin_cfg *cfg = &spec->autocfg;
3655         hda_nid_t fixed, ext;
3656         int i;
3657
3658         for (i = 0; i < cfg->num_inputs; i++) {
3659                 if (cfg->inputs[i].type >= AUTO_PIN_LINE)
3660                         return 0; /* must be exclusively mics */
3661         }
3662         fixed = ext = 0;
3663         for (i = 0; i < cfg->num_inputs; i++)
3664                 if (check_mic_pin(codec, cfg->inputs[i].pin, &fixed, &ext))
3665                         return 0;
3666         for (i = 0; i < spec->num_dmics; i++)
3667                 if (check_mic_pin(codec, spec->dmic_nids[i], &fixed, &ext))
3668                         return 0;
3669         if (!fixed || !ext)
3670                 return 0;
3671         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
3672                 return 0; /* no unsol support */
3673         if (set_mic_route(codec, &spec->ext_mic, ext) ||
3674             set_mic_route(codec, &spec->int_mic, fixed))
3675                 return 0; /* something is wrong */
3676         return 1;
3677 }
3678
3679 /* create playback/capture controls for input pins */
3680 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3681 {
3682         struct sigmatel_spec *spec = codec->spec;
3683         struct hda_input_mux *imux = &spec->private_imux;
3684         int i, j, type_idx = 0;
3685         const char *label;
3686
3687         for (i = 0; i < cfg->num_inputs; i++) {
3688                 hda_nid_t nid = cfg->inputs[i].pin;
3689                 int index, err;
3690
3691                 index = -1;
3692                 for (j = 0; j < spec->num_muxes; j++) {
3693                         index = get_connection_index(codec, spec->mux_nids[j],
3694                                                      nid);
3695                         if (index >= 0)
3696                                 break;
3697                 }
3698                 if (index < 0)
3699                         continue;
3700
3701                 if (i > 0 && cfg->inputs[i].type == cfg->inputs[i - 1].type)
3702                         type_idx++;
3703                 else
3704                         type_idx = 0;
3705
3706                 label = get_unique_inp_src_label(codec, nid);
3707                 if (label == NULL)
3708                         return -EINVAL;
3709
3710                 err = create_elem_capture_vol(codec, nid,
3711                                               label, type_idx,
3712                                               HDA_INPUT);
3713                 if (err < 0)
3714                         return err;
3715
3716                 strcpy(imux->items[imux->num_items].label, label);
3717                 imux->items[imux->num_items].index = index;
3718                 imux->num_items++;
3719         }
3720         spec->num_analog_muxes = imux->num_items;
3721
3722         if (imux->num_items) {
3723                 /*
3724                  * Set the current input for the muxes.
3725                  * The STAC9221 has two input muxes with identical source
3726                  * NID lists.  Hopefully this won't get confused.
3727                  */
3728                 for (i = 0; i < spec->num_muxes; i++) {
3729                         snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3730                                                   AC_VERB_SET_CONNECT_SEL,
3731                                                   imux->items[0].index);
3732                 }
3733         }
3734
3735         return 0;
3736 }
3737
3738 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3739 {
3740         struct sigmatel_spec *spec = codec->spec;
3741         int i;
3742
3743         for (i = 0; i < spec->autocfg.line_outs; i++) {
3744                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3745                 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3746         }
3747 }
3748
3749 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3750 {
3751         struct sigmatel_spec *spec = codec->spec;
3752         int i;
3753
3754         for (i = 0; i < spec->autocfg.hp_outs; i++) {
3755                 hda_nid_t pin;
3756                 pin = spec->autocfg.hp_pins[i];
3757                 if (pin) /* connect to front */
3758                         stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3759         }
3760         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3761                 hda_nid_t pin;
3762                 pin = spec->autocfg.speaker_pins[i];
3763                 if (pin) /* connect to front */
3764                         stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3765         }
3766 }
3767
3768 static int is_dual_headphones(struct hda_codec *codec)
3769 {
3770         struct sigmatel_spec *spec = codec->spec;
3771         int i, valid_hps;
3772
3773         if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT ||
3774             spec->autocfg.hp_outs <= 1)
3775                 return 0;
3776         valid_hps = 0;
3777         for (i = 0; i < spec->autocfg.hp_outs; i++) {
3778                 hda_nid_t nid = spec->autocfg.hp_pins[i];
3779                 unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid);
3780                 if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE)
3781                         continue;
3782                 valid_hps++;
3783         }
3784         return (valid_hps > 1);
3785 }
3786
3787
3788 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3789 {
3790         struct sigmatel_spec *spec = codec->spec;
3791         int hp_swap = 0;
3792         int i, err;
3793
3794         if ((err = snd_hda_parse_pin_def_config(codec,
3795                                                 &spec->autocfg,
3796                                                 spec->dmic_nids)) < 0)
3797                 return err;
3798         if (! spec->autocfg.line_outs)
3799                 return 0; /* can't find valid pin config */
3800
3801         /* If we have no real line-out pin and multiple hp-outs, HPs should
3802          * be set up as multi-channel outputs.
3803          */
3804         if (is_dual_headphones(codec)) {
3805                 /* Copy hp_outs to line_outs, backup line_outs in
3806                  * speaker_outs so that the following routines can handle
3807                  * HP pins as primary outputs.
3808                  */
3809                 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3810                 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3811                        sizeof(spec->autocfg.line_out_pins));
3812                 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3813                 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3814                        sizeof(spec->autocfg.hp_pins));
3815                 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3816                 spec->autocfg.line_out_type = AUTO_PI