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