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