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