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