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