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