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