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