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