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