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