projects / deliverable / linux.git / blob
? search:


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