Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jbarnes...
[linux-2.6.git] / sound / pci / hda / patch_sigmatel.c
1 /*
2  * Universal Interface for Intel High Definition Audio Codec
3  *
4  * HD audio interface patch for SigmaTel STAC92xx
5  *
6  * Copyright (c) 2005 Embedded Alley Solutions, Inc.
7  * Matt Porter <mporter@embeddedalley.com>
8  *
9  * Based on patch_cmedia.c and patch_realtek.c
10  * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
11  *
12  *  This driver is free software; you can redistribute it and/or modify
13  *  it under the terms of the GNU General Public License as published by
14  *  the Free Software Foundation; either version 2 of the License, or
15  *  (at your option) any later version.
16  *
17  *  This driver is distributed in the hope that it will be useful,
18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  *  GNU General Public License for more details.
21  *
22  *  You should have received a copy of the GNU General Public License
23  *  along with this program; if not, write to the Free Software
24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
25  */
26
27 #include <linux/init.h>
28 #include <linux/delay.h>
29 #include <linux/slab.h>
30 #include <linux/pci.h>
31 #include <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_92HD83XXX_MODELS
98 };
99
100 enum {
101         STAC_92HD71BXX_AUTO,
102         STAC_92HD71BXX_REF,
103         STAC_DELL_M4_1,
104         STAC_DELL_M4_2,
105         STAC_DELL_M4_3,
106         STAC_HP_M4,
107         STAC_HP_DV5,
108         STAC_HP_HDX,
109         STAC_HP_DV4_1222NR,
110         STAC_92HD71BXX_MODELS
111 };
112
113 enum {
114         STAC_925x_AUTO,
115         STAC_925x_REF,
116         STAC_M1,
117         STAC_M1_2,
118         STAC_M2,
119         STAC_M2_2,
120         STAC_M3,
121         STAC_M5,
122         STAC_M6,
123         STAC_925x_MODELS
124 };
125
126 enum {
127         STAC_922X_AUTO,
128         STAC_D945_REF,
129         STAC_D945GTP3,
130         STAC_D945GTP5,
131         STAC_INTEL_MAC_V1,
132         STAC_INTEL_MAC_V2,
133         STAC_INTEL_MAC_V3,
134         STAC_INTEL_MAC_V4,
135         STAC_INTEL_MAC_V5,
136         STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
137                               * is given, one of the above models will be
138                               * chosen according to the subsystem id. */
139         /* for backward compatibility */
140         STAC_MACMINI,
141         STAC_MACBOOK,
142         STAC_MACBOOK_PRO_V1,
143         STAC_MACBOOK_PRO_V2,
144         STAC_IMAC_INTEL,
145         STAC_IMAC_INTEL_20,
146         STAC_ECS_202,
147         STAC_922X_DELL_D81,
148         STAC_922X_DELL_D82,
149         STAC_922X_DELL_M81,
150         STAC_922X_DELL_M82,
151         STAC_922X_MODELS
152 };
153
154 enum {
155         STAC_927X_AUTO,
156         STAC_D965_REF_NO_JD, /* no jack-detection */
157         STAC_D965_REF,
158         STAC_D965_3ST,
159         STAC_D965_5ST,
160         STAC_D965_5ST_NO_FP,
161         STAC_DELL_3ST,
162         STAC_DELL_BIOS,
163         STAC_927X_VOLKNOB,
164         STAC_927X_MODELS
165 };
166
167 enum {
168         STAC_9872_AUTO,
169         STAC_9872_VAIO,
170         STAC_9872_MODELS
171 };
172
173 struct sigmatel_event {
174         hda_nid_t nid;
175         unsigned char type;
176         unsigned char tag;
177         int data;
178 };
179
180 struct sigmatel_jack {
181         hda_nid_t nid;
182         int type;
183         struct snd_jack *jack;
184 };
185
186 struct sigmatel_mic_route {
187         hda_nid_t pin;
188         signed char mux_idx;
189         signed char dmux_idx;
190 };
191
192 struct sigmatel_spec {
193         struct snd_kcontrol_new *mixers[4];
194         unsigned int num_mixers;
195
196         int board_config;
197         unsigned int eapd_switch: 1;
198         unsigned int surr_switch: 1;
199         unsigned int alt_switch: 1;
200         unsigned int hp_detect: 1;
201         unsigned int spdif_mute: 1;
202         unsigned int check_volume_offset:1;
203         unsigned int auto_mic:1;
204
205         /* gpio lines */
206         unsigned int eapd_mask;
207         unsigned int gpio_mask;
208         unsigned int gpio_dir;
209         unsigned int gpio_data;
210         unsigned int gpio_mute;
211         unsigned int gpio_led;
212         unsigned int gpio_led_polarity;
213
214         /* stream */
215         unsigned int stream_delay;
216
217         /* analog loopback */
218         struct snd_kcontrol_new *aloopback_ctl;
219         unsigned char aloopback_mask;
220         unsigned char aloopback_shift;
221
222         /* power management */
223         unsigned int num_pwrs;
224         unsigned int *pwr_mapping;
225         hda_nid_t *pwr_nids;
226         hda_nid_t *dac_list;
227
228         /* jack detection */
229         struct snd_array jacks;
230
231         /* events */
232         struct snd_array events;
233
234         /* playback */
235         struct hda_input_mux *mono_mux;
236         unsigned int cur_mmux;
237         struct hda_multi_out multiout;
238         hda_nid_t dac_nids[5];
239         hda_nid_t hp_dacs[5];
240         hda_nid_t speaker_dacs[5];
241
242         int volume_offset;
243
244         /* capture */
245         hda_nid_t *adc_nids;
246         unsigned int num_adcs;
247         hda_nid_t *mux_nids;
248         unsigned int num_muxes;
249         hda_nid_t *dmic_nids;
250         unsigned int num_dmics;
251         hda_nid_t *dmux_nids;
252         unsigned int num_dmuxes;
253         hda_nid_t *smux_nids;
254         unsigned int num_smuxes;
255         unsigned int num_analog_muxes;
256
257         unsigned long *capvols; /* amp-volume attr: HDA_COMPOSE_AMP_VAL() */
258         unsigned long *capsws; /* amp-mute attr: HDA_COMPOSE_AMP_VAL() */
259         unsigned int num_caps; /* number of capture volume/switch elements */
260
261         struct sigmatel_mic_route ext_mic;
262         struct sigmatel_mic_route int_mic;
263
264         const char **spdif_labels;
265
266         hda_nid_t dig_in_nid;
267         hda_nid_t mono_nid;
268         hda_nid_t anabeep_nid;
269         hda_nid_t digbeep_nid;
270
271         /* pin widgets */
272         hda_nid_t *pin_nids;
273         unsigned int num_pins;
274
275         /* codec specific stuff */
276         struct hda_verb *init;
277         struct snd_kcontrol_new *mixer;
278
279         /* capture source */
280         struct hda_input_mux *dinput_mux;
281         unsigned int cur_dmux[2];
282         struct hda_input_mux *input_mux;
283         unsigned int cur_mux[3];
284         struct hda_input_mux *sinput_mux;
285         unsigned int cur_smux[2];
286         unsigned int cur_amux;
287         hda_nid_t *amp_nids;
288         unsigned int powerdown_adcs;
289
290         /* i/o switches */
291         unsigned int io_switch[2];
292         unsigned int clfe_swap;
293         hda_nid_t line_switch;  /* shared line-in for input and output */
294         hda_nid_t mic_switch;   /* shared mic-in for input and output */
295         hda_nid_t hp_switch; /* NID of HP as line-out */
296         unsigned int aloopback;
297
298         struct hda_pcm pcm_rec[2];      /* PCM information */
299
300         /* dynamic controls and input_mux */
301         struct auto_pin_cfg autocfg;
302         struct snd_array kctls;
303         struct hda_input_mux private_dimux;
304         struct hda_input_mux private_imux;
305         struct hda_input_mux private_smux;
306         struct hda_input_mux private_mono_mux;
307 };
308
309 static hda_nid_t stac9200_adc_nids[1] = {
310         0x03,
311 };
312
313 static hda_nid_t stac9200_mux_nids[1] = {
314         0x0c,
315 };
316
317 static hda_nid_t stac9200_dac_nids[1] = {
318         0x02,
319 };
320
321 static hda_nid_t stac92hd73xx_pwr_nids[8] = {
322         0x0a, 0x0b, 0x0c, 0xd, 0x0e,
323         0x0f, 0x10, 0x11
324 };
325
326 static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
327         0x26, 0,
328 };
329
330 static hda_nid_t stac92hd73xx_adc_nids[2] = {
331         0x1a, 0x1b
332 };
333
334 #define STAC92HD73XX_NUM_DMICS  2
335 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
336         0x13, 0x14, 0
337 };
338
339 #define STAC92HD73_DAC_COUNT 5
340
341 static hda_nid_t stac92hd73xx_mux_nids[2] = {
342         0x20, 0x21,
343 };
344
345 static hda_nid_t stac92hd73xx_dmux_nids[2] = {
346         0x20, 0x21,
347 };
348
349 static hda_nid_t stac92hd73xx_smux_nids[2] = {
350         0x22, 0x23,
351 };
352
353 #define STAC92HD73XX_NUM_CAPS   2
354 static unsigned long stac92hd73xx_capvols[] = {
355         HDA_COMPOSE_AMP_VAL(0x20, 3, 0, HDA_OUTPUT),
356         HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
357 };
358 #define stac92hd73xx_capsws     stac92hd73xx_capvols
359
360 #define STAC92HD83_DAC_COUNT 3
361
362 static hda_nid_t stac92hd83xxx_mux_nids[2] = {
363         0x17, 0x18,
364 };
365
366 static hda_nid_t stac92hd83xxx_adc_nids[2] = {
367         0x15, 0x16,
368 };
369
370 static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
371         0xa, 0xb, 0xd, 0xe,
372 };
373
374 static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
375         0x1e, 0,
376 };
377
378 static unsigned int stac92hd83xxx_pwr_mapping[4] = {
379         0x03, 0x0c, 0x20, 0x40,
380 };
381
382 #define STAC92HD83XXX_NUM_CAPS  2
383 static unsigned long stac92hd83xxx_capvols[] = {
384         HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
385         HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_OUTPUT),
386 };
387 #define stac92hd83xxx_capsws    stac92hd83xxx_capvols
388
389 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
390         0x0a, 0x0d, 0x0f
391 };
392
393 static hda_nid_t stac92hd71bxx_adc_nids[2] = {
394         0x12, 0x13,
395 };
396
397 static hda_nid_t stac92hd71bxx_mux_nids[2] = {
398         0x1a, 0x1b
399 };
400
401 static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
402         0x1c, 0x1d,
403 };
404
405 static hda_nid_t stac92hd71bxx_smux_nids[2] = {
406         0x24, 0x25,
407 };
408
409 #define STAC92HD71BXX_NUM_DMICS 2
410 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
411         0x18, 0x19, 0
412 };
413
414 static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
415         0x22, 0
416 };
417
418 #define STAC92HD71BXX_NUM_CAPS          2
419 static unsigned long stac92hd71bxx_capvols[] = {
420         HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
421         HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
422 };
423 #define stac92hd71bxx_capsws    stac92hd71bxx_capvols
424
425 static hda_nid_t stac925x_adc_nids[1] = {
426         0x03,
427 };
428
429 static hda_nid_t stac925x_mux_nids[1] = {
430         0x0f,
431 };
432
433 static hda_nid_t stac925x_dac_nids[1] = {
434         0x02,
435 };
436
437 #define STAC925X_NUM_DMICS      1
438 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
439         0x15, 0
440 };
441
442 static hda_nid_t stac925x_dmux_nids[1] = {
443         0x14,
444 };
445
446 static unsigned long stac925x_capvols[] = {
447         HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
448 };
449 static unsigned long stac925x_capsws[] = {
450         HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
451 };
452
453 static hda_nid_t stac922x_adc_nids[2] = {
454         0x06, 0x07,
455 };
456
457 static hda_nid_t stac922x_mux_nids[2] = {
458         0x12, 0x13,
459 };
460
461 #define STAC922X_NUM_CAPS       2
462 static unsigned long stac922x_capvols[] = {
463         HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_INPUT),
464         HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
465 };
466 #define stac922x_capsws         stac922x_capvols
467
468 static hda_nid_t stac927x_slave_dig_outs[2] = {
469         0x1f, 0,
470 };
471
472 static hda_nid_t stac927x_adc_nids[3] = {
473         0x07, 0x08, 0x09
474 };
475
476 static hda_nid_t stac927x_mux_nids[3] = {
477         0x15, 0x16, 0x17
478 };
479
480 static hda_nid_t stac927x_smux_nids[1] = {
481         0x21,
482 };
483
484 static hda_nid_t stac927x_dac_nids[6] = {
485         0x02, 0x03, 0x04, 0x05, 0x06, 0
486 };
487
488 static hda_nid_t stac927x_dmux_nids[1] = {
489         0x1b,
490 };
491
492 #define STAC927X_NUM_DMICS 2
493 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
494         0x13, 0x14, 0
495 };
496
497 #define STAC927X_NUM_CAPS       3
498 static unsigned long stac927x_capvols[] = {
499         HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
500         HDA_COMPOSE_AMP_VAL(0x19, 3, 0, HDA_INPUT),
501         HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_INPUT),
502 };
503 static unsigned long stac927x_capsws[] = {
504         HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
505         HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
506         HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
507 };
508
509 static const char *stac927x_spdif_labels[5] = {
510         "Digital Playback", "ADAT", "Analog Mux 1",
511         "Analog Mux 2", "Analog Mux 3"
512 };
513
514 static hda_nid_t stac9205_adc_nids[2] = {
515         0x12, 0x13
516 };
517
518 static hda_nid_t stac9205_mux_nids[2] = {
519         0x19, 0x1a
520 };
521
522 static hda_nid_t stac9205_dmux_nids[1] = {
523         0x1d,
524 };
525
526 static hda_nid_t stac9205_smux_nids[1] = {
527         0x21,
528 };
529
530 #define STAC9205_NUM_DMICS      2
531 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
532         0x17, 0x18, 0
533 };
534
535 #define STAC9205_NUM_CAPS       2
536 static unsigned long stac9205_capvols[] = {
537         HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_INPUT),
538         HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_INPUT),
539 };
540 static unsigned long stac9205_capsws[] = {
541         HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
542         HDA_COMPOSE_AMP_VAL(0x1e, 3, 0, HDA_OUTPUT),
543 };
544
545 static hda_nid_t stac9200_pin_nids[8] = {
546         0x08, 0x09, 0x0d, 0x0e, 
547         0x0f, 0x10, 0x11, 0x12,
548 };
549
550 static hda_nid_t stac925x_pin_nids[8] = {
551         0x07, 0x08, 0x0a, 0x0b, 
552         0x0c, 0x0d, 0x10, 0x11,
553 };
554
555 static hda_nid_t stac922x_pin_nids[10] = {
556         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
557         0x0f, 0x10, 0x11, 0x15, 0x1b,
558 };
559
560 static hda_nid_t stac92hd73xx_pin_nids[13] = {
561         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
562         0x0f, 0x10, 0x11, 0x12, 0x13,
563         0x14, 0x22, 0x23
564 };
565
566 static hda_nid_t stac92hd83xxx_pin_nids[10] = {
567         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
568         0x0f, 0x10, 0x11, 0x1f, 0x20,
569 };
570
571 static hda_nid_t stac92hd88xxx_pin_nids[10] = {
572         0x0a, 0x0b, 0x0c, 0x0d,
573         0x0f, 0x11, 0x1f, 0x20,
574 };
575
576 #define STAC92HD71BXX_NUM_PINS 13
577 static hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
578         0x0a, 0x0b, 0x0c, 0x0d, 0x00,
579         0x00, 0x14, 0x18, 0x19, 0x1e,
580         0x1f, 0x20, 0x27
581 };
582 static hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
583         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
584         0x0f, 0x14, 0x18, 0x19, 0x1e,
585         0x1f, 0x20, 0x27
586 };
587
588 static hda_nid_t stac927x_pin_nids[14] = {
589         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
590         0x0f, 0x10, 0x11, 0x12, 0x13,
591         0x14, 0x21, 0x22, 0x23,
592 };
593
594 static hda_nid_t stac9205_pin_nids[12] = {
595         0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
596         0x0f, 0x14, 0x16, 0x17, 0x18,
597         0x21, 0x22,
598 };
599
600 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
601                                    struct snd_ctl_elem_info *uinfo)
602 {
603         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
604         struct sigmatel_spec *spec = codec->spec;
605         return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
606 }
607
608 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
609                                   struct snd_ctl_elem_value *ucontrol)
610 {
611         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
612         struct sigmatel_spec *spec = codec->spec;
613         unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
614
615         ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
616         return 0;
617 }
618
619 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
620                                   struct snd_ctl_elem_value *ucontrol)
621 {
622         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
623         struct sigmatel_spec *spec = codec->spec;
624         unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
625
626         return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
627                         spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
628 }
629
630 static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
631                                    struct snd_ctl_elem_info *uinfo)
632 {
633         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
634         struct sigmatel_spec *spec = codec->spec;
635         return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
636 }
637
638 static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
639                                   struct snd_ctl_elem_value *ucontrol)
640 {
641         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
642         struct sigmatel_spec *spec = codec->spec;
643         unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
644
645         ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
646         return 0;
647 }
648
649 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
650                                   struct snd_ctl_elem_value *ucontrol)
651 {
652         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
653         struct sigmatel_spec *spec = codec->spec;
654         struct hda_input_mux *smux = &spec->private_smux;
655         unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
656         int err, val;
657         hda_nid_t nid;
658
659         err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
660                         spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
661         if (err < 0)
662                 return err;
663
664         if (spec->spdif_mute) {
665                 if (smux_idx == 0)
666                         nid = spec->multiout.dig_out_nid;
667                 else
668                         nid = codec->slave_dig_outs[smux_idx - 1];
669                 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
670                         val = HDA_AMP_MUTE;
671                 else
672                         val = 0;
673                 /* un/mute SPDIF out */
674                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
675                                          HDA_AMP_MUTE, val);
676         }
677         return 0;
678 }
679
680 static unsigned int stac92xx_vref_set(struct hda_codec *codec,
681                                         hda_nid_t nid, unsigned int new_vref)
682 {
683         int error;
684         unsigned int pincfg;
685         pincfg = snd_hda_codec_read(codec, nid, 0,
686                                 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
687
688         pincfg &= 0xff;
689         pincfg &= ~(AC_PINCTL_VREFEN | AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
690         pincfg |= new_vref;
691
692         if (new_vref == AC_PINCTL_VREF_HIZ)
693                 pincfg |= AC_PINCTL_OUT_EN;
694         else
695                 pincfg |= AC_PINCTL_IN_EN;
696
697         error = snd_hda_codec_write_cache(codec, nid, 0,
698                                         AC_VERB_SET_PIN_WIDGET_CONTROL, pincfg);
699         if (error < 0)
700                 return error;
701         else
702                 return 1;
703 }
704
705 static unsigned int stac92xx_vref_get(struct hda_codec *codec, hda_nid_t nid)
706 {
707         unsigned int vref;
708         vref = snd_hda_codec_read(codec, nid, 0,
709                                 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
710         vref &= AC_PINCTL_VREFEN;
711         return vref;
712 }
713
714 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
715 {
716         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
717         struct sigmatel_spec *spec = codec->spec;
718         return snd_hda_input_mux_info(spec->input_mux, uinfo);
719 }
720
721 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
722 {
723         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
724         struct sigmatel_spec *spec = codec->spec;
725         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
726
727         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
728         return 0;
729 }
730
731 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
732 {
733         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
734         struct sigmatel_spec *spec = codec->spec;
735         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
736         const struct hda_input_mux *imux = spec->input_mux;
737         unsigned int idx, prev_idx;
738
739         idx = ucontrol->value.enumerated.item[0];
740         if (idx >= imux->num_items)
741                 idx = imux->num_items - 1;
742         prev_idx = spec->cur_mux[adc_idx];
743         if (prev_idx == idx)
744                 return 0;
745         if (idx < spec->num_analog_muxes) {
746                 snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0,
747                                           AC_VERB_SET_CONNECT_SEL,
748                                           imux->items[idx].index);
749                 if (prev_idx >= spec->num_analog_muxes) {
750                         imux = spec->dinput_mux;
751                         /* 0 = analog */
752                         snd_hda_codec_write_cache(codec,
753                                                   spec->dmux_nids[adc_idx], 0,
754                                                   AC_VERB_SET_CONNECT_SEL,
755                                                   imux->items[0].index);
756                 }
757         } else {
758                 imux = spec->dinput_mux;
759                 snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0,
760                                           AC_VERB_SET_CONNECT_SEL,
761                                           imux->items[idx - 1].index);
762         }
763         spec->cur_mux[adc_idx] = idx;
764         return 1;
765 }
766
767 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
768         struct snd_ctl_elem_info *uinfo)
769 {
770         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
771         struct sigmatel_spec *spec = codec->spec;
772         return snd_hda_input_mux_info(spec->mono_mux, uinfo);
773 }
774
775 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
776         struct snd_ctl_elem_value *ucontrol)
777 {
778         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
779         struct sigmatel_spec *spec = codec->spec;
780
781         ucontrol->value.enumerated.item[0] = spec->cur_mmux;
782         return 0;
783 }
784
785 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
786         struct snd_ctl_elem_value *ucontrol)
787 {
788         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
789         struct sigmatel_spec *spec = codec->spec;
790
791         return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
792                                      spec->mono_nid, &spec->cur_mmux);
793 }
794
795 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
796
797 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
798         struct snd_ctl_elem_value *ucontrol)
799 {
800         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
801         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
802         struct sigmatel_spec *spec = codec->spec;
803
804         ucontrol->value.integer.value[0] = !!(spec->aloopback &
805                                               (spec->aloopback_mask << idx));
806         return 0;
807 }
808
809 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
810                 struct snd_ctl_elem_value *ucontrol)
811 {
812         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
813         struct sigmatel_spec *spec = codec->spec;
814         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
815         unsigned int dac_mode;
816         unsigned int val, idx_val;
817
818         idx_val = spec->aloopback_mask << idx;
819         if (ucontrol->value.integer.value[0])
820                 val = spec->aloopback | idx_val;
821         else
822                 val = spec->aloopback & ~idx_val;
823         if (spec->aloopback == val)
824                 return 0;
825
826         spec->aloopback = val;
827
828         /* Only return the bits defined by the shift value of the
829          * first two bytes of the mask
830          */
831         dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
832                                       kcontrol->private_value & 0xFFFF, 0x0);
833         dac_mode >>= spec->aloopback_shift;
834
835         if (spec->aloopback & idx_val) {
836                 snd_hda_power_up(codec);
837                 dac_mode |= idx_val;
838         } else {
839                 snd_hda_power_down(codec);
840                 dac_mode &= ~idx_val;
841         }
842
843         snd_hda_codec_write_cache(codec, codec->afg, 0,
844                 kcontrol->private_value >> 16, dac_mode);
845
846         return 1;
847 }
848
849 static struct hda_verb stac9200_core_init[] = {
850         /* set dac0mux for dac converter */
851         { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
852         {}
853 };
854
855 static struct hda_verb stac9200_eapd_init[] = {
856         /* set dac0mux for dac converter */
857         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
858         {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
859         {}
860 };
861
862 static struct hda_verb dell_eq_core_init[] = {
863         /* set master volume to max value without distortion
864          * and direct control */
865         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
866         {}
867 };
868
869 static struct hda_verb stac92hd73xx_core_init[] = {
870         /* set master volume and direct control */
871         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
872         {}
873 };
874
875 static struct hda_verb stac92hd83xxx_core_init[] = {
876         /* power state controls amps */
877         { 0x01, AC_VERB_SET_EAPD, 1 << 2},
878         {}
879 };
880
881 static struct hda_verb stac92hd71bxx_core_init[] = {
882         /* set master volume and direct control */
883         { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
884         {}
885 };
886
887 static struct hda_verb stac92hd71bxx_unmute_core_init[] = {
888         /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
889         { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
890         { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
891         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
892         {}
893 };
894
895 static struct hda_verb stac925x_core_init[] = {
896         /* set dac0mux for dac converter */
897         { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
898         /* mute the master volume */
899         { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
900         {}
901 };
902
903 static struct hda_verb stac922x_core_init[] = {
904         /* set master volume and direct control */      
905         { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
906         {}
907 };
908
909 static struct hda_verb d965_core_init[] = {
910         /* set master volume and direct control */      
911         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
912         /* unmute node 0x1b */
913         { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
914         /* select node 0x03 as DAC */   
915         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
916         {}
917 };
918
919 static struct hda_verb dell_3st_core_init[] = {
920         /* don't set delta bit */
921         {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
922         /* unmute node 0x1b */
923         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
924         /* select node 0x03 as DAC */
925         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
926         {}
927 };
928
929 static struct hda_verb stac927x_core_init[] = {
930         /* set master volume and direct control */      
931         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
932         /* enable analog pc beep path */
933         { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
934         {}
935 };
936
937 static struct hda_verb stac927x_volknob_core_init[] = {
938         /* don't set delta bit */
939         {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
940         /* enable analog pc beep path */
941         {0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
942         {}
943 };
944
945 static struct hda_verb stac9205_core_init[] = {
946         /* set master volume and direct control */      
947         { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
948         /* enable analog pc beep path */
949         { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
950         {}
951 };
952
953 #define STAC_MONO_MUX \
954         { \
955                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
956                 .name = "Mono Mux", \
957                 .count = 1, \
958                 .info = stac92xx_mono_mux_enum_info, \
959                 .get = stac92xx_mono_mux_enum_get, \
960                 .put = stac92xx_mono_mux_enum_put, \
961         }
962
963 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
964         { \
965                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
966                 .name  = "Analog Loopback", \
967                 .count = cnt, \
968                 .info  = stac92xx_aloopback_info, \
969                 .get   = stac92xx_aloopback_get, \
970                 .put   = stac92xx_aloopback_put, \
971                 .private_value = verb_read | (verb_write << 16), \
972         }
973
974 #define DC_BIAS(xname, idx, nid) \
975         { \
976                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
977                 .name = xname, \
978                 .index = idx, \
979                 .info = stac92xx_dc_bias_info, \
980                 .get = stac92xx_dc_bias_get, \
981                 .put = stac92xx_dc_bias_put, \
982                 .private_value = nid, \
983         }
984
985 static struct snd_kcontrol_new stac9200_mixer[] = {
986         HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
987         HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
988         HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
989         HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
990         { } /* end */
991 };
992
993 static struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
994         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
995         {}
996 };
997
998 static struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = {
999         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1000         {}
1001 };
1002
1003 static struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
1004         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1005         {}
1006 };
1007
1008
1009 static struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
1010         STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
1011 };
1012
1013 static struct snd_kcontrol_new stac925x_mixer[] = {
1014         HDA_CODEC_VOLUME("Master Playback Volume", 0x0e, 0, HDA_OUTPUT),
1015         HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
1016         { } /* end */
1017 };
1018
1019 static struct snd_kcontrol_new stac9205_loopback[] = {
1020         STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1021         {}
1022 };
1023
1024 static struct snd_kcontrol_new stac927x_loopback[] = {
1025         STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1026         {}
1027 };
1028
1029 static struct snd_kcontrol_new stac_dmux_mixer = {
1030         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1031         .name = "Digital Input Source",
1032         /* count set later */
1033         .info = stac92xx_dmux_enum_info,
1034         .get = stac92xx_dmux_enum_get,
1035         .put = stac92xx_dmux_enum_put,
1036 };
1037
1038 static struct snd_kcontrol_new stac_smux_mixer = {
1039         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1040         .name = "IEC958 Playback Source",
1041         /* count set later */
1042         .info = stac92xx_smux_enum_info,
1043         .get = stac92xx_smux_enum_get,
1044         .put = stac92xx_smux_enum_put,
1045 };
1046
1047 static const char *slave_vols[] = {
1048         "Front Playback Volume",
1049         "Surround Playback Volume",
1050         "Center Playback Volume",
1051         "LFE Playback Volume",
1052         "Side Playback Volume",
1053         "Headphone Playback Volume",
1054         "Speaker Playback Volume",
1055         NULL
1056 };
1057
1058 static const char *slave_sws[] = {
1059         "Front Playback Switch",
1060         "Surround Playback Switch",
1061         "Center Playback Switch",
1062         "LFE Playback Switch",
1063         "Side Playback Switch",
1064         "Headphone Playback Switch",
1065         "Speaker Playback Switch",
1066         "IEC958 Playback Switch",
1067         NULL
1068 };
1069
1070 static void stac92xx_free_kctls(struct hda_codec *codec);
1071 static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
1072
1073 static int stac92xx_build_controls(struct hda_codec *codec)
1074 {
1075         struct sigmatel_spec *spec = codec->spec;
1076         struct auto_pin_cfg *cfg = &spec->autocfg;
1077         hda_nid_t nid;
1078         int err;
1079         int i;
1080
1081         if (spec->mixer) {
1082                 err = snd_hda_add_new_ctls(codec, spec->mixer);
1083                 if (err < 0)
1084                         return err;
1085         }
1086
1087         for (i = 0; i < spec->num_mixers; i++) {
1088                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1089                 if (err < 0)
1090                         return err;
1091         }
1092         if (!spec->auto_mic && spec->num_dmuxes > 0 &&
1093             snd_hda_get_bool_hint(codec, "separate_dmux") == 1) {
1094                 stac_dmux_mixer.count = spec->num_dmuxes;
1095                 err = snd_hda_ctl_add(codec, 0,
1096                                   snd_ctl_new1(&stac_dmux_mixer, codec));
1097                 if (err < 0)
1098                         return err;
1099         }
1100         if (spec->num_smuxes > 0) {
1101                 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1102                 struct hda_input_mux *smux = &spec->private_smux;
1103                 /* check for mute support on SPDIF out */
1104                 if (wcaps & AC_WCAP_OUT_AMP) {
1105                         smux->items[smux->num_items].label = "Off";
1106                         smux->items[smux->num_items].index = 0;
1107                         smux->num_items++;
1108                         spec->spdif_mute = 1;
1109                 }
1110                 stac_smux_mixer.count = spec->num_smuxes;
1111                 err = snd_hda_ctl_add(codec, 0,
1112                                   snd_ctl_new1(&stac_smux_mixer, codec));
1113                 if (err < 0)
1114                         return err;
1115         }
1116
1117         if (spec->multiout.dig_out_nid) {
1118                 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1119                 if (err < 0)
1120                         return err;
1121                 err = snd_hda_create_spdif_share_sw(codec,
1122                                                     &spec->multiout);
1123                 if (err < 0)
1124                         return err;
1125                 spec->multiout.share_spdif = 1;
1126         }
1127         if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1128                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1129                 if (err < 0)
1130                         return err;
1131         }
1132
1133         /* if we have no master control, let's create it */
1134         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1135                 unsigned int vmaster_tlv[4];
1136                 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1137                                         HDA_OUTPUT, vmaster_tlv);
1138                 /* correct volume offset */
1139                 vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
1140                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1141                                           vmaster_tlv, slave_vols);
1142                 if (err < 0)
1143                         return err;
1144         }
1145         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1146                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1147                                           NULL, slave_sws);
1148                 if (err < 0)
1149                         return err;
1150         }
1151
1152         if (spec->aloopback_ctl &&
1153             snd_hda_get_bool_hint(codec, "loopback") == 1) {
1154                 err = snd_hda_add_new_ctls(codec, spec->aloopback_ctl);
1155                 if (err < 0)
1156                         return err;
1157         }
1158
1159         stac92xx_free_kctls(codec); /* no longer needed */
1160
1161         /* create jack input elements */
1162         if (spec->hp_detect) {
1163                 for (i = 0; i < cfg->hp_outs; i++) {
1164                         int type = SND_JACK_HEADPHONE;
1165                         nid = cfg->hp_pins[i];
1166                         /* jack detection */
1167                         if (cfg->hp_outs == i)
1168                                 type |= SND_JACK_LINEOUT;
1169                         err = stac92xx_add_jack(codec, nid, type);
1170                         if (err < 0)
1171                                 return err;
1172                 }
1173         }
1174         for (i = 0; i < cfg->line_outs; i++) {
1175                 err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
1176                                         SND_JACK_LINEOUT);
1177                 if (err < 0)
1178                         return err;
1179         }
1180         for (i = 0; i < AUTO_PIN_LAST; i++) {
1181                 nid = cfg->input_pins[i];
1182                 if (nid) {
1183                         err = stac92xx_add_jack(codec, nid,
1184                                                 SND_JACK_MICROPHONE);
1185                         if (err < 0)
1186                                 return err;
1187                 }
1188         }
1189
1190         return 0;       
1191 }
1192
1193 static unsigned int ref9200_pin_configs[8] = {
1194         0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1195         0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1196 };
1197
1198 static unsigned int gateway9200_m4_pin_configs[8] = {
1199         0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1200         0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1201 };
1202 static unsigned int gateway9200_m4_2_pin_configs[8] = {
1203         0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1204         0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1205 };
1206
1207 /*
1208     STAC 9200 pin configs for
1209     102801A8
1210     102801DE
1211     102801E8
1212 */
1213 static unsigned int dell9200_d21_pin_configs[8] = {
1214         0x400001f0, 0x400001f1, 0x02214030, 0x01014010, 
1215         0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1216 };
1217
1218 /* 
1219     STAC 9200 pin configs for
1220     102801C0
1221     102801C1
1222 */
1223 static unsigned int dell9200_d22_pin_configs[8] = {
1224         0x400001f0, 0x400001f1, 0x0221401f, 0x01014010, 
1225         0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1226 };
1227
1228 /* 
1229     STAC 9200 pin configs for
1230     102801C4 (Dell Dimension E310)
1231     102801C5
1232     102801C7
1233     102801D9
1234     102801DA
1235     102801E3
1236 */
1237 static unsigned int dell9200_d23_pin_configs[8] = {
1238         0x400001f0, 0x400001f1, 0x0221401f, 0x01014010, 
1239         0x01813020, 0x01a19021, 0x90100140, 0x400001f2, 
1240 };
1241
1242
1243 /* 
1244     STAC 9200-32 pin configs for
1245     102801B5 (Dell Inspiron 630m)
1246     102801D8 (Dell Inspiron 640m)
1247 */
1248 static unsigned int dell9200_m21_pin_configs[8] = {
1249         0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1250         0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1251 };
1252
1253 /* 
1254     STAC 9200-32 pin configs for
1255     102801C2 (Dell Latitude D620)
1256     102801C8 
1257     102801CC (Dell Latitude D820)
1258     102801D4 
1259     102801D6 
1260 */
1261 static unsigned int dell9200_m22_pin_configs[8] = {
1262         0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310, 
1263         0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1264 };
1265
1266 /* 
1267     STAC 9200-32 pin configs for
1268     102801CE (Dell XPS M1710)
1269     102801CF (Dell Precision M90)
1270 */
1271 static unsigned int dell9200_m23_pin_configs[8] = {
1272         0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1273         0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1274 };
1275
1276 /*
1277     STAC 9200-32 pin configs for 
1278     102801C9
1279     102801CA
1280     102801CB (Dell Latitude 120L)
1281     102801D3
1282 */
1283 static unsigned int dell9200_m24_pin_configs[8] = {
1284         0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310, 
1285         0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe, 
1286 };
1287
1288 /*
1289     STAC 9200-32 pin configs for
1290     102801BD (Dell Inspiron E1505n)
1291     102801EE
1292     102801EF
1293 */
1294 static unsigned int dell9200_m25_pin_configs[8] = {
1295         0x40c003fa, 0x01441340, 0x0421121f, 0x90170310, 
1296         0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1297 };
1298
1299 /*
1300     STAC 9200-32 pin configs for
1301     102801F5 (Dell Inspiron 1501)
1302     102801F6
1303 */
1304 static unsigned int dell9200_m26_pin_configs[8] = {
1305         0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310, 
1306         0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1307 };
1308
1309 /*
1310     STAC 9200-32
1311     102801CD (Dell Inspiron E1705/9400)
1312 */
1313 static unsigned int dell9200_m27_pin_configs[8] = {
1314         0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1315         0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1316 };
1317
1318 static unsigned int oqo9200_pin_configs[8] = {
1319         0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1320         0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1321 };
1322
1323
1324 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1325         [STAC_REF] = ref9200_pin_configs,
1326         [STAC_9200_OQO] = oqo9200_pin_configs,
1327         [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1328         [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1329         [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1330         [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1331         [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1332         [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1333         [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1334         [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1335         [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1336         [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1337         [STAC_9200_M4] = gateway9200_m4_pin_configs,
1338         [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1339         [STAC_9200_PANASONIC] = ref9200_pin_configs,
1340 };
1341
1342 static const char *stac9200_models[STAC_9200_MODELS] = {
1343         [STAC_AUTO] = "auto",
1344         [STAC_REF] = "ref",
1345         [STAC_9200_OQO] = "oqo",
1346         [STAC_9200_DELL_D21] = "dell-d21",
1347         [STAC_9200_DELL_D22] = "dell-d22",
1348         [STAC_9200_DELL_D23] = "dell-d23",
1349         [STAC_9200_DELL_M21] = "dell-m21",
1350         [STAC_9200_DELL_M22] = "dell-m22",
1351         [STAC_9200_DELL_M23] = "dell-m23",
1352         [STAC_9200_DELL_M24] = "dell-m24",
1353         [STAC_9200_DELL_M25] = "dell-m25",
1354         [STAC_9200_DELL_M26] = "dell-m26",
1355         [STAC_9200_DELL_M27] = "dell-m27",
1356         [STAC_9200_M4] = "gateway-m4",
1357         [STAC_9200_M4_2] = "gateway-m4-2",
1358         [STAC_9200_PANASONIC] = "panasonic",
1359 };
1360
1361 static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1362         /* SigmaTel reference board */
1363         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1364                       "DFI LanParty", STAC_REF),
1365         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1366                       "DFI LanParty", STAC_REF),
1367         /* Dell laptops have BIOS problem */
1368         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1369                       "unknown Dell", STAC_9200_DELL_D21),
1370         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1371                       "Dell Inspiron 630m", STAC_9200_DELL_M21),
1372         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1373                       "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1374         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1375                       "unknown Dell", STAC_9200_DELL_D22),
1376         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1377                       "unknown Dell", STAC_9200_DELL_D22),
1378         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1379                       "Dell Latitude D620", STAC_9200_DELL_M22),
1380         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1381                       "unknown Dell", STAC_9200_DELL_D23),
1382         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1383                       "unknown Dell", STAC_9200_DELL_D23),
1384         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1385                       "unknown Dell", STAC_9200_DELL_M22),
1386         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1387                       "unknown Dell", STAC_9200_DELL_M24),
1388         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1389                       "unknown Dell", STAC_9200_DELL_M24),
1390         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1391                       "Dell Latitude 120L", STAC_9200_DELL_M24),
1392         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1393                       "Dell Latitude D820", STAC_9200_DELL_M22),
1394         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1395                       "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1396         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1397                       "Dell XPS M1710", STAC_9200_DELL_M23),
1398         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1399                       "Dell Precision M90", STAC_9200_DELL_M23),
1400         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1401                       "unknown Dell", STAC_9200_DELL_M22),
1402         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1403                       "unknown Dell", STAC_9200_DELL_M22),
1404         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1405                       "unknown Dell", STAC_9200_DELL_M22),
1406         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1407                       "Dell Inspiron 640m", STAC_9200_DELL_M21),
1408         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1409                       "unknown Dell", STAC_9200_DELL_D23),
1410         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1411                       "unknown Dell", STAC_9200_DELL_D23),
1412         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1413                       "unknown Dell", STAC_9200_DELL_D21),
1414         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1415                       "unknown Dell", STAC_9200_DELL_D23),
1416         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1417                       "unknown Dell", STAC_9200_DELL_D21),
1418         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1419                       "unknown Dell", STAC_9200_DELL_M25),
1420         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1421                       "unknown Dell", STAC_9200_DELL_M25),
1422         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1423                       "Dell Inspiron 1501", STAC_9200_DELL_M26),
1424         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1425                       "unknown Dell", STAC_9200_DELL_M26),
1426         /* Panasonic */
1427         SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1428         /* Gateway machines needs EAPD to be set on resume */
1429         SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1430         SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1431         SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1432         /* OQO Mobile */
1433         SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1434         {} /* terminator */
1435 };
1436
1437 static unsigned int ref925x_pin_configs[8] = {
1438         0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1439         0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1440 };
1441
1442 static unsigned int stac925xM1_pin_configs[8] = {
1443         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1444         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1445 };
1446
1447 static unsigned int stac925xM1_2_pin_configs[8] = {
1448         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1449         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1450 };
1451
1452 static unsigned int stac925xM2_pin_configs[8] = {
1453         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1454         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1455 };
1456
1457 static unsigned int stac925xM2_2_pin_configs[8] = {
1458         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1459         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1460 };
1461
1462 static unsigned int stac925xM3_pin_configs[8] = {
1463         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1464         0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1465 };
1466
1467 static unsigned int stac925xM5_pin_configs[8] = {
1468         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1469         0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1470 };
1471
1472 static unsigned int stac925xM6_pin_configs[8] = {
1473         0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1474         0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1475 };
1476
1477 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1478         [STAC_REF] = ref925x_pin_configs,
1479         [STAC_M1] = stac925xM1_pin_configs,
1480         [STAC_M1_2] = stac925xM1_2_pin_configs,
1481         [STAC_M2] = stac925xM2_pin_configs,
1482         [STAC_M2_2] = stac925xM2_2_pin_configs,
1483         [STAC_M3] = stac925xM3_pin_configs,
1484         [STAC_M5] = stac925xM5_pin_configs,
1485         [STAC_M6] = stac925xM6_pin_configs,
1486 };
1487
1488 static const char *stac925x_models[STAC_925x_MODELS] = {
1489         [STAC_925x_AUTO] = "auto",
1490         [STAC_REF] = "ref",
1491         [STAC_M1] = "m1",
1492         [STAC_M1_2] = "m1-2",
1493         [STAC_M2] = "m2",
1494         [STAC_M2_2] = "m2-2",
1495         [STAC_M3] = "m3",
1496         [STAC_M5] = "m5",
1497         [STAC_M6] = "m6",
1498 };
1499
1500 static struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1501         SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1502         SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1503         SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1504         SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1505         SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1506         /* Not sure about the brand name for those */
1507         SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1508         SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1509         SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1510         SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1511         {} /* terminator */
1512 };
1513
1514 static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1515         /* SigmaTel reference board */
1516         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1517         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
1518         SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1519
1520         /* Default table for unknown ID */
1521         SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1522
1523         {} /* terminator */
1524 };
1525
1526 static unsigned int ref92hd73xx_pin_configs[13] = {
1527         0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1528         0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1529         0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1530         0x01452050,
1531 };
1532
1533 static unsigned int dell_m6_pin_configs[13] = {
1534         0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1535         0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1536         0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1537         0x4f0000f0,
1538 };
1539
1540 static unsigned int alienware_m17x_pin_configs[13] = {
1541         0x0321101f, 0x0321101f, 0x03a11020, 0x03014020,
1542         0x90170110, 0x4f0000f0, 0x4f0000f0, 0x4f0000f0,
1543         0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1544         0x904601b0,
1545 };
1546
1547 static unsigned int intel_dg45id_pin_configs[14] = {
1548         0x02214230, 0x02A19240, 0x01013214, 0x01014210,
1549         0x01A19250, 0x01011212, 0x01016211, 0x40f000f0,
1550         0x40f000f0, 0x40f000f0, 0x40f000f0, 0x014510A0,
1551         0x074510B0, 0x40f000f0
1552 };
1553
1554 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1555         [STAC_92HD73XX_REF]     = ref92hd73xx_pin_configs,
1556         [STAC_DELL_M6_AMIC]     = dell_m6_pin_configs,
1557         [STAC_DELL_M6_DMIC]     = dell_m6_pin_configs,
1558         [STAC_DELL_M6_BOTH]     = dell_m6_pin_configs,
1559         [STAC_DELL_EQ]  = dell_m6_pin_configs,
1560         [STAC_ALIENWARE_M17X]   = alienware_m17x_pin_configs,
1561         [STAC_92HD73XX_INTEL]   = intel_dg45id_pin_configs,
1562 };
1563
1564 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1565         [STAC_92HD73XX_AUTO] = "auto",
1566         [STAC_92HD73XX_NO_JD] = "no-jd",
1567         [STAC_92HD73XX_REF] = "ref",
1568         [STAC_92HD73XX_INTEL] = "intel",
1569         [STAC_DELL_M6_AMIC] = "dell-m6-amic",
1570         [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1571         [STAC_DELL_M6_BOTH] = "dell-m6",
1572         [STAC_DELL_EQ] = "dell-eq",
1573         [STAC_ALIENWARE_M17X] = "alienware",
1574 };
1575
1576 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1577         /* SigmaTel reference board */
1578         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1579                                 "DFI LanParty", STAC_92HD73XX_REF),
1580         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1581                                 "DFI LanParty", STAC_92HD73XX_REF),
1582         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
1583                                 "Intel DG45ID", STAC_92HD73XX_INTEL),
1584         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
1585                                 "Intel DG45FC", STAC_92HD73XX_INTEL),
1586         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1587                                 "Dell Studio 1535", STAC_DELL_M6_DMIC),
1588         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1589                                 "unknown Dell", STAC_DELL_M6_DMIC),
1590         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1591                                 "unknown Dell", STAC_DELL_M6_BOTH),
1592         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1593                                 "unknown Dell", STAC_DELL_M6_BOTH),
1594         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1595                                 "unknown Dell", STAC_DELL_M6_AMIC),
1596         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1597                                 "unknown Dell", STAC_DELL_M6_AMIC),
1598         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1599                                 "unknown Dell", STAC_DELL_M6_DMIC),
1600         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1601                                 "unknown Dell", STAC_DELL_M6_DMIC),
1602         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1603                                 "Dell Studio 1537", STAC_DELL_M6_DMIC),
1604         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1605                                 "Dell Studio 17", STAC_DELL_M6_DMIC),
1606         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
1607                                 "Dell Studio 1555", STAC_DELL_M6_DMIC),
1608         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd,
1609                                 "Dell Studio 1557", STAC_DELL_M6_DMIC),
1610         {} /* terminator */
1611 };
1612
1613 static struct snd_pci_quirk stac92hd73xx_codec_id_cfg_tbl[] = {
1614         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1,
1615                       "Alienware M17x", STAC_ALIENWARE_M17X),
1616         {} /* terminator */
1617 };
1618
1619 static unsigned int ref92hd83xxx_pin_configs[10] = {
1620         0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1621         0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1622         0x01451160, 0x98560170,
1623 };
1624
1625 static unsigned int dell_s14_pin_configs[10] = {
1626         0x0221403f, 0x0221101f, 0x02a19020, 0x90170110,
1627         0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a60160,
1628         0x40f000f0, 0x40f000f0,
1629 };
1630
1631 static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1632         [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1633         [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
1634         [STAC_DELL_S14] = dell_s14_pin_configs,
1635 };
1636
1637 static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1638         [STAC_92HD83XXX_AUTO] = "auto",
1639         [STAC_92HD83XXX_REF] = "ref",
1640         [STAC_92HD83XXX_PWR_REF] = "mic-ref",
1641         [STAC_DELL_S14] = "dell-s14",
1642         [STAC_92HD83XXX_HP] = "hp",
1643 };
1644
1645 static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1646         /* SigmaTel reference board */
1647         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1648                       "DFI LanParty", STAC_92HD83XXX_REF),
1649         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1650                       "DFI LanParty", STAC_92HD83XXX_REF),
1651         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
1652                       "unknown Dell", STAC_DELL_S14),
1653         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x3600,
1654                       "HP", STAC_92HD83XXX_HP),
1655         {} /* terminator */
1656 };
1657
1658 static unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1659         0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1660         0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1661         0x90a000f0, 0x01452050, 0x01452050, 0x00000000,
1662         0x00000000
1663 };
1664
1665 static unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1666         0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1667         0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1668         0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000,
1669         0x00000000
1670 };
1671
1672 static unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1673         0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1674         0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1675         0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1676         0x00000000
1677 };
1678
1679 static unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1680         0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1681         0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1682         0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1683         0x00000000
1684 };
1685
1686 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1687         [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1688         [STAC_DELL_M4_1]        = dell_m4_1_pin_configs,
1689         [STAC_DELL_M4_2]        = dell_m4_2_pin_configs,
1690         [STAC_DELL_M4_3]        = dell_m4_3_pin_configs,
1691         [STAC_HP_M4]            = NULL,
1692         [STAC_HP_DV5]           = NULL,
1693         [STAC_HP_HDX]           = NULL,
1694         [STAC_HP_DV4_1222NR]    = NULL,
1695 };
1696
1697 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1698         [STAC_92HD71BXX_AUTO] = "auto",
1699         [STAC_92HD71BXX_REF] = "ref",
1700         [STAC_DELL_M4_1] = "dell-m4-1",
1701         [STAC_DELL_M4_2] = "dell-m4-2",
1702         [STAC_DELL_M4_3] = "dell-m4-3",
1703         [STAC_HP_M4] = "hp-m4",
1704         [STAC_HP_DV5] = "hp-dv5",
1705         [STAC_HP_HDX] = "hp-hdx",
1706         [STAC_HP_DV4_1222NR] = "hp-dv4-1222nr",
1707 };
1708
1709 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1710         /* SigmaTel reference board */
1711         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1712                       "DFI LanParty", STAC_92HD71BXX_REF),
1713         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1714                       "DFI LanParty", STAC_92HD71BXX_REF),
1715         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb,
1716                       "HP dv4-1222nr", STAC_HP_DV4_1222NR),
1717         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720,
1718                           "HP", STAC_HP_DV5),
1719         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
1720                       "HP", STAC_HP_DV5),
1721         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
1722                       "HP dv4-7", STAC_HP_DV5),
1723         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
1724                       "HP dv4-7", STAC_HP_DV5),
1725         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
1726                       "HP HDX", STAC_HP_HDX),  /* HDX18 */
1727         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1728                       "HP mini 1000", STAC_HP_M4),
1729         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
1730                       "HP HDX", STAC_HP_HDX),  /* HDX16 */
1731         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
1732                       "HP dv6", STAC_HP_DV5),
1733         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061,
1734                       "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */
1735         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
1736                       "HP", STAC_HP_DV5),
1737         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1738                                 "unknown Dell", STAC_DELL_M4_1),
1739         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1740                                 "unknown Dell", STAC_DELL_M4_1),
1741         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1742                                 "unknown Dell", STAC_DELL_M4_1),
1743         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1744                                 "unknown Dell", STAC_DELL_M4_1),
1745         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1746                                 "unknown Dell", STAC_DELL_M4_1),
1747         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1748                                 "unknown Dell", STAC_DELL_M4_1),
1749         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1750                                 "unknown Dell", STAC_DELL_M4_1),
1751         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1752                                 "unknown Dell", STAC_DELL_M4_2),
1753         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1754                                 "unknown Dell", STAC_DELL_M4_2),
1755         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1756                                 "unknown Dell", STAC_DELL_M4_2),
1757         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1758                                 "unknown Dell", STAC_DELL_M4_2),
1759         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1760                                 "unknown Dell", STAC_DELL_M4_3),
1761         {} /* terminator */
1762 };
1763
1764 static unsigned int ref922x_pin_configs[10] = {
1765         0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1766         0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1767         0x40000100, 0x40000100,
1768 };
1769
1770 /*
1771     STAC 922X pin configs for
1772     102801A7
1773     102801AB
1774     102801A9
1775     102801D1
1776     102801D2
1777 */
1778 static unsigned int dell_922x_d81_pin_configs[10] = {
1779         0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1780         0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1781         0x01813122, 0x400001f2,
1782 };
1783
1784 /*
1785     STAC 922X pin configs for
1786     102801AC
1787     102801D0
1788 */
1789 static unsigned int dell_922x_d82_pin_configs[10] = {
1790         0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1791         0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1792         0x01813122, 0x400001f1,
1793 };
1794
1795 /*
1796     STAC 922X pin configs for
1797     102801BF
1798 */
1799 static unsigned int dell_922x_m81_pin_configs[10] = {
1800         0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1801         0x03a11050, 0x01116221, 0x90a70330, 0x01452340, 
1802         0x40C003f1, 0x405003f0,
1803 };
1804
1805 /*
1806     STAC 9221 A1 pin configs for
1807     102801D7 (Dell XPS M1210)
1808 */
1809 static unsigned int dell_922x_m82_pin_configs[10] = {
1810         0x02211211, 0x408103ff, 0x02a1123e, 0x90100310, 
1811         0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2, 
1812         0x508003f3, 0x405003f4, 
1813 };
1814
1815 static unsigned int d945gtp3_pin_configs[10] = {
1816         0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1817         0x40000100, 0x40000100, 0x40000100, 0x40000100,
1818         0x02a19120, 0x40000100,
1819 };
1820
1821 static unsigned int d945gtp5_pin_configs[10] = {
1822         0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1823         0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1824         0x02a19320, 0x40000100,
1825 };
1826
1827 static unsigned int intel_mac_v1_pin_configs[10] = {
1828         0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1829         0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1830         0x400000fc, 0x400000fb,
1831 };
1832
1833 static unsigned int intel_mac_v2_pin_configs[10] = {
1834         0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1835         0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1836         0x400000fc, 0x400000fb,
1837 };
1838
1839 static unsigned int intel_mac_v3_pin_configs[10] = {
1840         0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1841         0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1842         0x400000fc, 0x400000fb,
1843 };
1844
1845 static unsigned int intel_mac_v4_pin_configs[10] = {
1846         0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1847         0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1848         0x400000fc, 0x400000fb,
1849 };
1850
1851 static unsigned int intel_mac_v5_pin_configs[10] = {
1852         0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1853         0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1854         0x400000fc, 0x400000fb,
1855 };
1856
1857 static unsigned int ecs202_pin_configs[10] = {
1858         0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1859         0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1860         0x9037012e, 0x40e000f2,
1861 };
1862
1863 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1864         [STAC_D945_REF] = ref922x_pin_configs,
1865         [STAC_D945GTP3] = d945gtp3_pin_configs,
1866         [STAC_D945GTP5] = d945gtp5_pin_configs,
1867         [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1868         [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1869         [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1870         [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1871         [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1872         [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1873         /* for backward compatibility */
1874         [STAC_MACMINI] = intel_mac_v3_pin_configs,
1875         [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1876         [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1877         [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1878         [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1879         [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1880         [STAC_ECS_202] = ecs202_pin_configs,
1881         [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1882         [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,       
1883         [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1884         [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,       
1885 };
1886
1887 static const char *stac922x_models[STAC_922X_MODELS] = {
1888         [STAC_922X_AUTO] = "auto",
1889         [STAC_D945_REF] = "ref",
1890         [STAC_D945GTP5] = "5stack",
1891         [STAC_D945GTP3] = "3stack",
1892         [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1893         [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1894         [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1895         [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1896         [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1897         [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1898         /* for backward compatibility */
1899         [STAC_MACMINI]  = "macmini",
1900         [STAC_MACBOOK]  = "macbook",
1901         [STAC_MACBOOK_PRO_V1]   = "macbook-pro-v1",
1902         [STAC_MACBOOK_PRO_V2]   = "macbook-pro",
1903         [STAC_IMAC_INTEL] = "imac-intel",
1904         [STAC_IMAC_INTEL_20] = "imac-intel-20",
1905         [STAC_ECS_202] = "ecs202",
1906         [STAC_922X_DELL_D81] = "dell-d81",
1907         [STAC_922X_DELL_D82] = "dell-d82",
1908         [STAC_922X_DELL_M81] = "dell-m81",
1909         [STAC_922X_DELL_M82] = "dell-m82",
1910 };
1911
1912 static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1913         /* SigmaTel reference board */
1914         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1915                       "DFI LanParty", STAC_D945_REF),
1916         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1917                       "DFI LanParty", STAC_D945_REF),
1918         /* Intel 945G based systems */
1919         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1920                       "Intel D945G", STAC_D945GTP3),
1921         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1922                       "Intel D945G", STAC_D945GTP3),
1923         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1924                       "Intel D945G", STAC_D945GTP3),
1925         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1926                       "Intel D945G", STAC_D945GTP3),
1927         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1928                       "Intel D945G", STAC_D945GTP3),
1929         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1930                       "Intel D945G", STAC_D945GTP3),
1931         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1932                       "Intel D945G", STAC_D945GTP3),
1933         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1934                       "Intel D945G", STAC_D945GTP3),
1935         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1936                       "Intel D945G", STAC_D945GTP3),
1937         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1938                       "Intel D945G", STAC_D945GTP3),
1939         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1940                       "Intel D945G", STAC_D945GTP3),
1941         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1942                       "Intel D945G", STAC_D945GTP3),
1943         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1944                       "Intel D945G", STAC_D945GTP3),
1945         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1946                       "Intel D945G", STAC_D945GTP3),
1947         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1948                       "Intel D945G", STAC_D945GTP3),
1949         /* Intel D945G 5-stack systems */
1950         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1951                       "Intel D945G", STAC_D945GTP5),
1952         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1953                       "Intel D945G", STAC_D945GTP5),
1954         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1955                       "Intel D945G", STAC_D945GTP5),
1956         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1957                       "Intel D945G", STAC_D945GTP5),
1958         /* Intel 945P based systems */
1959         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1960                       "Intel D945P", STAC_D945GTP3),
1961         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1962                       "Intel D945P", STAC_D945GTP3),
1963         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1964                       "Intel D945P", STAC_D945GTP3),
1965         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1966                       "Intel D945P", STAC_D945GTP3),
1967         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1968                       "Intel D945P", STAC_D945GTP3),
1969         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1970                       "Intel D945P", STAC_D945GTP5),
1971         /* other intel */
1972         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
1973                       "Intel D945", STAC_D945_REF),
1974         /* other systems  */
1975         /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
1976         SND_PCI_QUIRK(0x8384, 0x7680,
1977                       "Mac", STAC_INTEL_MAC_AUTO),
1978         /* Dell systems  */
1979         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1980                       "unknown Dell", STAC_922X_DELL_D81),
1981         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1982                       "unknown Dell", STAC_922X_DELL_D81),
1983         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1984                       "unknown Dell", STAC_922X_DELL_D81),
1985         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1986                       "unknown Dell", STAC_922X_DELL_D82),
1987         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1988                       "unknown Dell", STAC_922X_DELL_M81),
1989         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1990                       "unknown Dell", STAC_922X_DELL_D82),
1991         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
1992                       "unknown Dell", STAC_922X_DELL_D81),
1993         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
1994                       "unknown Dell", STAC_922X_DELL_D81),
1995         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
1996                       "Dell XPS M1210", STAC_922X_DELL_M82),
1997         /* ECS/PC Chips boards */
1998         SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
1999                       "ECS/PC chips", STAC_ECS_202),
2000         {} /* terminator */
2001 };
2002
2003 static unsigned int ref927x_pin_configs[14] = {
2004         0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2005         0x01a19040, 0x01011012, 0x01016011, 0x0101201f, 
2006         0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2007         0x01c42190, 0x40000100,
2008 };
2009
2010 static unsigned int d965_3st_pin_configs[14] = {
2011         0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2012         0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2013         0x40000100, 0x40000100, 0x40000100, 0x40000100,
2014         0x40000100, 0x40000100
2015 };
2016
2017 static unsigned int d965_5st_pin_configs[14] = {
2018         0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2019         0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2020         0x40000100, 0x40000100, 0x40000100, 0x01442070,
2021         0x40000100, 0x40000100
2022 };
2023
2024 static unsigned int d965_5st_no_fp_pin_configs[14] = {
2025         0x40000100, 0x40000100, 0x0181304e, 0x01014010,
2026         0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2027         0x40000100, 0x40000100, 0x40000100, 0x01442070,
2028         0x40000100, 0x40000100
2029 };
2030
2031 static unsigned int dell_3st_pin_configs[14] = {
2032         0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2033         0x01111212, 0x01116211, 0x01813050, 0x01112214,
2034         0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2035         0x40c003fc, 0x40000100
2036 };
2037
2038 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2039         [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2040         [STAC_D965_REF]  = ref927x_pin_configs,
2041         [STAC_D965_3ST]  = d965_3st_pin_configs,
2042         [STAC_D965_5ST]  = d965_5st_pin_configs,
2043         [STAC_D965_5ST_NO_FP]  = d965_5st_no_fp_pin_configs,
2044         [STAC_DELL_3ST]  = dell_3st_pin_configs,
2045         [STAC_DELL_BIOS] = NULL,
2046         [STAC_927X_VOLKNOB] = NULL,
2047 };
2048
2049 static const char *stac927x_models[STAC_927X_MODELS] = {
2050         [STAC_927X_AUTO]        = "auto",
2051         [STAC_D965_REF_NO_JD]   = "ref-no-jd",
2052         [STAC_D965_REF]         = "ref",
2053         [STAC_D965_3ST]         = "3stack",
2054         [STAC_D965_5ST]         = "5stack",
2055         [STAC_D965_5ST_NO_FP]   = "5stack-no-fp",
2056         [STAC_DELL_3ST]         = "dell-3stack",
2057         [STAC_DELL_BIOS]        = "dell-bios",
2058         [STAC_927X_VOLKNOB]     = "volknob",
2059 };
2060
2061 static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2062         /* SigmaTel reference board */
2063         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2064                       "DFI LanParty", STAC_D965_REF),
2065         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2066                       "DFI LanParty", STAC_D965_REF),
2067          /* Intel 946 based systems */
2068         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2069         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2070         /* 965 based 3 stack systems */
2071         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
2072                            "Intel D965", STAC_D965_3ST),
2073         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
2074                            "Intel D965", STAC_D965_3ST),
2075         /* Dell 3 stack systems */
2076         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
2077         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2078         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01ed, "Dell     ", STAC_DELL_3ST),
2079         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f4, "Dell     ", STAC_DELL_3ST),
2080         /* Dell 3 stack systems with verb table in BIOS */
2081         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2082         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0227, "Dell Vostro 1400  ", STAC_DELL_BIOS),
2083         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022e, "Dell     ", STAC_DELL_BIOS),
2084         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
2085         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0242, "Dell     ", STAC_DELL_BIOS),
2086         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0243, "Dell     ", STAC_DELL_BIOS),
2087         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x02ff, "Dell     ", STAC_DELL_BIOS),
2088         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2089         /* 965 based 5 stack systems */
2090         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
2091                            "Intel D965", STAC_D965_5ST),
2092         SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
2093                            "Intel D965", STAC_D965_5ST),
2094         /* volume-knob fixes */
2095         SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB),
2096         {} /* terminator */
2097 };
2098
2099 static unsigned int ref9205_pin_configs[12] = {
2100         0x40000100, 0x40000100, 0x01016011, 0x01014010,
2101         0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2102         0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2103 };
2104
2105 /*
2106     STAC 9205 pin configs for
2107     102801F1
2108     102801F2
2109     102801FC
2110     102801FD
2111     10280204
2112     1028021F
2113     10280228 (Dell Vostro 1500)
2114     10280229 (Dell Vostro 1700)
2115 */
2116 static unsigned int dell_9205_m42_pin_configs[12] = {
2117         0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2118         0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2119         0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2120 };
2121
2122 /*
2123     STAC 9205 pin configs for
2124     102801F9
2125     102801FA
2126     102801FE
2127     102801FF (Dell Precision M4300)
2128     10280206
2129     10280200
2130     10280201
2131 */
2132 static unsigned int dell_9205_m43_pin_configs[12] = {
2133         0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2134         0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2135         0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2136 };
2137
2138 static unsigned int dell_9205_m44_pin_configs[12] = {
2139         0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2140         0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2141         0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2142 };
2143
2144 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2145         [STAC_9205_REF] = ref9205_pin_configs,
2146         [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2147         [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2148         [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2149         [STAC_9205_EAPD] = NULL,
2150 };
2151
2152 static const char *stac9205_models[STAC_9205_MODELS] = {
2153         [STAC_9205_AUTO] = "auto",
2154         [STAC_9205_REF] = "ref",
2155         [STAC_9205_DELL_M42] = "dell-m42",
2156         [STAC_9205_DELL_M43] = "dell-m43",
2157         [STAC_9205_DELL_M44] = "dell-m44",
2158         [STAC_9205_EAPD] = "eapd",
2159 };
2160
2161 static struct snd_pci_quirk stac9205_cfg_tbl[] = {
2162         /* SigmaTel reference board */
2163         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2164                       "DFI LanParty", STAC_9205_REF),
2165         SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
2166                       "SigmaTel", STAC_9205_REF),
2167         SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2168                       "DFI LanParty", STAC_9205_REF),
2169         /* Dell */
2170         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2171                       "unknown Dell", STAC_9205_DELL_M42),
2172         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2173                       "unknown Dell", STAC_9205_DELL_M42),
2174         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2175                       "Dell Precision", STAC_9205_DELL_M43),
2176         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2177                       "Dell Precision", STAC_9205_DELL_M43),
2178         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2179                       "Dell Precision", STAC_9205_DELL_M43),
2180         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2181                       "unknown Dell", STAC_9205_DELL_M42),
2182         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2183                       "unknown Dell", STAC_9205_DELL_M42),
2184         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2185                       "Dell Precision", STAC_9205_DELL_M43),
2186         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2187                       "Dell Precision M4300", STAC_9205_DELL_M43),
2188         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2189                       "unknown Dell", STAC_9205_DELL_M42),
2190         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2191                       "Dell Precision", STAC_9205_DELL_M43),
2192         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2193                       "Dell Precision", STAC_9205_DELL_M43),
2194         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2195                       "Dell Precision", STAC_9205_DELL_M43),
2196         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2197                       "Dell Inspiron", STAC_9205_DELL_M44),
2198         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2199                       "Dell Vostro 1500", STAC_9205_DELL_M42),
2200         SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229,
2201                       "Dell Vostro 1700", STAC_9205_DELL_M42),
2202         /* Gateway */
2203         SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
2204         SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
2205         {} /* terminator */
2206 };
2207
2208 static void stac92xx_set_config_regs(struct hda_codec *codec,
2209                                      unsigned int *pincfgs)
2210 {
2211         int i;
2212         struct sigmatel_spec *spec = codec->spec;
2213
2214         if (!pincfgs)
2215                 return;
2216
2217         for (i = 0; i < spec->num_pins; i++)
2218                 if (spec->pin_nids[i] && pincfgs[i])
2219                         snd_hda_codec_set_pincfg(codec, spec->pin_nids[i],
2220                                                  pincfgs[i]);
2221 }
2222
2223 /*
2224  * Analog playback callbacks
2225  */
2226 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2227                                       struct hda_codec *codec,
2228                                       struct snd_pcm_substream *substream)
2229 {
2230         struct sigmatel_spec *spec = codec->spec;
2231         if (spec->stream_delay)
2232                 msleep(spec->stream_delay);
2233         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2234                                              hinfo);
2235 }
2236
2237 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2238                                          struct hda_codec *codec,
2239                                          unsigned int stream_tag,
2240                                          unsigned int format,
2241                                          struct snd_pcm_substream *substream)
2242 {
2243         struct sigmatel_spec *spec = codec->spec;
2244         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2245 }
2246
2247 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2248                                         struct hda_codec *codec,
2249                                         struct snd_pcm_substream *substream)
2250 {
2251         struct sigmatel_spec *spec = codec->spec;
2252         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2253 }
2254
2255 /*
2256  * Digital playback callbacks
2257  */
2258 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2259                                           struct hda_codec *codec,
2260                                           struct snd_pcm_substream *substream)
2261 {
2262         struct sigmatel_spec *spec = codec->spec;
2263         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2264 }
2265
2266 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2267                                            struct hda_codec *codec,
2268                                            struct snd_pcm_substream *substream)
2269 {
2270         struct sigmatel_spec *spec = codec->spec;
2271         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2272 }
2273
2274 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2275                                          struct hda_codec *codec,
2276                                          unsigned int stream_tag,
2277                                          unsigned int format,
2278                                          struct snd_pcm_substream *substream)
2279 {
2280         struct sigmatel_spec *spec = codec->spec;
2281         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2282                                              stream_tag, format, substream);
2283 }
2284
2285 static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2286                                         struct hda_codec *codec,
2287                                         struct snd_pcm_substream *substream)
2288 {
2289         struct sigmatel_spec *spec = codec->spec;
2290         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2291 }
2292
2293
2294 /*
2295  * Analog capture callbacks
2296  */
2297 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2298                                         struct hda_codec *codec,
2299                                         unsigned int stream_tag,
2300                                         unsigned int format,
2301                                         struct snd_pcm_substream *substream)
2302 {
2303         struct sigmatel_spec *spec = codec->spec;
2304         hda_nid_t nid = spec->adc_nids[substream->number];
2305
2306         if (spec->powerdown_adcs) {
2307                 msleep(40);
2308                 snd_hda_codec_write(codec, nid, 0,
2309                         AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2310         }
2311         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2312         return 0;
2313 }
2314
2315 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2316                                         struct hda_codec *codec,
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         snd_hda_codec_cleanup_stream(codec, nid);
2323         if (spec->powerdown_adcs)
2324                 snd_hda_codec_write(codec, nid, 0,
2325                         AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2326         return 0;
2327 }
2328
2329 static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2330         .substreams = 1,
2331         .channels_min = 2,
2332         .channels_max = 2,
2333         /* NID is set in stac92xx_build_pcms */
2334         .ops = {
2335                 .open = stac92xx_dig_playback_pcm_open,
2336                 .close = stac92xx_dig_playback_pcm_close,
2337                 .prepare = stac92xx_dig_playback_pcm_prepare,
2338                 .cleanup = stac92xx_dig_playback_pcm_cleanup
2339         },
2340 };
2341
2342 static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2343         .substreams = 1,
2344         .channels_min = 2,
2345         .channels_max = 2,
2346         /* NID is set in stac92xx_build_pcms */
2347 };
2348
2349 static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2350         .substreams = 1,
2351         .channels_min = 2,
2352         .channels_max = 8,
2353         .nid = 0x02, /* NID to query formats and rates */
2354         .ops = {
2355                 .open = stac92xx_playback_pcm_open,
2356                 .prepare = stac92xx_playback_pcm_prepare,
2357                 .cleanup = stac92xx_playback_pcm_cleanup
2358         },
2359 };
2360
2361 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2362         .substreams = 1,
2363         .channels_min = 2,
2364         .channels_max = 2,
2365         .nid = 0x06, /* NID to query formats and rates */
2366         .ops = {
2367                 .open = stac92xx_playback_pcm_open,
2368                 .prepare = stac92xx_playback_pcm_prepare,
2369                 .cleanup = stac92xx_playback_pcm_cleanup
2370         },
2371 };
2372
2373 static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2374         .channels_min = 2,
2375         .channels_max = 2,
2376         /* NID + .substreams is set in stac92xx_build_pcms */
2377         .ops = {
2378                 .prepare = stac92xx_capture_pcm_prepare,
2379                 .cleanup = stac92xx_capture_pcm_cleanup
2380         },
2381 };
2382
2383 static int stac92xx_build_pcms(struct hda_codec *codec)
2384 {
2385         struct sigmatel_spec *spec = codec->spec;
2386         struct hda_pcm *info = spec->pcm_rec;
2387
2388         codec->num_pcms = 1;
2389         codec->pcm_info = info;
2390
2391         info->name = "STAC92xx Analog";
2392         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2393         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2394                 spec->multiout.dac_nids[0];
2395         info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2396         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2397         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2398
2399         if (spec->alt_switch) {
2400                 codec->num_pcms++;
2401                 info++;
2402                 info->name = "STAC92xx Analog Alt";
2403                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2404         }
2405
2406         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2407                 codec->num_pcms++;
2408                 info++;
2409                 info->name = "STAC92xx Digital";
2410                 info->pcm_type = spec->autocfg.dig_out_type[0];
2411                 if (spec->multiout.dig_out_nid) {
2412                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2413                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2414                 }
2415                 if (spec->dig_in_nid) {
2416                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2417                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2418                 }
2419         }
2420
2421         return 0;
2422 }
2423
2424 static unsigned int stac92xx_get_default_vref(struct hda_codec *codec,
2425                                         hda_nid_t nid)
2426 {
2427         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2428         pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2429         if (pincap & AC_PINCAP_VREF_100)
2430                 return AC_PINCTL_VREF_100;
2431         if (pincap & AC_PINCAP_VREF_80)
2432                 return AC_PINCTL_VREF_80;
2433         if (pincap & AC_PINCAP_VREF_50)
2434                 return AC_PINCTL_VREF_50;
2435         if (pincap & AC_PINCAP_VREF_GRD)
2436                 return AC_PINCTL_VREF_GRD;
2437         return 0;
2438 }
2439
2440 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2441
2442 {
2443         snd_hda_codec_write_cache(codec, nid, 0,
2444                                   AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2445 }
2446
2447 #define stac92xx_hp_switch_info         snd_ctl_boolean_mono_info
2448
2449 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2450                         struct snd_ctl_elem_value *ucontrol)
2451 {
2452         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2453         struct sigmatel_spec *spec = codec->spec;
2454
2455         ucontrol->value.integer.value[0] = !!spec->hp_switch;
2456         return 0;
2457 }
2458
2459 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid);
2460
2461 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2462                         struct snd_ctl_elem_value *ucontrol)
2463 {
2464         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2465         struct sigmatel_spec *spec = codec->spec;
2466         int nid = kcontrol->private_value;
2467  
2468         spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2469
2470         /* check to be sure that the ports are upto date with
2471          * switch changes
2472          */
2473         stac_issue_unsol_event(codec, nid);
2474
2475         return 1;
2476 }
2477
2478 static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol,
2479                                 struct snd_ctl_elem_info *uinfo)
2480 {
2481         int i;
2482         static char *texts[] = {
2483                 "Mic In", "Line In", "Line Out"
2484         };
2485
2486         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2487         struct sigmatel_spec *spec = codec->spec;
2488         hda_nid_t nid = kcontrol->private_value;
2489
2490         if (nid == spec->mic_switch || nid == spec->line_switch)
2491                 i = 3;
2492         else
2493                 i = 2;
2494
2495         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2496         uinfo->value.enumerated.items = i;
2497         uinfo->count = 1;
2498         if (uinfo->value.enumerated.item >= i)
2499                 uinfo->value.enumerated.item = i-1;
2500         strcpy(uinfo->value.enumerated.name,
2501                 texts[uinfo->value.enumerated.item]);
2502
2503         return 0;
2504 }
2505
2506 static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol,
2507                                 struct snd_ctl_elem_value *ucontrol)
2508 {
2509         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2510         hda_nid_t nid = kcontrol->private_value;
2511         unsigned int vref = stac92xx_vref_get(codec, nid);
2512
2513         if (vref == stac92xx_get_default_vref(codec, nid))
2514                 ucontrol->value.enumerated.item[0] = 0;
2515         else if (vref == AC_PINCTL_VREF_GRD)
2516                 ucontrol->value.enumerated.item[0] = 1;
2517         else if (vref == AC_PINCTL_VREF_HIZ)
2518                 ucontrol->value.enumerated.item[0] = 2;
2519
2520         return 0;
2521 }
2522
2523 static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol,
2524                                 struct snd_ctl_elem_value *ucontrol)
2525 {
2526         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2527         unsigned int new_vref = 0;
2528         int error;
2529         hda_nid_t nid = kcontrol->private_value;
2530
2531         if (ucontrol->value.enumerated.item[0] == 0)
2532                 new_vref = stac92xx_get_default_vref(codec, nid);
2533         else if (ucontrol->value.enumerated.item[0] == 1)
2534                 new_vref = AC_PINCTL_VREF_GRD;
2535         else if (ucontrol->value.enumerated.item[0] == 2)
2536                 new_vref = AC_PINCTL_VREF_HIZ;
2537         else
2538                 return 0;
2539
2540         if (new_vref != stac92xx_vref_get(codec, nid)) {
2541                 error = stac92xx_vref_set(codec, nid, new_vref);
2542                 return error;
2543         }
2544
2545         return 0;
2546 }
2547
2548 static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol,
2549                                 struct snd_ctl_elem_info *uinfo)
2550 {
2551         static char *texts[2];
2552         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2553         struct sigmatel_spec *spec = codec->spec;
2554
2555         if (kcontrol->private_value == spec->line_switch)
2556                 texts[0] = "Line In";
2557         else
2558                 texts[0] = "Mic In";
2559         texts[1] = "Line Out";
2560         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2561         uinfo->value.enumerated.items = 2;
2562         uinfo->count = 1;
2563
2564         if (uinfo->value.enumerated.item >= 2)
2565                 uinfo->value.enumerated.item = 1;
2566         strcpy(uinfo->value.enumerated.name,
2567                 texts[uinfo->value.enumerated.item]);
2568
2569         return 0;
2570 }
2571
2572 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2573 {
2574         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2575         struct sigmatel_spec *spec = codec->spec;
2576         hda_nid_t nid = kcontrol->private_value;
2577         int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2578
2579         ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx];
2580         return 0;
2581 }
2582
2583 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2584 {
2585         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2586         struct sigmatel_spec *spec = codec->spec;
2587         hda_nid_t nid = kcontrol->private_value;
2588         int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2589         unsigned short val = !!ucontrol->value.enumerated.item[0];
2590
2591         spec->io_switch[io_idx] = val;
2592
2593         if (val)
2594                 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2595         else {
2596                 unsigned int pinctl = AC_PINCTL_IN_EN;
2597                 if (io_idx) /* set VREF for mic */
2598                         pinctl |= stac92xx_get_default_vref(codec, nid);
2599                 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2600         }
2601
2602         /* check the auto-mute again: we need to mute/unmute the speaker
2603          * appropriately according to the pin direction
2604          */
2605         if (spec->hp_detect)
2606                 stac_issue_unsol_event(codec, nid);
2607
2608         return 1;
2609 }
2610
2611 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2612
2613 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2614                 struct snd_ctl_elem_value *ucontrol)
2615 {
2616         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2617         struct sigmatel_spec *spec = codec->spec;
2618
2619         ucontrol->value.integer.value[0] = spec->clfe_swap;
2620         return 0;
2621 }
2622
2623 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2624                 struct snd_ctl_elem_value *ucontrol)
2625 {
2626         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2627         struct sigmatel_spec *spec = codec->spec;
2628         hda_nid_t nid = kcontrol->private_value & 0xff;
2629         unsigned int val = !!ucontrol->value.integer.value[0];
2630
2631         if (spec->clfe_swap == val)
2632                 return 0;
2633
2634         spec->clfe_swap = val;
2635
2636         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2637                 spec->clfe_swap ? 0x4 : 0x0);
2638
2639         return 1;
2640 }
2641
2642 #define STAC_CODEC_HP_SWITCH(xname) \
2643         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2644           .name = xname, \
2645           .index = 0, \
2646           .info = stac92xx_hp_switch_info, \
2647           .get = stac92xx_hp_switch_get, \
2648           .put = stac92xx_hp_switch_put, \
2649         }
2650
2651 #define STAC_CODEC_IO_SWITCH(xname, xpval) \
2652         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2653           .name = xname, \
2654           .index = 0, \
2655           .info = stac92xx_io_switch_info, \
2656           .get = stac92xx_io_switch_get, \
2657           .put = stac92xx_io_switch_put, \
2658           .private_value = xpval, \
2659         }
2660
2661 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2662         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2663           .name = xname, \
2664           .index = 0, \
2665           .info = stac92xx_clfe_switch_info, \
2666           .get = stac92xx_clfe_switch_get, \
2667           .put = stac92xx_clfe_switch_put, \
2668           .private_value = xpval, \
2669         }
2670
2671 enum {
2672         STAC_CTL_WIDGET_VOL,
2673         STAC_CTL_WIDGET_MUTE,
2674         STAC_CTL_WIDGET_MUTE_BEEP,
2675         STAC_CTL_WIDGET_MONO_MUX,
2676         STAC_CTL_WIDGET_HP_SWITCH,
2677         STAC_CTL_WIDGET_IO_SWITCH,
2678         STAC_CTL_WIDGET_CLFE_SWITCH,
2679         STAC_CTL_WIDGET_DC_BIAS
2680 };
2681
2682 static struct snd_kcontrol_new stac92xx_control_templates[] = {
2683         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2684         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2685         HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0),
2686         STAC_MONO_MUX,
2687         STAC_CODEC_HP_SWITCH(NULL),
2688         STAC_CODEC_IO_SWITCH(NULL, 0),
2689         STAC_CODEC_CLFE_SWITCH(NULL, 0),
2690         DC_BIAS(NULL, 0, 0),
2691 };
2692
2693 /* add dynamic controls */
2694 static struct snd_kcontrol_new *
2695 stac_control_new(struct sigmatel_spec *spec,
2696                  struct snd_kcontrol_new *ktemp,
2697                  const char *name,
2698                  unsigned int subdev)
2699 {
2700         struct snd_kcontrol_new *knew;
2701
2702         snd_array_init(&spec->kctls, sizeof(*knew), 32);
2703         knew = snd_array_new(&spec->kctls);
2704         if (!knew)
2705                 return NULL;
2706         *knew = *ktemp;
2707         knew->name = kstrdup(name, GFP_KERNEL);
2708         if (!knew->name) {
2709                 /* roolback */
2710                 memset(knew, 0, sizeof(*knew));
2711                 spec->kctls.alloced--;
2712                 return NULL;
2713         }
2714         knew->subdevice = subdev;
2715         return knew;
2716 }
2717
2718 static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2719                                      struct snd_kcontrol_new *ktemp,
2720                                      int idx, const char *name,
2721                                      unsigned long val)
2722 {
2723         struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name,
2724                                                          HDA_SUBDEV_AMP_FLAG);
2725         if (!knew)
2726                 return -ENOMEM;
2727         knew->index = idx;
2728         knew->private_value = val;
2729         return 0;
2730 }
2731
2732 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2733                                            int type, int idx, const char *name,
2734                                            unsigned long val)
2735 {
2736         return stac92xx_add_control_temp(spec,
2737                                          &stac92xx_control_templates[type],
2738                                          idx, name, val);
2739 }
2740
2741
2742 /* add dynamic controls */
2743 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2744                                        const char *name, unsigned long val)
2745 {
2746         return stac92xx_add_control_idx(spec, type, 0, name, val);
2747 }
2748
2749 static struct snd_kcontrol_new stac_input_src_temp = {
2750         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2751         .name = "Input Source",
2752         .info = stac92xx_mux_enum_info,
2753         .get = stac92xx_mux_enum_get,
2754         .put = stac92xx_mux_enum_put,
2755 };
2756
2757 static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
2758                                                 hda_nid_t nid, int idx)
2759 {
2760         int def_conf = snd_hda_codec_get_pincfg(codec, nid);
2761         int control = 0;
2762         struct sigmatel_spec *spec = codec->spec;
2763         char name[22];
2764
2765         if (!((get_defcfg_connect(def_conf)) & AC_JACK_PORT_FIXED)) {
2766                 if (stac92xx_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
2767                         && nid == spec->line_switch)
2768                         control = STAC_CTL_WIDGET_IO_SWITCH;
2769                 else if (snd_hda_query_pin_caps(codec, nid)
2770                         & (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT))
2771                         control = STAC_CTL_WIDGET_DC_BIAS;
2772                 else if (nid == spec->mic_switch)
2773                         control = STAC_CTL_WIDGET_IO_SWITCH;
2774         }
2775
2776         if (control) {
2777                 strcpy(name, auto_pin_cfg_labels[idx]);
2778                 return stac92xx_add_control(codec->spec, control,
2779                                         strcat(name, " Jack Mode"), nid);
2780         }
2781
2782         return 0;
2783 }
2784
2785 static int stac92xx_add_input_source(struct sigmatel_spec *spec)
2786 {
2787         struct snd_kcontrol_new *knew;
2788         struct hda_input_mux *imux = &spec->private_imux;
2789
2790         if (spec->auto_mic)
2791                 return 0; /* no need for input source */
2792         if (!spec->num_adcs || imux->num_items <= 1)
2793                 return 0; /* no need for input source control */
2794         knew = stac_control_new(spec, &stac_input_src_temp,
2795                                 stac_input_src_temp.name, 0);
2796         if (!knew)
2797                 return -ENOMEM;
2798         knew->count = spec->num_adcs;
2799         return 0;
2800 }
2801
2802 /* check whether the line-input can be used as line-out */
2803 static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2804 {
2805         struct sigmatel_spec *spec = codec->spec;
2806         struct auto_pin_cfg *cfg = &spec->autocfg;
2807         hda_nid_t nid;
2808         unsigned int pincap;
2809
2810         if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2811                 return 0;
2812         nid = cfg->input_pins[AUTO_PIN_LINE];
2813         pincap = snd_hda_query_pin_caps(codec, nid);
2814         if (pincap & AC_PINCAP_OUT)
2815                 return nid;
2816         return 0;
2817 }
2818
2819 /* check whether the mic-input can be used as line-out */
2820 static hda_nid_t check_mic_out_switch(struct hda_codec *codec)
2821 {
2822         struct sigmatel_spec *spec = codec->spec;
2823         struct auto_pin_cfg *cfg = &spec->autocfg;
2824         unsigned int def_conf, pincap;
2825         unsigned int mic_pin;
2826
2827         if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2828                 return 0;
2829         mic_pin = AUTO_PIN_MIC;
2830         for (;;) {
2831                 hda_nid_t nid = cfg->input_pins[mic_pin];
2832                 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2833                 /* some laptops have an internal analog microphone
2834                  * which can't be used as a output */
2835                 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
2836                         pincap = snd_hda_query_pin_caps(codec, nid);
2837                         if (pincap & AC_PINCAP_OUT)
2838                                 return nid;
2839                 }
2840                 if (mic_pin == AUTO_PIN_MIC)
2841                         mic_pin = AUTO_PIN_FRONT_MIC;
2842                 else
2843                         break;
2844         }
2845         return 0;
2846 }
2847
2848 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2849 {
2850         int i;
2851         
2852         for (i = 0; i < spec->multiout.num_dacs; i++) {
2853                 if (spec->multiout.dac_nids[i] == nid)
2854                         return 1;
2855         }
2856
2857         return 0;
2858 }
2859
2860 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2861 {
2862         int i;
2863         if (is_in_dac_nids(spec, nid))
2864                 return 1;
2865         for (i = 0; i < spec->autocfg.hp_outs; i++)
2866                 if (spec->hp_dacs[i] == nid)
2867                         return 1;
2868         for (i = 0; i < spec->autocfg.speaker_outs; i++)
2869                 if (spec->speaker_dacs[i] == nid)
2870                         return 1;
2871         return 0;
2872 }
2873
2874 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2875 {
2876         struct sigmatel_spec *spec = codec->spec;
2877         int j, conn_len;
2878         hda_nid_t conn[HDA_MAX_CONNECTIONS];
2879         unsigned int wcaps, wtype;
2880
2881         conn_len = snd_hda_get_connections(codec, nid, conn,
2882                                            HDA_MAX_CONNECTIONS);
2883         /* 92HD88: trace back up the link of nids to find the DAC */
2884         while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0]))
2885                                         != AC_WID_AUD_OUT)) {
2886                 nid = conn[0];
2887                 conn_len = snd_hda_get_connections(codec, nid, conn,
2888                         HDA_MAX_CONNECTIONS);
2889         }
2890         for (j = 0; j < conn_len; j++) {
2891                 wcaps = get_wcaps(codec, conn[j]);
2892                 wtype = get_wcaps_type(wcaps);
2893                 /* we check only analog outputs */
2894                 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2895                         continue;
2896                 /* if this route has a free DAC, assign it */
2897                 if (!check_all_dac_nids(spec, conn[j])) {
2898                         if (conn_len > 1) {
2899                                 /* select this DAC in the pin's input mux */
2900                                 snd_hda_codec_write_cache(codec, nid, 0,
2901                                                   AC_VERB_SET_CONNECT_SEL, j);
2902                         }
2903                         return conn[j];
2904                 }
2905         }
2906         /* if all DACs are already assigned, connect to the primary DAC */
2907         if (conn_len > 1) {
2908                 for (j = 0; j < conn_len; j++) {
2909                         if (conn[j] == spec->multiout.dac_nids[0]) {
2910                                 snd_hda_codec_write_cache(codec, nid, 0,
2911                                                   AC_VERB_SET_CONNECT_SEL, j);
2912                                 break;
2913                         }
2914                 }
2915         }
2916         return 0;
2917 }
2918
2919 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2920 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2921
2922 /*
2923  * Fill in the dac_nids table from the parsed pin configuration
2924  * This function only works when every pin in line_out_pins[]
2925  * contains atleast one DAC in its connection list. Some 92xx
2926  * codecs are not connected directly to a DAC, such as the 9200
2927  * and 9202/925x. For those, dac_nids[] must be hard-coded.
2928  */
2929 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2930 {
2931         struct sigmatel_spec *spec = codec->spec;
2932         struct auto_pin_cfg *cfg = &spec->autocfg;
2933         int i;
2934         hda_nid_t nid, dac;
2935         
2936         for (i = 0; i < cfg->line_outs; i++) {
2937                 nid = cfg->line_out_pins[i];
2938                 dac = get_unassigned_dac(codec, nid);
2939                 if (!dac) {
2940                         if (spec->multiout.num_dacs > 0) {
2941                                 /* we have already working output pins,
2942                                  * so let's drop the broken ones again
2943                                  */
2944                                 cfg->line_outs = spec->multiout.num_dacs;
2945                                 break;
2946                         }
2947                         /* error out, no available DAC found */
2948                         snd_printk(KERN_ERR
2949                                    "%s: No available DAC for pin 0x%x\n",
2950                                    __func__, nid);
2951                         return -ENODEV;
2952                 }
2953                 add_spec_dacs(spec, dac);
2954         }
2955
2956         for (i = 0; i < cfg->hp_outs; i++) {
2957                 nid = cfg->hp_pins[i];
2958                 dac = get_unassigned_dac(codec, nid);
2959                 if (dac) {
2960                         if (!spec->multiout.hp_nid)
2961                                 spec->multiout.hp_nid = dac;
2962                         else
2963                                 add_spec_extra_dacs(spec, dac);
2964                 }
2965                 spec->hp_dacs[i] = dac;
2966         }
2967
2968         for (i = 0; i < cfg->speaker_outs; i++) {
2969                 nid = cfg->speaker_pins[i];
2970                 dac = get_unassigned_dac(codec, nid);
2971                 if (dac)
2972                         add_spec_extra_dacs(spec, dac);
2973                 spec->speaker_dacs[i] = dac;
2974         }
2975
2976         /* add line-in as output */
2977         nid = check_line_out_switch(codec);
2978         if (nid) {
2979                 dac = get_unassigned_dac(codec, nid);
2980                 if (dac) {
2981                         snd_printdd("STAC: Add line-in 0x%x as output %d\n",
2982                                     nid, cfg->line_outs);
2983                         cfg->line_out_pins[cfg->line_outs] = nid;
2984                         cfg->line_outs++;
2985                         spec->line_switch = nid;
2986                         add_spec_dacs(spec, dac);
2987                 }
2988         }
2989         /* add mic as output */
2990         nid = check_mic_out_switch(codec);
2991         if (nid) {
2992                 dac = get_unassigned_dac(codec, nid);
2993                 if (dac) {
2994                         snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
2995                                     nid, cfg->line_outs);
2996                         cfg->line_out_pins[cfg->line_outs] = nid;
2997                         cfg->line_outs++;
2998                         spec->mic_switch = nid;
2999                         add_spec_dacs(spec, dac);
3000                 }
3001         }
3002
3003         snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3004                    spec->multiout.num_dacs,
3005                    spec->multiout.dac_nids[0],
3006                    spec->multiout.dac_nids[1],
3007                    spec->multiout.dac_nids[2],
3008                    spec->multiout.dac_nids[3],
3009                    spec->multiout.dac_nids[4]);
3010
3011         return 0;
3012 }
3013
3014 /* create volume control/switch for the given prefx type */
3015 static int create_controls_idx(struct hda_codec *codec, const char *pfx,
3016                                int idx, hda_nid_t nid, int chs)
3017 {
3018         struct sigmatel_spec *spec = codec->spec;
3019         char name[32];
3020         int err;
3021
3022         if (!spec->check_volume_offset) {
3023                 unsigned int caps, step, nums, db_scale;
3024                 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3025                 step = (caps & AC_AMPCAP_STEP_SIZE) >>
3026                         AC_AMPCAP_STEP_SIZE_SHIFT;
3027                 step = (step + 1) * 25; /* in .01dB unit */
3028                 nums = (caps & AC_AMPCAP_NUM_STEPS) >>
3029                         AC_AMPCAP_NUM_STEPS_SHIFT;
3030                 db_scale = nums * step;
3031                 /* if dB scale is over -64dB, and finer enough,
3032                  * let's reduce it to half
3033                  */
3034                 if (db_scale > 6400 && nums >= 0x1f)
3035                         spec->volume_offset = nums / 2;
3036                 spec->check_volume_offset = 1;
3037         }
3038
3039         sprintf(name, "%s Playback Volume", pfx);
3040         err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
3041                 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3042                                         spec->volume_offset));
3043         if (err < 0)
3044                 return err;
3045         sprintf(name, "%s Playback Switch", pfx);
3046         err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
3047                                    HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3048         if (err < 0)
3049                 return err;
3050         return 0;
3051 }
3052
3053 #define create_controls(codec, pfx, nid, chs) \
3054         create_controls_idx(codec, pfx, 0, nid, chs)
3055
3056 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3057 {
3058         if (spec->multiout.num_dacs > 4) {
3059                 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3060                 return 1;
3061         } else {
3062                 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
3063                 spec->multiout.num_dacs++;
3064         }
3065         return 0;
3066 }
3067
3068 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3069 {
3070         int i;
3071         for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3072                 if (!spec->multiout.extra_out_nid[i]) {
3073                         spec->multiout.extra_out_nid[i] = nid;
3074                         return 0;
3075                 }
3076         }
3077         printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3078         return 1;
3079 }
3080
3081 /* Create output controls
3082  * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
3083  */
3084 static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
3085                                  const hda_nid_t *pins,
3086                                  const hda_nid_t *dac_nids,
3087                                  int type)
3088 {
3089         struct sigmatel_spec *spec = codec->spec;
3090         static const char *chname[4] = {
3091                 "Front", "Surround", NULL /*CLFE*/, "Side"
3092         };
3093         hda_nid_t nid;
3094         int i, err;
3095         unsigned int wid_caps;
3096
3097         for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
3098                 if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3099                         wid_caps = get_wcaps(codec, pins[i]);
3100                         if (wid_caps & AC_WCAP_UNSOL_CAP)
3101                                 spec->hp_detect = 1;
3102                 }
3103                 nid = dac_nids[i];
3104                 if (!nid)
3105                         continue;
3106                 if (type != AUTO_PIN_HP_OUT && i == 2) {
3107                         /* Center/LFE */
3108                         err = create_controls(codec, "Center", nid, 1);
3109                         if (err < 0)
3110                                 return err;
3111                         err = create_controls(codec, "LFE", nid, 2);
3112                         if (err < 0)
3113                                 return err;
3114
3115                         wid_caps = get_wcaps(codec, nid);
3116
3117                         if (wid_caps & AC_WCAP_LR_SWAP) {
3118                                 err = stac92xx_add_control(spec,
3119                                         STAC_CTL_WIDGET_CLFE_SWITCH,
3120                                         "Swap Center/LFE Playback Switch", nid);
3121
3122                                 if (err < 0)
3123                                         return err;
3124                         }
3125
3126                 } else {
3127                         const char *name;
3128                         int idx;
3129                         switch (type) {
3130                         case AUTO_PIN_HP_OUT:
3131                                 name = "Headphone";
3132                                 idx = i;
3133                                 break;
3134                         case AUTO_PIN_SPEAKER_OUT:
3135                                 name = "Speaker";
3136                                 idx = i;
3137                                 break;
3138                         default:
3139                                 name = chname[i];
3140                                 idx = 0;
3141                                 break;
3142                         }
3143                         err = create_controls_idx(codec, name, idx, nid, 3);
3144                         if (err < 0)
3145                                 return err;
3146                 }
3147         }
3148         return 0;
3149 }
3150
3151 static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol,
3152                                     unsigned long sw, int idx)
3153 {
3154         int err;
3155         err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx,
3156                                        "Capture Volume", vol);
3157         if (err < 0)
3158                 return err;
3159         err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_MUTE, idx,
3160                                        "Capture Switch", sw);
3161         if (err < 0)
3162                 return err;
3163         return 0;
3164 }
3165
3166 /* add playback controls from the parsed DAC table */
3167 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3168                                                const struct auto_pin_cfg *cfg)
3169 {
3170         struct sigmatel_spec *spec = codec->spec;
3171         hda_nid_t nid;
3172         int err;
3173         int idx;
3174
3175         err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
3176                                     spec->multiout.dac_nids,
3177                                     cfg->line_out_type);
3178         if (err < 0)
3179                 return err;
3180
3181         if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3182                 err = stac92xx_add_control(spec,
3183                         STAC_CTL_WIDGET_HP_SWITCH,
3184                         "Headphone as Line Out Switch",
3185                         cfg->hp_pins[cfg->hp_outs - 1]);
3186                 if (err < 0)
3187                         return err;
3188         }
3189
3190         for (idx = AUTO_PIN_MIC; idx <= AUTO_PIN_FRONT_LINE; idx++) {
3191                 nid = cfg->input_pins[idx];
3192                 if (nid) {
3193                         err = stac92xx_add_jack_mode_control(codec, nid, idx);
3194                         if (err < 0)
3195                                 return err;
3196                 }
3197         }
3198
3199         return 0;
3200 }
3201
3202 /* add playback controls for Speaker and HP outputs */
3203 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3204                                         struct auto_pin_cfg *cfg)
3205 {
3206         struct sigmatel_spec *spec = codec->spec;
3207         int err;
3208
3209         err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
3210                                     spec->hp_dacs, AUTO_PIN_HP_OUT);
3211         if (err < 0)
3212                 return err;
3213
3214         err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
3215                                     spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
3216         if (err < 0)
3217                 return err;
3218
3219         return 0;
3220 }
3221
3222 /* labels for mono mux outputs */
3223 static const char *stac92xx_mono_labels[4] = {
3224         "DAC0", "DAC1", "Mixer", "DAC2"
3225 };
3226
3227 /* create mono mux for mono out on capable codecs */
3228 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3229 {
3230         struct sigmatel_spec *spec = codec->spec;
3231         struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3232         int i, num_cons;
3233         hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3234
3235         num_cons = snd_hda_get_connections(codec,
3236                                 spec->mono_nid,
3237                                 con_lst,
3238                                 HDA_MAX_NUM_INPUTS);
3239         if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3240                 return -EINVAL;
3241
3242         for (i = 0; i < num_cons; i++) {
3243                 mono_mux->items[mono_mux->num_items].label =
3244                                         stac92xx_mono_labels[i];
3245                 mono_mux->items[mono_mux->num_items].index = i;
3246                 mono_mux->num_items++;
3247         }
3248
3249         return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3250                                 "Mono Mux", spec->mono_nid);
3251 }
3252
3253 /* create PC beep volume controls */
3254 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3255                                                 hda_nid_t nid)
3256 {
3257         struct sigmatel_spec *spec = codec->spec;
3258         u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3259         int err, type = STAC_CTL_WIDGET_MUTE_BEEP;
3260
3261         if (spec->anabeep_nid == nid)
3262                 type = STAC_CTL_WIDGET_MUTE;
3263
3264         /* check for mute support for the the amp */
3265         if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3266                 err = stac92xx_add_control(spec, type,
3267                         "Beep Playback Switch",
3268                         HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3269                         if (err < 0)
3270                                 return err;
3271         }
3272
3273         /* check to see if there is volume support for the amp */
3274         if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3275                 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3276                         "Beep Playback Volume",
3277                         HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3278                         if (err < 0)
3279                                 return err;
3280         }
3281         return 0;
3282 }
3283
3284 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3285 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3286
3287 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3288                                         struct snd_ctl_elem_value *ucontrol)
3289 {
3290         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3291         ucontrol->value.integer.value[0] = codec->beep->enabled;
3292         return 0;
3293 }
3294
3295 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3296                                         struct snd_ctl_elem_value *ucontrol)
3297 {
3298         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3299         return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
3300 }
3301
3302 static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3303         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3304         .info = stac92xx_dig_beep_switch_info,
3305         .get = stac92xx_dig_beep_switch_get,
3306         .put = stac92xx_dig_beep_switch_put,
3307 };
3308
3309 static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3310 {
3311         return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3312                                          0, "Beep Playback Switch", 0);
3313 }
3314 #endif
3315
3316 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3317 {
3318         struct sigmatel_spec *spec = codec->spec;
3319         int i, j, err = 0;
3320
3321         for (i = 0; i < spec->num_muxes; i++) {
3322                 hda_nid_t nid;
3323                 unsigned int wcaps;
3324                 unsigned long val;
3325
3326                 nid = spec->mux_nids[i];
3327                 wcaps = get_wcaps(codec, nid);
3328                 if (!(wcaps & AC_WCAP_OUT_AMP))
3329                         continue;
3330
3331                 /* check whether already the same control was created as
3332                  * normal Capture Volume.
3333                  */
3334                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3335                 for (j = 0; j < spec->num_caps; j++) {
3336                         if (spec->capvols[j] == val)
3337                                 break;
3338                 }
3339                 if (j < spec->num_caps)
3340                         continue;
3341
3342                 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i,
3343                                                "Mux Capture Volume", val);
3344                 if (err < 0)
3345                         return err;
3346         }
3347         return 0;
3348 };
3349
3350 static const char *stac92xx_spdif_labels[3] = {
3351         "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3352 };
3353
3354 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3355 {
3356         struct sigmatel_spec *spec = codec->spec;
3357         struct hda_input_mux *spdif_mux = &spec->private_smux;
3358         const char **labels = spec->spdif_labels;
3359         int i, num_cons;
3360         hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3361
3362         num_cons = snd_hda_get_connections(codec,
3363                                 spec->smux_nids[0],
3364                                 con_lst,
3365                                 HDA_MAX_NUM_INPUTS);
3366         if (num_cons <= 0)
3367                 return -EINVAL;
3368
3369         if (!labels)
3370                 labels = stac92xx_spdif_labels;
3371
3372         for (i = 0; i < num_cons; i++) {
3373                 spdif_mux->items[spdif_mux->num_items].label = labels[i];
3374                 spdif_mux->items[spdif_mux->num_items].index = i;
3375                 spdif_mux->num_items++;
3376         }
3377
3378         return 0;
3379 }
3380
3381 /* labels for dmic mux inputs */
3382 static const char *stac92xx_dmic_labels[5] = {
3383         "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3384         "Digital Mic 3", "Digital Mic 4"
3385 };
3386
3387 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
3388                                 hda_nid_t nid)
3389 {
3390         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3391         int i, nums;
3392
3393         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3394         for (i = 0; i < nums; i++)
3395                 if (conn[i] == nid)
3396                         return i;
3397         return -1;
3398 }
3399
3400 /* create a volume assigned to the given pin (only if supported) */
3401 /* return 1 if the volume control is created */
3402 static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
3403                                    const char *label, int direction)
3404 {
3405         unsigned int caps, nums;
3406         char name[32];
3407         int err;
3408
3409         if (direction == HDA_OUTPUT)
3410                 caps = AC_WCAP_OUT_AMP;
3411         else
3412                 caps = AC_WCAP_IN_AMP;
3413         if (!(get_wcaps(codec, nid) & caps))
3414                 return 0;
3415         caps = query_amp_caps(codec, nid, direction);
3416         nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
3417         if (!nums)
3418                 return 0;
3419         snprintf(name, sizeof(name), "%s Capture Volume", label);
3420         err = stac92xx_add_control(codec->spec, STAC_CTL_WIDGET_VOL, name,
3421                                     HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction));
3422         if (err < 0)
3423                 return err;
3424         return 1;
3425 }
3426
3427 /* create playback/capture controls for input pins on dmic capable codecs */
3428 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3429                                                 const struct auto_pin_cfg *cfg)
3430 {
3431         struct sigmatel_spec *spec = codec->spec;
3432         struct hda_input_mux *imux = &spec->private_imux;
3433         struct hda_input_mux *dimux = &spec->private_dimux;
3434         int err, i, active_mics;
3435         unsigned int def_conf;
3436
3437         dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
3438         dimux->items[dimux->num_items].index = 0;
3439         dimux->num_items++;
3440
3441         active_mics = 0;
3442         for (i = 0; i < spec->num_dmics; i++) {
3443                 /* check the validity: sometimes it's a dead vendor-spec node */
3444                 if (get_wcaps_type(get_wcaps(codec, spec->dmic_nids[i]))
3445                     != AC_WID_PIN)
3446                         continue;
3447                 def_conf = snd_hda_codec_get_pincfg(codec, spec->dmic_nids[i]);
3448                 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)
3449                         active_mics++;
3450         }
3451
3452         for (i = 0; i < spec->num_dmics; i++) {
3453                 hda_nid_t nid;
3454                 int index;
3455                 const char *label;
3456
3457                 nid = spec->dmic_nids[i];
3458                 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
3459                         continue;
3460                 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3461                 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3462                         continue;
3463
3464                 index = get_connection_index(codec, spec->dmux_nids[0], nid);
3465                 if (index < 0)
3466                         continue;
3467
3468                 if (active_mics == 1)
3469                         label = "Digital Mic";
3470                 else
3471                         label = stac92xx_dmic_labels[dimux->num_items];
3472
3473                 err = create_elem_capture_vol(codec, nid, label, HDA_INPUT);
3474                 if (err < 0)
3475                         return err;
3476                 if (!err) {
3477                         err = create_elem_capture_vol(codec, nid, label,
3478                                                       HDA_OUTPUT);
3479                         if (err < 0)
3480                                 return err;
3481                 }
3482
3483                 dimux->items[dimux->num_items].label = label;
3484                 dimux->items[dimux->num_items].index = index;
3485                 dimux->num_items++;
3486                 if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1) {
3487                         imux->items[imux->num_items].label = label;
3488                         imux->items[imux->num_items].index = index;
3489                         imux->num_items++;
3490                 }
3491         }
3492
3493         return 0;
3494 }
3495
3496 static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid,
3497                          hda_nid_t *fixed, hda_nid_t *ext)
3498 {
3499         unsigned int cfg;
3500
3501         if (!nid)
3502                 return 0;
3503         cfg = snd_hda_codec_get_pincfg(codec, nid);
3504         switch (get_defcfg_connect(cfg)) {
3505         case AC_JACK_PORT_FIXED:
3506                 if (*fixed)
3507                         return 1; /* already occupied */
3508                 *fixed = nid;
3509                 break;
3510         case AC_JACK_PORT_COMPLEX:
3511                 if (*ext)
3512                         return 1; /* already occupied */
3513                 *ext = nid;
3514                 break;
3515         }
3516         return 0;
3517 }
3518
3519 static int set_mic_route(struct hda_codec *codec,
3520                          struct sigmatel_mic_route *mic,
3521                          hda_nid_t pin)
3522 {
3523         struct sigmatel_spec *spec = codec->spec;
3524         struct auto_pin_cfg *cfg = &spec->autocfg;
3525         int i;
3526
3527         mic->pin = pin;
3528         for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++)
3529                 if (pin == cfg->input_pins[i])
3530                         break;
3531         if (i <= AUTO_PIN_FRONT_MIC) {
3532                 /* analog pin */
3533                 i = get_connection_index(codec, spec->mux_nids[0], pin);
3534                 if (i < 0)
3535                         return -1;
3536                 mic->mux_idx = i;
3537                 mic->dmux_idx = -1;
3538                 if (spec->dmux_nids)
3539                         mic->dmux_idx = get_connection_index(codec,
3540                                                              spec->dmux_nids[0],
3541                                                              spec->mux_nids[0]);
3542         }  else if (spec->dmux_nids) {
3543                 /* digital pin */
3544                 i = get_connection_index(codec, spec->dmux_nids[0], pin);
3545                 if (i < 0)
3546                         return -1;
3547                 mic->dmux_idx = i;
3548                 mic->mux_idx = -1;
3549                 if (spec->mux_nids)
3550                         mic->mux_idx = get_connection_index(codec,
3551                                                             spec->mux_nids[0],
3552                                                             spec->dmux_nids[0]);
3553         }
3554         return 0;
3555 }
3556
3557 /* return non-zero if the device is for automatic mic switch */
3558 static int stac_check_auto_mic(struct hda_codec *codec)
3559 {
3560         struct sigmatel_spec *spec = codec->spec;
3561         struct auto_pin_cfg *cfg = &spec->autocfg;
3562         hda_nid_t fixed, ext;
3563         int i;
3564
3565         for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++) {
3566                 if (cfg->input_pins[i])
3567                         return 0; /* must be exclusively mics */
3568         }
3569         fixed = ext = 0;
3570         for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++)
3571                 if (check_mic_pin(codec, cfg->input_pins[i], &fixed, &ext))
3572                         return 0;
3573         for (i = 0; i < spec->num_dmics; i++)
3574                 if (check_mic_pin(codec, spec->dmic_nids[i], &fixed, &ext))
3575                         return 0;
3576         if (!fixed || !ext)
3577                 return 0;
3578         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
3579                 return 0; /* no unsol support */
3580         if (set_mic_route(codec, &spec->ext_mic, ext) ||
3581             set_mic_route(codec, &spec->int_mic, fixed))
3582                 return 0; /* something is wrong */
3583         return 1;
3584 }
3585
3586 /* create playback/capture controls for input pins */
3587 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3588 {
3589         struct sigmatel_spec *spec = codec->spec;
3590         struct hda_input_mux *imux = &spec->private_imux;
3591         int i, j;
3592
3593         for (i = 0; i < AUTO_PIN_LAST; i++) {
3594                 hda_nid_t nid = cfg->input_pins[i];
3595                 int index, err;
3596
3597                 if (!nid)
3598                         continue;
3599                 index = -1;
3600                 for (j = 0; j < spec->num_muxes; j++) {
3601                         index = get_connection_index(codec, spec->mux_nids[j],
3602                                                      nid);
3603                         if (index >= 0)
3604                                 break;
3605                 }
3606                 if (index < 0)
3607                         continue;
3608
3609                 err = create_elem_capture_vol(codec, nid,
3610                                               auto_pin_cfg_labels[i],
3611                                               HDA_INPUT);
3612                 if (err < 0)
3613                         return err;
3614
3615                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3616                 imux->items[imux->num_items].index = index;
3617                 imux->num_items++;
3618         }
3619         spec->num_analog_muxes = imux->num_items;
3620
3621         if (imux->num_items) {
3622                 /*
3623                  * Set the current input for the muxes.
3624                  * The STAC9221 has two input muxes with identical source
3625                  * NID lists.  Hopefully this won't get confused.
3626                  */
3627                 for (i = 0; i < spec->num_muxes; i++) {
3628                         snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3629                                                   AC_VERB_SET_CONNECT_SEL,
3630                                                   imux->items[0].index);
3631                 }
3632         }
3633
3634         return 0;
3635 }
3636
3637 static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3638 {
3639         struct sigmatel_spec *spec = codec->spec;
3640         int i;
3641
3642         for (i = 0; i < spec->autocfg.line_outs; i++) {
3643                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3644                 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3645         }
3646 }
3647
3648 static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3649 {
3650         struct sigmatel_spec *spec = codec->spec;
3651         int i;
3652
3653         for (i = 0; i < spec->autocfg.hp_outs; i++) {
3654                 hda_nid_t pin;
3655                 pin = spec->autocfg.hp_pins[i];
3656                 if (pin) /* connect to front */
3657                         stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3658         }
3659         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3660                 hda_nid_t pin;
3661                 pin = spec->autocfg.speaker_pins[i];
3662                 if (pin) /* connect to front */
3663                         stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3664         }
3665 }
3666
3667 static int is_dual_headphones(struct hda_codec *codec)
3668 {
3669         struct sigmatel_spec *spec = codec->spec;
3670         int i, valid_hps;
3671
3672         if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT ||
3673             spec->autocfg.hp_outs <= 1)
3674                 return 0;
3675         valid_hps = 0;
3676         for (i = 0; i < spec->autocfg.hp_outs; i++) {
3677                 hda_nid_t nid = spec->autocfg.hp_pins[i];
3678                 unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid);
3679                 if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE)
3680                         continue;
3681                 valid_hps++;
3682         }
3683         return (valid_hps > 1);
3684 }
3685
3686
3687 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3688 {
3689         struct sigmatel_spec *spec = codec->spec;
3690         int hp_swap = 0;
3691         int i, err;
3692
3693         if ((err = snd_hda_parse_pin_def_config(codec,
3694                                                 &spec->autocfg,
3695                                                 spec->dmic_nids)) < 0)
3696                 return err;
3697         if (! spec->autocfg.line_outs)
3698                 return 0; /* can't find valid pin config */
3699
3700         /* If we have no real line-out pin and multiple hp-outs, HPs should
3701          * be set up as multi-channel outputs.
3702          */
3703         if (is_dual_headphones(codec)) {
3704                 /* Copy hp_outs to line_outs, backup line_outs in
3705                  * speaker_outs so that the following routines can handle
3706                  * HP pins as primary outputs.
3707                  */
3708                 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3709                 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3710                        sizeof(spec->autocfg.line_out_pins));
3711                 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3712                 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3713                        sizeof(spec->autocfg.hp_pins));
3714                 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3715                 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3716                 spec->autocfg.hp_outs = 0;
3717                 hp_swap = 1;
3718         }
3719         if (spec->autocfg.mono_out_pin) {
3720                 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3721                         (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3722                 u32 caps = query_amp_caps(codec,
3723                                 spec->autocfg.mono_out_pin, dir);
3724                 hda_nid_t conn_list[1];
3725
3726                 /* get the mixer node and then the mono mux if it exists */
3727                 if (snd_hda_get_connections(codec,
3728                                 spec->autocfg.mono_out_pin, conn_list, 1) &&
3729                                 snd_hda_get_connections(codec, conn_list[0],
3730                                 conn_list, 1) > 0) {
3731
3732                                 int wcaps = get_wcaps(codec, conn_list[0]);
3733                                 int wid_type = get_wcaps_type(wcaps);
3734                                 /* LR swap check, some stac925x have a mux that
3735                                  * changes the DACs output path instead of the
3736                                  * mono-mux path.
3737                                  */
3738                                 if (wid_type == AC_WID_AUD_SEL &&
3739                                                 !(wcaps & AC_WCAP_LR_SWAP))
3740                                         spec->mono_nid = conn_list[0];
3741                 }
3742                 if (dir) {
3743                         hda_nid_t nid = spec->autocfg.mono_out_pin;
3744
3745                         /* most mono outs have a least a mute/unmute switch */
3746                         dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3747                         err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3748                                 "Mono Playback Switch",
3749                                 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3750                         if (err < 0)
3751                                 return err;
3752                         /* check for volume support for the amp */
3753                         if ((caps & AC_AMPCAP_NUM_STEPS)
3754                                         >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3755                                 err = stac92xx_add_control(spec,
3756                                         STAC_CTL_WIDGET_VOL,
3757                                         "Mono Playback Volume",
3758                                 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3759                                 if (err < 0)
3760                                         return err;
3761                         }
3762                 }
3763
3764                 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3765                                          AC_PINCTL_OUT_EN);
3766         }
3767
3768         if (!spec->multiout.num_dacs) {
3769                 err = stac92xx_auto_fill_dac_nids(codec);
3770                 if (err < 0)
3771                         return err;
3772                 err = stac92xx_auto_create_multi_out_ctls(codec,
3773                                                           &spec->autocfg);
3774                 if (err < 0)
3775                         return err;
3776         }
3777
3778         /* setup analog beep controls */
3779         if (spec->anabeep_nid > 0) {
3780                 err = stac92xx_auto_create_beep_ctls(codec,
3781                         spec->anabeep_nid);
3782                 if (err < 0)
3783                         return err;
3784         }
3785
3786         /* setup digital beep controls and input device */
3787 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3788         if (spec->digbeep_nid > 0) {
3789                 hda_nid_t nid = spec->digbeep_nid;
3790                 unsigned int caps;
3791
3792                 err = stac92xx_auto_create_beep_ctls(codec, nid);
3793                 if (err < 0)
3794                         return err;
3795                 err = snd_hda_attach_beep_device(codec, nid);
3796                 if (err < 0)
3797                         return err;
3798                 if (codec->beep) {
3799                         /* IDT/STAC codecs have linear beep tone parameter */
3800                         codec->beep->linear_tone = 1;
3801                         /* if no beep switch is available, make its own one */
3802                         caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3803                         if (!(caps & AC_AMPCAP_MUTE)) {
3804                                 err = stac92xx_beep_switch_ctl(codec);
3805                                 if (err < 0)
3806                                         return err;
3807                         }
3808                 }
3809         }
3810 #endif
3811
3812         err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3813         if (err < 0)
3814                 return err;
3815
3816         /* All output parsing done, now restore the swapped hp pins */
3817         if (hp_swap) {
3818                 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3819                        sizeof(spec->autocfg.hp_pins));
3820                 spec->autocfg.hp_outs = spec->autocfg.line_outs;
3821                 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3822                 spec->autocfg.line_outs = 0;
3823         }
3824
3825         if (stac_check_auto_mic(codec)) {
3826                 spec->auto_mic = 1;
3827                 /* only one capture for auto-mic */
3828                 spec->num_adcs = 1;
3829                 spec->num_caps = 1;
3830                 spec->num_muxes = 1;
3831         }
3832
3833         for (i = 0; i < spec->num_caps; i++) {
3834                 err = stac92xx_add_capvol_ctls(codec, spec->capvols[i],
3835                                                spec->capsws[i], i);
3836                 if (err < 0)
3837                         return err;
3838         }
3839
3840         err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3841         if (err < 0)
3842                 return err;
3843
3844         if (spec->mono_nid > 0) {
3845                 err = stac92xx_auto_create_mono_output_ctls(codec);
3846                 if (err < 0)
3847                         return err;
3848         }
3849         if (spec->num_dmics > 0 && !spec->dinput_mux)
3850                 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3851                                                 &spec->autocfg)) < 0)
3852                         return err;
3853         if (spec->num_muxes > 0) {
3854                 err = stac92xx_auto_create_mux_input_ctls(codec);
3855                 if (err < 0)
3856                         return err;
3857         }
3858         if (spec->num_smuxes > 0) {
3859                 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3860                 if (err < 0)
3861                         return err;
3862         }
3863
3864         err = stac92xx_add_input_source(spec);
3865         if (err < 0)
3866                 return err;
3867
3868         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3869         if (spec->multiout.max_channels > 2)
3870                 spec->surr_switch = 1;
3871
3872         if (spec->autocfg.dig_outs)
3873                 spec->multiout.dig_out_nid = dig_out;
3874         if (dig_in && spec->autocfg.dig_in_pin)
3875                 spec->dig_in_nid = dig_in;
3876
3877         if (spec->kctls.list)
3878                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3879
3880         spec->input_mux = &spec->private_imux;
3881         if (!spec->dinput_mux)
3882                 spec->dinput_mux = &spec->private_dimux;
3883         spec->sinput_mux = &spec->private_smux;
3884         spec->mono_mux = &spec->private_mono_mux;
3885         return 1;
3886 }
3887
3888 /* add playback controls for HP output */
3889 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3890                                         struct auto_pin_cfg *cfg)
3891 {
3892         struct sigmatel_spec *spec = codec->spec;
3893         hda_nid_t pin = cfg->hp_pins[0];
3894         unsigned int wid_caps;
3895
3896         if (! pin)
3897                 return 0;
3898
3899         wid_caps = get_wcaps(codec, pin);
3900         if (wid_caps & AC_WCAP_UNSOL_CAP)
3901                 spec->hp_detect = 1;
3902
3903         return 0;
3904 }
3905
3906 /* add playback controls for LFE output */
3907 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3908                                         struct auto_pin_cfg *cfg)
3909 {
3910         struct sigmatel_spec *spec = codec->spec;
3911         int err;
3912         hda_nid_t lfe_pin = 0x0;
3913         int i;
3914
3915         /*
3916          * search speaker outs and line outs for a mono speaker pin
3917          * with an amp.  If one is found, add LFE controls
3918          * for it.
3919          */
3920         for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3921                 hda_nid_t pin = spec->autocfg.speaker_pins[i];
3922                 unsigned int wcaps = get_wcaps(codec, pin);
3923                 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3924                 if (wcaps == AC_WCAP_OUT_AMP)
3925                         /* found a mono speaker with an amp, must be lfe */
3926                         lfe_pin = pin;
3927         }
3928
3929         /* if speaker_outs is 0, then speakers may be in line_outs */
3930         if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3931                 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3932                         hda_nid_t pin = spec->autocfg.line_out_pins[i];
3933                         unsigned int defcfg;
3934                         defcfg = snd_hda_codec_get_pincfg(codec, pin);
3935                         if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3936                                 unsigned int wcaps = get_wcaps(codec, pin);
3937                                 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3938                                 if (wcaps == AC_WCAP_OUT_AMP)
3939                                         /* found a mono speaker with an amp,
3940                                            must be lfe */
3941                                         lfe_pin = pin;
3942                         }
3943                 }
3944         }
3945
3946         if (lfe_pin) {
3947                 err = create_controls(codec, "LFE", lfe_pin, 1);
3948                 if (err < 0)
3949                         return err;
3950         }
3951
3952         return 0;
3953 }
3954
3955 static int stac9200_parse_auto_config(struct hda_codec *codec)
3956 {
3957         struct sigmatel_spec *spec = codec->spec;
3958         int err;
3959
3960         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3961                 return err;
3962
3963         if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3964                 return err;
3965
3966         if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
3967                 return err;
3968
3969         if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
3970                 return err;
3971
3972         if (spec->num_muxes > 0) {
3973                 err = stac92xx_auto_create_mux_input_ctls(codec);
3974                 if (err < 0)
3975                         return err;
3976         }
3977
3978         err = stac92xx_add_input_source(spec);
3979         if (err < 0)
3980                 return err;
3981
3982         if (spec->autocfg.dig_outs)
3983                 spec->multiout.dig_out_nid = 0x05;
3984         if (spec->autocfg.dig_in_pin)
3985                 spec->dig_in_nid = 0x04;
3986
3987         if (spec->kctls.list)
3988                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3989
3990         spec->input_mux = &spec->private_imux;
3991         spec->dinput_mux = &spec->private_dimux;
3992
3993         return 1;
3994 }
3995
3996 /*
3997  * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
3998  * funky external mute control using GPIO pins.
3999  */
4000
4001 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
4002                           unsigned int dir_mask, unsigned int data)
4003 {
4004         unsigned int gpiostate, gpiomask, gpiodir;
4005
4006         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4007                                        AC_VERB_GET_GPIO_DATA, 0);
4008         gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
4009
4010         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4011                                       AC_VERB_GET_GPIO_MASK, 0);
4012         gpiomask |= mask;
4013
4014         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4015                                      AC_VERB_GET_GPIO_DIRECTION, 0);
4016         gpiodir |= dir_mask;
4017
4018         /* Configure GPIOx as CMOS */
4019         snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
4020
4021         snd_hda_codec_write(codec, codec->afg, 0,
4022                             AC_VERB_SET_GPIO_MASK, gpiomask);
4023         snd_hda_codec_read(codec, codec->afg, 0,
4024                            AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
4025
4026         msleep(1);
4027
4028         snd_hda_codec_read(codec, codec->afg, 0,
4029                            AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
4030 }
4031
4032 #ifdef CONFIG_SND_HDA_INPUT_JACK
4033 static void stac92xx_free_jack_priv(struct snd_jack *jack)
4034 {
4035         struct sigmatel_jack *jacks = jack->private_data;
4036         jacks->nid = 0;
4037         jacks->jack = NULL;
4038 }
4039 #endif
4040
4041 static int stac92xx_add_jack(struct hda_codec *codec,
4042                 hda_nid_t nid, int type)
4043 {
4044 #ifdef CONFIG_SND_HDA_INPUT_JACK
4045         struct sigmatel_spec *spec = codec->spec;
4046         struct sigmatel_jack *jack;
4047         int def_conf = snd_hda_codec_get_pincfg(codec, nid);
4048         int connectivity = get_defcfg_connect(def_conf);
4049         char name[32];
4050         int err;
4051
4052         if (connectivity && connectivity != AC_JACK_PORT_FIXED)
4053                 return 0;
4054
4055         snd_array_init(&spec->jacks, sizeof(*jack), 32);
4056         jack = snd_array_new(&spec->jacks);
4057         if (!jack)
4058                 return -ENOMEM;
4059         jack->nid = nid;
4060         jack->type = type;
4061
4062         snprintf(name, sizeof(name), "%s at %s %s Jack",
4063                 snd_hda_get_jack_type(def_conf),
4064                 snd_hda_get_jack_connectivity(def_conf),
4065                 snd_hda_get_jack_location(def_conf));
4066
4067         err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
4068         if (err < 0) {
4069                 jack->nid = 0;
4070                 return err;
4071         }
4072         jack->jack->private_data = jack;
4073         jack->jack->private_free = stac92xx_free_jack_priv;
4074 #endif
4075         return 0;
4076 }
4077
4078 static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
4079                           unsigned char type, int data)
4080 {
4081         struct sigmatel_event *event;
4082
4083         snd_array_init(&spec->events, sizeof(*event), 32);
4084         event = snd_array_new(&spec->events);
4085         if (!event)
4086                 return -ENOMEM;
4087         event->nid = nid;
4088         event->type = type;
4089         event->tag = spec->events.used;
4090         event->data = data;
4091
4092         return event->tag;
4093 }
4094
4095 static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
4096                                              hda_nid_t nid)
4097 {
4098         struct sigmatel_spec *spec = codec->spec;
4099         struct sigmatel_event *event = spec->events.list;
4100         int i;
4101
4102         for (i = 0; i < spec->events.used; i++, event++) {
4103                 if (event->nid == nid)
4104                         return event;
4105         }
4106         return NULL;
4107 }
4108
4109 static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
4110                                                       unsigned char tag)
4111 {
4112         struct sigmatel_spec *spec = codec->spec;
4113         struct sigmatel_event *event = spec->events.list;
4114         int i;
4115
4116         for (i = 0; i < spec->events.used; i++, event++) {
4117                 if (event->tag == tag)
4118                         return event;
4119         }
4120         return NULL;
4121 }
4122
4123 /* check if given nid is a valid pin and no other events are assigned
4124  * to it.  If OK, assign the event, set the unsol flag, and returns 1.
4125  * Otherwise, returns zero.
4126  */
4127 static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
4128                              unsigned int type)
4129 {
4130         struct sigmatel_event *event;
4131         int tag;
4132
4133         if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
4134                 return 0;
4135         event = stac_get_event(codec, nid);
4136         if (event) {
4137                 if (event->type != type)
4138                         return 0;
4139                 tag = event->tag;
4140         } else {
4141                 tag = stac_add_event(codec->spec, nid, type, 0);
4142                 if (tag < 0)
4143                         return 0;
4144         }
4145         snd_hda_codec_write_cache(codec, nid, 0,
4146                                   AC_VERB_SET_UNSOLICITED_ENABLE,
4147                                   AC_USRSP_EN | tag);
4148         return 1;
4149 }
4150
4151 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
4152 {
4153         int i;
4154         for (i = 0; i < cfg->hp_outs; i++)
4155                 if (cfg->hp_pins[i] == nid)
4156                         return 1; /* nid is a HP-Out */
4157
4158         return 0; /* nid is not a HP-Out */
4159 };
4160
4161 static void stac92xx_power_down(struct hda_codec *codec)
4162 {
4163         struct sigmatel_spec *spec = codec->spec;
4164
4165         /* power down inactive DACs */
4166         hda_nid_t *dac;
4167         for (dac = spec->dac_list; *dac; dac++)
4168                 if (!check_all_dac_nids(spec, *dac))
4169                         snd_hda_codec_write(codec, *dac, 0,
4170                                         AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4171 }
4172
4173 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4174                                   int enable);
4175
4176 static inline int get_int_hint(struct hda_codec *codec, const char *key,
4177                                int *valp)
4178 {
4179         const char *p;
4180         p = snd_hda_get_hint(codec, key);
4181         if (p) {
4182                 unsigned long val;
4183                 if (!strict_strtoul(p, 0, &val)) {
4184                         *valp = val;
4185                         return 1;
4186                 }
4187         }
4188         return 0;
4189 }
4190
4191 /* override some hints from the hwdep entry */
4192 static void stac_store_hints(struct hda_codec *codec)
4193 {
4194         struct sigmatel_spec *spec = codec->spec;
4195         int val;
4196
4197         val = snd_hda_get_bool_hint(codec, "hp_detect");
4198         if (val >= 0)
4199                 spec->hp_detect = val;
4200         if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) {
4201                 spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
4202                         spec->gpio_mask;
4203         }
4204         if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir))
4205                 spec->gpio_mask &= spec->gpio_mask;
4206         if (get_int_hint(codec, "gpio_data", &spec->gpio_data))
4207                 spec->gpio_dir &= spec->gpio_mask;
4208         if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask))
4209                 spec->eapd_mask &= spec->gpio_mask;
4210         if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute))
4211                 spec->gpio_mute &= spec->gpio_mask;
4212         val = snd_hda_get_bool_hint(codec, "eapd_switch");
4213         if (val >= 0)
4214                 spec->eapd_switch = val;
4215         get_int_hint(codec, "gpio_led_polarity", &spec->gpio_led_polarity);
4216         if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) {
4217                 spec->gpio_mask |= spec->gpio_led;
4218                 spec->gpio_dir |= spec->gpio_led;
4219                 if (spec->gpio_led_polarity)
4220                         spec->gpio_data |= spec->gpio_led;
4221         }
4222 }
4223
4224 static int stac92xx_init(struct hda_codec *codec)
4225 {
4226         struct sigmatel_spec *spec = codec->spec;
4227         struct auto_pin_cfg *cfg = &spec->autocfg;
4228         unsigned int gpio;
4229         int i;
4230
4231         snd_hda_sequence_write(codec, spec->init);
4232
4233         /* power down adcs initially */
4234         if (spec->powerdown_adcs)
4235                 for (i = 0; i < spec->num_adcs; i++)
4236                         snd_hda_codec_write(codec,
4237                                 spec->adc_nids[i], 0,
4238                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4239
4240         /* override some hints */
4241         stac_store_hints(codec);
4242
4243         /* set up GPIO */
4244         gpio = spec->gpio_data;
4245         /* turn on EAPD statically when spec->eapd_switch isn't set.
4246          * otherwise, unsol event will turn it on/off dynamically
4247          */
4248         if (!spec->eapd_switch)
4249                 gpio |= spec->eapd_mask;
4250         stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
4251
4252         /* set up pins */
4253         if (spec->hp_detect) {
4254                 /* Enable unsolicited responses on the HP widget */
4255                 for (i = 0; i < cfg->hp_outs; i++) {
4256                         hda_nid_t nid = cfg->hp_pins[i];
4257                         enable_pin_detect(codec, nid, STAC_HP_EVENT);
4258                 }
4259                 if (cfg->line_out_type == AUTO_PIN_LINE_OUT &&
4260                     cfg->speaker_outs > 0) {
4261                         /* enable pin-detect for line-outs as well */
4262                         for (i = 0; i < cfg->line_outs; i++) {
4263                                 hda_nid_t nid = cfg->line_out_pins[i];
4264                                 enable_pin_detect(codec, nid, STAC_LO_EVENT);
4265                         }
4266                 }
4267
4268                 /* force to enable the first line-out; the others are set up
4269                  * in unsol_event
4270                  */
4271                 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
4272                                 AC_PINCTL_OUT_EN);
4273                 /* fake event to set up pins */
4274                 if (cfg->hp_pins[0])
4275                         stac_issue_unsol_event(codec, cfg->hp_pins[0]);
4276                 else if (cfg->line_out_pins[0])
4277                         stac_issue_unsol_event(codec, cfg->line_out_pins[0]);
4278         } else {
4279                 stac92xx_auto_init_multi_out(codec);
4280                 stac92xx_auto_init_hp_out(codec);
4281                 for (i = 0; i < cfg->hp_outs; i++)
4282                         stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
4283         }
4284         if (spec->auto_mic) {
4285                 /* initialize connection to analog input */
4286                 if (spec->dmux_nids)
4287                         snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4288                                           AC_VERB_SET_CONNECT_SEL, 0);
4289                 if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT))
4290                         stac_issue_unsol_event(codec, spec->ext_mic.pin);
4291         }
4292         for (i = 0; i < AUTO_PIN_LAST; i++) {
4293                 hda_nid_t nid = cfg->input_pins[i];
4294                 if (nid) {
4295                         unsigned int pinctl, conf;
4296                         if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
4297                                 /* for mic pins, force to initialize */
4298                                 pinctl = stac92xx_get_default_vref(codec, nid);
4299                                 pinctl |= AC_PINCTL_IN_EN;
4300                                 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4301                         } else {
4302                                 pinctl = snd_hda_codec_read(codec, nid, 0,
4303                                         AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4304                                 /* if PINCTL already set then skip */
4305                                 /* Also, if both INPUT and OUTPUT are set,
4306                                  * it must be a BIOS bug; need to override, too
4307                                  */
4308                                 if (!(pinctl & AC_PINCTL_IN_EN) ||
4309                                     (pinctl & AC_PINCTL_OUT_EN)) {
4310                                         pinctl &= ~AC_PINCTL_OUT_EN;
4311                                         pinctl |= AC_PINCTL_IN_EN;
4312                                         stac92xx_auto_set_pinctl(codec, nid,
4313                                                                  pinctl);
4314                                 }
4315                         }
4316                         conf = snd_hda_codec_get_pincfg(codec, nid);
4317                         if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
4318                                 if (enable_pin_detect(codec, nid,
4319                                                       STAC_INSERT_EVENT))
4320                                         stac_issue_unsol_event(codec, nid);
4321                         }
4322                 }
4323         }
4324         for (i = 0; i < spec->num_dmics; i++)
4325                 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4326                                         AC_PINCTL_IN_EN);
4327         if (cfg->dig_out_pins[0])
4328                 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0],
4329                                          AC_PINCTL_OUT_EN);
4330         if (cfg->dig_in_pin)
4331                 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4332                                          AC_PINCTL_IN_EN);
4333         for (i = 0; i < spec->num_pwrs; i++)  {
4334                 hda_nid_t nid = spec->pwr_nids[i];
4335                 int pinctl, def_conf;
4336
4337                 /* power on when no jack detection is available */
4338                 if (!spec->hp_detect) {
4339                         stac_toggle_power_map(codec, nid, 1);
4340                         continue;
4341                 }
4342
4343                 if (is_nid_hp_pin(cfg, nid))
4344                         continue; /* already has an unsol event */
4345
4346                 pinctl = snd_hda_codec_read(codec, nid, 0,
4347                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4348                 /* outputs are only ports capable of power management
4349                  * any attempts on powering down a input port cause the
4350                  * referenced VREF to act quirky.
4351                  */
4352                 if (pinctl & AC_PINCTL_IN_EN) {
4353                         stac_toggle_power_map(codec, nid, 1);
4354                         continue;
4355                 }
4356                 def_conf = snd_hda_codec_get_pincfg(codec, nid);
4357                 def_conf = get_defcfg_connect(def_conf);
4358                 /* skip any ports that don't have jacks since presence
4359                  * detection is useless */
4360                 if (def_conf != AC_JACK_PORT_COMPLEX) {
4361                         if (def_conf != AC_JACK_PORT_NONE)
4362                                 stac_toggle_power_map(codec, nid, 1);
4363                         continue;
4364                 }
4365                 if (enable_pin_detect(codec, nid, STAC_PWR_EVENT))
4366                         stac_issue_unsol_event(codec, nid);
4367         }
4368
4369 #ifdef CONFIG_SND_HDA_POWER_SAVE
4370         /* sync mute LED */
4371         if (spec->gpio_led && codec->patch_ops.check_power_status)
4372                 codec->patch_ops.check_power_status(codec, 0x01);
4373 #endif  
4374         if (spec->dac_list)
4375                 stac92xx_power_down(codec);
4376         return 0;
4377 }
4378
4379 static void stac92xx_free_jacks(struct hda_codec *codec)
4380 {
4381 #ifdef CONFIG_SND_HDA_INPUT_JACK
4382         /* free jack instances manually when clearing/reconfiguring */
4383         struct sigmatel_spec *spec = codec->spec;
4384         if (!codec->bus->shutdown && spec->jacks.list) {
4385                 struct sigmatel_jack *jacks = spec->jacks.list;
4386                 int i;
4387                 for (i = 0; i < spec->jacks.used; i++, jacks++) {
4388                         if (jacks->jack)
4389                                 snd_device_free(codec->bus->card, jacks->jack);
4390                 }
4391         }
4392         snd_array_free(&spec->jacks);
4393 #endif
4394 }
4395
4396 static void stac92xx_free_kctls(struct hda_codec *codec)
4397 {
4398         struct sigmatel_spec *spec = codec->spec;
4399
4400         if (spec->kctls.list) {
4401                 struct snd_kcontrol_new *kctl = spec->kctls.list;
4402                 int i;
4403                 for (i = 0; i < spec->kctls.used; i++)
4404                         kfree(kctl[i].name);
4405         }
4406         snd_array_free(&spec->kctls);
4407 }
4408
4409 static void stac92xx_shutup(struct hda_codec *codec)
4410 {
4411         struct sigmatel_spec *spec = codec->spec;
4412
4413         snd_hda_shutup_pins(codec);
4414
4415         if (spec->eapd_mask)
4416                 stac_gpio_set(codec, spec->gpio_mask,
4417                                 spec->gpio_dir, spec->gpio_data &
4418                                 ~spec->eapd_mask);
4419 }
4420
4421 static void stac92xx_free(struct hda_codec *codec)
4422 {
4423         struct sigmatel_spec *spec = codec->spec;
4424
4425         if (! spec)
4426                 return;
4427
4428         stac92xx_shutup(codec);
4429         stac92xx_free_jacks(codec);
4430         snd_array_free(&spec->events);
4431
4432         kfree(spec);
4433         snd_hda_detach_beep_device(codec);
4434 }
4435
4436 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4437                                 unsigned int flag)
4438 {
4439         unsigned int old_ctl, pin_ctl;
4440
4441         pin_ctl = snd_hda_codec_read(codec, nid,
4442                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4443
4444         if (pin_ctl & AC_PINCTL_IN_EN) {
4445                 /*
4446                  * we need to check the current set-up direction of
4447                  * shared input pins since they can be switched via
4448                  * "xxx as Output" mixer switch
4449                  */
4450                 struct sigmatel_spec *spec = codec->spec;
4451                 if (nid == spec->line_switch || nid == spec->mic_switch)
4452                         return;
4453         }
4454
4455         old_ctl = pin_ctl;
4456         /* if setting pin direction bits, clear the current
4457            direction bits first */
4458         if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4459                 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4460         
4461         pin_ctl |= flag;
4462         if (old_ctl != pin_ctl)
4463                 snd_hda_codec_write_cache(codec, nid, 0,
4464                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4465                                           pin_ctl);
4466 }
4467
4468 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4469                                   unsigned int flag)
4470 {
4471         unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4472                         0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4473         if (pin_ctl & flag)
4474                 snd_hda_codec_write_cache(codec, nid, 0,
4475                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4476                                           pin_ctl & ~flag);
4477 }
4478
4479 static inline int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4480 {
4481         if (!nid)
4482                 return 0;
4483         return snd_hda_jack_detect(codec, nid);
4484 }
4485
4486 static void stac92xx_line_out_detect(struct hda_codec *codec,
4487                                      int presence)
4488 {
4489         struct sigmatel_spec *spec = codec->spec;
4490         struct auto_pin_cfg *cfg = &spec->autocfg;
4491         int i;
4492
4493         for (i = 0; i < cfg->line_outs; i++) {
4494                 if (presence)
4495                         break;
4496                 presence = get_pin_presence(codec, cfg->line_out_pins[i]);
4497                 if (presence) {
4498                         unsigned int pinctl;
4499                         pinctl = snd_hda_codec_read(codec,
4500                                                     cfg->line_out_pins[i], 0,
4501                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4502                         if (pinctl & AC_PINCTL_IN_EN)
4503                                 presence = 0; /* mic- or line-input */
4504                 }
4505         }
4506
4507         if (presence) {
4508                 /* disable speakers */
4509                 for (i = 0; i < cfg->speaker_outs; i++)
4510                         stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4511                                                 AC_PINCTL_OUT_EN);
4512                 if (spec->eapd_mask && spec->eapd_switch)
4513                         stac_gpio_set(codec, spec->gpio_mask,
4514                                 spec->gpio_dir, spec->gpio_data &
4515                                 ~spec->eapd_mask);
4516         } else {
4517                 /* enable speakers */
4518                 for (i = 0; i < cfg->speaker_outs; i++)
4519                         stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4520                                                 AC_PINCTL_OUT_EN);
4521                 if (spec->eapd_mask && spec->eapd_switch)
4522                         stac_gpio_set(codec, spec->gpio_mask,
4523                                 spec->gpio_dir, spec->gpio_data |
4524                                 spec->eapd_mask);
4525         }
4526
4527
4528 /* return non-zero if the hp-pin of the given array index isn't
4529  * a jack-detection target
4530  */
4531 static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4532 {
4533         struct auto_pin_cfg *cfg = &spec->autocfg;
4534
4535         /* ignore sensing of shared line and mic jacks */
4536         if (cfg->hp_pins[i] == spec->line_switch)
4537                 return 1;
4538         if (cfg->hp_pins[i] == spec->mic_switch)
4539                 return 1;
4540         /* ignore if the pin is set as line-out */
4541         if (cfg->hp_pins[i] == spec->hp_switch)
4542                 return 1;
4543         return 0;
4544 }
4545
4546 static void stac92xx_hp_detect(struct hda_codec *codec)
4547 {
4548         struct sigmatel_spec *spec = codec->spec;
4549         struct auto_pin_cfg *cfg = &spec->autocfg;
4550         int i, presence;
4551
4552         presence = 0;
4553         if (spec->gpio_mute)
4554                 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4555                         AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4556
4557         for (i = 0; i < cfg->hp_outs; i++) {
4558                 if (presence)
4559                         break;
4560                 if (no_hp_sensing(spec, i))
4561                         continue;
4562                 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4563                 if (presence) {
4564                         unsigned int pinctl;
4565                         pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4566                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4567                         if (pinctl & AC_PINCTL_IN_EN)
4568                                 presence = 0; /* mic- or line-input */
4569                 }
4570         }
4571
4572         if (presence) {
4573                 /* disable lineouts */
4574                 if (spec->hp_switch)
4575                         stac92xx_reset_pinctl(codec, spec->hp_switch,
4576                                               AC_PINCTL_OUT_EN);
4577                 for (i = 0; i < cfg->line_outs; i++)
4578                         stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4579                                                 AC_PINCTL_OUT_EN);
4580         } else {
4581                 /* enable lineouts */
4582                 if (spec->hp_switch)
4583                         stac92xx_set_pinctl(codec, spec->hp_switch,
4584                                             AC_PINCTL_OUT_EN);
4585                 for (i = 0; i < cfg->line_outs; i++)
4586                         stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4587                                                 AC_PINCTL_OUT_EN);
4588         }
4589         stac92xx_line_out_detect(codec, presence);
4590         /* toggle hp outs */
4591         for (i = 0; i < cfg->hp_outs; i++) {
4592                 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4593                 if (no_hp_sensing(spec, i))
4594                         continue;
4595                 if (presence)
4596                         stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4597 #if 0 /* FIXME */
4598 /* Resetting the pinctl like below may lead to (a sort of) regressions
4599  * on some devices since they use the HP pin actually for line/speaker
4600  * outs although the default pin config shows a different pin (that is
4601  * wrong and useless).
4602  *
4603  * So, it's basically a problem of default pin configs, likely a BIOS issue.
4604  * But, disabling the code below just works around it, and I'm too tired of
4605  * bug reports with such devices... 
4606  */
4607                 else
4608                         stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4609 #endif /* FIXME */
4610         }
4611
4612
4613 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4614                                   int enable)
4615 {
4616         struct sigmatel_spec *spec = codec->spec;
4617         unsigned int idx, val;
4618
4619         for (idx = 0; idx < spec->num_pwrs; idx++) {
4620                 if (spec->pwr_nids[idx] == nid)
4621                         break;
4622         }
4623         if (idx >= spec->num_pwrs)
4624                 return;
4625
4626         /* several codecs have two power down bits */
4627         if (spec->pwr_mapping)
4628                 idx = spec->pwr_mapping[idx];
4629         else
4630                 idx = 1 << idx;
4631
4632         val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
4633         if (enable)
4634                 val &= ~idx;
4635         else
4636                 val |= idx;
4637
4638         /* power down unused output ports */
4639         snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4640 }
4641
4642 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4643 {
4644         stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4645 }
4646
4647 static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
4648 {
4649         struct sigmatel_spec *spec = codec->spec;
4650         struct sigmatel_jack *jacks = spec->jacks.list;
4651
4652         if (jacks) {
4653                 int i;
4654                 for (i = 0; i < spec->jacks.used; i++) {
4655                         if (jacks->nid == nid) {
4656                                 unsigned int pin_ctl =
4657                                         snd_hda_codec_read(codec, nid,
4658                                         0, AC_VERB_GET_PIN_WIDGET_CONTROL,
4659                                          0x00);
4660                                 int type = jacks->type;
4661                                 if (type == (SND_JACK_LINEOUT
4662                                                 | SND_JACK_HEADPHONE))
4663                                         type = (pin_ctl & AC_PINCTL_HP_EN)
4664                                         ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
4665                                 snd_jack_report(jacks->jack,
4666                                         get_pin_presence(codec, nid)
4667                                         ? type : 0);
4668                         }
4669                         jacks++;
4670                 }
4671         }
4672 }
4673
4674 static void stac92xx_mic_detect(struct hda_codec *codec)
4675 {
4676         struct sigmatel_spec *spec = codec->spec;
4677         struct sigmatel_mic_route *mic;
4678
4679         if (get_pin_presence(codec, spec->ext_mic.pin))
4680                 mic = &spec->ext_mic;
4681         else
4682                 mic = &spec->int_mic;
4683         if (mic->dmux_idx >= 0)
4684                 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4685                                           AC_VERB_SET_CONNECT_SEL,
4686                                           mic->dmux_idx);
4687         if (mic->mux_idx >= 0)
4688                 snd_hda_codec_write_cache(codec, spec->mux_nids[0], 0,
4689                                           AC_VERB_SET_CONNECT_SEL,
4690                                           mic->mux_idx);
4691 }
4692
4693 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid)
4694 {
4695         struct sigmatel_event *event = stac_get_event(codec, nid);
4696         if (!event)
4697                 return;
4698         codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
4699 }
4700
4701 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4702 {
4703         struct sigmatel_spec *spec = codec->spec;
4704         struct sigmatel_event *event;
4705         int tag, data;
4706
4707         tag = (res >> 26) & 0x7f;
4708         event = stac_get_event_from_tag(codec, tag);
4709         if (!event)
4710                 return;
4711
4712         switch (event->type) {
4713         case STAC_HP_EVENT:
4714         case STAC_LO_EVENT:
4715                 stac92xx_hp_detect(codec);
4716                 break;
4717         case STAC_MIC_EVENT:
4718                 stac92xx_mic_detect(codec);
4719                 break;
4720         }
4721
4722         switch (event->type) {
4723         case STAC_HP_EVENT:
4724         case STAC_LO_EVENT:
4725         case STAC_MIC_EVENT:
4726         case STAC_INSERT_EVENT:
4727         case STAC_PWR_EVENT:
4728                 if (spec->num_pwrs > 0)
4729                         stac92xx_pin_sense(codec, event->nid);
4730                 stac92xx_report_jack(codec, event->nid);
4731
4732                 switch (codec->subsystem_id) {
4733                 case 0x103c308f:
4734                         if (event->nid == 0xb) {
4735                                 int pin = AC_PINCTL_IN_EN;
4736
4737                                 if (get_pin_presence(codec, 0xa)
4738                                                 && get_pin_presence(codec, 0xb))
4739                                         pin |= AC_PINCTL_VREF_80;
4740                                 if (!get_pin_presence(codec, 0xb))
4741                                         pin |= AC_PINCTL_VREF_80;
4742
4743                                 /* toggle VREF state based on mic + hp pin
4744                                  * status
4745                                  */
4746                                 stac92xx_auto_set_pinctl(codec, 0x0a, pin);
4747                         }
4748                 }
4749                 break;
4750         case STAC_VREF_EVENT:
4751                 data = snd_hda_codec_read(codec, codec->afg, 0,
4752                                           AC_VERB_GET_GPIO_DATA, 0);
4753                 /* toggle VREF state based on GPIOx status */
4754                 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4755                                     !!(data & (1 << event->data)));
4756                 break;
4757         }
4758 }
4759
4760 static int hp_blike_system(u32 subsystem_id);
4761
4762 static void set_hp_led_gpio(struct hda_codec *codec)
4763 {
4764         struct sigmatel_spec *spec = codec->spec;
4765         unsigned int gpio;
4766
4767         gpio = snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP);
4768         gpio &= AC_GPIO_IO_COUNT;
4769         if (gpio > 3)
4770                 spec->gpio_led = 0x08; /* GPIO 3 */
4771         else
4772                 spec->gpio_led = 0x01; /* GPIO 0 */
4773 }
4774
4775 /*
4776  * This method searches for the mute LED GPIO configuration
4777  * provided as OEM string in SMBIOS. The format of that string
4778  * is HP_Mute_LED_P_G or HP_Mute_LED_P
4779  * where P can be 0 or 1 and defines mute LED GPIO control state (low/high)
4780  * that corresponds to the NOT muted state of the master volume
4781  * and G is the index of the GPIO to use as the mute LED control (0..9)
4782  * If _G portion is missing it is assigned based on the codec ID
4783  *
4784  * So, HP B-series like systems may have HP_Mute_LED_0 (current models)
4785  * or  HP_Mute_LED_0_3 (future models) OEM SMBIOS strings
4786  *
4787  *
4788  * The dv-series laptops don't seem to have the HP_Mute_LED* strings in
4789  * SMBIOS - at least the ones I have seen do not have them - which include
4790  * my own system (HP Pavilion dv6-1110ax) and my cousin's
4791  * HP Pavilion dv9500t CTO.
4792  * Need more information on whether it is true across the entire series.
4793  * -- kunal
4794  */
4795 static int find_mute_led_gpio(struct hda_codec *codec, int default_polarity)
4796 {
4797         struct sigmatel_spec *spec = codec->spec;
4798         const struct dmi_device *dev = NULL;
4799
4800         if ((codec->subsystem_id >> 16) == PCI_VENDOR_ID_HP) {
4801                 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING,
4802                                                                 NULL, dev))) {
4803                         if (sscanf(dev->name, "HP_Mute_LED_%d_%d",
4804                                   &spec->gpio_led_polarity,
4805                                   &spec->gpio_led) == 2) {
4806                                 spec->gpio_led = 1 << spec->gpio_led;
4807                                 return 1;
4808                         }
4809                         if (sscanf(dev->name, "HP_Mute_LED_%d",
4810                                   &spec->gpio_led_polarity) == 1) {
4811                                 set_hp_led_gpio(codec);
4812                                 return 1;
4813                         }
4814                 }
4815
4816                 /*
4817                  * Fallback case - if we don't find the DMI strings,
4818                  * we statically set the GPIO - if not a B-series system.
4819                  */
4820                 if (!hp_blike_system(codec->subsystem_id)) {
4821                         set_hp_led_gpio(codec);
4822                         spec->gpio_led_polarity = default_polarity;
4823                         return 1;
4824                 }
4825         }
4826         return 0;
4827 }
4828
4829 static int hp_blike_system(u32 subsystem_id)
4830 {
4831         switch (subsystem_id) {
4832         case 0x103c1520:
4833         case 0x103c1521:
4834         case 0x103c1523:
4835         case 0x103c1524:
4836         case 0x103c1525:
4837         case 0x103c1722:
4838         case 0x103c1723:
4839         case 0x103c1724:
4840         case 0x103c1725:
4841         case 0x103c1726:
4842         case 0x103c1727:
4843         case 0x103c1728:
4844         case 0x103c1729:
4845         case 0x103c172a:
4846         case 0x103c172b:
4847         case 0x103c307e:
4848         case 0x103c307f:
4849         case 0x103c3080:
4850         case 0x103c3081:
4851         case 0x103c7007:
4852         case 0x103c7008:
4853                 return 1;
4854         }
4855         return 0;
4856 }
4857
4858 #ifdef CONFIG_PROC_FS
4859 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4860                                struct hda_codec *codec, hda_nid_t nid)
4861 {
4862         if (nid == codec->afg)
4863                 snd_iprintf(buffer, "Power-Map: 0x%02x\n", 
4864                             snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
4865 }
4866
4867 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4868                                   struct hda_codec *codec,
4869                                   unsigned int verb)
4870 {
4871         snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4872                     snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
4873 }
4874
4875 /* stac92hd71bxx, stac92hd73xx */
4876 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4877                                  struct hda_codec *codec, hda_nid_t nid)
4878 {
4879         stac92hd_proc_hook(buffer, codec, nid);
4880         if (nid == codec->afg)
4881                 analog_loop_proc_hook(buffer, codec, 0xfa0);
4882 }
4883
4884 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4885                                struct hda_codec *codec, hda_nid_t nid)
4886 {
4887         if (nid == codec->afg)
4888                 analog_loop_proc_hook(buffer, codec, 0xfe0);
4889 }
4890
4891 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4892                                struct hda_codec *codec, hda_nid_t nid)
4893 {
4894         if (nid == codec->afg)
4895                 analog_loop_proc_hook(buffer, codec, 0xfeb);
4896 }
4897 #else
4898 #define stac92hd_proc_hook      NULL
4899 #define stac92hd7x_proc_hook    NULL
4900 #define stac9205_proc_hook      NULL
4901 #define stac927x_proc_hook      NULL
4902 #endif
4903
4904 #ifdef SND_HDA_NEEDS_RESUME
4905 static int stac92xx_resume(struct hda_codec *codec)
4906 {
4907         struct sigmatel_spec *spec = codec->spec;
4908
4909         stac92xx_init(codec);
4910         snd_hda_codec_resume_amp(codec);
4911         snd_hda_codec_resume_cache(codec);
4912         /* fake event to set up pins again to override cached values */
4913         if (spec->hp_detect) {
4914                 if (spec->autocfg.hp_pins[0])
4915                         stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0]);
4916                 else if (spec->autocfg.line_out_pins[0])
4917                         stac_issue_unsol_event(codec,
4918                                                spec->autocfg.line_out_pins[0]);
4919         }
4920 #ifdef CONFIG_SND_HDA_POWER_SAVE
4921         /* sync mute LED */
4922         if (spec->gpio_led && codec->patch_ops.check_power_status)
4923                 codec->patch_ops.check_power_status(codec, 0x01);
4924 #endif  
4925         return 0;
4926 }
4927
4928 /*
4929  * using power check for controlling mute led of HP notebooks
4930  * check for mute state only on Speakers (nid = 0x10)
4931  *
4932  * For this feature CONFIG_SND_HDA_POWER_SAVE is needed, otherwise
4933  * the LED is NOT working properly !
4934  *
4935  * Changed name to reflect that it now works for any designated
4936  * model, not just HP HDX.
4937  */
4938
4939 #ifdef CONFIG_SND_HDA_POWER_SAVE
4940 static int stac92xx_hp_check_power_status(struct hda_codec *codec,
4941                                               hda_nid_t nid)
4942 {
4943         struct sigmatel_spec *spec = codec->spec;
4944         int i, muted = 1;
4945
4946         for (i = 0; i < spec->multiout.num_dacs; i++) {
4947                 nid = spec->multiout.dac_nids[i];
4948                 if (!(snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
4949                       HDA_AMP_MUTE)) {
4950                         muted = 0; /* something heard */
4951                         break;
4952                 }
4953         }
4954         if (muted)
4955                 spec->gpio_data &= ~spec->gpio_led; /* orange */
4956         else
4957                 spec->gpio_data |= spec->gpio_led; /* white */
4958
4959         if (!spec->gpio_led_polarity) {
4960                 /* LED state is inverted on these systems */
4961                 spec->gpio_data ^= spec->gpio_led;
4962         }
4963
4964         stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
4965         return 0;
4966 }
4967 #endif
4968
4969 static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
4970 {
4971         stac92xx_shutup(codec);
4972         return 0;
4973 }
4974 #endif
4975
4976 static struct hda_codec_ops stac92xx_patch_ops = {
4977         .build_controls = stac92xx_build_controls,
4978         .build_pcms = stac92xx_build_pcms,
4979         .init = stac92xx_init,
4980         .free = stac92xx_free,
4981         .unsol_event = stac92xx_unsol_event,
4982 #ifdef SND_HDA_NEEDS_RESUME
4983         .suspend = stac92xx_suspend,
4984         .resume = stac92xx_resume,
4985 #endif
4986         .reboot_notify = stac92xx_shutup,
4987 };
4988
4989 static int patch_stac9200(struct hda_codec *codec)
4990 {
4991         struct sigmatel_spec *spec;
4992         int err;
4993
4994         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4995         if (spec == NULL)
4996                 return -ENOMEM;
4997
4998         codec->no_trigger_sense = 1;
4999         codec->spec = spec;
5000         spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
5001         spec->pin_nids = stac9200_pin_nids;
5002         spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
5003                                                         stac9200_models,
5004                                                         stac9200_cfg_tbl);
5005         if (spec->board_config < 0)
5006                 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5007                             codec->chip_name);
5008         else
5009                 stac92xx_set_config_regs(codec,
5010                                          stac9200_brd_tbl[spec->board_config]);
5011
5012         spec->multiout.max_channels = 2;
5013         spec->multiout.num_dacs = 1;
5014         spec->multiout.dac_nids = stac9200_dac_nids;
5015         spec->adc_nids = stac9200_adc_nids;
5016         spec->mux_nids = stac9200_mux_nids;
5017         spec->num_muxes = 1;
5018         spec->num_dmics = 0;
5019         spec->num_adcs = 1;
5020         spec->num_pwrs = 0;
5021
5022         if (spec->board_config == STAC_9200_M4 ||
5023             spec->board_config == STAC_9200_M4_2 ||
5024             spec->board_config == STAC_9200_OQO)
5025                 spec->init = stac9200_eapd_init;
5026         else
5027                 spec->init = stac9200_core_init;
5028         spec->mixer = stac9200_mixer;
5029
5030         if (spec->board_config == STAC_9200_PANASONIC) {
5031                 spec->gpio_mask = spec->gpio_dir = 0x09;
5032                 spec->gpio_data = 0x00;
5033         }
5034
5035         err = stac9200_parse_auto_config(codec);
5036         if (err < 0) {
5037                 stac92xx_free(codec);
5038                 return err;
5039         }
5040
5041         /* CF-74 has no headphone detection, and the driver should *NOT*
5042          * do detection and HP/speaker toggle because the hardware does it.
5043          */
5044         if (spec->board_config == STAC_9200_PANASONIC)
5045                 spec->hp_detect = 0;
5046
5047         codec->patch_ops = stac92xx_patch_ops;
5048
5049         return 0;
5050 }
5051
5052 static int patch_stac925x(struct hda_codec *codec)
5053 {
5054         struct sigmatel_spec *spec;
5055         int err;
5056
5057         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5058         if (spec == NULL)
5059                 return -ENOMEM;
5060
5061         codec->no_trigger_sense = 1;
5062         codec->spec = spec;
5063         spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
5064         spec->pin_nids = stac925x_pin_nids;
5065
5066         /* Check first for codec ID */
5067         spec->board_config = snd_hda_check_board_codec_sid_config(codec,
5068                                                         STAC_925x_MODELS,
5069                                                         stac925x_models,
5070                                                         stac925x_codec_id_cfg_tbl);
5071
5072         /* Now checks for PCI ID, if codec ID is not found */
5073         if (spec->board_config < 0)
5074                 spec->board_config = snd_hda_check_board_config(codec,
5075                                                         STAC_925x_MODELS,
5076                                                         stac925x_models,
5077                                                         stac925x_cfg_tbl);
5078  again:
5079         if (spec->board_config < 0)
5080                 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5081                             codec->chip_name);
5082         else
5083                 stac92xx_set_config_regs(codec,
5084                                          stac925x_brd_tbl[spec->board_config]);
5085
5086         spec->multiout.max_channels = 2;
5087         spec->multiout.num_dacs = 1;
5088         spec->multiout.dac_nids = stac925x_dac_nids;
5089         spec->adc_nids = stac925x_adc_nids;
5090         spec->mux_nids = stac925x_mux_nids;
5091         spec->num_muxes = 1;
5092         spec->num_adcs = 1;
5093         spec->num_pwrs = 0;
5094         switch (codec->vendor_id) {
5095         case 0x83847632: /* STAC9202  */
5096         case 0x83847633: /* STAC9202D */
5097         case 0x83847636: /* STAC9251  */
5098         case 0x83847637: /* STAC9251D */
5099                 spec->num_dmics = STAC925X_NUM_DMICS;
5100                 spec->dmic_nids = stac925x_dmic_nids;
5101                 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
5102                 spec->dmux_nids = stac925x_dmux_nids;
5103                 break;
5104         default:
5105                 spec->num_dmics = 0;
5106                 break;
5107         }
5108
5109         spec->init = stac925x_core_init;
5110         spec->mixer = stac925x_mixer;
5111         spec->num_caps = 1;
5112         spec->capvols = stac925x_capvols;
5113         spec->capsws = stac925x_capsws;
5114
5115         err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
5116         if (!err) {
5117                 if (spec->board_config < 0) {
5118                         printk(KERN_WARNING "hda_codec: No auto-config is "
5119                                "available, default to model=ref\n");
5120                         spec->board_config = STAC_925x_REF;
5121                         goto again;
5122                 }
5123                 err = -EINVAL;
5124         }
5125         if (err < 0) {
5126                 stac92xx_free(codec);
5127                 return err;
5128         }
5129
5130         codec->patch_ops = stac92xx_patch_ops;
5131
5132         return 0;
5133 }
5134
5135 static int patch_stac92hd73xx(struct hda_codec *codec)
5136 {
5137         struct sigmatel_spec *spec;
5138         hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
5139         int err = 0;
5140         int num_dacs;
5141
5142         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5143         if (spec == NULL)
5144                 return -ENOMEM;
5145
5146         codec->no_trigger_sense = 1;
5147         codec->spec = spec;
5148         codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
5149         spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
5150         spec->pin_nids = stac92hd73xx_pin_nids;
5151         spec->board_config = snd_hda_check_board_config(codec,
5152                                                         STAC_92HD73XX_MODELS,
5153                                                         stac92hd73xx_models,
5154                                                         stac92hd73xx_cfg_tbl);
5155         /* check codec subsystem id if not found */
5156         if (spec->board_config < 0)
5157                 spec->board_config =
5158                         snd_hda_check_board_codec_sid_config(codec,
5159                                 STAC_92HD73XX_MODELS, stac92hd73xx_models,
5160                                 stac92hd73xx_codec_id_cfg_tbl);
5161 again:
5162         if (spec->board_config < 0)
5163                 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5164                             codec->chip_name);
5165         else
5166                 stac92xx_set_config_regs(codec,
5167                                 stac92hd73xx_brd_tbl[spec->board_config]);
5168
5169         num_dacs = snd_hda_get_connections(codec, 0x0a,
5170                         conn, STAC92HD73_DAC_COUNT + 2) - 1;
5171
5172         if (num_dacs < 3 || num_dacs > 5) {
5173                 printk(KERN_WARNING "hda_codec: Could not determine "
5174                        "number of channels defaulting to DAC count\n");
5175                 num_dacs = STAC92HD73_DAC_COUNT;
5176         }
5177         spec->init = stac92hd73xx_core_init;
5178         switch (num_dacs) {
5179         case 0x3: /* 6 Channel */
5180                 spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
5181                 break;
5182         case 0x4: /* 8 Channel */
5183                 spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
5184                 break;
5185         case 0x5: /* 10 Channel */
5186                 spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
5187                 break;
5188         }
5189         spec->multiout.dac_nids = spec->dac_nids;
5190
5191         spec->aloopback_mask = 0x01;
5192         spec->aloopback_shift = 8;
5193
5194         spec->digbeep_nid = 0x1c;
5195         spec->mux_nids = stac92hd73xx_mux_nids;
5196         spec->adc_nids = stac92hd73xx_adc_nids;
5197         spec->dmic_nids = stac92hd73xx_dmic_nids;
5198         spec->dmux_nids = stac92hd73xx_dmux_nids;
5199         spec->smux_nids = stac92hd73xx_smux_nids;
5200
5201         spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
5202         spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
5203         spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
5204
5205         spec->num_caps = STAC92HD73XX_NUM_CAPS;
5206         spec->capvols = stac92hd73xx_capvols;
5207         spec->capsws = stac92hd73xx_capsws;
5208
5209         switch (spec->board_config) {
5210         case STAC_DELL_EQ:
5211                 spec->init = dell_eq_core_init;
5212                 /* fallthru */
5213         case STAC_DELL_M6_AMIC:
5214         case STAC_DELL_M6_DMIC:
5215         case STAC_DELL_M6_BOTH:
5216                 spec->num_smuxes = 0;
5217                 spec->eapd_switch = 0;
5218
5219                 switch (spec->board_config) {
5220                 case STAC_DELL_M6_AMIC: /* Analog Mics */
5221                         snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5222                         spec->num_dmics = 0;
5223                         break;
5224                 case STAC_DELL_M6_DMIC: /* Digital Mics */
5225                         snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5226                         spec->num_dmics = 1;
5227                         break;
5228                 case STAC_DELL_M6_BOTH: /* Both */
5229                         snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5230                         snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5231                         spec->num_dmics = 1;
5232                         break;
5233                 }
5234                 break;
5235         case STAC_ALIENWARE_M17X:
5236                 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
5237                 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
5238                 spec->eapd_switch = 0;
5239                 break;
5240         default:
5241                 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
5242                 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
5243                 spec->eapd_switch = 1;
5244                 break;
5245         }
5246         if (spec->board_config != STAC_92HD73XX_REF) {
5247                 /* GPIO0 High = Enable EAPD */
5248                 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5249                 spec->gpio_data = 0x01;
5250         }
5251
5252         spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
5253         spec->pwr_nids = stac92hd73xx_pwr_nids;
5254
5255         err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
5256
5257         if (!err) {
5258                 if (spec->board_config < 0) {
5259                         printk(KERN_WARNING "hda_codec: No auto-config is "
5260                                "available, default to model=ref\n");
5261                         spec->board_config = STAC_92HD73XX_REF;
5262                         goto again;
5263                 }
5264                 err = -EINVAL;
5265         }
5266
5267         if (err < 0) {
5268                 stac92xx_free(codec);
5269                 return err;
5270         }
5271
5272         if (spec->board_config == STAC_92HD73XX_NO_JD)
5273                 spec->hp_detect = 0;
5274
5275         codec->patch_ops = stac92xx_patch_ops;
5276
5277         codec->proc_widget_hook = stac92hd7x_proc_hook;
5278
5279         return 0;
5280 }
5281
5282 static int patch_stac92hd83xxx(struct hda_codec *codec)
5283 {
5284         struct sigmatel_spec *spec;
5285         hda_nid_t conn[STAC92HD83_DAC_COUNT + 1];
5286         int err;
5287         int num_dacs;
5288
5289         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5290         if (spec == NULL)
5291                 return -ENOMEM;
5292
5293         codec->no_trigger_sense = 1;
5294         codec->spec = spec;
5295         codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
5296         spec->digbeep_nid = 0x21;
5297         spec->mux_nids = stac92hd83xxx_mux_nids;
5298         spec->num_muxes = ARRAY_SIZE(stac92hd83xxx_mux_nids);
5299         spec->adc_nids = stac92hd83xxx_adc_nids;
5300         spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
5301         spec->pwr_nids = stac92hd83xxx_pwr_nids;
5302         spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
5303         spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
5304         spec->multiout.dac_nids = spec->dac_nids;
5305
5306         spec->init = stac92hd83xxx_core_init;
5307         spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
5308         spec->pin_nids = stac92hd83xxx_pin_nids;
5309         spec->num_caps = STAC92HD83XXX_NUM_CAPS;
5310         spec->capvols = stac92hd83xxx_capvols;
5311         spec->capsws = stac92hd83xxx_capsws;
5312
5313         spec->board_config = snd_hda_check_board_config(codec,
5314                                                         STAC_92HD83XXX_MODELS,
5315                                                         stac92hd83xxx_models,
5316                                                         stac92hd83xxx_cfg_tbl);
5317 again:
5318         if (spec->board_config < 0)
5319                 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5320                             codec->chip_name);
5321         else
5322                 stac92xx_set_config_regs(codec,
5323                                 stac92hd83xxx_brd_tbl[spec->board_config]);
5324
5325         switch (codec->vendor_id) {
5326         case 0x111d7666:
5327         case 0x111d7667:
5328         case 0x111d7668:
5329         case 0x111d7669:
5330                 spec->num_pins = ARRAY_SIZE(stac92hd88xxx_pin_nids);
5331                 spec->pin_nids = stac92hd88xxx_pin_nids;
5332                 spec->mono_nid = 0;
5333                 spec->digbeep_nid = 0;
5334                 spec->num_pwrs = 0;
5335                 break;
5336         case 0x111d7604:
5337         case 0x111d76d4:
5338         case 0x111d7605:
5339         case 0x111d76d5:
5340                 if (spec->board_config == STAC_92HD83XXX_PWR_REF)
5341                         break;
5342                 spec->num_pwrs = 0;
5343                 break;
5344         }
5345
5346         codec->patch_ops = stac92xx_patch_ops;
5347
5348         if (find_mute_led_gpio(codec, 0))
5349                 snd_printd("mute LED gpio %d polarity %d\n",
5350                                 spec->gpio_led,
5351                                 spec->gpio_led_polarity);
5352
5353 #ifdef CONFIG_SND_HDA_POWER_SAVE
5354         if (spec->gpio_led) {
5355                 spec->gpio_mask |= spec->gpio_led;
5356                 spec->gpio_dir |= spec->gpio_led;
5357                 spec->gpio_data |= spec->gpio_led;
5358                 /* register check_power_status callback. */
5359                 codec->patch_ops.check_power_status =
5360                         stac92xx_hp_check_power_status;
5361         }
5362 #endif  
5363
5364         err = stac92xx_parse_auto_config(codec, 0x1d, 0);
5365         if (!err) {
5366                 if (spec->board_config < 0) {
5367                         printk(KERN_WARNING "hda_codec: No auto-config is "
5368                                "available, default to model=ref\n");
5369                         spec->board_config = STAC_92HD83XXX_REF;
5370                         goto again;
5371                 }
5372                 err = -EINVAL;
5373         }
5374
5375         if (err < 0) {
5376                 stac92xx_free(codec);
5377                 return err;
5378         }
5379
5380         /* docking output support */
5381         num_dacs = snd_hda_get_connections(codec, 0xF,
5382                                 conn, STAC92HD83_DAC_COUNT + 1) - 1;
5383         /* skip non-DAC connections */
5384         while (num_dacs >= 0 &&
5385                         (get_wcaps_type(get_wcaps(codec, conn[num_dacs]))
5386                                         != AC_WID_AUD_OUT))
5387                 num_dacs--;
5388         /* set port E and F to select the last DAC */
5389         if (num_dacs >= 0) {
5390                 snd_hda_codec_write_cache(codec, 0xE, 0,
5391                         AC_VERB_SET_CONNECT_SEL, num_dacs);
5392                 snd_hda_codec_write_cache(codec, 0xF, 0,
5393                         AC_VERB_SET_CONNECT_SEL, num_dacs);
5394         }
5395
5396         codec->proc_widget_hook = stac92hd_proc_hook;
5397
5398         return 0;
5399 }
5400
5401 /* get the pin connection (fixed, none, etc) */
5402 static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
5403 {
5404         struct sigmatel_spec *spec = codec->spec;
5405         unsigned int cfg;
5406
5407         cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]);
5408         return get_defcfg_connect(cfg);
5409 }
5410
5411 static int stac92hd71bxx_connected_ports(struct hda_codec *codec,
5412                                          hda_nid_t *nids, int num_nids)
5413 {
5414         struct sigmatel_spec *spec = codec->spec;
5415         int idx, num;
5416         unsigned int def_conf;
5417
5418         for (num = 0; num < num_nids; num++) {
5419                 for (idx = 0; idx < spec->num_pins; idx++)
5420                         if (spec->pin_nids[idx] == nids[num])
5421                                 break;
5422                 if (idx >= spec->num_pins)
5423                         break;
5424                 def_conf = stac_get_defcfg_connect(codec, idx);
5425                 if (def_conf == AC_JACK_PORT_NONE)
5426                         break;
5427         }
5428         return num;
5429 }
5430
5431 static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
5432                                           hda_nid_t dig0pin)
5433 {
5434         struct sigmatel_spec *spec = codec->spec;
5435         int idx;
5436
5437         for (idx = 0; idx < spec->num_pins; idx++)
5438                 if (spec->pin_nids[idx] == dig0pin)
5439                         break;
5440         if ((idx + 2) >= spec->num_pins)
5441                 return 0;
5442
5443         /* dig1pin case */
5444         if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE)
5445                 return 2;
5446
5447         /* dig0pin + dig2pin case */
5448         if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE)
5449                 return 2;
5450         if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE)
5451                 return 1;
5452         else
5453                 return 0;
5454 }
5455
5456 /* HP dv7 bass switch - GPIO5 */
5457 #define stac_hp_bass_gpio_info  snd_ctl_boolean_mono_info
5458 static int stac_hp_bass_gpio_get(struct snd_kcontrol *kcontrol,
5459                                  struct snd_ctl_elem_value *ucontrol)
5460 {
5461         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5462         struct sigmatel_spec *spec = codec->spec;
5463         ucontrol->value.integer.value[0] = !!(spec->gpio_data & 0x20);
5464         return 0;
5465 }
5466
5467 static int stac_hp_bass_gpio_put(struct snd_kcontrol *kcontrol,
5468                                  struct snd_ctl_elem_value *ucontrol)
5469 {
5470         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5471         struct sigmatel_spec *spec = codec->spec;
5472         unsigned int gpio_data;
5473
5474         gpio_data = (spec->gpio_data & ~0x20) |
5475                 (ucontrol->value.integer.value[0] ? 0x20 : 0);
5476         if (gpio_data == spec->gpio_data)
5477                 return 0;
5478         spec->gpio_data = gpio_data;
5479         stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
5480         return 1;
5481 }
5482
5483 static struct snd_kcontrol_new stac_hp_bass_sw_ctrl = {
5484         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5485         .info = stac_hp_bass_gpio_info,
5486         .get = stac_hp_bass_gpio_get,
5487         .put = stac_hp_bass_gpio_put,
5488 };
5489
5490 static int stac_add_hp_bass_switch(struct hda_codec *codec)
5491 {
5492         struct sigmatel_spec *spec = codec->spec;
5493
5494         if (!stac_control_new(spec, &stac_hp_bass_sw_ctrl,
5495                               "Bass Speaker Playback Switch", 0))
5496                 return -ENOMEM;
5497
5498         spec->gpio_mask |= 0x20;
5499         spec->gpio_dir |= 0x20;
5500         spec->gpio_data |= 0x20;
5501         return 0;
5502 }
5503
5504 static int patch_stac92hd71bxx(struct hda_codec *codec)
5505 {
5506         struct sigmatel_spec *spec;
5507         struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
5508         unsigned int pin_cfg;
5509         int err = 0;
5510
5511         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5512         if (spec == NULL)
5513                 return -ENOMEM;
5514
5515         codec->no_trigger_sense = 1;
5516         codec->spec = spec;
5517         codec->patch_ops = stac92xx_patch_ops;
5518         spec->num_pins = STAC92HD71BXX_NUM_PINS;
5519         switch (codec->vendor_id) {
5520         case 0x111d76b6:
5521         case 0x111d76b7:
5522                 spec->pin_nids = stac92hd71bxx_pin_nids_4port;
5523                 break;
5524         case 0x111d7603:
5525         case 0x111d7608:
5526                 /* On 92HD75Bx 0x27 isn't a pin nid */
5527                 spec->num_pins--;
5528                 /* fallthrough */
5529         default:
5530                 spec->pin_nids = stac92hd71bxx_pin_nids_6port;
5531         }
5532         spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
5533         spec->board_config = snd_hda_check_board_config(codec,
5534                                                         STAC_92HD71BXX_MODELS,
5535                                                         stac92hd71bxx_models,
5536                                                         stac92hd71bxx_cfg_tbl);
5537 again:
5538         if (spec->board_config < 0)
5539                 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5540                             codec->chip_name);
5541         else
5542                 stac92xx_set_config_regs(codec,
5543                                 stac92hd71bxx_brd_tbl[spec->board_config]);
5544
5545         if (spec->board_config != STAC_92HD71BXX_REF) {
5546                 /* GPIO0 = EAPD */
5547                 spec->gpio_mask = 0x01;
5548                 spec->gpio_dir = 0x01;
5549                 spec->gpio_data = 0x01;
5550         }
5551
5552         spec->dmic_nids = stac92hd71bxx_dmic_nids;
5553         spec->dmux_nids = stac92hd71bxx_dmux_nids;
5554
5555         spec->num_caps = STAC92HD71BXX_NUM_CAPS;
5556         spec->capvols = stac92hd71bxx_capvols;
5557         spec->capsws = stac92hd71bxx_capsws;
5558
5559         switch (codec->vendor_id) {
5560         case 0x111d76b6: /* 4 Port without Analog Mixer */
5561         case 0x111d76b7:
5562                 unmute_init++;
5563                 /* fallthru */
5564         case 0x111d76b4: /* 6 Port without Analog Mixer */
5565         case 0x111d76b5:
5566                 spec->init = stac92hd71bxx_core_init;
5567                 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5568                 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5569                                         stac92hd71bxx_dmic_nids,
5570                                         STAC92HD71BXX_NUM_DMICS);
5571                 break;
5572         case 0x111d7608: /* 5 Port with Analog Mixer */
5573                 switch (spec->board_config) {
5574                 case STAC_HP_M4:
5575                         /* Enable VREF power saving on GPIO1 detect */
5576                         err = stac_add_event(spec, codec->afg,
5577                                              STAC_VREF_EVENT, 0x02);
5578                         if (err < 0)
5579                                 return err;
5580                         snd_hda_codec_write_cache(codec, codec->afg, 0,
5581                                 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
5582                         snd_hda_codec_write_cache(codec, codec->afg, 0,
5583                                 AC_VERB_SET_UNSOLICITED_ENABLE,
5584                                 AC_USRSP_EN | err);
5585                         spec->gpio_mask |= 0x02;
5586                         break;
5587                 }
5588                 if ((codec->revision_id & 0xf) == 0 ||
5589                     (codec->revision_id & 0xf) == 1)
5590                         spec->stream_delay = 40; /* 40 milliseconds */
5591
5592                 /* no output amps */
5593                 spec->num_pwrs = 0;
5594                 /* disable VSW */
5595                 spec->init = stac92hd71bxx_core_init;
5596                 unmute_init++;
5597                 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
5598                 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
5599                 stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS - 1] = 0;
5600                 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5601                                         stac92hd71bxx_dmic_nids,
5602                                         STAC92HD71BXX_NUM_DMICS - 1);
5603                 break;
5604         case 0x111d7603: /* 6 Port with Analog Mixer */
5605                 if ((codec->revision_id & 0xf) == 1)
5606                         spec->stream_delay = 40; /* 40 milliseconds */
5607
5608                 /* no output amps */
5609                 spec->num_pwrs = 0;
5610                 /* fallthru */
5611         default:
5612                 spec->init = stac92hd71bxx_core_init;
5613                 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5614                 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5615                                         stac92hd71bxx_dmic_nids,
5616                                         STAC92HD71BXX_NUM_DMICS);
5617                 break;
5618         }
5619
5620         if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
5621                 snd_hda_sequence_write_cache(codec, unmute_init);
5622
5623         /* Some HP machines seem to have unstable codec communications
5624          * especially with ATI fglrx driver.  For recovering from the
5625          * CORB/RIRB stall, allow the BUS reset and keep always sync
5626          */
5627         if (spec->board_config == STAC_HP_DV5) {
5628                 codec->bus->sync_write = 1;
5629                 codec->bus->allow_bus_reset = 1;
5630         }
5631
5632         spec->aloopback_ctl = stac92hd71bxx_loopback;
5633         spec->aloopback_mask = 0x50;
5634         spec->aloopback_shift = 0;
5635
5636         spec->powerdown_adcs = 1;
5637         spec->digbeep_nid = 0x26;
5638         spec->mux_nids = stac92hd71bxx_mux_nids;
5639         spec->adc_nids = stac92hd71bxx_adc_nids;
5640         spec->smux_nids = stac92hd71bxx_smux_nids;
5641         spec->pwr_nids = stac92hd71bxx_pwr_nids;
5642
5643         spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
5644         spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
5645         spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5646         spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
5647
5648         snd_printdd("Found board config: %d\n", spec->board_config);
5649
5650         switch (spec->board_config) {
5651         case STAC_HP_M4:
5652                 /* enable internal microphone */
5653                 snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
5654                 stac92xx_auto_set_pinctl(codec, 0x0e,
5655                         AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
5656                 /* fallthru */
5657         case STAC_DELL_M4_2:
5658                 spec->num_dmics = 0;
5659                 spec->num_smuxes = 0;
5660                 spec->num_dmuxes = 0;
5661                 break;
5662         case STAC_DELL_M4_1:
5663         case STAC_DELL_M4_3:
5664                 spec->num_dmics = 1;
5665                 spec->num_smuxes = 0;
5666                 spec->num_dmuxes = 1;
5667                 break;
5668         case STAC_HP_DV4_1222NR:
5669                 spec->num_dmics = 1;
5670                 /* I don't know if it needs 1 or 2 smuxes - will wait for
5671                  * bug reports to fix if needed
5672                  */
5673                 spec->num_smuxes = 1;
5674                 spec->num_dmuxes = 1;
5675                 /* fallthrough */
5676         case STAC_HP_DV5:
5677                 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
5678                 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
5679                 /* HP dv6 gives the headphone pin as a line-out.  Thus we
5680                  * need to set hp_detect flag here to force to enable HP
5681                  * detection.
5682                  */
5683                 spec->hp_detect = 1;
5684                 break;
5685         case STAC_HP_HDX:
5686                 spec->num_dmics = 1;
5687                 spec->num_dmuxes = 1;
5688                 spec->num_smuxes = 1;
5689                 break;
5690         }
5691
5692         if (hp_blike_system(codec->subsystem_id)) {
5693                 pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f);
5694                 if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT ||
5695                         get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER  ||
5696                         get_defcfg_device(pin_cfg) == AC_JACK_HP_OUT) {
5697                         /* It was changed in the BIOS to just satisfy MS DTM.
5698                          * Lets turn it back into slaved HP
5699                          */
5700                         pin_cfg = (pin_cfg & (~AC_DEFCFG_DEVICE))
5701                                         | (AC_JACK_HP_OUT <<
5702                                                 AC_DEFCFG_DEVICE_SHIFT);
5703                         pin_cfg = (pin_cfg & (~(AC_DEFCFG_DEF_ASSOC
5704                                                         | AC_DEFCFG_SEQUENCE)))
5705                                                                 | 0x1f;
5706                         snd_hda_codec_set_pincfg(codec, 0x0f, pin_cfg);
5707                 }
5708         }
5709
5710         if (find_mute_led_gpio(codec, 1))
5711                 snd_printd("mute LED gpio %d polarity %d\n",
5712                                 spec->gpio_led,
5713                                 spec->gpio_led_polarity);
5714
5715 #ifdef CONFIG_SND_HDA_POWER_SAVE
5716         if (spec->gpio_led) {
5717                 spec->gpio_mask |= spec->gpio_led;
5718                 spec->gpio_dir |= spec->gpio_led;
5719                 spec->gpio_data |= spec->gpio_led;
5720                 /* register check_power_status callback. */
5721                 codec->patch_ops.check_power_status =
5722                         stac92xx_hp_check_power_status;
5723         }
5724 #endif  
5725
5726         spec->multiout.dac_nids = spec->dac_nids;
5727
5728         err = stac92xx_parse_auto_config(codec, 0x21, 0);
5729         if (!err) {
5730                 if (spec->board_config < 0) {
5731                         printk(KERN_WARNING "hda_codec: No auto-config is "
5732                                "available, default to model=ref\n");
5733                         spec->board_config = STAC_92HD71BXX_REF;
5734                         goto again;
5735                 }
5736                 err = -EINVAL;
5737         }
5738
5739         if (err < 0) {
5740                 stac92xx_free(codec);
5741                 return err;
5742         }
5743
5744         /* enable bass on HP dv7 */
5745         if (spec->board_config == STAC_HP_DV5) {
5746                 unsigned int cap;
5747                 cap = snd_hda_param_read(codec, 0x1, AC_PAR_GPIO_CAP);
5748                 cap &= AC_GPIO_IO_COUNT;
5749                 if (cap >= 6)
5750                         stac_add_hp_bass_switch(codec);
5751         }
5752
5753         codec->proc_widget_hook = stac92hd7x_proc_hook;
5754
5755         return 0;
5756 }
5757
5758 static int patch_stac922x(struct hda_codec *codec)
5759 {
5760         struct sigmatel_spec *spec;
5761         int err;
5762
5763         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5764         if (spec == NULL)
5765                 return -ENOMEM;
5766
5767         codec->no_trigger_sense = 1;
5768         codec->spec = spec;
5769         spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
5770         spec->pin_nids = stac922x_pin_nids;
5771         spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
5772                                                         stac922x_models,
5773                                                         stac922x_cfg_tbl);
5774         if (spec->board_config == STAC_INTEL_MAC_AUTO) {
5775                 spec->gpio_mask = spec->gpio_dir = 0x03;
5776                 spec->gpio_data = 0x03;
5777                 /* Intel Macs have all same PCI SSID, so we need to check
5778                  * codec SSID to distinguish the exact models
5779                  */
5780                 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
5781                 switch (codec->subsystem_id) {
5782
5783                 case 0x106b0800:
5784                         spec->board_config = STAC_INTEL_MAC_V1;
5785                         break;
5786                 case 0x106b0600:
5787                 case 0x106b0700:
5788                         spec->board_config = STAC_INTEL_MAC_V2;
5789                         break;
5790                 case 0x106b0e00:
5791                 case 0x106b0f00:
5792                 case 0x106b1600:
5793                 case 0x106b1700:
5794                 case 0x106b0200:
5795                 case 0x106b1e00:
5796                         spec->board_config = STAC_INTEL_MAC_V3;
5797                         break;
5798                 case 0x106b1a00:
5799                 case 0x00000100:
5800                         spec->board_config = STAC_INTEL_MAC_V4;
5801                         break;
5802                 case 0x106b0a00:
5803                 case 0x106b2200:
5804                         spec->board_config = STAC_INTEL_MAC_V5;
5805                         break;
5806                 default:
5807                         spec->board_config = STAC_INTEL_MAC_V3;
5808                         break;
5809                 }
5810         }
5811
5812  again:
5813         if (spec->board_config < 0)
5814                 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5815                             codec->chip_name);
5816         else
5817                 stac92xx_set_config_regs(codec,
5818                                 stac922x_brd_tbl[spec->board_config]);
5819
5820         spec->adc_nids = stac922x_adc_nids;
5821         spec->mux_nids = stac922x_mux_nids;
5822         spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
5823         spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
5824         spec->num_dmics = 0;
5825         spec->num_pwrs = 0;
5826
5827         spec->init = stac922x_core_init;
5828
5829         spec->num_caps = STAC922X_NUM_CAPS;
5830         spec->capvols = stac922x_capvols;
5831         spec->capsws = stac922x_capsws;
5832
5833         spec->multiout.dac_nids = spec->dac_nids;
5834         
5835         err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
5836         if (!err) {
5837                 if (spec->board_config < 0) {
5838                         printk(KERN_WARNING "hda_codec: No auto-config is "
5839                                "available, default to model=ref\n");
5840                         spec->board_config = STAC_D945_REF;
5841                         goto again;
5842                 }
5843                 err = -EINVAL;
5844         }
5845         if (err < 0) {
5846                 stac92xx_free(codec);
5847                 return err;
5848         }
5849
5850         codec->patch_ops = stac92xx_patch_ops;
5851
5852         /* Fix Mux capture level; max to 2 */
5853         snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
5854                                   (0 << AC_AMPCAP_OFFSET_SHIFT) |
5855                                   (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5856                                   (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5857                                   (0 << AC_AMPCAP_MUTE_SHIFT));
5858
5859         return 0;
5860 }
5861
5862 static int patch_stac927x(struct hda_codec *codec)
5863 {
5864         struct sigmatel_spec *spec;
5865         int err;
5866
5867         spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5868         if (spec == NULL)
5869                 return -ENOMEM;
5870
5871         codec->no_trigger_sense = 1;
5872         codec->spec = spec;
5873         codec->slave_dig_outs = stac927x_slave_dig_outs;
5874         spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
5875         spec->pin_nids = stac927x_pin_nids;
5876         spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
5877                                                         stac927x_models,
5878                                                         stac927x_cfg_tbl);
5879  again:
5880         if (spec->board_config < 0)
5881                 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5882                             codec->chip_name);
5883         else
5884                 stac92xx_set_config_regs(codec,
5885                                 stac927x_brd_tbl[spec->board_config]);
5886
5887         spec->digbeep_nid = 0x23;
5888         spec->adc_nids = stac927x_adc_nids;
5889         spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
5890         spec->mux_nids = stac927x_mux_nids;
5891         spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
5892         spec->smux_nids = stac927x_smux_nids;
5893         spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
5894         spec->spdif_labels = stac927x_spdif_labels;
5895         spec->dac_list = stac927x_dac_nids;
5896         spec->multiout.dac_nids = spec->dac_nids;
5897
5898         if (spec->board_config != STAC_D965_REF) {
5899                 /* GPIO0 High = Enable EAPD */
5900                 spec->eapd_mask = spec->gpio_mask = 0x01;
5901                 spec->gpio_dir = spec->gpio_data = 0x01;
5902         }
5903
5904         switch (spec->board_config) {
5905         case STAC_D965_3ST:
5906         case STAC_D965_5ST:
5907                 /* GPIO0 High = Enable EAPD */
5908                 spec->num_dmics = 0;
5909                 spec->init = d965_core_init;
5910                 break;
5911         case STAC_DELL_BIOS:
5912                 switch (codec->subsystem_id) {
5913                 case 0x10280209:
5914                 case 0x1028022e:
5915                         /* correct the device field to SPDIF out */
5916                         snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
5917                         break;
5918                 }
5919                 /* configure the analog microphone on some laptops */
5920                 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
5921                 /* correct the front output jack as a hp out */
5922                 snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f);
5923                 /* correct the front input jack as a mic */
5924                 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
5925                 /* fallthru */
5926         case STAC_DELL_3ST:
5927                 if (codec->subsystem_id != 0x1028022f) {
5928                         /* GPIO2 High = Enable EAPD */
5929                         spec->eapd_mask = spec->gpio_mask = 0x04;
5930                         spec->gpio_dir = spec->gpio_data = 0x04;
5931                 }
5932                 spec->dmic_nids = stac927x_dmic_nids;
5933                 spec->num_dmics = STAC927X_NUM_DMICS;
5934
5935                 spec->init = dell_3st_core_init;
5936                 spec->dmux_nids = stac927x_dmux_nids;
5937                 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
5938                 break;
5939         case STAC_927X_VOLKNOB:
5940                 spec->num_dmics = 0;
5941                 spec->init = stac927x_volknob_core_init;
5942                 break;
5943         default:
5944                 spec->num_dmics = 0;
5945                 spec->init = stac927x_core_init;
5946                 break;
5947         }
5948
5949         spec->num_caps = STAC927X_NUM_CAPS;
5950         spec->capvols = stac927x_capvols;
5951         spec->capsws = stac927x_capsws;
5952
5953         spec->num_pwrs = 0;
5954         spec->aloopback_ctl = stac927x_loopback;
5955         spec->aloopback_mask = 0x40;
5956         spec->aloopback_shift = 0;
5957         spec->eapd_switch = 1;
5958
5959         err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
5960         if (!err) {
5961                 if (spec->board_config < 0) {
5962                         printk(KERN_WARNING "hda_codec: No auto-config is "
5963                                "available, default to model=ref\n");
5964                         spec->board_config = STAC_D965_REF;
5965                         goto again;
5966                 }
5967                 err = -EINVAL;
5968         }
5969         if (err < 0) {
5970                 stac92xx_free(codec);
5971                 return err;
5972         }
5973
5974         codec->patch_ops = stac92xx_patch_ops;
5975
5976         codec->proc_widget_hook = stac927x_proc_hook;
5977
5978         /*
5979          * !!FIXME!!
5980          * The STAC927x seem to require fairly long delays for certain
5981          * command sequences.  With too short delays (even if the answer
5982          * is set to RIRB properly), it results in the silence output
5983          * on some hardwares like Dell.
5984          *
5985          * The below flag enables the longer delay (see get_response
5986          * in hda_intel.c).
5987          */
5988         codec->bus-&g