1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <linux/init.h>
28#include <linux/delay.h>
29#include <linux/slab.h>
30#include <linux/pci.h>
31#include <linux/dmi.h>
32#include <sound/core.h>
33#include <sound/asoundef.h>
34#include <sound/jack.h>
35#include <sound/tlv.h>
36#include "hda_codec.h"
37#include "hda_local.h"
38#include "hda_beep.h"
39
40enum {
41 STAC_VREF_EVENT = 1,
42 STAC_INSERT_EVENT,
43 STAC_PWR_EVENT,
44 STAC_HP_EVENT,
45 STAC_LO_EVENT,
46 STAC_MIC_EVENT,
47};
48
49enum {
50 STAC_AUTO,
51 STAC_REF,
52 STAC_9200_OQO,
53 STAC_9200_DELL_D21,
54 STAC_9200_DELL_D22,
55 STAC_9200_DELL_D23,
56 STAC_9200_DELL_M21,
57 STAC_9200_DELL_M22,
58 STAC_9200_DELL_M23,
59 STAC_9200_DELL_M24,
60 STAC_9200_DELL_M25,
61 STAC_9200_DELL_M26,
62 STAC_9200_DELL_M27,
63 STAC_9200_M4,
64 STAC_9200_M4_2,
65 STAC_9200_PANASONIC,
66 STAC_9200_MODELS
67};
68
69enum {
70 STAC_9205_AUTO,
71 STAC_9205_REF,
72 STAC_9205_DELL_M42,
73 STAC_9205_DELL_M43,
74 STAC_9205_DELL_M44,
75 STAC_9205_EAPD,
76 STAC_9205_MODELS
77};
78
79enum {
80 STAC_92HD73XX_AUTO,
81 STAC_92HD73XX_NO_JD,
82 STAC_92HD73XX_REF,
83 STAC_92HD73XX_INTEL,
84 STAC_DELL_M6_AMIC,
85 STAC_DELL_M6_DMIC,
86 STAC_DELL_M6_BOTH,
87 STAC_DELL_EQ,
88 STAC_ALIENWARE_M17X,
89 STAC_92HD73XX_MODELS
90};
91
92enum {
93 STAC_92HD83XXX_AUTO,
94 STAC_92HD83XXX_REF,
95 STAC_92HD83XXX_PWR_REF,
96 STAC_DELL_S14,
97 STAC_92HD83XXX_HP,
98 STAC_HP_DV7_4000,
99 STAC_92HD83XXX_MODELS
100};
101
102enum {
103 STAC_92HD71BXX_AUTO,
104 STAC_92HD71BXX_REF,
105 STAC_DELL_M4_1,
106 STAC_DELL_M4_2,
107 STAC_DELL_M4_3,
108 STAC_HP_M4,
109 STAC_HP_DV4,
110 STAC_HP_DV5,
111 STAC_HP_HDX,
112 STAC_HP_DV4_1222NR,
113 STAC_92HD71BXX_MODELS
114};
115
116enum {
117 STAC_925x_AUTO,
118 STAC_925x_REF,
119 STAC_M1,
120 STAC_M1_2,
121 STAC_M2,
122 STAC_M2_2,
123 STAC_M3,
124 STAC_M5,
125 STAC_M6,
126 STAC_925x_MODELS
127};
128
129enum {
130 STAC_922X_AUTO,
131 STAC_D945_REF,
132 STAC_D945GTP3,
133 STAC_D945GTP5,
134 STAC_INTEL_MAC_V1,
135 STAC_INTEL_MAC_V2,
136 STAC_INTEL_MAC_V3,
137 STAC_INTEL_MAC_V4,
138 STAC_INTEL_MAC_V5,
139 STAC_INTEL_MAC_AUTO,
140
141
142
143 STAC_MACMINI,
144 STAC_MACBOOK,
145 STAC_MACBOOK_PRO_V1,
146 STAC_MACBOOK_PRO_V2,
147 STAC_IMAC_INTEL,
148 STAC_IMAC_INTEL_20,
149 STAC_ECS_202,
150 STAC_922X_DELL_D81,
151 STAC_922X_DELL_D82,
152 STAC_922X_DELL_M81,
153 STAC_922X_DELL_M82,
154 STAC_922X_MODELS
155};
156
157enum {
158 STAC_927X_AUTO,
159 STAC_D965_REF_NO_JD,
160 STAC_D965_REF,
161 STAC_D965_3ST,
162 STAC_D965_5ST,
163 STAC_D965_5ST_NO_FP,
164 STAC_DELL_3ST,
165 STAC_DELL_BIOS,
166 STAC_927X_VOLKNOB,
167 STAC_927X_MODELS
168};
169
170enum {
171 STAC_9872_AUTO,
172 STAC_9872_VAIO,
173 STAC_9872_MODELS
174};
175
176struct sigmatel_event {
177 hda_nid_t nid;
178 unsigned char type;
179 unsigned char tag;
180 int data;
181};
182
183struct sigmatel_mic_route {
184 hda_nid_t pin;
185 signed char mux_idx;
186 signed char dmux_idx;
187};
188
189#define MAX_PINS_NUM 16
190#define MAX_ADCS_NUM 4
191#define MAX_DMICS_NUM 4
192
193struct sigmatel_spec {
194 struct snd_kcontrol_new *mixers[4];
195 unsigned int num_mixers;
196
197 int board_config;
198 unsigned int eapd_switch: 1;
199 unsigned int surr_switch: 1;
200 unsigned int alt_switch: 1;
201 unsigned int hp_detect: 1;
202 unsigned int spdif_mute: 1;
203 unsigned int check_volume_offset:1;
204 unsigned int auto_mic:1;
205 unsigned int linear_tone_beep:1;
206
207
208 unsigned int eapd_mask;
209 unsigned int gpio_mask;
210 unsigned int gpio_dir;
211 unsigned int gpio_data;
212 unsigned int gpio_mute;
213 unsigned int gpio_led;
214 unsigned int gpio_led_polarity;
215
216
217 unsigned int stream_delay;
218
219
220 struct snd_kcontrol_new *aloopback_ctl;
221 unsigned char aloopback_mask;
222 unsigned char aloopback_shift;
223
224
225 unsigned int num_pwrs;
226 unsigned int *pwr_mapping;
227 hda_nid_t *pwr_nids;
228 hda_nid_t *dac_list;
229
230
231 struct snd_array events;
232
233
234 struct hda_input_mux *mono_mux;
235 unsigned int cur_mmux;
236 struct hda_multi_out multiout;
237 hda_nid_t dac_nids[5];
238 hda_nid_t hp_dacs[5];
239 hda_nid_t speaker_dacs[5];
240
241 int volume_offset;
242
243
244 hda_nid_t *adc_nids;
245 unsigned int num_adcs;
246 hda_nid_t *mux_nids;
247 unsigned int num_muxes;
248 hda_nid_t *dmic_nids;
249 unsigned int num_dmics;
250 hda_nid_t *dmux_nids;
251 unsigned int num_dmuxes;
252 hda_nid_t *smux_nids;
253 unsigned int num_smuxes;
254 unsigned int num_analog_muxes;
255
256 unsigned long *capvols;
257 unsigned long *capsws;
258 unsigned int num_caps;
259
260 struct sigmatel_mic_route ext_mic;
261 struct sigmatel_mic_route int_mic;
262 struct sigmatel_mic_route dock_mic;
263
264 const char * const *spdif_labels;
265
266 hda_nid_t dig_in_nid;
267 hda_nid_t mono_nid;
268 hda_nid_t anabeep_nid;
269 hda_nid_t digbeep_nid;
270
271
272 hda_nid_t *pin_nids;
273 unsigned int num_pins;
274
275
276 struct hda_verb *init;
277 struct snd_kcontrol_new *mixer;
278
279
280 struct hda_input_mux *dinput_mux;
281 unsigned int cur_dmux[2];
282 struct hda_input_mux *input_mux;
283 unsigned int cur_mux[3];
284 struct hda_input_mux *sinput_mux;
285 unsigned int cur_smux[2];
286 unsigned int cur_amux;
287 hda_nid_t *amp_nids;
288 unsigned int powerdown_adcs;
289
290
291 unsigned int io_switch[2];
292 unsigned int clfe_swap;
293 hda_nid_t line_switch;
294 hda_nid_t mic_switch;
295 hda_nid_t hp_switch;
296 unsigned int aloopback;
297
298 struct hda_pcm pcm_rec[2];
299
300
301 struct auto_pin_cfg autocfg;
302 struct snd_array kctls;
303 struct hda_input_mux private_dimux;
304 struct hda_input_mux private_imux;
305 struct hda_input_mux private_smux;
306 struct hda_input_mux private_mono_mux;
307
308
309 unsigned auto_pin_cnt;
310 hda_nid_t auto_pin_nids[MAX_PINS_NUM];
311 unsigned auto_adc_cnt;
312 hda_nid_t auto_adc_nids[MAX_ADCS_NUM];
313 hda_nid_t auto_mux_nids[MAX_ADCS_NUM];
314 hda_nid_t auto_dmux_nids[MAX_ADCS_NUM];
315 unsigned long auto_capvols[MAX_ADCS_NUM];
316 unsigned auto_dmic_cnt;
317 hda_nid_t auto_dmic_nids[MAX_DMICS_NUM];
318};
319
320static hda_nid_t stac9200_adc_nids[1] = {
321 0x03,
322};
323
324static hda_nid_t stac9200_mux_nids[1] = {
325 0x0c,
326};
327
328static hda_nid_t stac9200_dac_nids[1] = {
329 0x02,
330};
331
332static hda_nid_t stac92hd73xx_pwr_nids[8] = {
333 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
334 0x0f, 0x10, 0x11
335};
336
337static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
338 0x26, 0,
339};
340
341static hda_nid_t stac92hd73xx_adc_nids[2] = {
342 0x1a, 0x1b
343};
344
345#define STAC92HD73XX_NUM_DMICS 2
346static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
347 0x13, 0x14, 0
348};
349
350#define STAC92HD73_DAC_COUNT 5
351
352static hda_nid_t stac92hd73xx_mux_nids[2] = {
353 0x20, 0x21,
354};
355
356static hda_nid_t stac92hd73xx_dmux_nids[2] = {
357 0x20, 0x21,
358};
359
360static hda_nid_t stac92hd73xx_smux_nids[2] = {
361 0x22, 0x23,
362};
363
364#define STAC92HD73XX_NUM_CAPS 2
365static unsigned long stac92hd73xx_capvols[] = {
366 HDA_COMPOSE_AMP_VAL(0x20, 3, 0, HDA_OUTPUT),
367 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
368};
369#define stac92hd73xx_capsws stac92hd73xx_capvols
370
371#define STAC92HD83_DAC_COUNT 3
372
373static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
374 0xa, 0xb, 0xd, 0xe,
375};
376
377static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
378 0x1e, 0,
379};
380
381static unsigned int stac92hd83xxx_pwr_mapping[4] = {
382 0x03, 0x0c, 0x20, 0x40,
383};
384
385static hda_nid_t stac92hd83xxx_dmic_nids[] = {
386 0x11, 0x20,
387};
388
389static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
390 0x0a, 0x0d, 0x0f
391};
392
393static hda_nid_t stac92hd71bxx_adc_nids[2] = {
394 0x12, 0x13,
395};
396
397static hda_nid_t stac92hd71bxx_mux_nids[2] = {
398 0x1a, 0x1b
399};
400
401static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
402 0x1c, 0x1d,
403};
404
405static hda_nid_t stac92hd71bxx_smux_nids[2] = {
406 0x24, 0x25,
407};
408
409#define STAC92HD71BXX_NUM_DMICS 2
410static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
411 0x18, 0x19, 0
412};
413
414static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
415 0x22, 0
416};
417
418#define STAC92HD71BXX_NUM_CAPS 2
419static unsigned long stac92hd71bxx_capvols[] = {
420 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
421 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
422};
423#define stac92hd71bxx_capsws stac92hd71bxx_capvols
424
425static hda_nid_t stac925x_adc_nids[1] = {
426 0x03,
427};
428
429static hda_nid_t stac925x_mux_nids[1] = {
430 0x0f,
431};
432
433static hda_nid_t stac925x_dac_nids[1] = {
434 0x02,
435};
436
437#define STAC925X_NUM_DMICS 1
438static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
439 0x15, 0
440};
441
442static hda_nid_t stac925x_dmux_nids[1] = {
443 0x14,
444};
445
446static unsigned long stac925x_capvols[] = {
447 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
448};
449static unsigned long stac925x_capsws[] = {
450 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
451};
452
453static hda_nid_t stac922x_adc_nids[2] = {
454 0x06, 0x07,
455};
456
457static hda_nid_t stac922x_mux_nids[2] = {
458 0x12, 0x13,
459};
460
461#define STAC922X_NUM_CAPS 2
462static unsigned long stac922x_capvols[] = {
463 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_INPUT),
464 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
465};
466#define stac922x_capsws stac922x_capvols
467
468static hda_nid_t stac927x_slave_dig_outs[2] = {
469 0x1f, 0,
470};
471
472static hda_nid_t stac927x_adc_nids[3] = {
473 0x07, 0x08, 0x09
474};
475
476static hda_nid_t stac927x_mux_nids[3] = {
477 0x15, 0x16, 0x17
478};
479
480static hda_nid_t stac927x_smux_nids[1] = {
481 0x21,
482};
483
484static hda_nid_t stac927x_dac_nids[6] = {
485 0x02, 0x03, 0x04, 0x05, 0x06, 0
486};
487
488static hda_nid_t stac927x_dmux_nids[1] = {
489 0x1b,
490};
491
492#define STAC927X_NUM_DMICS 2
493static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
494 0x13, 0x14, 0
495};
496
497#define STAC927X_NUM_CAPS 3
498static unsigned long stac927x_capvols[] = {
499 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
500 HDA_COMPOSE_AMP_VAL(0x19, 3, 0, HDA_INPUT),
501 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_INPUT),
502};
503static unsigned long stac927x_capsws[] = {
504 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
505 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
506 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
507};
508
509static const char * const stac927x_spdif_labels[5] = {
510 "Digital Playback", "ADAT", "Analog Mux 1",
511 "Analog Mux 2", "Analog Mux 3"
512};
513
514static hda_nid_t stac9205_adc_nids[2] = {
515 0x12, 0x13
516};
517
518static hda_nid_t stac9205_mux_nids[2] = {
519 0x19, 0x1a
520};
521
522static hda_nid_t stac9205_dmux_nids[1] = {
523 0x1d,
524};
525
526static hda_nid_t stac9205_smux_nids[1] = {
527 0x21,
528};
529
530#define STAC9205_NUM_DMICS 2
531static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
532 0x17, 0x18, 0
533};
534
535#define STAC9205_NUM_CAPS 2
536static unsigned long stac9205_capvols[] = {
537 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_INPUT),
538 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_INPUT),
539};
540static unsigned long stac9205_capsws[] = {
541 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
542 HDA_COMPOSE_AMP_VAL(0x1e, 3, 0, HDA_OUTPUT),
543};
544
545static hda_nid_t stac9200_pin_nids[8] = {
546 0x08, 0x09, 0x0d, 0x0e,
547 0x0f, 0x10, 0x11, 0x12,
548};
549
550static hda_nid_t stac925x_pin_nids[8] = {
551 0x07, 0x08, 0x0a, 0x0b,
552 0x0c, 0x0d, 0x10, 0x11,
553};
554
555static hda_nid_t stac922x_pin_nids[10] = {
556 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
557 0x0f, 0x10, 0x11, 0x15, 0x1b,
558};
559
560static hda_nid_t stac92hd73xx_pin_nids[13] = {
561 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
562 0x0f, 0x10, 0x11, 0x12, 0x13,
563 0x14, 0x22, 0x23
564};
565
566#define STAC92HD71BXX_NUM_PINS 13
567static hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
568 0x0a, 0x0b, 0x0c, 0x0d, 0x00,
569 0x00, 0x14, 0x18, 0x19, 0x1e,
570 0x1f, 0x20, 0x27
571};
572static hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
573 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
574 0x0f, 0x14, 0x18, 0x19, 0x1e,
575 0x1f, 0x20, 0x27
576};
577
578static hda_nid_t stac927x_pin_nids[14] = {
579 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
580 0x0f, 0x10, 0x11, 0x12, 0x13,
581 0x14, 0x21, 0x22, 0x23,
582};
583
584static hda_nid_t stac9205_pin_nids[12] = {
585 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
586 0x0f, 0x14, 0x16, 0x17, 0x18,
587 0x21, 0x22,
588};
589
590static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
591 struct snd_ctl_elem_info *uinfo)
592{
593 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
594 struct sigmatel_spec *spec = codec->spec;
595 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
596}
597
598static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
599 struct snd_ctl_elem_value *ucontrol)
600{
601 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
602 struct sigmatel_spec *spec = codec->spec;
603 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
604
605 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
606 return 0;
607}
608
609static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
610 struct snd_ctl_elem_value *ucontrol)
611{
612 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
613 struct sigmatel_spec *spec = codec->spec;
614 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
615
616 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
617 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
618}
619
620static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
621 struct snd_ctl_elem_info *uinfo)
622{
623 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
624 struct sigmatel_spec *spec = codec->spec;
625 return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
626}
627
628static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
629 struct snd_ctl_elem_value *ucontrol)
630{
631 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
632 struct sigmatel_spec *spec = codec->spec;
633 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
634
635 ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
636 return 0;
637}
638
639static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
640 struct snd_ctl_elem_value *ucontrol)
641{
642 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
643 struct sigmatel_spec *spec = codec->spec;
644 struct hda_input_mux *smux = &spec->private_smux;
645 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
646 int err, val;
647 hda_nid_t nid;
648
649 err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
650 spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
651 if (err < 0)
652 return err;
653
654 if (spec->spdif_mute) {
655 if (smux_idx == 0)
656 nid = spec->multiout.dig_out_nid;
657 else
658 nid = codec->slave_dig_outs[smux_idx - 1];
659 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
660 val = HDA_AMP_MUTE;
661 else
662 val = 0;
663
664 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
665 HDA_AMP_MUTE, val);
666 }
667 return 0;
668}
669
670static unsigned int stac92xx_vref_set(struct hda_codec *codec,
671 hda_nid_t nid, unsigned int new_vref)
672{
673 int error;
674 unsigned int pincfg;
675 pincfg = snd_hda_codec_read(codec, nid, 0,
676 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
677
678 pincfg &= 0xff;
679 pincfg &= ~(AC_PINCTL_VREFEN | AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
680 pincfg |= new_vref;
681
682 if (new_vref == AC_PINCTL_VREF_HIZ)
683 pincfg |= AC_PINCTL_OUT_EN;
684 else
685 pincfg |= AC_PINCTL_IN_EN;
686
687 error = snd_hda_codec_write_cache(codec, nid, 0,
688 AC_VERB_SET_PIN_WIDGET_CONTROL, pincfg);
689 if (error < 0)
690 return error;
691 else
692 return 1;
693}
694
695static unsigned int stac92xx_vref_get(struct hda_codec *codec, hda_nid_t nid)
696{
697 unsigned int vref;
698 vref = snd_hda_codec_read(codec, nid, 0,
699 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
700 vref &= AC_PINCTL_VREFEN;
701 return vref;
702}
703
704static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
705{
706 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
707 struct sigmatel_spec *spec = codec->spec;
708 return snd_hda_input_mux_info(spec->input_mux, uinfo);
709}
710
711static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
712{
713 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
714 struct sigmatel_spec *spec = codec->spec;
715 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
716
717 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
718 return 0;
719}
720
721static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
722{
723 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
724 struct sigmatel_spec *spec = codec->spec;
725 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
726 const struct hda_input_mux *imux = spec->input_mux;
727 unsigned int idx, prev_idx, didx;
728
729 idx = ucontrol->value.enumerated.item[0];
730 if (idx >= imux->num_items)
731 idx = imux->num_items - 1;
732 prev_idx = spec->cur_mux[adc_idx];
733 if (prev_idx == idx)
734 return 0;
735 if (idx < spec->num_analog_muxes) {
736 snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0,
737 AC_VERB_SET_CONNECT_SEL,
738 imux->items[idx].index);
739 if (prev_idx >= spec->num_analog_muxes &&
740 spec->mux_nids[adc_idx] != spec->dmux_nids[adc_idx]) {
741 imux = spec->dinput_mux;
742
743 snd_hda_codec_write_cache(codec,
744 spec->dmux_nids[adc_idx], 0,
745 AC_VERB_SET_CONNECT_SEL,
746 imux->items[0].index);
747 }
748 } else {
749 imux = spec->dinput_mux;
750
751
752
753 didx = idx - spec->num_analog_muxes + 1;
754 snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0,
755 AC_VERB_SET_CONNECT_SEL,
756 imux->items[didx].index);
757 }
758 spec->cur_mux[adc_idx] = idx;
759 return 1;
760}
761
762static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
763 struct snd_ctl_elem_info *uinfo)
764{
765 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
766 struct sigmatel_spec *spec = codec->spec;
767 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
768}
769
770static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
771 struct snd_ctl_elem_value *ucontrol)
772{
773 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
774 struct sigmatel_spec *spec = codec->spec;
775
776 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
777 return 0;
778}
779
780static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
781 struct snd_ctl_elem_value *ucontrol)
782{
783 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
784 struct sigmatel_spec *spec = codec->spec;
785
786 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
787 spec->mono_nid, &spec->cur_mmux);
788}
789
790#define stac92xx_aloopback_info snd_ctl_boolean_mono_info
791
792static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
793 struct snd_ctl_elem_value *ucontrol)
794{
795 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
796 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
797 struct sigmatel_spec *spec = codec->spec;
798
799 ucontrol->value.integer.value[0] = !!(spec->aloopback &
800 (spec->aloopback_mask << idx));
801 return 0;
802}
803
804static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
805 struct snd_ctl_elem_value *ucontrol)
806{
807 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
808 struct sigmatel_spec *spec = codec->spec;
809 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
810 unsigned int dac_mode;
811 unsigned int val, idx_val;
812
813 idx_val = spec->aloopback_mask << idx;
814 if (ucontrol->value.integer.value[0])
815 val = spec->aloopback | idx_val;
816 else
817 val = spec->aloopback & ~idx_val;
818 if (spec->aloopback == val)
819 return 0;
820
821 spec->aloopback = val;
822
823
824
825
826 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
827 kcontrol->private_value & 0xFFFF, 0x0);
828 dac_mode >>= spec->aloopback_shift;
829
830 if (spec->aloopback & idx_val) {
831 snd_hda_power_up(codec);
832 dac_mode |= idx_val;
833 } else {
834 snd_hda_power_down(codec);
835 dac_mode &= ~idx_val;
836 }
837
838 snd_hda_codec_write_cache(codec, codec->afg, 0,
839 kcontrol->private_value >> 16, dac_mode);
840
841 return 1;
842}
843
844static struct hda_verb stac9200_core_init[] = {
845
846 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
847 {}
848};
849
850static struct hda_verb stac9200_eapd_init[] = {
851
852 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
853 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
854 {}
855};
856
857static struct hda_verb dell_eq_core_init[] = {
858
859
860 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
861 {}
862};
863
864static struct hda_verb stac92hd73xx_core_init[] = {
865
866 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
867 {}
868};
869
870static struct hda_verb stac92hd83xxx_core_init[] = {
871
872 { 0x01, AC_VERB_SET_EAPD, 1 << 2},
873 {}
874};
875
876static struct hda_verb stac92hd71bxx_core_init[] = {
877
878 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
879 {}
880};
881
882static struct hda_verb stac92hd71bxx_unmute_core_init[] = {
883
884 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
885 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
886 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
887 {}
888};
889
890static struct hda_verb stac925x_core_init[] = {
891
892 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
893
894 { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
895 {}
896};
897
898static struct hda_verb stac922x_core_init[] = {
899
900 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
901 {}
902};
903
904static struct hda_verb d965_core_init[] = {
905
906 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
907
908 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
909
910 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
911 {}
912};
913
914static struct hda_verb dell_3st_core_init[] = {
915
916 {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
917
918 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
919
920 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
921 {}
922};
923
924static struct hda_verb stac927x_core_init[] = {
925
926 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
927
928 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
929 {}
930};
931
932static struct hda_verb stac927x_volknob_core_init[] = {
933
934 {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
935
936 {0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
937 {}
938};
939
940static struct hda_verb stac9205_core_init[] = {
941
942 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
943
944 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
945 {}
946};
947
948#define STAC_MONO_MUX \
949 { \
950 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
951 .name = "Mono Mux", \
952 .count = 1, \
953 .info = stac92xx_mono_mux_enum_info, \
954 .get = stac92xx_mono_mux_enum_get, \
955 .put = stac92xx_mono_mux_enum_put, \
956 }
957
958#define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
959 { \
960 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
961 .name = "Analog Loopback", \
962 .count = cnt, \
963 .info = stac92xx_aloopback_info, \
964 .get = stac92xx_aloopback_get, \
965 .put = stac92xx_aloopback_put, \
966 .private_value = verb_read | (verb_write << 16), \
967 }
968
969#define DC_BIAS(xname, idx, nid) \
970 { \
971 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
972 .name = xname, \
973 .index = idx, \
974 .info = stac92xx_dc_bias_info, \
975 .get = stac92xx_dc_bias_get, \
976 .put = stac92xx_dc_bias_put, \
977 .private_value = nid, \
978 }
979
980static struct snd_kcontrol_new stac9200_mixer[] = {
981 HDA_CODEC_VOLUME_MIN_MUTE("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
982 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
983 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
984 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
985 { }
986};
987
988static struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
989 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
990 {}
991};
992
993static struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = {
994 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
995 {}
996};
997
998static struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
999 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1000 {}
1001};
1002
1003
1004static struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
1005 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
1006};
1007
1008static struct snd_kcontrol_new stac925x_mixer[] = {
1009 HDA_CODEC_VOLUME_MIN_MUTE("Master Playback Volume", 0xe, 0, HDA_OUTPUT),
1010 HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
1011 { }
1012};
1013
1014static struct snd_kcontrol_new stac9205_loopback[] = {
1015 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1016 {}
1017};
1018
1019static struct snd_kcontrol_new stac927x_loopback[] = {
1020 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1021 {}
1022};
1023
1024static struct snd_kcontrol_new stac_dmux_mixer = {
1025 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1026 .name = "Digital Input Source",
1027
1028 .info = stac92xx_dmux_enum_info,
1029 .get = stac92xx_dmux_enum_get,
1030 .put = stac92xx_dmux_enum_put,
1031};
1032
1033static struct snd_kcontrol_new stac_smux_mixer = {
1034 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1035 .name = "IEC958 Playback Source",
1036
1037 .info = stac92xx_smux_enum_info,
1038 .get = stac92xx_smux_enum_get,
1039 .put = stac92xx_smux_enum_put,
1040};
1041
1042static const char * const slave_vols[] = {
1043 "Front Playback Volume",
1044 "Surround Playback Volume",
1045 "Center Playback Volume",
1046 "LFE Playback Volume",
1047 "Side Playback Volume",
1048 "Headphone Playback Volume",
1049 "Speaker Playback Volume",
1050 NULL
1051};
1052
1053static const char * const slave_sws[] = {
1054 "Front Playback Switch",
1055 "Surround Playback Switch",
1056 "Center Playback Switch",
1057 "LFE Playback Switch",
1058 "Side Playback Switch",
1059 "Headphone Playback Switch",
1060 "Speaker Playback Switch",
1061 "IEC958 Playback Switch",
1062 NULL
1063};
1064
1065static void stac92xx_free_kctls(struct hda_codec *codec);
1066static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
1067
1068static int stac92xx_build_controls(struct hda_codec *codec)
1069{
1070 struct sigmatel_spec *spec = codec->spec;
1071 struct auto_pin_cfg *cfg = &spec->autocfg;
1072 hda_nid_t nid;
1073 int err;
1074 int i;
1075
1076 if (spec->mixer) {
1077 err = snd_hda_add_new_ctls(codec, spec->mixer);
1078 if (err < 0)
1079 return err;
1080 }
1081
1082 for (i = 0; i < spec->num_mixers; i++) {
1083 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1084 if (err < 0)
1085 return err;
1086 }
1087 if (!spec->auto_mic && spec->num_dmuxes > 0 &&
1088 snd_hda_get_bool_hint(codec, "separate_dmux") == 1) {
1089 stac_dmux_mixer.count = spec->num_dmuxes;
1090 err = snd_hda_ctl_add(codec, 0,
1091 snd_ctl_new1(&stac_dmux_mixer, codec));
1092 if (err < 0)
1093 return err;
1094 }
1095 if (spec->num_smuxes > 0) {
1096 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1097 struct hda_input_mux *smux = &spec->private_smux;
1098
1099 if (wcaps & AC_WCAP_OUT_AMP) {
1100 snd_hda_add_imux_item(smux, "Off", 0, NULL);
1101 spec->spdif_mute = 1;
1102 }
1103 stac_smux_mixer.count = spec->num_smuxes;
1104 err = snd_hda_ctl_add(codec, 0,
1105 snd_ctl_new1(&stac_smux_mixer, codec));
1106 if (err < 0)
1107 return err;
1108 }
1109
1110 if (spec->multiout.dig_out_nid) {
1111 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1112 if (err < 0)
1113 return err;
1114 err = snd_hda_create_spdif_share_sw(codec,
1115 &spec->multiout);
1116 if (err < 0)
1117 return err;
1118 spec->multiout.share_spdif = 1;
1119 }
1120 if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1121 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1122 if (err < 0)
1123 return err;
1124 }
1125
1126
1127 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1128 unsigned int vmaster_tlv[4];
1129 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1130 HDA_OUTPUT, vmaster_tlv);
1131
1132 vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
1133
1134 vmaster_tlv[3] |= TLV_DB_SCALE_MUTE;
1135 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1136 vmaster_tlv, slave_vols);
1137 if (err < 0)
1138 return err;
1139 }
1140 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1141 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1142 NULL, slave_sws);
1143 if (err < 0)
1144 return err;
1145 }
1146
1147 if (spec->aloopback_ctl &&
1148 snd_hda_get_bool_hint(codec, "loopback") == 1) {
1149 err = snd_hda_add_new_ctls(codec, spec->aloopback_ctl);
1150 if (err < 0)
1151 return err;
1152 }
1153
1154 stac92xx_free_kctls(codec);
1155
1156
1157 if (spec->hp_detect) {
1158 for (i = 0; i < cfg->hp_outs; i++) {
1159 int type = SND_JACK_HEADPHONE;
1160 nid = cfg->hp_pins[i];
1161
1162 if (cfg->hp_outs == i)
1163 type |= SND_JACK_LINEOUT;
1164 err = stac92xx_add_jack(codec, nid, type);
1165 if (err < 0)
1166 return err;
1167 }
1168 }
1169 for (i = 0; i < cfg->line_outs; i++) {
1170 err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
1171 SND_JACK_LINEOUT);
1172 if (err < 0)
1173 return err;
1174 }
1175 for (i = 0; i < cfg->num_inputs; i++) {
1176 nid = cfg->inputs[i].pin;
1177 err = stac92xx_add_jack(codec, nid, SND_JACK_MICROPHONE);
1178 if (err < 0)
1179 return err;
1180 }
1181
1182 return 0;
1183}
1184
1185static unsigned int ref9200_pin_configs[8] = {
1186 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1187 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1188};
1189
1190static unsigned int gateway9200_m4_pin_configs[8] = {
1191 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1192 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1193};
1194static unsigned int gateway9200_m4_2_pin_configs[8] = {
1195 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1196 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1197};
1198
1199
1200
1201
1202
1203
1204
1205static unsigned int dell9200_d21_pin_configs[8] = {
1206 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
1207 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1208};
1209
1210
1211
1212
1213
1214
1215static unsigned int dell9200_d22_pin_configs[8] = {
1216 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1217 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1218};
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229static unsigned int dell9200_d23_pin_configs[8] = {
1230 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1231 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
1232};
1233
1234
1235
1236
1237
1238
1239
1240static unsigned int dell9200_m21_pin_configs[8] = {
1241 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1242 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1243};
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253static unsigned int dell9200_m22_pin_configs[8] = {
1254 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1255 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1256};
1257
1258
1259
1260
1261
1262
1263static unsigned int dell9200_m23_pin_configs[8] = {
1264 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1265 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1266};
1267
1268
1269
1270
1271
1272
1273
1274
1275static unsigned int dell9200_m24_pin_configs[8] = {
1276 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1277 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
1278};
1279
1280
1281
1282
1283
1284
1285
1286static unsigned int dell9200_m25_pin_configs[8] = {
1287 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1288 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1289};
1290
1291
1292
1293
1294
1295
1296static unsigned int dell9200_m26_pin_configs[8] = {
1297 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1298 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1299};
1300
1301
1302
1303
1304
1305static unsigned int dell9200_m27_pin_configs[8] = {
1306 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1307 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1308};
1309
1310static unsigned int oqo9200_pin_configs[8] = {
1311 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1312 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1313};
1314
1315
1316static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1317 [STAC_REF] = ref9200_pin_configs,
1318 [STAC_9200_OQO] = oqo9200_pin_configs,
1319 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1320 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1321 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1322 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1323 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1324 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1325 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1326 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1327 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1328 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1329 [STAC_9200_M4] = gateway9200_m4_pin_configs,
1330 [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1331 [STAC_9200_PANASONIC] = ref9200_pin_configs,
1332};
1333
1334static const char * const stac9200_models[STAC_9200_MODELS] = {
1335 [STAC_AUTO] = "auto",
1336 [STAC_REF] = "ref",
1337 [STAC_9200_OQO] = "oqo",
1338 [STAC_9200_DELL_D21] = "dell-d21",
1339 [STAC_9200_DELL_D22] = "dell-d22",
1340 [STAC_9200_DELL_D23] = "dell-d23",
1341 [STAC_9200_DELL_M21] = "dell-m21",
1342 [STAC_9200_DELL_M22] = "dell-m22",
1343 [STAC_9200_DELL_M23] = "dell-m23",
1344 [STAC_9200_DELL_M24] = "dell-m24",
1345 [STAC_9200_DELL_M25] = "dell-m25",
1346 [STAC_9200_DELL_M26] = "dell-m26",
1347 [STAC_9200_DELL_M27] = "dell-m27",
1348 [STAC_9200_M4] = "gateway-m4",
1349 [STAC_9200_M4_2] = "gateway-m4-2",
1350 [STAC_9200_PANASONIC] = "panasonic",
1351};
1352
1353static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1354
1355 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1356 "DFI LanParty", STAC_REF),
1357 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1358 "DFI LanParty", STAC_REF),
1359
1360 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1361 "unknown Dell", STAC_9200_DELL_D21),
1362 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1363 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1364 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1365 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1366 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1367 "unknown Dell", STAC_9200_DELL_D22),
1368 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1369 "unknown Dell", STAC_9200_DELL_D22),
1370 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1371 "Dell Latitude D620", STAC_9200_DELL_M22),
1372 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1373 "unknown Dell", STAC_9200_DELL_D23),
1374 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1375 "unknown Dell", STAC_9200_DELL_D23),
1376 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1377 "unknown Dell", STAC_9200_DELL_M22),
1378 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1379 "unknown Dell", STAC_9200_DELL_M24),
1380 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1381 "unknown Dell", STAC_9200_DELL_M24),
1382 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1383 "Dell Latitude 120L", STAC_9200_DELL_M24),
1384 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1385 "Dell Latitude D820", STAC_9200_DELL_M22),
1386 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1387 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1388 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1389 "Dell XPS M1710", STAC_9200_DELL_M23),
1390 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1391 "Dell Precision M90", STAC_9200_DELL_M23),
1392 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1393 "unknown Dell", STAC_9200_DELL_M22),
1394 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1395 "unknown Dell", STAC_9200_DELL_M22),
1396 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1397 "unknown Dell", STAC_9200_DELL_M22),
1398 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1399 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1400 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1401 "unknown Dell", STAC_9200_DELL_D23),
1402 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1403 "unknown Dell", STAC_9200_DELL_D23),
1404 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1405 "unknown Dell", STAC_9200_DELL_D21),
1406 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1407 "unknown Dell", STAC_9200_DELL_D23),
1408 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1409 "unknown Dell", STAC_9200_DELL_D21),
1410 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1411 "unknown Dell", STAC_9200_DELL_M25),
1412 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1413 "unknown Dell", STAC_9200_DELL_M25),
1414 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1415 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1416 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1417 "unknown Dell", STAC_9200_DELL_M26),
1418
1419 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1420
1421 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1422 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1423 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1424
1425 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1426 {}
1427};
1428
1429static unsigned int ref925x_pin_configs[8] = {
1430 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1431 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1432};
1433
1434static unsigned int stac925xM1_pin_configs[8] = {
1435 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1436 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1437};
1438
1439static unsigned int stac925xM1_2_pin_configs[8] = {
1440 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1441 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1442};
1443
1444static unsigned int stac925xM2_pin_configs[8] = {
1445 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1446 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1447};
1448
1449static unsigned int stac925xM2_2_pin_configs[8] = {
1450 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1451 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1452};
1453
1454static unsigned int stac925xM3_pin_configs[8] = {
1455 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1456 0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1457};
1458
1459static unsigned int stac925xM5_pin_configs[8] = {
1460 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1461 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1462};
1463
1464static unsigned int stac925xM6_pin_configs[8] = {
1465 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1466 0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1467};
1468
1469static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1470 [STAC_REF] = ref925x_pin_configs,
1471 [STAC_M1] = stac925xM1_pin_configs,
1472 [STAC_M1_2] = stac925xM1_2_pin_configs,
1473 [STAC_M2] = stac925xM2_pin_configs,
1474 [STAC_M2_2] = stac925xM2_2_pin_configs,
1475 [STAC_M3] = stac925xM3_pin_configs,
1476 [STAC_M5] = stac925xM5_pin_configs,
1477 [STAC_M6] = stac925xM6_pin_configs,
1478};
1479
1480static const char * const stac925x_models[STAC_925x_MODELS] = {
1481 [STAC_925x_AUTO] = "auto",
1482 [STAC_REF] = "ref",
1483 [STAC_M1] = "m1",
1484 [STAC_M1_2] = "m1-2",
1485 [STAC_M2] = "m2",
1486 [STAC_M2_2] = "m2-2",
1487 [STAC_M3] = "m3",
1488 [STAC_M5] = "m5",
1489 [STAC_M6] = "m6",
1490};
1491
1492static struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1493 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1494 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1495 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1496 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1497 SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1498
1499 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1500 SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1501 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1502 SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1503 {}
1504};
1505
1506static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1507
1508 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1509 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
1510 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1511
1512
1513 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1514
1515 {}
1516};
1517
1518static unsigned int ref92hd73xx_pin_configs[13] = {
1519 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1520 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1521 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1522 0x01452050,
1523};
1524
1525static unsigned int dell_m6_pin_configs[13] = {
1526 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1527 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1528 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1529 0x4f0000f0,
1530};
1531
1532static unsigned int alienware_m17x_pin_configs[13] = {
1533 0x0321101f, 0x0321101f, 0x03a11020, 0x03014020,
1534 0x90170110, 0x4f0000f0, 0x4f0000f0, 0x4f0000f0,
1535 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1536 0x904601b0,
1537};
1538
1539static unsigned int intel_dg45id_pin_configs[13] = {
1540 0x02214230, 0x02A19240, 0x01013214, 0x01014210,
1541 0x01A19250, 0x01011212, 0x01016211
1542};
1543
1544static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1545 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
1546 [STAC_DELL_M6_AMIC] = dell_m6_pin_configs,
1547 [STAC_DELL_M6_DMIC] = dell_m6_pin_configs,
1548 [STAC_DELL_M6_BOTH] = dell_m6_pin_configs,
1549 [STAC_DELL_EQ] = dell_m6_pin_configs,
1550 [STAC_ALIENWARE_M17X] = alienware_m17x_pin_configs,
1551 [STAC_92HD73XX_INTEL] = intel_dg45id_pin_configs,
1552};
1553
1554static const char * const stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1555 [STAC_92HD73XX_AUTO] = "auto",
1556 [STAC_92HD73XX_NO_JD] = "no-jd",
1557 [STAC_92HD73XX_REF] = "ref",
1558 [STAC_92HD73XX_INTEL] = "intel",
1559 [STAC_DELL_M6_AMIC] = "dell-m6-amic",
1560 [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1561 [STAC_DELL_M6_BOTH] = "dell-m6",
1562 [STAC_DELL_EQ] = "dell-eq",
1563 [STAC_ALIENWARE_M17X] = "alienware",
1564};
1565
1566static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1567
1568 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1569 "DFI LanParty", STAC_92HD73XX_REF),
1570 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1571 "DFI LanParty", STAC_92HD73XX_REF),
1572 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
1573 "Intel DG45ID", STAC_92HD73XX_INTEL),
1574 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
1575 "Intel DG45FC", STAC_92HD73XX_INTEL),
1576 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1577 "Dell Studio 1535", STAC_DELL_M6_DMIC),
1578 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1579 "unknown Dell", STAC_DELL_M6_DMIC),
1580 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1581 "unknown Dell", STAC_DELL_M6_BOTH),
1582 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1583 "unknown Dell", STAC_DELL_M6_BOTH),
1584 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1585 "unknown Dell", STAC_DELL_M6_AMIC),
1586 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1587 "unknown Dell", STAC_DELL_M6_AMIC),
1588 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1589 "unknown Dell", STAC_DELL_M6_DMIC),
1590 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1591 "unknown Dell", STAC_DELL_M6_DMIC),
1592 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1593 "Dell Studio 1537", STAC_DELL_M6_DMIC),
1594 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1595 "Dell Studio 17", STAC_DELL_M6_DMIC),
1596 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
1597 "Dell Studio 1555", STAC_DELL_M6_DMIC),
1598 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd,
1599 "Dell Studio 1557", STAC_DELL_M6_DMIC),
1600 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe,
1601 "Dell Studio XPS 1645", STAC_DELL_M6_BOTH),
1602 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413,
1603 "Dell Studio 1558", STAC_DELL_M6_DMIC),
1604 {}
1605};
1606
1607static struct snd_pci_quirk stac92hd73xx_codec_id_cfg_tbl[] = {
1608 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1,
1609 "Alienware M17x", STAC_ALIENWARE_M17X),
1610 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x043a,
1611 "Alienware M17x", STAC_ALIENWARE_M17X),
1612 {}
1613};
1614
1615static unsigned int ref92hd83xxx_pin_configs[10] = {
1616 0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1617 0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1618 0x01451160, 0x98560170,
1619};
1620
1621static unsigned int dell_s14_pin_configs[10] = {
1622 0x0221403f, 0x0221101f, 0x02a19020, 0x90170110,
1623 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a60160,
1624 0x40f000f0, 0x40f000f0,
1625};
1626
1627static unsigned int hp_dv7_4000_pin_configs[10] = {
1628 0x03a12050, 0x0321201f, 0x40f000f0, 0x90170110,
1629 0x40f000f0, 0x40f000f0, 0x90170110, 0xd5a30140,
1630 0x40f000f0, 0x40f000f0,
1631};
1632
1633static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1634 [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1635 [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
1636 [STAC_DELL_S14] = dell_s14_pin_configs,
1637 [STAC_HP_DV7_4000] = hp_dv7_4000_pin_configs,
1638};
1639
1640static const char * const stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1641 [STAC_92HD83XXX_AUTO] = "auto",
1642 [STAC_92HD83XXX_REF] = "ref",
1643 [STAC_92HD83XXX_PWR_REF] = "mic-ref",
1644 [STAC_DELL_S14] = "dell-s14",
1645 [STAC_92HD83XXX_HP] = "hp",
1646 [STAC_HP_DV7_4000] = "hp-dv7-4000",
1647};
1648
1649static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1650
1651 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1652 "DFI LanParty", STAC_92HD83XXX_REF),
1653 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1654 "DFI LanParty", STAC_92HD83XXX_REF),
1655 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
1656 "unknown Dell", STAC_DELL_S14),
1657 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x3600,
1658 "HP", STAC_92HD83XXX_HP),
1659 {}
1660};
1661
1662static unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1663 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1664 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1665 0x90a000f0, 0x01452050, 0x01452050, 0x00000000,
1666 0x00000000
1667};
1668
1669static unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1670 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1671 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1672 0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000,
1673 0x00000000
1674};
1675
1676static unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1677 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1678 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1679 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1680 0x00000000
1681};
1682
1683static unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1684 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1685 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1686 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1687 0x00000000
1688};
1689
1690static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1691 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1692 [STAC_DELL_M4_1] = dell_m4_1_pin_configs,
1693 [STAC_DELL_M4_2] = dell_m4_2_pin_configs,
1694 [STAC_DELL_M4_3] = dell_m4_3_pin_configs,
1695 [STAC_HP_M4] = NULL,
1696 [STAC_HP_DV4] = NULL,
1697 [STAC_HP_DV5] = NULL,
1698 [STAC_HP_HDX] = NULL,
1699 [STAC_HP_DV4_1222NR] = NULL,
1700};
1701
1702static const char * const stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1703 [STAC_92HD71BXX_AUTO] = "auto",
1704 [STAC_92HD71BXX_REF] = "ref",
1705 [STAC_DELL_M4_1] = "dell-m4-1",
1706 [STAC_DELL_M4_2] = "dell-m4-2",
1707 [STAC_DELL_M4_3] = "dell-m4-3",
1708 [STAC_HP_M4] = "hp-m4",
1709 [STAC_HP_DV4] = "hp-dv4",
1710 [STAC_HP_DV5] = "hp-dv5",
1711 [STAC_HP_HDX] = "hp-hdx",
1712 [STAC_HP_DV4_1222NR] = "hp-dv4-1222nr",
1713};
1714
1715static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1716
1717 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1718 "DFI LanParty", STAC_92HD71BXX_REF),
1719 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1720 "DFI LanParty", STAC_92HD71BXX_REF),
1721 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb,
1722 "HP dv4-1222nr", STAC_HP_DV4_1222NR),
1723 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720,
1724 "HP", STAC_HP_DV5),
1725 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
1726 "HP", STAC_HP_DV5),
1727 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
1728 "HP dv4-7", STAC_HP_DV4),
1729 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
1730 "HP dv4-7", STAC_HP_DV5),
1731 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
1732 "HP HDX", STAC_HP_HDX),
1733 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1734 "HP mini 1000", STAC_HP_M4),
1735 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
1736 "HP HDX", STAC_HP_HDX),
1737 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
1738 "HP dv6", STAC_HP_DV5),
1739 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061,
1740 "HP dv6", STAC_HP_DV5),
1741 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x363e,
1742 "HP DV6", STAC_HP_DV5),
1743 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
1744 "HP", STAC_HP_DV5),
1745 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1746 "unknown Dell", STAC_DELL_M4_1),
1747 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1748 "unknown Dell", STAC_DELL_M4_1),
1749 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1750 "unknown Dell", STAC_DELL_M4_1),
1751 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1752 "unknown Dell", STAC_DELL_M4_1),
1753 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1754 "unknown Dell", STAC_DELL_M4_1),
1755 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1756 "unknown Dell", STAC_DELL_M4_1),
1757 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1758 "unknown Dell", STAC_DELL_M4_1),
1759 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1760 "unknown Dell", STAC_DELL_M4_2),
1761 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1762 "unknown Dell", STAC_DELL_M4_2),
1763 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1764 "unknown Dell", STAC_DELL_M4_2),
1765 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1766 "unknown Dell", STAC_DELL_M4_2),
1767 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1768 "unknown Dell", STAC_DELL_M4_3),
1769 {}
1770};
1771
1772static unsigned int ref922x_pin_configs[10] = {
1773 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1774 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1775 0x40000100, 0x40000100,
1776};
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786static unsigned int dell_922x_d81_pin_configs[10] = {
1787 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1788 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1789 0x01813122, 0x400001f2,
1790};
1791
1792
1793
1794
1795
1796
1797static unsigned int dell_922x_d82_pin_configs[10] = {
1798 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1799 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1800 0x01813122, 0x400001f1,
1801};
1802
1803
1804
1805
1806
1807static unsigned int dell_922x_m81_pin_configs[10] = {
1808 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1809 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1810 0x40C003f1, 0x405003f0,
1811};
1812
1813
1814
1815
1816
1817static unsigned int dell_922x_m82_pin_configs[10] = {
1818 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1819 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
1820 0x508003f3, 0x405003f4,
1821};
1822
1823static unsigned int d945gtp3_pin_configs[10] = {
1824 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1825 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1826 0x02a19120, 0x40000100,
1827};
1828
1829static unsigned int d945gtp5_pin_configs[10] = {
1830 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1831 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1832 0x02a19320, 0x40000100,
1833};
1834
1835static unsigned int intel_mac_v1_pin_configs[10] = {
1836 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1837 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1838 0x400000fc, 0x400000fb,
1839};
1840
1841static unsigned int intel_mac_v2_pin_configs[10] = {
1842 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1843 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1844 0x400000fc, 0x400000fb,
1845};
1846
1847static unsigned int intel_mac_v3_pin_configs[10] = {
1848 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1849 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1850 0x400000fc, 0x400000fb,
1851};
1852
1853static unsigned int intel_mac_v4_pin_configs[10] = {
1854 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1855 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1856 0x400000fc, 0x400000fb,
1857};
1858
1859static unsigned int intel_mac_v5_pin_configs[10] = {
1860 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1861 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1862 0x400000fc, 0x400000fb,
1863};
1864
1865static unsigned int ecs202_pin_configs[10] = {
1866 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1867 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1868 0x9037012e, 0x40e000f2,
1869};
1870
1871static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1872 [STAC_D945_REF] = ref922x_pin_configs,
1873 [STAC_D945GTP3] = d945gtp3_pin_configs,
1874 [STAC_D945GTP5] = d945gtp5_pin_configs,
1875 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1876 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1877 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1878 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1879 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1880 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1881
1882 [STAC_MACMINI] = intel_mac_v3_pin_configs,
1883 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1884 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1885 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1886 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1887 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1888 [STAC_ECS_202] = ecs202_pin_configs,
1889 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1890 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
1891 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1892 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
1893};
1894
1895static const char * const stac922x_models[STAC_922X_MODELS] = {
1896 [STAC_922X_AUTO] = "auto",
1897 [STAC_D945_REF] = "ref",
1898 [STAC_D945GTP5] = "5stack",
1899 [STAC_D945GTP3] = "3stack",
1900 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1901 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1902 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1903 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1904 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1905 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1906
1907 [STAC_MACMINI] = "macmini",
1908 [STAC_MACBOOK] = "macbook",
1909 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
1910 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
1911 [STAC_IMAC_INTEL] = "imac-intel",
1912 [STAC_IMAC_INTEL_20] = "imac-intel-20",
1913 [STAC_ECS_202] = "ecs202",
1914 [STAC_922X_DELL_D81] = "dell-d81",
1915 [STAC_922X_DELL_D82] = "dell-d82",
1916 [STAC_922X_DELL_M81] = "dell-m81",
1917 [STAC_922X_DELL_M82] = "dell-m82",
1918};
1919
1920static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1921
1922 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1923 "DFI LanParty", STAC_D945_REF),
1924 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1925 "DFI LanParty", STAC_D945_REF),
1926
1927 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1928 "Intel D945G", STAC_D945GTP3),
1929 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1930 "Intel D945G", STAC_D945GTP3),
1931 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1932 "Intel D945G", STAC_D945GTP3),
1933 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1934 "Intel D945G", STAC_D945GTP3),
1935 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1936 "Intel D945G", STAC_D945GTP3),
1937 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1938 "Intel D945G", STAC_D945GTP3),
1939 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1940 "Intel D945G", STAC_D945GTP3),
1941 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1942 "Intel D945G", STAC_D945GTP3),
1943 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1944 "Intel D945G", STAC_D945GTP3),
1945 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1946 "Intel D945G", STAC_D945GTP3),
1947 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1948 "Intel D945G", STAC_D945GTP3),
1949 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1950 "Intel D945G", STAC_D945GTP3),
1951 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1952 "Intel D945G", STAC_D945GTP3),
1953 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1954 "Intel D945G", STAC_D945GTP3),
1955 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1956 "Intel D945G", STAC_D945GTP3),
1957
1958 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1959 "Intel D945G", STAC_D945GTP5),
1960 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1961 "Intel D945G", STAC_D945GTP5),
1962 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1963 "Intel D945G", STAC_D945GTP5),
1964 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1965 "Intel D945G", STAC_D945GTP5),
1966
1967 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1968 "Intel D945P", STAC_D945GTP3),
1969 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1970 "Intel D945P", STAC_D945GTP3),
1971 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1972 "Intel D945P", STAC_D945GTP3),
1973 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1974 "Intel D945P", STAC_D945GTP3),
1975 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1976 "Intel D945P", STAC_D945GTP3),
1977 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1978 "Intel D945P", STAC_D945GTP5),
1979
1980 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
1981 "Intel D945", STAC_D945_REF),
1982
1983
1984 SND_PCI_QUIRK(0x8384, 0x7680,
1985 "Mac", STAC_INTEL_MAC_AUTO),
1986
1987 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1988 "unknown Dell", STAC_922X_DELL_D81),
1989 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1990 "unknown Dell", STAC_922X_DELL_D81),
1991 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1992 "unknown Dell", STAC_922X_DELL_D81),
1993 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1994 "unknown Dell", STAC_922X_DELL_D82),
1995 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1996 "unknown Dell", STAC_922X_DELL_M81),
1997 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1998 "unknown Dell", STAC_922X_DELL_D82),
1999 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
2000 "unknown Dell", STAC_922X_DELL_D81),
2001 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
2002 "unknown Dell", STAC_922X_DELL_D81),
2003 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
2004 "Dell XPS M1210", STAC_922X_DELL_M82),
2005
2006 SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
2007 "ECS/PC chips", STAC_ECS_202),
2008 {}
2009};
2010
2011static unsigned int ref927x_pin_configs[14] = {
2012 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2013 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
2014 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2015 0x01c42190, 0x40000100,
2016};
2017
2018static unsigned int d965_3st_pin_configs[14] = {
2019 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2020 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2021 0x40000100, 0x40000100, 0x40000100, 0x40000100,
2022 0x40000100, 0x40000100
2023};
2024
2025static unsigned int d965_5st_pin_configs[14] = {
2026 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2027 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2028 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2029 0x40000100, 0x40000100
2030};
2031
2032static unsigned int d965_5st_no_fp_pin_configs[14] = {
2033 0x40000100, 0x40000100, 0x0181304e, 0x01014010,
2034 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2035 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2036 0x40000100, 0x40000100
2037};
2038
2039static unsigned int dell_3st_pin_configs[14] = {
2040 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2041 0x01111212, 0x01116211, 0x01813050, 0x01112214,
2042 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2043 0x40c003fc, 0x40000100
2044};
2045
2046static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2047 [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2048 [STAC_D965_REF] = ref927x_pin_configs,
2049 [STAC_D965_3ST] = d965_3st_pin_configs,
2050 [STAC_D965_5ST] = d965_5st_pin_configs,
2051 [STAC_D965_5ST_NO_FP] = d965_5st_no_fp_pin_configs,
2052 [STAC_DELL_3ST] = dell_3st_pin_configs,
2053 [STAC_DELL_BIOS] = NULL,
2054 [STAC_927X_VOLKNOB] = NULL,
2055};
2056
2057static const char * const stac927x_models[STAC_927X_MODELS] = {
2058 [STAC_927X_AUTO] = "auto",
2059 [STAC_D965_REF_NO_JD] = "ref-no-jd",
2060 [STAC_D965_REF] = "ref",
2061 [STAC_D965_3ST] = "3stack",
2062 [STAC_D965_5ST] = "5stack",
2063 [STAC_D965_5ST_NO_FP] = "5stack-no-fp",
2064 [STAC_DELL_3ST] = "dell-3stack",
2065 [STAC_DELL_BIOS] = "dell-bios",
2066 [STAC_927X_VOLKNOB] = "volknob",
2067};
2068
2069static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2070
2071 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2072 "DFI LanParty", STAC_D965_REF),
2073 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2074 "DFI LanParty", STAC_D965_REF),
2075
2076 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2077 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2078
2079 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
2080 "Intel D965", STAC_D965_3ST),
2081 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
2082 "Intel D965", STAC_D965_3ST),
2083
2084 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2085 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
2086 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
2087
2088 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2089 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_BIOS),
2090 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
2091 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
2092 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
2093 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
2094 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
2095 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
2096 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2097
2098 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
2099 "Intel D965", STAC_D965_5ST),
2100 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
2101 "Intel D965", STAC_D965_5ST),
2102
2103 SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB),
2104 {}
2105};
2106
2107static unsigned int ref9205_pin_configs[12] = {
2108 0x40000100, 0x40000100, 0x01016011, 0x01014010,
2109 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2110 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2111};
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124static unsigned int dell_9205_m42_pin_configs[12] = {
2125 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2126 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2127 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2128};
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140static unsigned int dell_9205_m43_pin_configs[12] = {
2141 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2142 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2143 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2144};
2145
2146static unsigned int dell_9205_m44_pin_configs[12] = {
2147 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2148 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2149 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2150};
2151
2152static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2153 [STAC_9205_REF] = ref9205_pin_configs,
2154 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2155 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2156 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2157 [STAC_9205_EAPD] = NULL,
2158};
2159
2160static const char * const stac9205_models[STAC_9205_MODELS] = {
2161 [STAC_9205_AUTO] = "auto",
2162 [STAC_9205_REF] = "ref",
2163 [STAC_9205_DELL_M42] = "dell-m42",
2164 [STAC_9205_DELL_M43] = "dell-m43",
2165 [STAC_9205_DELL_M44] = "dell-m44",
2166 [STAC_9205_EAPD] = "eapd",
2167};
2168
2169static struct snd_pci_quirk stac9205_cfg_tbl[] = {
2170
2171 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2172 "DFI LanParty", STAC_9205_REF),
2173 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
2174 "SigmaTel", STAC_9205_REF),
2175 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2176 "DFI LanParty", STAC_9205_REF),
2177
2178 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2179 "unknown Dell", STAC_9205_DELL_M42),
2180 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2181 "unknown Dell", STAC_9205_DELL_M42),
2182 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2183 "Dell Precision", STAC_9205_DELL_M43),
2184 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2185 "Dell Precision", STAC_9205_DELL_M43),
2186 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2187 "Dell Precision", STAC_9205_DELL_M43),
2188 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2189 "unknown Dell", STAC_9205_DELL_M42),
2190 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2191 "unknown Dell", STAC_9205_DELL_M42),
2192 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2193 "Dell Precision", STAC_9205_DELL_M43),
2194 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2195 "Dell Precision M4300", STAC_9205_DELL_M43),
2196 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2197 "unknown Dell", STAC_9205_DELL_M42),
2198 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2199 "Dell Precision", STAC_9205_DELL_M43),
2200 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2201 "Dell Precision", STAC_9205_DELL_M43),
2202 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2203 "Dell Precision", STAC_9205_DELL_M43),
2204 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2205 "Dell Inspiron", STAC_9205_DELL_M44),
2206 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2207 "Dell Vostro 1500", STAC_9205_DELL_M42),
2208 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229,
2209 "Dell Vostro 1700", STAC_9205_DELL_M42),
2210
2211 SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
2212 SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
2213 {}
2214};
2215
2216static void stac92xx_set_config_regs(struct hda_codec *codec,
2217 unsigned int *pincfgs)
2218{
2219 int i;
2220 struct sigmatel_spec *spec = codec->spec;
2221
2222 if (!pincfgs)
2223 return;
2224
2225 for (i = 0; i < spec->num_pins; i++)
2226 if (spec->pin_nids[i] && pincfgs[i])
2227 snd_hda_codec_set_pincfg(codec, spec->pin_nids[i],
2228 pincfgs[i]);
2229}
2230
2231
2232
2233
2234static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2235 struct hda_codec *codec,
2236 struct snd_pcm_substream *substream)
2237{
2238 struct sigmatel_spec *spec = codec->spec;
2239 if (spec->stream_delay)
2240 msleep(spec->stream_delay);
2241 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2242 hinfo);
2243}
2244
2245static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2246 struct hda_codec *codec,
2247 unsigned int stream_tag,
2248 unsigned int format,
2249 struct snd_pcm_substream *substream)
2250{
2251 struct sigmatel_spec *spec = codec->spec;
2252 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2253}
2254
2255static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2256 struct hda_codec *codec,
2257 struct snd_pcm_substream *substream)
2258{
2259 struct sigmatel_spec *spec = codec->spec;
2260 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2261}
2262
2263
2264
2265
2266static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2267 struct hda_codec *codec,
2268 struct snd_pcm_substream *substream)
2269{
2270 struct sigmatel_spec *spec = codec->spec;
2271 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2272}
2273
2274static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2275 struct hda_codec *codec,
2276 struct snd_pcm_substream *substream)
2277{
2278 struct sigmatel_spec *spec = codec->spec;
2279 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2280}
2281
2282static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2283 struct hda_codec *codec,
2284 unsigned int stream_tag,
2285 unsigned int format,
2286 struct snd_pcm_substream *substream)
2287{
2288 struct sigmatel_spec *spec = codec->spec;
2289 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2290 stream_tag, format, substream);
2291}
2292
2293static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2294 struct hda_codec *codec,
2295 struct snd_pcm_substream *substream)
2296{
2297 struct sigmatel_spec *spec = codec->spec;
2298 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2299}
2300
2301
2302
2303
2304
2305static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2306 struct hda_codec *codec,
2307 unsigned int stream_tag,
2308 unsigned int format,
2309 struct snd_pcm_substream *substream)
2310{
2311 struct sigmatel_spec *spec = codec->spec;
2312 hda_nid_t nid = spec->adc_nids[substream->number];
2313
2314 if (spec->powerdown_adcs) {
2315 msleep(40);
2316 snd_hda_codec_write(codec, nid, 0,
2317 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2318 }
2319 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2320 return 0;
2321}
2322
2323static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2324 struct hda_codec *codec,
2325 struct snd_pcm_substream *substream)
2326{
2327 struct sigmatel_spec *spec = codec->spec;
2328 hda_nid_t nid = spec->adc_nids[substream->number];
2329
2330 snd_hda_codec_cleanup_stream(codec, nid);
2331 if (spec->powerdown_adcs)
2332 snd_hda_codec_write(codec, nid, 0,
2333 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2334 return 0;
2335}
2336
2337static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2338 .substreams = 1,
2339 .channels_min = 2,
2340 .channels_max = 2,
2341
2342 .ops = {
2343 .open = stac92xx_dig_playback_pcm_open,
2344 .close = stac92xx_dig_playback_pcm_close,
2345 .prepare = stac92xx_dig_playback_pcm_prepare,
2346 .cleanup = stac92xx_dig_playback_pcm_cleanup
2347 },
2348};
2349
2350static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2351 .substreams = 1,
2352 .channels_min = 2,
2353 .channels_max = 2,
2354
2355};
2356
2357static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2358 .substreams = 1,
2359 .channels_min = 2,
2360 .channels_max = 8,
2361 .nid = 0x02,
2362 .ops = {
2363 .open = stac92xx_playback_pcm_open,
2364 .prepare = stac92xx_playback_pcm_prepare,
2365 .cleanup = stac92xx_playback_pcm_cleanup
2366 },
2367};
2368
2369static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2370 .substreams = 1,
2371 .channels_min = 2,
2372 .channels_max = 2,
2373 .nid = 0x06,
2374 .ops = {
2375 .open = stac92xx_playback_pcm_open,
2376 .prepare = stac92xx_playback_pcm_prepare,
2377 .cleanup = stac92xx_playback_pcm_cleanup
2378 },
2379};
2380
2381static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2382 .channels_min = 2,
2383 .channels_max = 2,
2384
2385 .ops = {
2386 .prepare = stac92xx_capture_pcm_prepare,
2387 .cleanup = stac92xx_capture_pcm_cleanup
2388 },
2389};
2390
2391static int stac92xx_build_pcms(struct hda_codec *codec)
2392{
2393 struct sigmatel_spec *spec = codec->spec;
2394 struct hda_pcm *info = spec->pcm_rec;
2395
2396 codec->num_pcms = 1;
2397 codec->pcm_info = info;
2398
2399 info->name = "STAC92xx Analog";
2400 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2401 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2402 spec->multiout.dac_nids[0];
2403 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2404 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2405 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2406
2407 if (spec->alt_switch) {
2408 codec->num_pcms++;
2409 info++;
2410 info->name = "STAC92xx Analog Alt";
2411 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2412 }
2413
2414 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2415 codec->num_pcms++;
2416 info++;
2417 info->name = "STAC92xx Digital";
2418 info->pcm_type = spec->autocfg.dig_out_type[0];
2419 if (spec->multiout.dig_out_nid) {
2420 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2421 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2422 }
2423 if (spec->dig_in_nid) {
2424 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2425 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2426 }
2427 }
2428
2429 return 0;
2430}
2431
2432static unsigned int stac92xx_get_default_vref(struct hda_codec *codec,
2433 hda_nid_t nid)
2434{
2435 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2436 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2437 if (pincap & AC_PINCAP_VREF_100)
2438 return AC_PINCTL_VREF_100;
2439 if (pincap & AC_PINCAP_VREF_80)
2440 return AC_PINCTL_VREF_80;
2441 if (pincap & AC_PINCAP_VREF_50)
2442 return AC_PINCTL_VREF_50;
2443 if (pincap & AC_PINCAP_VREF_GRD)
2444 return AC_PINCTL_VREF_GRD;
2445 return 0;
2446}
2447
2448static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2449
2450{
2451 snd_hda_codec_write_cache(codec, nid, 0,
2452 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2453}
2454
2455#define stac92xx_hp_switch_info snd_ctl_boolean_mono_info
2456
2457static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2458 struct snd_ctl_elem_value *ucontrol)
2459{
2460 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2461 struct sigmatel_spec *spec = codec->spec;
2462
2463 ucontrol->value.integer.value[0] = !!spec->hp_switch;
2464 return 0;
2465}
2466
2467static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid);
2468
2469static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2470 struct snd_ctl_elem_value *ucontrol)
2471{
2472 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2473 struct sigmatel_spec *spec = codec->spec;
2474 int nid = kcontrol->private_value;
2475
2476 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2477
2478
2479
2480
2481 stac_issue_unsol_event(codec, nid);
2482
2483 return 1;
2484}
2485
2486static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol,
2487 struct snd_ctl_elem_info *uinfo)
2488{
2489 int i;
2490 static char *texts[] = {
2491 "Mic In", "Line In", "Line Out"
2492 };
2493
2494 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2495 struct sigmatel_spec *spec = codec->spec;
2496 hda_nid_t nid = kcontrol->private_value;
2497
2498 if (nid == spec->mic_switch || nid == spec->line_switch)
2499 i = 3;
2500 else
2501 i = 2;
2502
2503 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2504 uinfo->value.enumerated.items = i;
2505 uinfo->count = 1;
2506 if (uinfo->value.enumerated.item >= i)
2507 uinfo->value.enumerated.item = i-1;
2508 strcpy(uinfo->value.enumerated.name,
2509 texts[uinfo->value.enumerated.item]);
2510
2511 return 0;
2512}
2513
2514static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol,
2515 struct snd_ctl_elem_value *ucontrol)
2516{
2517 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2518 hda_nid_t nid = kcontrol->private_value;
2519 unsigned int vref = stac92xx_vref_get(codec, nid);
2520
2521 if (vref == stac92xx_get_default_vref(codec, nid))
2522 ucontrol->value.enumerated.item[0] = 0;
2523 else if (vref == AC_PINCTL_VREF_GRD)
2524 ucontrol->value.enumerated.item[0] = 1;
2525 else if (vref == AC_PINCTL_VREF_HIZ)
2526 ucontrol->value.enumerated.item[0] = 2;
2527
2528 return 0;
2529}
2530
2531static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol,
2532 struct snd_ctl_elem_value *ucontrol)
2533{
2534 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2535 unsigned int new_vref = 0;
2536 int error;
2537 hda_nid_t nid = kcontrol->private_value;
2538
2539 if (ucontrol->value.enumerated.item[0] == 0)
2540 new_vref = stac92xx_get_default_vref(codec, nid);
2541 else if (ucontrol->value.enumerated.item[0] == 1)
2542 new_vref = AC_PINCTL_VREF_GRD;
2543 else if (ucontrol->value.enumerated.item[0] == 2)
2544 new_vref = AC_PINCTL_VREF_HIZ;
2545 else
2546 return 0;
2547
2548 if (new_vref != stac92xx_vref_get(codec, nid)) {
2549 error = stac92xx_vref_set(codec, nid, new_vref);
2550 return error;
2551 }
2552
2553 return 0;
2554}
2555
2556static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol,
2557 struct snd_ctl_elem_info *uinfo)
2558{
2559 static char *texts[2];
2560 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2561 struct sigmatel_spec *spec = codec->spec;
2562
2563 if (kcontrol->private_value == spec->line_switch)
2564 texts[0] = "Line In";
2565 else
2566 texts[0] = "Mic In";
2567 texts[1] = "Line Out";
2568 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2569 uinfo->value.enumerated.items = 2;
2570 uinfo->count = 1;
2571
2572 if (uinfo->value.enumerated.item >= 2)
2573 uinfo->value.enumerated.item = 1;
2574 strcpy(uinfo->value.enumerated.name,
2575 texts[uinfo->value.enumerated.item]);
2576
2577 return 0;
2578}
2579
2580static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2581{
2582 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2583 struct sigmatel_spec *spec = codec->spec;
2584 hda_nid_t nid = kcontrol->private_value;
2585 int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2586
2587 ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx];
2588 return 0;
2589}
2590
2591static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2592{
2593 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2594 struct sigmatel_spec *spec = codec->spec;
2595 hda_nid_t nid = kcontrol->private_value;
2596 int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2597 unsigned short val = !!ucontrol->value.enumerated.item[0];
2598
2599 spec->io_switch[io_idx] = val;
2600
2601 if (val)
2602 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2603 else {
2604 unsigned int pinctl = AC_PINCTL_IN_EN;
2605 if (io_idx)
2606 pinctl |= stac92xx_get_default_vref(codec, nid);
2607 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2608 }
2609
2610
2611
2612
2613 if (spec->hp_detect)
2614 stac_issue_unsol_event(codec, nid);
2615
2616 return 1;
2617}
2618
2619#define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2620
2621static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2622 struct snd_ctl_elem_value *ucontrol)
2623{
2624 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2625 struct sigmatel_spec *spec = codec->spec;
2626
2627 ucontrol->value.integer.value[0] = spec->clfe_swap;
2628 return 0;
2629}
2630
2631static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2632 struct snd_ctl_elem_value *ucontrol)
2633{
2634 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2635 struct sigmatel_spec *spec = codec->spec;
2636 hda_nid_t nid = kcontrol->private_value & 0xff;
2637 unsigned int val = !!ucontrol->value.integer.value[0];
2638
2639 if (spec->clfe_swap == val)
2640 return 0;
2641
2642 spec->clfe_swap = val;
2643
2644 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2645 spec->clfe_swap ? 0x4 : 0x0);
2646
2647 return 1;
2648}
2649
2650#define STAC_CODEC_HP_SWITCH(xname) \
2651 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2652 .name = xname, \
2653 .index = 0, \
2654 .info = stac92xx_hp_switch_info, \
2655 .get = stac92xx_hp_switch_get, \
2656 .put = stac92xx_hp_switch_put, \
2657 }
2658
2659#define STAC_CODEC_IO_SWITCH(xname, xpval) \
2660 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2661 .name = xname, \
2662 .index = 0, \
2663 .info = stac92xx_io_switch_info, \
2664 .get = stac92xx_io_switch_get, \
2665 .put = stac92xx_io_switch_put, \
2666 .private_value = xpval, \
2667 }
2668
2669#define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2670 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2671 .name = xname, \
2672 .index = 0, \
2673 .info = stac92xx_clfe_switch_info, \
2674 .get = stac92xx_clfe_switch_get, \
2675 .put = stac92xx_clfe_switch_put, \
2676 .private_value = xpval, \
2677 }
2678
2679enum {
2680 STAC_CTL_WIDGET_VOL,
2681 STAC_CTL_WIDGET_MUTE,
2682 STAC_CTL_WIDGET_MUTE_BEEP,
2683 STAC_CTL_WIDGET_MONO_MUX,
2684 STAC_CTL_WIDGET_HP_SWITCH,
2685 STAC_CTL_WIDGET_IO_SWITCH,
2686 STAC_CTL_WIDGET_CLFE_SWITCH,
2687 STAC_CTL_WIDGET_DC_BIAS
2688};
2689
2690static struct snd_kcontrol_new stac92xx_control_templates[] = {
2691 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2692 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2693 HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0),
2694 STAC_MONO_MUX,
2695 STAC_CODEC_HP_SWITCH(NULL),
2696 STAC_CODEC_IO_SWITCH(NULL, 0),
2697 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2698 DC_BIAS(NULL, 0, 0),
2699};
2700
2701
2702static struct snd_kcontrol_new *
2703stac_control_new(struct sigmatel_spec *spec,
2704 struct snd_kcontrol_new *ktemp,
2705 const char *name,
2706 unsigned int subdev)
2707{
2708 struct snd_kcontrol_new *knew;
2709
2710 snd_array_init(&spec->kctls, sizeof(*knew), 32);
2711 knew = snd_array_new(&spec->kctls);
2712 if (!knew)
2713 return NULL;
2714 *knew = *ktemp;
2715 knew->name = kstrdup(name, GFP_KERNEL);
2716 if (!knew->name) {
2717
2718 memset(knew, 0, sizeof(*knew));
2719 spec->kctls.alloced--;
2720 return NULL;
2721 }
2722 knew->subdevice = subdev;
2723 return knew;
2724}
2725
2726static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2727 struct snd_kcontrol_new *ktemp,
2728 int idx, const char *name,
2729 unsigned long val)
2730{
2731 struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name,
2732 HDA_SUBDEV_AMP_FLAG);
2733 if (!knew)
2734 return -ENOMEM;
2735 knew->index = idx;
2736 knew->private_value = val;
2737 return 0;
2738}
2739
2740static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2741 int type, int idx, const char *name,
2742 unsigned long val)
2743{
2744 return stac92xx_add_control_temp(spec,
2745 &stac92xx_control_templates[type],
2746 idx, name, val);
2747}
2748
2749
2750
2751static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2752 const char *name, unsigned long val)
2753{
2754 return stac92xx_add_control_idx(spec, type, 0, name, val);
2755}
2756
2757static struct snd_kcontrol_new stac_input_src_temp = {
2758 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2759 .name = "Input Source",
2760 .info = stac92xx_mux_enum_info,
2761 .get = stac92xx_mux_enum_get,
2762 .put = stac92xx_mux_enum_put,
2763};
2764
2765static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
2766 hda_nid_t nid, int idx)
2767{
2768 int def_conf = snd_hda_codec_get_pincfg(codec, nid);
2769 int control = 0;
2770 struct sigmatel_spec *spec = codec->spec;
2771 char name[22];
2772
2773 if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
2774 if (stac92xx_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
2775 && nid == spec->line_switch)
2776 control = STAC_CTL_WIDGET_IO_SWITCH;
2777 else if (snd_hda_query_pin_caps(codec, nid)
2778 & (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT))
2779 control = STAC_CTL_WIDGET_DC_BIAS;
2780 else if (nid == spec->mic_switch)
2781 control = STAC_CTL_WIDGET_IO_SWITCH;
2782 }
2783
2784 if (control) {
2785 strcpy(name, hda_get_input_pin_label(codec, nid, 1));
2786 return stac92xx_add_control(codec->spec, control,
2787 strcat(name, " Jack Mode"), nid);
2788 }
2789
2790 return 0;
2791}
2792
2793static int stac92xx_add_input_source(struct sigmatel_spec *spec)
2794{
2795 struct snd_kcontrol_new *knew;
2796 struct hda_input_mux *imux = &spec->private_imux;
2797
2798 if (spec->auto_mic)
2799 return 0;
2800 if (!spec->num_adcs || imux->num_items <= 1)
2801 return 0;
2802 knew = stac_control_new(spec, &stac_input_src_temp,
2803 stac_input_src_temp.name, 0);
2804 if (!knew)
2805 return -ENOMEM;
2806 knew->count = spec->num_adcs;
2807 return 0;
2808}
2809
2810
2811static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2812{
2813 struct sigmatel_spec *spec = codec->spec;
2814 struct auto_pin_cfg *cfg = &spec->autocfg;
2815 hda_nid_t nid;
2816 unsigned int pincap;
2817 int i;
2818
2819 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2820 return 0;
2821 for (i = 0; i < cfg->num_inputs; i++) {
2822 if (cfg->inputs[i].type == AUTO_PIN_LINE_IN) {
2823 nid = cfg->inputs[i].pin;
2824 pincap = snd_hda_query_pin_caps(codec, nid);
2825 if (pincap & AC_PINCAP_OUT)
2826 return nid;
2827 }
2828 }
2829 return 0;
2830}
2831
2832static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid);
2833
2834
2835static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac)
2836{
2837 struct sigmatel_spec *spec = codec->spec;
2838 struct auto_pin_cfg *cfg = &spec->autocfg;
2839 unsigned int def_conf, pincap;
2840 int i;
2841
2842 *dac = 0;
2843 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2844 return 0;
2845 for (i = 0; i < cfg->num_inputs; i++) {
2846 hda_nid_t nid = cfg->inputs[i].pin;
2847 if (cfg->inputs[i].type != AUTO_PIN_MIC)
2848 continue;
2849 def_conf = snd_hda_codec_get_pincfg(codec, nid);
2850
2851
2852 if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
2853 pincap = snd_hda_query_pin_caps(codec, nid);
2854 if (pincap & AC_PINCAP_OUT) {
2855 *dac = get_unassigned_dac(codec, nid);
2856 if (*dac)
2857 return nid;
2858 }
2859 }
2860 }
2861 return 0;
2862}
2863
2864static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2865{
2866 int i;
2867
2868 for (i = 0; i < spec->multiout.num_dacs; i++) {
2869 if (spec->multiout.dac_nids[i] == nid)
2870 return 1;
2871 }
2872
2873 return 0;
2874}
2875
2876static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2877{
2878 int i;
2879 if (is_in_dac_nids(spec, nid))
2880 return 1;
2881 for (i = 0; i < spec->autocfg.hp_outs; i++)
2882 if (spec->hp_dacs[i] == nid)
2883 return 1;
2884 for (i = 0; i < spec->autocfg.speaker_outs; i++)
2885 if (spec->speaker_dacs[i] == nid)
2886 return 1;
2887 return 0;
2888}
2889
2890static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2891{
2892 struct sigmatel_spec *spec = codec->spec;
2893 int j, conn_len;
2894 hda_nid_t conn[HDA_MAX_CONNECTIONS];
2895 unsigned int wcaps, wtype;
2896
2897 conn_len = snd_hda_get_connections(codec, nid, conn,
2898 HDA_MAX_CONNECTIONS);
2899
2900 while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0]))
2901 != AC_WID_AUD_OUT)) {
2902 nid = conn[0];
2903 conn_len = snd_hda_get_connections(codec, nid, conn,
2904 HDA_MAX_CONNECTIONS);
2905 }
2906 for (j = 0; j < conn_len; j++) {
2907 wcaps = get_wcaps(codec, conn[j]);
2908 wtype = get_wcaps_type(wcaps);
2909
2910 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2911 continue;
2912
2913 if (!check_all_dac_nids(spec, conn[j])) {
2914 if (conn_len > 1) {
2915
2916 snd_hda_codec_write_cache(codec, nid, 0,
2917 AC_VERB_SET_CONNECT_SEL, j);
2918 }
2919 return conn[j];
2920 }
2921 }
2922
2923 if (conn_len > 1) {
2924 for (j = 0; j < conn_len; j++) {
2925 if (conn[j] == spec->multiout.dac_nids[0]) {
2926 snd_hda_codec_write_cache(codec, nid, 0,
2927 AC_VERB_SET_CONNECT_SEL, j);
2928 break;
2929 }
2930 }
2931 }
2932 return 0;
2933}
2934
2935static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2936static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2937
2938
2939
2940
2941
2942
2943
2944
2945static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2946{
2947 struct sigmatel_spec *spec = codec->spec;
2948 struct auto_pin_cfg *cfg = &spec->autocfg;
2949 int i;
2950 hda_nid_t nid, dac;
2951
2952 for (i = 0; i < cfg->line_outs; i++) {
2953 nid = cfg->line_out_pins[i];
2954 dac = get_unassigned_dac(codec, nid);
2955 if (!dac) {
2956 if (spec->multiout.num_dacs > 0) {
2957
2958
2959
2960 cfg->line_outs = spec->multiout.num_dacs;
2961 break;
2962 }
2963
2964 snd_printk(KERN_ERR
2965 "%s: No available DAC for pin 0x%x\n",
2966 __func__, nid);
2967 return -ENODEV;
2968 }
2969 add_spec_dacs(spec, dac);
2970 }
2971
2972 for (i = 0; i < cfg->hp_outs; i++) {
2973 nid = cfg->hp_pins[i];
2974 dac = get_unassigned_dac(codec, nid);
2975 if (dac) {
2976 if (!spec->multiout.hp_nid)
2977 spec->multiout.hp_nid = dac;
2978 else
2979 add_spec_extra_dacs(spec, dac);
2980 }
2981 spec->hp_dacs[i] = dac;
2982 }
2983
2984 for (i = 0; i < cfg->speaker_outs; i++) {
2985 nid = cfg->speaker_pins[i];
2986 dac = get_unassigned_dac(codec, nid);
2987 if (dac)
2988 add_spec_extra_dacs(spec, dac);
2989 spec->speaker_dacs[i] = dac;
2990 }
2991
2992
2993 nid = check_line_out_switch(codec);
2994 if (nid) {
2995 dac = get_unassigned_dac(codec, nid);
2996 if (dac) {
2997 snd_printdd("STAC: Add line-in 0x%x as output %d\n",
2998 nid, cfg->line_outs);
2999 cfg->line_out_pins[cfg->line_outs] = nid;
3000 cfg->line_outs++;
3001 spec->line_switch = nid;
3002 add_spec_dacs(spec, dac);
3003 }
3004 }
3005
3006 nid = check_mic_out_switch(codec, &dac);
3007 if (nid && dac) {
3008 snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
3009 nid, cfg->line_outs);
3010 cfg->line_out_pins[cfg->line_outs] = nid;
3011 cfg->line_outs++;
3012 spec->mic_switch = nid;
3013 add_spec_dacs(spec, dac);
3014 }
3015
3016 snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3017 spec->multiout.num_dacs,
3018 spec->multiout.dac_nids[0],
3019 spec->multiout.dac_nids[1],
3020 spec->multiout.dac_nids[2],
3021 spec->multiout.dac_nids[3],
3022 spec->multiout.dac_nids[4]);
3023
3024 return 0;
3025}
3026
3027
3028static int create_controls_idx(struct hda_codec *codec, const char *pfx,
3029 int idx, hda_nid_t nid, int chs)
3030{
3031 struct sigmatel_spec *spec = codec->spec;
3032 char name[32];
3033 int err;
3034
3035 if (!spec->check_volume_offset) {
3036 unsigned int caps, step, nums, db_scale;
3037 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3038 step = (caps & AC_AMPCAP_STEP_SIZE) >>
3039 AC_AMPCAP_STEP_SIZE_SHIFT;
3040 step = (step + 1) * 25;
3041 nums = (caps & AC_AMPCAP_NUM_STEPS) >>
3042 AC_AMPCAP_NUM_STEPS_SHIFT;
3043 db_scale = nums * step;
3044
3045
3046
3047 if (db_scale > 6400 && nums >= 0x1f)
3048 spec->volume_offset = nums / 2;
3049 spec->check_volume_offset = 1;
3050 }
3051
3052 sprintf(name, "%s Playback Volume", pfx);
3053 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
3054 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3055 spec->volume_offset));
3056 if (err < 0)
3057 return err;
3058 sprintf(name, "%s Playback Switch", pfx);
3059 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
3060 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3061 if (err < 0)
3062 return err;
3063 return 0;
3064}
3065
3066#define create_controls(codec, pfx, nid, chs) \
3067 create_controls_idx(codec, pfx, 0, nid, chs)
3068
3069static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3070{
3071 if (spec->multiout.num_dacs > 4) {
3072 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3073 return 1;
3074 } else {
3075 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
3076 spec->multiout.num_dacs++;
3077 }
3078 return 0;
3079}
3080
3081static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3082{
3083 int i;
3084 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3085 if (!spec->multiout.extra_out_nid[i]) {
3086 spec->multiout.extra_out_nid[i] = nid;
3087 return 0;
3088 }
3089 }
3090 printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3091 return 1;
3092}
3093
3094
3095
3096
3097static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
3098 const hda_nid_t *pins,
3099 const hda_nid_t *dac_nids,
3100 int type)
3101{
3102 struct sigmatel_spec *spec = codec->spec;
3103 static const char * const chname[4] = {
3104 "Front", "Surround", NULL , "Side"
3105 };
3106 hda_nid_t nid;
3107 int i, err;
3108 unsigned int wid_caps;
3109
3110 for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
3111 if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3112 wid_caps = get_wcaps(codec, pins[i]);
3113 if (wid_caps & AC_WCAP_UNSOL_CAP)
3114 spec->hp_detect = 1;
3115 }
3116 nid = dac_nids[i];
3117 if (!nid)
3118 continue;
3119 if (type != AUTO_PIN_HP_OUT && i == 2) {
3120
3121 err = create_controls(codec, "Center", nid, 1);
3122 if (err < 0)
3123 return err;
3124 err = create_controls(codec, "LFE", nid, 2);
3125 if (err < 0)
3126 return err;
3127
3128 wid_caps = get_wcaps(codec, nid);
3129
3130 if (wid_caps & AC_WCAP_LR_SWAP) {
3131 err = stac92xx_add_control(spec,
3132 STAC_CTL_WIDGET_CLFE_SWITCH,
3133 "Swap Center/LFE Playback Switch", nid);
3134
3135 if (err < 0)
3136 return err;
3137 }
3138
3139 } else {
3140 const char *name;
3141 int idx;
3142 switch (type) {
3143 case AUTO_PIN_HP_OUT:
3144 name = "Headphone";
3145 idx = i;
3146 break;
3147 case AUTO_PIN_SPEAKER_OUT:
3148 name = "Speaker";
3149 idx = i;
3150 break;
3151 default:
3152 name = chname[i];
3153 idx = 0;
3154 break;
3155 }
3156 err = create_controls_idx(codec, name, idx, nid, 3);
3157 if (err < 0)
3158 return err;
3159 }
3160 }
3161 return 0;
3162}
3163
3164static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol,
3165 unsigned long sw, int idx)
3166{
3167 int err;
3168 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx,
3169 "Capture Volume", vol);
3170 if (err < 0)
3171 return err;
3172 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_MUTE, idx,
3173 "Capture Switch", sw);
3174 if (err < 0)
3175 return err;
3176 return 0;
3177}
3178
3179
3180static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3181 const struct auto_pin_cfg *cfg)
3182{
3183 struct sigmatel_spec *spec = codec->spec;
3184 hda_nid_t nid;
3185 int err;
3186 int idx;
3187
3188 err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
3189 spec->multiout.dac_nids,
3190 cfg->line_out_type);
3191 if (err < 0)
3192 return err;
3193
3194 if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3195 err = stac92xx_add_control(spec,
3196 STAC_CTL_WIDGET_HP_SWITCH,
3197 "Headphone as Line Out Switch",
3198 cfg->hp_pins[cfg->hp_outs - 1]);
3199 if (err < 0)
3200 return err;
3201 }
3202
3203 for (idx = 0; idx < cfg->num_inputs; idx++) {
3204 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3205 break;
3206 nid = cfg->inputs[idx].pin;
3207 err = stac92xx_add_jack_mode_control(codec, nid, idx);
3208 if (err < 0)
3209 return err;
3210 }
3211
3212 return 0;
3213}
3214
3215
3216static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3217 struct auto_pin_cfg *cfg)
3218{
3219 struct sigmatel_spec *spec = codec->spec;
3220 int err;
3221
3222 err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
3223 spec->hp_dacs, AUTO_PIN_HP_OUT);
3224 if (err < 0)
3225 return err;
3226
3227 err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
3228 spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
3229 if (err < 0)
3230 return err;
3231
3232 return 0;
3233}
3234
3235
3236static const char * const stac92xx_mono_labels[4] = {
3237 "DAC0", "DAC1", "Mixer", "DAC2"
3238};
3239
3240
3241static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3242{
3243 struct sigmatel_spec *spec = codec->spec;
3244 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3245 int i, num_cons;
3246 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3247
3248 num_cons = snd_hda_get_connections(codec,
3249 spec->mono_nid,
3250 con_lst,
3251 HDA_MAX_NUM_INPUTS);
3252 if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3253 return -EINVAL;
3254
3255 for (i = 0; i < num_cons; i++)
3256 snd_hda_add_imux_item(mono_mux, stac92xx_mono_labels[i], i,
3257 NULL);
3258
3259 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3260 "Mono Mux", spec->mono_nid);
3261}
3262
3263
3264static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3265 hda_nid_t nid)
3266{
3267 struct sigmatel_spec *spec = codec->spec;
3268 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3269 int err, type = STAC_CTL_WIDGET_MUTE_BEEP;
3270
3271 if (spec->anabeep_nid == nid)
3272 type = STAC_CTL_WIDGET_MUTE;
3273
3274
3275 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3276 err = stac92xx_add_control(spec, type,
3277 "Beep Playback Switch",
3278 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3279 if (err < 0)
3280 return err;
3281 }
3282
3283
3284 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3285 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3286 "Beep Playback Volume",
3287 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3288 if (err < 0)
3289 return err;
3290 }
3291 return 0;
3292}
3293
3294#ifdef CONFIG_SND_HDA_INPUT_BEEP
3295#define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3296
3297static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3298 struct snd_ctl_elem_value *ucontrol)
3299{
3300 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3301 ucontrol->value.integer.value[0] = codec->beep->enabled;
3302 return 0;
3303}
3304
3305static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3306 struct snd_ctl_elem_value *ucontrol)
3307{
3308 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3309 return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
3310}
3311
3312static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3313 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3314 .info = stac92xx_dig_beep_switch_info,
3315 .get = stac92xx_dig_beep_switch_get,
3316 .put = stac92xx_dig_beep_switch_put,
3317};
3318
3319static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3320{
3321 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3322 0, "Beep Playback Switch", 0);
3323}
3324#endif
3325
3326static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3327{
3328 struct sigmatel_spec *spec = codec->spec;
3329 int i, j, err = 0;
3330
3331 for (i = 0; i < spec->num_muxes; i++) {
3332 hda_nid_t nid;
3333 unsigned int wcaps;
3334 unsigned long val;
3335
3336 nid = spec->mux_nids[i];
3337 wcaps = get_wcaps(codec, nid);
3338 if (!(wcaps & AC_WCAP_OUT_AMP))
3339 continue;
3340
3341
3342
3343
3344 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3345 for (j = 0; j < spec->num_caps; j++) {
3346 if (spec->capvols[j] == val)
3347 break;
3348 }
3349 if (j < spec->num_caps)
3350 continue;
3351
3352 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i,
3353 "Mux Capture Volume", val);
3354 if (err < 0)
3355 return err;
3356 }
3357 return 0;
3358};
3359
3360static const char * const stac92xx_spdif_labels[3] = {
3361 "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3362};
3363
3364static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3365{
3366 struct sigmatel_spec *spec = codec->spec;
3367 struct hda_input_mux *spdif_mux = &spec->private_smux;
3368 const char * const *labels = spec->spdif_labels;
3369 int i, num_cons;
3370 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3371
3372 num_cons = snd_hda_get_connections(codec,
3373 spec->smux_nids[0],
3374 con_lst,
3375 HDA_MAX_NUM_INPUTS);
3376 if (num_cons <= 0)
3377 return -EINVAL;
3378
3379 if (!labels)
3380 labels = stac92xx_spdif_labels;
3381
3382 for (i = 0; i < num_cons; i++)
3383 snd_hda_add_imux_item(spdif_mux, labels[i], i, NULL);
3384
3385 return 0;
3386}
3387
3388
3389static const char * const stac92xx_dmic_labels[5] = {
3390 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3391 "Digital Mic 3", "Digital Mic 4"
3392};
3393
3394static hda_nid_t get_connected_node(struct hda_codec *codec, hda_nid_t mux,
3395 int idx)
3396{
3397 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3398 int nums;
3399 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3400 if (idx >= 0 && idx < nums)
3401 return conn[idx];
3402 return 0;
3403}
3404
3405static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
3406 hda_nid_t nid)
3407{
3408 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3409 int i, nums;
3410
3411 if (!(get_wcaps(codec, mux) & AC_WCAP_CONN_LIST))
3412 return -1;
3413
3414 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3415 for (i = 0; i < nums; i++)
3416 if (conn[i] == nid)
3417 return i;
3418
3419 for (i = 0; i < nums; i++) {
3420 unsigned int wid_caps = get_wcaps(codec, conn[i]);
3421 unsigned int wid_type = get_wcaps_type(wid_caps);
3422
3423 if (wid_type != AC_WID_PIN && wid_type != AC_WID_AUD_MIX)
3424 if (get_connection_index(codec, conn[i], nid) >= 0)
3425 return i;
3426 }
3427 return -1;
3428}
3429
3430
3431
3432static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
3433 const char *label, int idx, int direction)
3434{
3435 unsigned int caps, nums;
3436 char name[32];
3437 int err;
3438
3439 if (direction == HDA_OUTPUT)
3440 caps = AC_WCAP_OUT_AMP;
3441 else
3442 caps = AC_WCAP_IN_AMP;
3443 if (!(get_wcaps(codec, nid) & caps))
3444 return 0;
3445 caps = query_amp_caps(codec, nid, direction);
3446 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
3447 if (!nums)
3448 return 0;
3449 snprintf(name, sizeof(name), "%s Capture Volume", label);
3450 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, name,
3451 HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction));
3452 if (err < 0)
3453 return err;
3454 return 1;
3455}
3456
3457
3458static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3459 const struct auto_pin_cfg *cfg)
3460{
3461 struct sigmatel_spec *spec = codec->spec;
3462 struct hda_input_mux *imux = &spec->private_imux;
3463 struct hda_input_mux *dimux = &spec->private_dimux;
3464 int err, i;
3465 unsigned int def_conf;
3466
3467 snd_hda_add_imux_item(dimux, stac92xx_dmic_labels[0], 0, NULL);
3468
3469 for (i = 0; i < spec->num_dmics; i++) {
3470 hda_nid_t nid;
3471 int index, type_idx;
3472 const char *label;
3473
3474 nid = spec->dmic_nids[i];
3475 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
3476 continue;
3477 def_conf = snd_hda_codec_get_pincfg(codec, nid);
3478 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3479 continue;
3480
3481 index = get_connection_index(codec, spec->dmux_nids[0], nid);
3482 if (index < 0)
3483 continue;
3484
3485 label = hda_get_input_pin_label(codec, nid, 1);
3486 snd_hda_add_imux_item(dimux, label, index, &type_idx);
3487 if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1)
3488 snd_hda_add_imux_item(imux, label, index, &type_idx);
3489
3490 err = create_elem_capture_vol(codec, nid, label, type_idx,
3491 HDA_INPUT);
3492 if (err < 0)
3493 return err;
3494 if (!err) {
3495 err = create_elem_capture_vol(codec, nid, label,
3496 type_idx, HDA_OUTPUT);
3497 if (err < 0)
3498 return err;
3499 if (!err) {
3500 nid = get_connected_node(codec,
3501 spec->dmux_nids[0], index);
3502 if (nid)
3503 err = create_elem_capture_vol(codec,
3504 nid, label,
3505 type_idx, HDA_INPUT);
3506 if (err < 0)
3507 return err;
3508 }
3509 }
3510 }
3511
3512 return 0;
3513}
3514
3515static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid,
3516 hda_nid_t *fixed, hda_nid_t *ext, hda_nid_t *dock)
3517{
3518 unsigned int cfg;
3519
3520 if (!nid)
3521 return 0;
3522 cfg = snd_hda_codec_get_pincfg(codec, nid);
3523 switch (snd_hda_get_input_pin_attr(cfg)) {
3524 case INPUT_PIN_ATTR_INT:
3525 if (*fixed)
3526 return 1;
3527 *fixed = nid;
3528 break;
3529 case INPUT_PIN_ATTR_UNUSED:
3530 break;
3531 case INPUT_PIN_ATTR_DOCK:
3532 if (*dock)
3533 return 1;
3534 *dock = nid;
3535 break;
3536 default:
3537 if (*ext)
3538 return 1;
3539 *ext = nid;
3540 break;
3541 }
3542 return 0;
3543}
3544
3545static int set_mic_route(struct hda_codec *codec,
3546 struct sigmatel_mic_route *mic,
3547 hda_nid_t pin)
3548{
3549 struct sigmatel_spec *spec = codec->spec;
3550 struct auto_pin_cfg *cfg = &spec->autocfg;
3551 int i;
3552
3553 mic->pin = pin;
3554 if (pin == 0)
3555 return 0;
3556 for (i = 0; i < cfg->num_inputs; i++) {
3557 if (pin == cfg->inputs[i].pin)
3558 break;
3559 }
3560 if (i < cfg->num_inputs && cfg->inputs[i].type == AUTO_PIN_MIC) {
3561
3562 i = get_connection_index(codec, spec->mux_nids[0], pin);
3563 if (i < 0)
3564 return -1;
3565 mic->mux_idx = i;
3566 mic->dmux_idx = -1;
3567 if (spec->dmux_nids)
3568 mic->dmux_idx = get_connection_index(codec,
3569 spec->dmux_nids[0],
3570 spec->mux_nids[0]);
3571 } else if (spec->dmux_nids) {
3572
3573 i = get_connection_index(codec, spec->dmux_nids[0], pin);
3574 if (i < 0)
3575 return -1;
3576 mic->dmux_idx = i;
3577 mic->mux_idx = -1;
3578 if (spec->mux_nids)
3579 mic->mux_idx = get_connection_index(codec,
3580 spec->mux_nids[0],
3581 spec->dmux_nids[0]);
3582 }
3583 return 0;
3584}
3585
3586
3587static int stac_check_auto_mic(struct hda_codec *codec)
3588{
3589 struct sigmatel_spec *spec = codec->spec;
3590 struct auto_pin_cfg *cfg = &spec->autocfg;
3591 hda_nid_t fixed, ext, dock;
3592 int i;
3593
3594 for (i = 0; i < cfg->num_inputs; i++) {
3595 if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN)
3596 return 0;
3597 }
3598 fixed = ext = dock = 0;
3599 for (i = 0; i < cfg->num_inputs; i++)
3600 if (check_mic_pin(codec, cfg->inputs[i].pin,
3601 &fixed, &ext, &dock))
3602 return 0;
3603 for (i = 0; i < spec->num_dmics; i++)
3604 if (check_mic_pin(codec, spec->dmic_nids[i],
3605 &fixed, &ext, &dock))
3606 return 0;
3607 if (!fixed || (!ext && !dock))
3608 return 0;
3609 if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
3610 return 0;
3611 if (set_mic_route(codec, &spec->ext_mic, ext) ||
3612 set_mic_route(codec, &spec->int_mic, fixed) ||
3613 set_mic_route(codec, &spec->dock_mic, dock))
3614 return 0;
3615 return 1;
3616}
3617
3618
3619static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3620{
3621 struct sigmatel_spec *spec = codec->spec;
3622 struct hda_input_mux *imux = &spec->private_imux;
3623 int i, j;
3624 const char *label;
3625
3626 for (i = 0; i < cfg->num_inputs; i++) {
3627 hda_nid_t nid = cfg->inputs[i].pin;
3628 int index, err, type_idx;
3629
3630 index = -1;
3631 for (j = 0; j < spec->num_muxes; j++) {
3632 index = get_connection_index(codec, spec->mux_nids[j],
3633 nid);
3634 if (index >= 0)
3635 break;
3636 }
3637 if (index < 0)
3638 continue;
3639
3640 label = hda_get_autocfg_input_label(codec, cfg, i);
3641 snd_hda_add_imux_item(imux, label, index, &type_idx);
3642
3643 err = create_elem_capture_vol(codec, nid,
3644 label, type_idx,
3645 HDA_INPUT);
3646 if (err < 0)
3647 return err;
3648 }
3649 spec->num_analog_muxes = imux->num_items;
3650
3651 if (imux->num_items) {
3652
3653
3654
3655
3656
3657 for (i = 0; i < spec->num_muxes; i++) {
3658 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3659 AC_VERB_SET_CONNECT_SEL,
3660 imux->items[0].index);
3661 }
3662 }
3663
3664 return 0;
3665}
3666
3667static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3668{
3669 struct sigmatel_spec *spec = codec->spec;
3670 int i;
3671
3672 for (i = 0; i < spec->autocfg.line_outs; i++) {
3673 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3674 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3675 }
3676}
3677
3678static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3679{
3680 struct sigmatel_spec *spec = codec->spec;
3681 int i;
3682
3683 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3684 hda_nid_t pin;
3685 pin = spec->autocfg.hp_pins[i];
3686 if (pin)
3687 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3688 }
3689 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3690 hda_nid_t pin;
3691 pin = spec->autocfg.speaker_pins[i];
3692 if (pin)
3693 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3694 }
3695}
3696
3697static int is_dual_headphones(struct hda_codec *codec)
3698{
3699 struct sigmatel_spec *spec = codec->spec;
3700 int i, valid_hps;
3701
3702 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT ||
3703 spec->autocfg.hp_outs <= 1)
3704 return 0;
3705 valid_hps = 0;
3706 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3707 hda_nid_t nid = spec->autocfg.hp_pins[i];
3708 unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid);
3709 if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE)
3710 continue;
3711 valid_hps++;
3712 }
3713 return (valid_hps > 1);
3714}
3715
3716
3717static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3718{
3719 struct sigmatel_spec *spec = codec->spec;
3720 int hp_swap = 0;
3721 int i, err;
3722
3723 if ((err = snd_hda_parse_pin_def_config(codec,
3724 &spec->autocfg,
3725 spec->dmic_nids)) < 0)
3726 return err;
3727 if (! spec->autocfg.line_outs)
3728 return 0;
3729
3730
3731
3732
3733 if (is_dual_headphones(codec)) {
3734
3735
3736
3737
3738 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3739 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3740 sizeof(spec->autocfg.line_out_pins));
3741 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3742 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3743 sizeof(spec->autocfg.hp_pins));
3744 spec->autocfg.line_outs = spec->autocfg.hp_outs;
3745 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3746 spec->autocfg.hp_outs = 0;
3747 hp_swap = 1;
3748 }
3749 if (spec->autocfg.mono_out_pin) {
3750 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3751 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3752 u32 caps = query_amp_caps(codec,
3753 spec->autocfg.mono_out_pin, dir);
3754 hda_nid_t conn_list[1];
3755
3756
3757 if (snd_hda_get_connections(codec,
3758 spec->autocfg.mono_out_pin, conn_list, 1) &&
3759 snd_hda_get_connections(codec, conn_list[0],
3760 conn_list, 1) > 0) {
3761
3762 int wcaps = get_wcaps(codec, conn_list[0]);
3763 int wid_type = get_wcaps_type(wcaps);
3764
3765
3766
3767
3768 if (wid_type == AC_WID_AUD_SEL &&
3769 !(wcaps & AC_WCAP_LR_SWAP))
3770 spec->mono_nid = conn_list[0];
3771 }
3772 if (dir) {
3773 hda_nid_t nid = spec->autocfg.mono_out_pin;
3774
3775
3776 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3777 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3778 "Mono Playback Switch",
3779 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3780 if (err < 0)
3781 return err;
3782
3783 if ((caps & AC_AMPCAP_NUM_STEPS)
3784 >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3785 err = stac92xx_add_control(spec,
3786 STAC_CTL_WIDGET_VOL,
3787 "Mono Playback Volume",
3788 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3789 if (err < 0)
3790 return err;
3791 }
3792 }
3793
3794 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3795 AC_PINCTL_OUT_EN);
3796 }
3797
3798 if (!spec->multiout.num_dacs) {
3799 err = stac92xx_auto_fill_dac_nids(codec);
3800 if (err < 0)
3801 return err;
3802 err = stac92xx_auto_create_multi_out_ctls(codec,
3803 &spec->autocfg);
3804 if (err < 0)
3805 return err;
3806 }
3807
3808
3809 if (spec->anabeep_nid > 0) {
3810 err = stac92xx_auto_create_beep_ctls(codec,
3811 spec->anabeep_nid);
3812 if (err < 0)
3813 return err;
3814 }
3815
3816
3817#ifdef CONFIG_SND_HDA_INPUT_BEEP
3818 if (spec->digbeep_nid > 0) {
3819 hda_nid_t nid = spec->digbeep_nid;
3820 unsigned int caps;
3821
3822 err = stac92xx_auto_create_beep_ctls(codec, nid);
3823 if (err < 0)
3824 return err;
3825 err = snd_hda_attach_beep_device(codec, nid);
3826 if (err < 0)
3827 return err;
3828 if (codec->beep) {
3829
3830 codec->beep->linear_tone = spec->linear_tone_beep;
3831
3832 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3833 if (!(caps & AC_AMPCAP_MUTE)) {
3834 err = stac92xx_beep_switch_ctl(codec);
3835 if (err < 0)
3836 return err;
3837 }
3838 }
3839 }
3840#endif
3841
3842 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3843 if (err < 0)
3844 return err;
3845
3846
3847 if (hp_swap) {
3848 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3849 sizeof(spec->autocfg.hp_pins));
3850 spec->autocfg.hp_outs = spec->autocfg.line_outs;
3851 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3852 spec->autocfg.line_outs = 0;
3853 }
3854
3855 if (stac_check_auto_mic(codec)) {
3856 spec->auto_mic = 1;
3857
3858 spec->num_adcs = 1;
3859 spec->num_caps = 1;
3860 spec->num_muxes = 1;
3861 }
3862
3863 for (i = 0; i < spec->num_caps; i++) {
3864 err = stac92xx_add_capvol_ctls(codec, spec->capvols[i],
3865 spec->capsws[i], i);
3866 if (err < 0)
3867 return err;
3868 }
3869
3870 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3871 if (err < 0)
3872 return err;
3873
3874 if (spec->mono_nid > 0) {
3875 err = stac92xx_auto_create_mono_output_ctls(codec);
3876 if (err < 0)
3877 return err;
3878 }
3879 if (spec->num_dmics > 0 && !spec->dinput_mux)
3880 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3881 &spec->autocfg)) < 0)
3882 return err;
3883 if (spec->num_muxes > 0) {
3884 err = stac92xx_auto_create_mux_input_ctls(codec);
3885 if (err < 0)
3886 return err;
3887 }
3888 if (spec->num_smuxes > 0) {
3889 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3890 if (err < 0)
3891 return err;
3892 }
3893
3894 err = stac92xx_add_input_source(spec);
3895 if (err < 0)
3896 return err;
3897
3898 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3899 if (spec->multiout.max_channels > 2)
3900 spec->surr_switch = 1;
3901
3902 if (spec->autocfg.dig_outs)
3903 spec->multiout.dig_out_nid = dig_out;
3904 if (dig_in && spec->autocfg.dig_in_pin)
3905 spec->dig_in_nid = dig_in;
3906
3907 if (spec->kctls.list)
3908 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3909
3910 spec->input_mux = &spec->private_imux;
3911 if (!spec->dinput_mux)
3912 spec->dinput_mux = &spec->private_dimux;
3913 spec->sinput_mux = &spec->private_smux;
3914 spec->mono_mux = &spec->private_mono_mux;
3915 return 1;
3916}
3917
3918
3919static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3920 struct auto_pin_cfg *cfg)
3921{
3922 struct sigmatel_spec *spec = codec->spec;
3923 hda_nid_t pin = cfg->hp_pins[0];
3924 unsigned int wid_caps;
3925
3926 if (! pin)
3927 return 0;
3928
3929 wid_caps = get_wcaps(codec, pin);
3930 if (wid_caps & AC_WCAP_UNSOL_CAP)
3931 spec->hp_detect = 1;
3932
3933 return 0;
3934}
3935
3936
3937static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3938 struct auto_pin_cfg *cfg)
3939{
3940 struct sigmatel_spec *spec = codec->spec;
3941 int err;
3942 hda_nid_t lfe_pin = 0x0;
3943 int i;
3944
3945
3946
3947
3948
3949
3950 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3951 hda_nid_t pin = spec->autocfg.speaker_pins[i];
3952 unsigned int wcaps = get_wcaps(codec, pin);
3953 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3954 if (wcaps == AC_WCAP_OUT_AMP)
3955
3956 lfe_pin = pin;
3957 }
3958
3959
3960 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3961 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3962 hda_nid_t pin = spec->autocfg.line_out_pins[i];
3963 unsigned int defcfg;
3964 defcfg = snd_hda_codec_get_pincfg(codec, pin);
3965 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3966 unsigned int wcaps = get_wcaps(codec, pin);
3967 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3968 if (wcaps == AC_WCAP_OUT_AMP)
3969
3970
3971 lfe_pin = pin;
3972 }
3973 }
3974 }
3975
3976 if (lfe_pin) {
3977 err = create_controls(codec, "LFE", lfe_pin, 1);
3978 if (err < 0)
3979 return err;
3980 }
3981
3982 return 0;
3983}
3984
3985static int stac9200_parse_auto_config(struct hda_codec *codec)
3986{
3987 struct sigmatel_spec *spec = codec->spec;
3988 int err;
3989
3990 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3991 return err;
3992
3993 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3994 return err;
3995
3996 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
3997 return err;
3998
3999 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
4000 return err;
4001
4002 if (spec->num_muxes > 0) {
4003 err = stac92xx_auto_create_mux_input_ctls(codec);
4004 if (err < 0)
4005 return err;
4006 }
4007
4008 err = stac92xx_add_input_source(spec);
4009 if (err < 0)
4010 return err;
4011
4012 if (spec->autocfg.dig_outs)
4013 spec->multiout.dig_out_nid = 0x05;
4014 if (spec->autocfg.dig_in_pin)
4015 spec->dig_in_nid = 0x04;
4016
4017 if (spec->kctls.list)
4018 spec->mixers[spec->num_mixers++] = spec->kctls.list;
4019
4020 spec->input_mux = &spec->private_imux;
4021 spec->dinput_mux = &spec->private_dimux;
4022
4023 return 1;
4024}
4025
4026
4027
4028
4029
4030
4031static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
4032 unsigned int dir_mask, unsigned int data)
4033{
4034 unsigned int gpiostate, gpiomask, gpiodir;
4035
4036 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4037 AC_VERB_GET_GPIO_DATA, 0);
4038 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
4039
4040 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4041 AC_VERB_GET_GPIO_MASK, 0);
4042 gpiomask |= mask;
4043
4044 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4045 AC_VERB_GET_GPIO_DIRECTION, 0);
4046 gpiodir |= dir_mask;
4047
4048
4049 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
4050
4051 snd_hda_codec_write(codec, codec->afg, 0,
4052 AC_VERB_SET_GPIO_MASK, gpiomask);
4053 snd_hda_codec_read(codec, codec->afg, 0,
4054 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
4055
4056 msleep(1);
4057
4058 snd_hda_codec_read(codec, codec->afg, 0,
4059 AC_VERB_SET_GPIO_DATA, gpiostate);
4060}
4061
4062static int stac92xx_add_jack(struct hda_codec *codec,
4063 hda_nid_t nid, int type)
4064{
4065#ifdef CONFIG_SND_HDA_INPUT_JACK
4066 int def_conf = snd_hda_codec_get_pincfg(codec, nid);
4067 int connectivity = get_defcfg_connect(def_conf);
4068 char name[32];
4069 int err;
4070
4071 if (connectivity && connectivity != AC_JACK_PORT_FIXED)
4072 return 0;
4073
4074 snprintf(name, sizeof(name), "%s at %s %s Jack",
4075 snd_hda_get_jack_type(def_conf),
4076 snd_hda_get_jack_connectivity(def_conf),
4077 snd_hda_get_jack_location(def_conf));
4078
4079 err = snd_hda_input_jack_add(codec, nid, type, name);
4080 if (err < 0)
4081 return err;
4082#endif
4083 return 0;
4084}
4085
4086static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
4087 unsigned char type, int data)
4088{
4089 struct sigmatel_event *event;
4090
4091 snd_array_init(&spec->events, sizeof(*event), 32);
4092 event = snd_array_new(&spec->events);
4093 if (!event)
4094 return -ENOMEM;
4095 event->nid = nid;
4096 event->type = type;
4097 event->tag = spec->events.used;
4098 event->data = data;
4099
4100 return event->tag;
4101}
4102
4103static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
4104 hda_nid_t nid)
4105{
4106 struct sigmatel_spec *spec = codec->spec;
4107 struct sigmatel_event *event = spec->events.list;
4108 int i;
4109
4110 for (i = 0; i < spec->events.used; i++, event++) {
4111 if (event->nid == nid)
4112 return event;
4113 }
4114 return NULL;
4115}
4116
4117static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
4118 unsigned char tag)
4119{
4120 struct sigmatel_spec *spec = codec->spec;
4121 struct sigmatel_event *event = spec->events.list;
4122 int i;
4123
4124 for (i = 0; i < spec->events.used; i++, event++) {
4125 if (event->tag == tag)
4126 return event;
4127 }
4128 return NULL;
4129}
4130
4131
4132
4133
4134
4135static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
4136 unsigned int type)
4137{
4138 struct sigmatel_event *event;
4139 int tag;
4140
4141 if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
4142 return 0;
4143 event = stac_get_event(codec, nid);
4144 if (event) {
4145 if (event->type != type)
4146 return 0;
4147 tag = event->tag;
4148 } else {
4149 tag = stac_add_event(codec->spec, nid, type, 0);
4150 if (tag < 0)
4151 return 0;
4152 }
4153 snd_hda_codec_write_cache(codec, nid, 0,
4154 AC_VERB_SET_UNSOLICITED_ENABLE,
4155 AC_USRSP_EN | tag);
4156 return 1;
4157}
4158
4159static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
4160{
4161 int i;
4162 for (i = 0; i < cfg->hp_outs; i++)
4163 if (cfg->hp_pins[i] == nid)
4164 return 1;
4165
4166 return 0;
4167};
4168
4169static void stac92xx_power_down(struct hda_codec *codec)
4170{
4171 struct sigmatel_spec *spec = codec->spec;
4172
4173
4174 hda_nid_t *dac;
4175 for (dac = spec->dac_list; *dac; dac++)
4176 if (!check_all_dac_nids(spec, *dac))
4177 snd_hda_codec_write(codec, *dac, 0,
4178 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4179}
4180
4181static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4182 int enable);
4183
4184static inline int get_int_hint(struct hda_codec *codec, const char *key,
4185 int *valp)
4186{
4187 const char *p;
4188 p = snd_hda_get_hint(codec, key);
4189 if (p) {
4190 unsigned long val;
4191 if (!strict_strtoul(p, 0, &val)) {
4192 *valp = val;
4193 return 1;
4194 }
4195 }
4196 return 0;
4197}
4198
4199
4200static void stac_store_hints(struct hda_codec *codec)
4201{
4202 struct sigmatel_spec *spec = codec->spec;
4203 int val;
4204
4205 val = snd_hda_get_bool_hint(codec, "hp_detect");
4206 if (val >= 0)
4207 spec->hp_detect = val;
4208 if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) {
4209 spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
4210 spec->gpio_mask;
4211 }
4212 if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir))
4213 spec->gpio_mask &= spec->gpio_mask;
4214 if (get_int_hint(codec, "gpio_data", &spec->gpio_data))
4215 spec->gpio_dir &= spec->gpio_mask;
4216 if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask))
4217 spec->eapd_mask &= spec->gpio_mask;
4218 if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute))
4219 spec->gpio_mute &= spec->gpio_mask;
4220 val = snd_hda_get_bool_hint(codec, "eapd_switch");
4221 if (val >= 0)
4222 spec->eapd_switch = val;
4223 get_int_hint(codec, "gpio_led_polarity", &spec->gpio_led_polarity);
4224 if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) {
4225 spec->gpio_mask |= spec->gpio_led;
4226 spec->gpio_dir |= spec->gpio_led;
4227 if (spec->gpio_led_polarity)
4228 spec->gpio_data |= spec->gpio_led;
4229 }
4230}
4231
4232static int stac92xx_init(struct hda_codec *codec)
4233{
4234 struct sigmatel_spec *spec = codec->spec;
4235 struct auto_pin_cfg *cfg = &spec->autocfg;
4236 unsigned int gpio;
4237 int i;
4238
4239 snd_hda_sequence_write(codec, spec->init);
4240
4241
4242 if (spec->powerdown_adcs)
4243 for (i = 0; i < spec->num_adcs; i++)
4244 snd_hda_codec_write(codec,
4245 spec->adc_nids[i], 0,
4246 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4247
4248
4249 stac_store_hints(codec);
4250
4251
4252 gpio = spec->gpio_data;
4253
4254
4255
4256 if (!spec->eapd_switch)
4257 gpio |= spec->eapd_mask;
4258 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
4259
4260
4261 if (spec->hp_detect) {
4262
4263 for (i = 0; i < cfg->hp_outs; i++) {
4264 hda_nid_t nid = cfg->hp_pins[i];
4265 enable_pin_detect(codec, nid, STAC_HP_EVENT);
4266 }
4267 if (cfg->line_out_type == AUTO_PIN_LINE_OUT &&
4268 cfg->speaker_outs > 0) {
4269
4270 for (i = 0; i < cfg->line_outs; i++) {
4271 hda_nid_t nid = cfg->line_out_pins[i];
4272 enable_pin_detect(codec, nid, STAC_LO_EVENT);
4273 }
4274 }
4275
4276
4277
4278
4279 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
4280 AC_PINCTL_OUT_EN);
4281
4282 if (cfg->hp_pins[0])
4283 stac_issue_unsol_event(codec, cfg->hp_pins[0]);
4284 else if (cfg->line_out_pins[0])
4285 stac_issue_unsol_event(codec, cfg->line_out_pins[0]);
4286 } else {
4287 stac92xx_auto_init_multi_out(codec);
4288 stac92xx_auto_init_hp_out(codec);
4289 for (i = 0; i < cfg->hp_outs; i++)
4290 stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
4291 }
4292 if (spec->auto_mic) {
4293
4294 if (spec->dmux_nids)
4295 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4296 AC_VERB_SET_CONNECT_SEL, 0);
4297 if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT))
4298 stac_issue_unsol_event(codec, spec->ext_mic.pin);
4299 if (enable_pin_detect(codec, spec->dock_mic.pin,
4300 STAC_MIC_EVENT))
4301 stac_issue_unsol_event(codec, spec->dock_mic.pin);
4302 }
4303 for (i = 0; i < cfg->num_inputs; i++) {
4304 hda_nid_t nid = cfg->inputs[<
