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