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