]> git.ipfire.org Git - people/pmueller/ipfire-2.x.git/blame - src/patches/suse-2.6.27.25/patches.drivers/alsa-hda-sigmatel-update
projects / people / pmueller / ipfire-2.x.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Reenabled linux-xen and xen-image build
[people/pmueller/ipfire-2.x.git] / src / patches / suse-2.6.27.25 / patches.drivers / alsa-hda-sigmatel-update
CommitLineData
00e5a55c
BS		 1From: Takashi Iwai <tiwai@suse.de>
2Subject: ALSA: hda - IDT/Sigmatel codec updates
3Patch-mainline: 2.6.28-rc1
4References: bnc#409140
5
6A pile of updates for IDT/Sigtmatel codecs.
7
8- digital beep support
9- 92HD83x codecs
10- HP M4 model support
11- ECS 202 model support
12- Multiple SPDIF support
13- More power-saving
14
15Signed-off-by: Takashi Iwai <tiwai@suse.de>
16
17---
18---
19 sound/pci/hda/hda_codec.c | 9
20 sound/pci/hda/hda_local.h | 9
21 sound/pci/hda/patch_sigmatel.c | 975 ++++++++++++++++++++++++++++++++++++-----
22 3 files changed, 877 insertions(+), 116 deletions(-)
23
24--- a/sound/pci/hda/hda_codec.c
25+++ b/sound/pci/hda/hda_codec.c
26@@ -959,15 +959,6 @@ void snd_hda_codec_resume_amp(struct hda
27 }
28 #endif /* SND_HDA_NEEDS_RESUME */
29
30-/*
31- * AMP control callbacks
32- */
33-/* retrieve parameters from private_value */
34-#define get_amp_nid(kc) ((kc)->private_value & 0xffff)
35-#define get_amp_channels(kc) (((kc)->private_value >> 16) & 0x3)
36-#define get_amp_direction(kc) (((kc)->private_value >> 18) & 0x1)
37-#define get_amp_index(kc) (((kc)->private_value >> 19) & 0xf)
38-
39 /* volume */
40 int snd_hda_mixer_amp_volume_info(struct snd_kcontrol *kcontrol,
41 struct snd_ctl_elem_info *uinfo)
42--- a/sound/pci/hda/hda_local.h
43+++ b/sound/pci/hda/hda_local.h
44@@ -421,4 +421,13 @@ int snd_hda_check_amp_list_power(struct
45 hda_nid_t nid);
46 #endif /* CONFIG_SND_HDA_POWER_SAVE */
47
48+/*
49+ * AMP control callbacks
50+ */
51+/* retrieve parameters from private_value */
52+#define get_amp_nid(kc) ((kc)->private_value & 0xffff)
53+#define get_amp_channels(kc) (((kc)->private_value >> 16) & 0x3)
54+#define get_amp_direction(kc) (((kc)->private_value >> 18) & 0x1)
55+#define get_amp_index(kc) (((kc)->private_value >> 19) & 0xf)
56+
57 #endif /* __SOUND_HDA_LOCAL_H */
58--- a/sound/pci/hda/patch_sigmatel.c
59+++ b/sound/pci/hda/patch_sigmatel.c
60@@ -33,10 +33,12 @@
61 #include "hda_codec.h"
62 #include "hda_local.h"
63 #include "hda_patch.h"
64+#include "hda_beep.h"
65
66 #define NUM_CONTROL_ALLOC 32
67 #define STAC_PWR_EVENT 0x20
68 #define STAC_HP_EVENT 0x30
69+#define STAC_VREF_EVENT 0x40
70
71 enum {
72 STAC_REF,
73@@ -72,9 +74,15 @@ enum {
74 };
75
76 enum {
77+ STAC_92HD83XXX_REF,
78+ STAC_92HD83XXX_MODELS
79+};
80+
81+enum {
82 STAC_92HD71BXX_REF,
83 STAC_DELL_M4_1,
84 STAC_DELL_M4_2,
85+ STAC_HP_M4,
86 STAC_92HD71BXX_MODELS
87 };
88
89@@ -132,6 +140,7 @@ struct sigmatel_spec {
90 unsigned int mic_switch: 1;
91 unsigned int alt_switch: 1;
92 unsigned int hp_detect: 1;
93+ unsigned int spdif_mute: 1;
94
95 /* gpio lines */
96 unsigned int eapd_mask;
97@@ -140,17 +149,22 @@ struct sigmatel_spec {
98 unsigned int gpio_data;
99 unsigned int gpio_mute;
100
101+ /* stream */
102+ unsigned int stream_delay;
103+
104 /* analog loopback */
105 unsigned char aloopback_mask;
106 unsigned char aloopback_shift;
107
108 /* power management */
109 unsigned int num_pwrs;
110+ unsigned int *pwr_mapping;
111 hda_nid_t *pwr_nids;
112 hda_nid_t *dac_list;
113
114 /* playback */
115 struct hda_input_mux *mono_mux;
116+ struct hda_input_mux *amp_mux;
117 unsigned int cur_mmux;
118 struct hda_multi_out multiout;
119 hda_nid_t dac_nids[5];
120@@ -164,8 +178,14 @@ struct sigmatel_spec {
121 unsigned int num_dmics;
122 hda_nid_t *dmux_nids;
123 unsigned int num_dmuxes;
124+ hda_nid_t *smux_nids;
125+ unsigned int num_smuxes;
126+ const char **spdif_labels;
127+
128 hda_nid_t dig_in_nid;
129 hda_nid_t mono_nid;
130+ hda_nid_t anabeep_nid;
131+ hda_nid_t digbeep_nid;
132
133 /* pin widgets */
134 hda_nid_t *pin_nids;
135@@ -182,6 +202,12 @@ struct sigmatel_spec {
136 unsigned int cur_dmux[2];
137 struct hda_input_mux *input_mux;
138 unsigned int cur_mux[3];
139+ struct hda_input_mux *sinput_mux;
140+ unsigned int cur_smux[2];
141+ unsigned int cur_amux;
142+ hda_nid_t *amp_nids;
143+ unsigned int num_amps;
144+ unsigned int powerdown_adcs;
145
146 /* i/o switches */
147 unsigned int io_switch[2];
148@@ -197,6 +223,8 @@ struct sigmatel_spec {
149 struct snd_kcontrol_new *kctl_alloc;
150 struct hda_input_mux private_dimux;
151 struct hda_input_mux private_imux;
152+ struct hda_input_mux private_smux;
153+ struct hda_input_mux private_amp_mux;
154 struct hda_input_mux private_mono_mux;
155 };
156
157@@ -217,10 +245,19 @@ static hda_nid_t stac92hd73xx_pwr_nids[8
158 0x0f, 0x10, 0x11
159 };
160
161+static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
162+ 0x26, 0,
163+};
164+
165 static hda_nid_t stac92hd73xx_adc_nids[2] = {
166 0x1a, 0x1b
167 };
168
169+#define DELL_M6_AMP 2
170+static hda_nid_t stac92hd73xx_amp_nids[3] = {
171+ 0x0b, 0x0c, 0x0e
172+};
173+
174 #define STAC92HD73XX_NUM_DMICS 2
175 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
176 0x13, 0x14, 0
177@@ -239,6 +276,41 @@ static hda_nid_t stac92hd73xx_dmux_nids[
178 0x20, 0x21,
179 };
180
181+static hda_nid_t stac92hd73xx_smux_nids[2] = {
182+ 0x22, 0x23,
183+};
184+
185+#define STAC92HD83XXX_NUM_DMICS 2
186+static hda_nid_t stac92hd83xxx_dmic_nids[STAC92HD83XXX_NUM_DMICS + 1] = {
187+ 0x11, 0x12, 0
188+};
189+
190+#define STAC92HD81_DAC_COUNT 2
191+#define STAC92HD83_DAC_COUNT 3
192+static hda_nid_t stac92hd83xxx_dac_nids[STAC92HD73_DAC_COUNT] = {
193+ 0x13, 0x14, 0x22,
194+};
195+
196+static hda_nid_t stac92hd83xxx_dmux_nids[2] = {
197+ 0x17, 0x18,
198+};
199+
200+static hda_nid_t stac92hd83xxx_adc_nids[2] = {
201+ 0x15, 0x16,
202+};
203+
204+static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
205+ 0xa, 0xb, 0xd, 0xe,
206+};
207+
208+static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
209+ 0x1e, 0,
210+};
211+
212+static unsigned int stac92hd83xxx_pwr_mapping[4] = {
213+ 0x03, 0x0c, 0x10, 0x40,
214+};
215+
216 static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
217 0x0a, 0x0d, 0x0f
218 };
219@@ -251,8 +323,12 @@ static hda_nid_t stac92hd71bxx_mux_nids[
220 0x1a, 0x1b
221 };
222
223-static hda_nid_t stac92hd71bxx_dmux_nids[1] = {
224- 0x1c,
225+static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
226+ 0x1c, 0x1d,
227+};
228+
229+static hda_nid_t stac92hd71bxx_smux_nids[2] = {
230+ 0x24, 0x25,
231 };
232
233 static hda_nid_t stac92hd71bxx_dac_nids[1] = {
234@@ -264,6 +340,10 @@ static hda_nid_t stac92hd71bxx_dmic_nids
235 0x18, 0x19, 0
236 };
237
238+static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
239+ 0x22, 0
240+};
241+
242 static hda_nid_t stac925x_adc_nids[1] = {
243 0x03,
244 };
245@@ -301,6 +381,10 @@ static hda_nid_t stac927x_mux_nids[3] =
246 0x15, 0x16, 0x17
247 };
248
249+static hda_nid_t stac927x_smux_nids[1] = {
250+ 0x21,
251+};
252+
253 static hda_nid_t stac927x_dac_nids[6] = {
254 0x02, 0x03, 0x04, 0x05, 0x06, 0
255 };
256@@ -314,6 +398,11 @@ static hda_nid_t stac927x_dmic_nids[STAC
257 0x13, 0x14, 0
258 };
259
260+static const char *stac927x_spdif_labels[5] = {
261+ "Digital Playback", "ADAT", "Analog Mux 1",
262+ "Analog Mux 2", "Analog Mux 3"
263+};
264+
265 static hda_nid_t stac9205_adc_nids[2] = {
266 0x12, 0x13
267 };
268@@ -326,6 +415,10 @@ static hda_nid_t stac9205_dmux_nids[1] =
269 0x1d,
270 };
271
272+static hda_nid_t stac9205_smux_nids[1] = {
273+ 0x21,
274+};
275+
276 #define STAC9205_NUM_DMICS 2
277 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
278 0x17, 0x18, 0
279@@ -349,12 +442,18 @@ static hda_nid_t stac922x_pin_nids[10] =
280 static hda_nid_t stac92hd73xx_pin_nids[13] = {
281 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
282 0x0f, 0x10, 0x11, 0x12, 0x13,
283- 0x14, 0x1e, 0x22
284+ 0x14, 0x22, 0x23
285 };
286
287-static hda_nid_t stac92hd71bxx_pin_nids[10] = {
288+static hda_nid_t stac92hd83xxx_pin_nids[14] = {
289+ 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
290+ 0x0f, 0x10, 0x11, 0x12, 0x13,
291+ 0x1d, 0x1e, 0x1f, 0x20
292+};
293+static hda_nid_t stac92hd71bxx_pin_nids[11] = {
294 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
295 0x0f, 0x14, 0x18, 0x19, 0x1e,
296+ 0x1f,
297 };
298
299 static hda_nid_t stac927x_pin_nids[14] = {
300@@ -369,6 +468,34 @@ static hda_nid_t stac9205_pin_nids[12] =
301 0x21, 0x22,
302 };
303
304+#define stac92xx_amp_volume_info snd_hda_mixer_amp_volume_info
305+
306+static int stac92xx_amp_volume_get(struct snd_kcontrol *kcontrol,
307+ struct snd_ctl_elem_value *ucontrol)
308+{
309+ struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
310+ struct sigmatel_spec *spec = codec->spec;
311+ hda_nid_t nid = spec->amp_nids[spec->cur_amux];
312+
313+ kcontrol->private_value ^= get_amp_nid(kcontrol);
314+ kcontrol->private_value |= nid;
315+
316+ return snd_hda_mixer_amp_volume_get(kcontrol, ucontrol);
317+}
318+
319+static int stac92xx_amp_volume_put(struct snd_kcontrol *kcontrol,
320+ struct snd_ctl_elem_value *ucontrol)
321+{
322+ struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
323+ struct sigmatel_spec *spec = codec->spec;
324+ hda_nid_t nid = spec->amp_nids[spec->cur_amux];
325+
326+ kcontrol->private_value ^= get_amp_nid(kcontrol);
327+ kcontrol->private_value |= nid;
328+
329+ return snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
330+}
331+
332 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
333 struct snd_ctl_elem_info *uinfo)
334 {
335@@ -399,6 +526,58 @@ static int stac92xx_dmux_enum_put(struct
336 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
337 }
338
339+static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
340+ struct snd_ctl_elem_info *uinfo)
341+{
342+ struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
343+ struct sigmatel_spec *spec = codec->spec;
344+ return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
345+}
346+
347+static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
348+ struct snd_ctl_elem_value *ucontrol)
349+{
350+ struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
351+ struct sigmatel_spec *spec = codec->spec;
352+ unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
353+
354+ ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
355+ return 0;
356+}
357+
358+static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
359+ struct snd_ctl_elem_value *ucontrol)
360+{
361+ struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
362+ struct sigmatel_spec *spec = codec->spec;
363+ struct hda_input_mux *smux = &spec->private_smux;
364+ unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
365+ int err, val;
366+ hda_nid_t nid;
367+
368+ err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
369+ spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
370+ if (err < 0)
371+ return err;
372+
373+ if (spec->spdif_mute) {
374+ if (smux_idx == 0)
375+ nid = spec->multiout.dig_out_nid;
376+ else
377+ nid = codec->slave_dig_outs[smux_idx - 1];
378+ if (spec->cur_smux[smux_idx] == smux->num_items - 1)
379+ val = AMP_OUT_MUTE;
380+ if (smux_idx == 0)
381+ nid = spec->multiout.dig_out_nid;
382+ else
383+ nid = codec->slave_dig_outs[smux_idx - 1];
384+ /* un/mute SPDIF out */
385+ snd_hda_codec_write_cache(codec, nid, 0,
386+ AC_VERB_SET_AMP_GAIN_MUTE, val);
387+ }
388+ return 0;
389+}
390+
391 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
392 {
393 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
394@@ -454,6 +633,41 @@ static int stac92xx_mono_mux_enum_put(st
395 spec->mono_nid, &spec->cur_mmux);
396 }
397
398+static int stac92xx_amp_mux_enum_info(struct snd_kcontrol *kcontrol,
399+ struct snd_ctl_elem_info *uinfo)
400+{
401+ struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
402+ struct sigmatel_spec *spec = codec->spec;
403+ return snd_hda_input_mux_info(spec->amp_mux, uinfo);
404+}
405+
406+static int stac92xx_amp_mux_enum_get(struct snd_kcontrol *kcontrol,
407+ struct snd_ctl_elem_value *ucontrol)
408+{
409+ struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
410+ struct sigmatel_spec *spec = codec->spec;
411+
412+ ucontrol->value.enumerated.item[0] = spec->cur_amux;
413+ return 0;
414+}
415+
416+static int stac92xx_amp_mux_enum_put(struct snd_kcontrol *kcontrol,
417+ struct snd_ctl_elem_value *ucontrol)
418+{
419+ struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
420+ struct sigmatel_spec *spec = codec->spec;
421+ struct snd_kcontrol *ctl =
422+ snd_hda_find_mixer_ctl(codec, "Amp Capture Volume");
423+ if (!ctl)
424+ return -EINVAL;
425+
426+ snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE |
427+ SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
428+
429+ return snd_hda_input_mux_put(codec, spec->amp_mux, ucontrol,
430+ 0, &spec->cur_amux);
431+}
432+
433 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info
434
435 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
436@@ -565,8 +779,8 @@ static struct hda_verb dell_m6_core_init
437 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
438 /* setup audio connections */
439 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
440- { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
441- { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x02},
442+ { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x02},
443+ { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x01},
444 /* setup adcs to point to mixer */
445 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
446 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
447@@ -628,12 +842,25 @@ static struct hda_verb stac92hd73xx_10ch
448 {}
449 };
450
451+static struct hda_verb stac92hd83xxx_core_init[] = {
452+ /* start of config #1 */
453+ { 0xe, AC_VERB_SET_CONNECT_SEL, 0x3},
454+
455+ /* start of config #2 */
456+ { 0xa, AC_VERB_SET_CONNECT_SEL, 0x0},
457+ { 0xb, AC_VERB_SET_CONNECT_SEL, 0x0},
458+ { 0xd, AC_VERB_SET_CONNECT_SEL, 0x1},
459+
460+ /* power state controls amps */
461+ { 0x01, AC_VERB_SET_EAPD, 1 << 2},
462+ {}
463+};
464+
465 static struct hda_verb stac92hd71bxx_core_init[] = {
466 /* set master volume and direct control */
467 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
468 /* connect headphone jack to dac1 */
469 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
470- { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */
471 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
472 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
473 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
474@@ -641,13 +868,12 @@ static struct hda_verb stac92hd71bxx_cor
475 {}
476 };
477
478-#define HD_DISABLE_PORTF 3
479+#define HD_DISABLE_PORTF 2
480 static struct hda_verb stac92hd71bxx_analog_core_init[] = {
481 /* start of config #1 */
482
483 /* connect port 0f to audio mixer */
484 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
485- { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */
486 /* unmute right and left channels for node 0x0f */
487 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
488 /* start of config #2 */
489@@ -656,10 +882,6 @@ static struct hda_verb stac92hd71bxx_ana
490 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
491 /* connect headphone jack to dac1 */
492 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01},
493- /* connect port 0d to audio mixer */
494- { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x2},
495- /* unmute dac0 input in audio mixer */
496- { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
497 /* unmute right and left channels for nodes 0x0a, 0xd */
498 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
499 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
500@@ -691,12 +913,16 @@ static struct hda_verb d965_core_init[]
501 static struct hda_verb stac927x_core_init[] = {
502 /* set master volume and direct control */
503 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
504+ /* enable analog pc beep path */
505+ { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
506 {}
507 };
508
509 static struct hda_verb stac9205_core_init[] = {
510 /* set master volume and direct control */
511 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
512+ /* enable analog pc beep path */
513+ { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
514 {}
515 };
516
517@@ -710,6 +936,31 @@ static struct hda_verb stac9205_core_ini
518 .put = stac92xx_mono_mux_enum_put, \
519 }
520
521+#define STAC_AMP_MUX \
522+ { \
523+ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
524+ .name = "Amp Selector Capture Switch", \
525+ .count = 1, \
526+ .info = stac92xx_amp_mux_enum_info, \
527+ .get = stac92xx_amp_mux_enum_get, \
528+ .put = stac92xx_amp_mux_enum_put, \
529+ }
530+
531+#define STAC_AMP_VOL(xname, nid, chs, idx, dir) \
532+ { \
533+ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
534+ .name = xname, \
535+ .index = 0, \
536+ .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
537+ SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
538+ SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
539+ .info = stac92xx_amp_volume_info, \
540+ .get = stac92xx_amp_volume_get, \
541+ .put = stac92xx_amp_volume_put, \
542+ .tlv = { .c = snd_hda_mixer_amp_tlv }, \
543+ .private_value = HDA_COMPOSE_AMP_VAL(nid, chs, idx, dir) \
544+ }
545+
546 #define STAC_INPUT_SOURCE(cnt) \
547 { \
548 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
549@@ -737,33 +988,36 @@ static struct snd_kcontrol_new stac9200_
550 STAC_INPUT_SOURCE(1),
551 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
552 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
553- HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT),
554 { } /* end */
555 };
556
557+#define DELL_M6_MIXER 6
558 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
559- STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
560-
561- HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
562- HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
563-
564- HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
565- HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
566-
567+ /* start of config #1 */
568 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
569 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
570
571- HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
572- HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
573-
574 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
575 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
576
577+ HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
578+ HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
579+
580+ /* start of config #2 */
581+ HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
582+ HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
583+
584 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
585 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
586
587- HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
588- HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
589+ STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
590+
591+ HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
592+ HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),
593+
594+ HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
595+ HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),
596+
597 { } /* end */
598 };
599
600@@ -819,22 +1073,59 @@ static struct snd_kcontrol_new stac92hd7
601 { } /* end */
602 };
603
604+
605+static struct snd_kcontrol_new stac92hd83xxx_mixer[] = {
606+ HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_OUTPUT),
607+ HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_OUTPUT),
608+
609+ HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_OUTPUT),
610+ HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_OUTPUT),
611+
612+ HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x1b, 0, HDA_INPUT),
613+ HDA_CODEC_MUTE("DAC0 Capture Switch", 0x1b, 0, HDA_INPUT),
614+
615+ HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x1b, 0x1, HDA_INPUT),
616+ HDA_CODEC_MUTE("DAC1 Capture Switch", 0x1b, 0x1, HDA_INPUT),
617+
618+ HDA_CODEC_VOLUME("Front Mic Capture Volume", 0x1b, 0x2, HDA_INPUT),
619+ HDA_CODEC_MUTE("Front Mic Capture Switch", 0x1b, 0x2, HDA_INPUT),
620+
621+ HDA_CODEC_VOLUME("Line In Capture Volume", 0x1b, 0x3, HDA_INPUT),
622+ HDA_CODEC_MUTE("Line In Capture Switch", 0x1b, 0x3, HDA_INPUT),
623+
624+ /*
625+ HDA_CODEC_VOLUME("Mic Capture Volume", 0x1b, 0x4, HDA_INPUT),
626+ HDA_CODEC_MUTE("Mic Capture Switch", 0x1b 0x4, HDA_INPUT),
627+ */
628+ { } /* end */
629+};
630+
631 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
632 STAC_INPUT_SOURCE(2),
633+ STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
634
635 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
636 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
637- HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
638
639 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
640 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
641- HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
642-
643+ /* analog pc-beep replaced with digital beep support */
644+ /*
645 HDA_CODEC_VOLUME("PC Beep Volume", 0x17, 0x2, HDA_INPUT),
646 HDA_CODEC_MUTE("PC Beep Switch", 0x17, 0x2, HDA_INPUT),
647+ */
648+
649+ HDA_CODEC_MUTE("Import0 Mux Capture Switch", 0x17, 0x0, HDA_INPUT),
650+ HDA_CODEC_VOLUME("Import0 Mux Capture Volume", 0x17, 0x0, HDA_INPUT),
651+
652+ HDA_CODEC_MUTE("Import1 Mux Capture Switch", 0x17, 0x1, HDA_INPUT),
653+ HDA_CODEC_VOLUME("Import1 Mux Capture Volume", 0x17, 0x1, HDA_INPUT),
654
655- HDA_CODEC_MUTE("Analog Loopback 1", 0x17, 0x3, HDA_INPUT),
656- HDA_CODEC_MUTE("Analog Loopback 2", 0x17, 0x4, HDA_INPUT),
657+ HDA_CODEC_MUTE("DAC0 Capture Switch", 0x17, 0x3, HDA_INPUT),
658+ HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x17, 0x3, HDA_INPUT),
659+
660+ HDA_CODEC_MUTE("DAC1 Capture Switch", 0x17, 0x4, HDA_INPUT),
661+ HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x17, 0x4, HDA_INPUT),
662 { } /* end */
663 };
664
665@@ -844,11 +1135,9 @@ static struct snd_kcontrol_new stac92hd7
666
667 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
668 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),
669- HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT),
670
671 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
672 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
673- HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT),
674 { } /* end */
675 };
676
677@@ -856,7 +1145,6 @@ static struct snd_kcontrol_new stac925x_
678 STAC_INPUT_SOURCE(1),
679 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
680 HDA_CODEC_MUTE("Capture Switch", 0x14, 0, HDA_OUTPUT),
681- HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT),
682 { } /* end */
683 };
684
685@@ -866,12 +1154,9 @@ static struct snd_kcontrol_new stac9205_
686
687 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
688 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),
689- HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT),
690
691 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
692 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
693- HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT),
694-
695 { } /* end */
696 };
697
698@@ -880,11 +1165,9 @@ static struct snd_kcontrol_new stac922x_
699 STAC_INPUT_SOURCE(2),
700 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
701 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),
702- HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT),
703
704 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
705 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
706- HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT),
707 { } /* end */
708 };
709
710@@ -895,15 +1178,12 @@ static struct snd_kcontrol_new stac927x_
711
712 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
713 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),
714- HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT),
715
716 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
717 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),
718- HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT),
719
720 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
721 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
722- HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT),
723 { } /* end */
724 };
725
726@@ -916,6 +1196,15 @@ static struct snd_kcontrol_new stac_dmux
727 .put = stac92xx_dmux_enum_put,
728 };
729
730+static struct snd_kcontrol_new stac_smux_mixer = {
731+ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
732+ .name = "IEC958 Playback Source",
733+ /* count set later */
734+ .info = stac92xx_smux_enum_info,
735+ .get = stac92xx_smux_enum_get,
736+ .put = stac92xx_smux_enum_put,
737+};
738+
739 static const char *slave_vols[] = {
740 "Front Playback Volume",
741 "Surround Playback Volume",
742@@ -967,6 +1256,22 @@ static int stac92xx_build_controls(struc
743 if (err < 0)
744 return err;
745 }
746+ if (spec->num_smuxes > 0) {
747+ int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
748+ struct hda_input_mux *smux = &spec->private_smux;
749+ /* check for mute support on SPDIF out */
750+ if (wcaps & AC_WCAP_OUT_AMP) {
751+ smux->items[smux->num_items].label = "Off";
752+ smux->items[smux->num_items].index = 0;
753+ smux->num_items++;
754+ spec->spdif_mute = 1;
755+ }
756+ stac_smux_mixer.count = spec->num_smuxes;
757+ err = snd_ctl_add(codec->bus->card,
758+ snd_ctl_new1(&stac_smux_mixer, codec));
759+ if (err < 0)
760+ return err;
761+ }
762
763 if (spec->multiout.dig_out_nid) {
764 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
765@@ -978,7 +1283,7 @@ static int stac92xx_build_controls(struc
766 return err;
767 spec->multiout.share_spdif = 1;
768 }
769- if (spec->dig_in_nid) {
770+ if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
771 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
772 if (err < 0)
773 return err;
774@@ -1330,40 +1635,65 @@ static struct snd_pci_quirk stac92hd73xx
775 {} /* terminator */
776 };
777
778-static unsigned int ref92hd71bxx_pin_configs[10] = {
779+static unsigned int ref92hd83xxx_pin_configs[14] = {
780+ 0x02214030, 0x02211010, 0x02a19020, 0x02170130,
781+ 0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
782+ 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x40f000f0,
783+ 0x01451160, 0x98560170,
784+};
785+
786+static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
787+ [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
788+};
789+
790+static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
791+ [STAC_92HD83XXX_REF] = "ref",
792+};
793+
794+static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
795+ /* SigmaTel reference board */
796+ SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
797+ "DFI LanParty", STAC_92HD71BXX_REF),
798+};
799+
800+static unsigned int ref92hd71bxx_pin_configs[11] = {
801 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
802- 0x0181302e, 0x01114010, 0x01019020, 0x90a000f0,
803- 0x90a000f0, 0x01452050,
804+ 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
805+ 0x90a000f0, 0x01452050, 0x01452050,
806 };
807
808-static unsigned int dell_m4_1_pin_configs[10] = {
809+static unsigned int dell_m4_1_pin_configs[11] = {
810 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
811 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
812- 0x40f000f0, 0x4f0000f0,
813+ 0x40f000f0, 0x4f0000f0, 0x4f0000f0,
814 };
815
816-static unsigned int dell_m4_2_pin_configs[10] = {
817+static unsigned int dell_m4_2_pin_configs[11] = {
818 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
819 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
820- 0x40f000f0, 0x044413b0,
821+ 0x40f000f0, 0x044413b0, 0x044413b0,
822 };
823
824 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
825 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
826 [STAC_DELL_M4_1] = dell_m4_1_pin_configs,
827 [STAC_DELL_M4_2] = dell_m4_2_pin_configs,
828+ [STAC_HP_M4] = NULL,
829 };
830
831 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
832 [STAC_92HD71BXX_REF] = "ref",
833 [STAC_DELL_M4_1] = "dell-m4-1",
834 [STAC_DELL_M4_2] = "dell-m4-2",
835+ [STAC_HP_M4] = "hp-m4",
836 };
837
838 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
839 /* SigmaTel reference board */
840 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
841 "DFI LanParty", STAC_92HD71BXX_REF),
842+ SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
843+ "unknown HP", STAC_HP_M4),
844 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
845 "unknown Dell", STAC_DELL_M4_1),
846 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
847@@ -1906,6 +2236,8 @@ static int stac92xx_playback_pcm_open(st
848 struct snd_pcm_substream *substream)
849 {
850 struct sigmatel_spec *spec = codec->spec;
851+ if (spec->stream_delay)
852+ msleep(spec->stream_delay);
853 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
854 hinfo);
855 }
856@@ -1958,7 +2290,6 @@ static int stac92xx_dig_playback_pcm_pre
857 stream_tag, format, substream);
858 }
859
860-
861 /*
862 * Analog capture callbacks
863 */
864@@ -1969,9 +2300,14 @@ static int stac92xx_capture_pcm_prepare(
865 struct snd_pcm_substream *substream)
866 {
867 struct sigmatel_spec *spec = codec->spec;
868+ hda_nid_t nid = spec->adc_nids[substream->number];
869
870- snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
871- stream_tag, 0, format);
872+ if (spec->powerdown_adcs) {
873+ msleep(40);
874+ snd_hda_codec_write_cache(codec, nid, 0,
875+ AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
876+ }
877+ snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
878 return 0;
879 }
880
881@@ -1980,8 +2316,12 @@ static int stac92xx_capture_pcm_cleanup(
882 struct snd_pcm_substream *substream)
883 {
884 struct sigmatel_spec *spec = codec->spec;
885+ hda_nid_t nid = spec->adc_nids[substream->number];
886
887- snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
888+ snd_hda_codec_cleanup_stream(codec, nid);
889+ if (spec->powerdown_adcs)
890+ snd_hda_codec_write_cache(codec, nid, 0,
891+ AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
892 return 0;
893 }
894
895@@ -2234,6 +2574,8 @@ enum {
896 STAC_CTL_WIDGET_VOL,
897 STAC_CTL_WIDGET_MUTE,
898 STAC_CTL_WIDGET_MONO_MUX,
899+ STAC_CTL_WIDGET_AMP_MUX,
900+ STAC_CTL_WIDGET_AMP_VOL,
901 STAC_CTL_WIDGET_HP_SWITCH,
902 STAC_CTL_WIDGET_IO_SWITCH,
903 STAC_CTL_WIDGET_CLFE_SWITCH
904@@ -2243,13 +2585,16 @@ static struct snd_kcontrol_new stac92xx_
905 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
906 HDA_CODEC_MUTE(NULL, 0, 0, 0),
907 STAC_MONO_MUX,
908+ STAC_AMP_MUX,
909+ STAC_AMP_VOL(NULL, 0, 0, 0, 0),
910 STAC_CODEC_HP_SWITCH(NULL),
911 STAC_CODEC_IO_SWITCH(NULL, 0),
912 STAC_CODEC_CLFE_SWITCH(NULL, 0),
913 };
914
915 /* add dynamic controls */
916-static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val)
917+static int stac92xx_add_control_idx(struct sigmatel_spec *spec, int type,
918+ int idx, const char *name, unsigned long val)
919 {
920 struct snd_kcontrol_new *knew;
921
922@@ -2269,6 +2614,7 @@ static int stac92xx_add_control(struct s
923
924 knew = &spec->kctl_alloc[spec->num_kctl_used];
925 *knew = stac92xx_control_templates[type];
926+ knew->index = idx;
927 knew->name = kstrdup(name, GFP_KERNEL);
928 if (! knew->name)
929 return -ENOMEM;
930@@ -2277,6 +2623,14 @@ static int stac92xx_add_control(struct s
931 return 0;
932 }
933
934+
935+/* add dynamic controls */
936+static int stac92xx_add_control(struct sigmatel_spec *spec, int type,
937+ const char *name, unsigned long val)
938+{
939+ return stac92xx_add_control_idx(spec, type, 0, name, val);
940+}
941+
942 /* flag inputs as additional dynamic lineouts */
943 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg)
944 {
945@@ -2468,7 +2822,7 @@ static int stac92xx_auto_create_multi_ou
946 static const char *chname[4] = {
947 "Front", "Surround", NULL /*CLFE*/, "Side"
948 };
949- hda_nid_t nid;
950+ hda_nid_t nid = 0;
951 int i, err;
952
953 struct sigmatel_spec *spec = codec->spec;
954@@ -2508,6 +2862,10 @@ static int stac92xx_auto_create_multi_ou
955 }
956 }
957
958+ if ((spec->multiout.num_dacs - cfg->line_outs) > 0 &&
959+ cfg->hp_outs && !spec->multiout.hp_nid)
960+ spec->multiout.hp_nid = nid;
961+
962 if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
963 err = stac92xx_add_control(spec,
964 STAC_CTL_WIDGET_HP_SWITCH,
965@@ -2620,8 +2978,8 @@ static int stac92xx_auto_create_hp_ctls(
966 }
967
968 /* labels for mono mux outputs */
969-static const char *stac92xx_mono_labels[3] = {
970- "DAC0", "DAC1", "Mixer"
971+static const char *stac92xx_mono_labels[4] = {
972+ "DAC0", "DAC1", "Mixer", "DAC2"
973 };
974
975 /* create mono mux for mono out on capable codecs */
976@@ -2650,6 +3008,116 @@ static int stac92xx_auto_create_mono_out
977 "Mono Mux", spec->mono_nid);
978 }
979
980+/* labels for amp mux outputs */
981+static const char *stac92xx_amp_labels[3] = {
982+ "Front Microphone", "Microphone", "Line In",
983+};
984+
985+/* create amp out controls mux on capable codecs */
986+static int stac92xx_auto_create_amp_output_ctls(struct hda_codec *codec)
987+{
988+ struct sigmatel_spec *spec = codec->spec;
989+ struct hda_input_mux *amp_mux = &spec->private_amp_mux;
990+ int i, err;
991+
992+ for (i = 0; i < spec->num_amps; i++) {
993+ amp_mux->items[amp_mux->num_items].label =
994+ stac92xx_amp_labels[i];
995+ amp_mux->items[amp_mux->num_items].index = i;
996+ amp_mux->num_items++;
997+ }
998+
999+ if (spec->num_amps > 1) {
1000+ err = stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_MUX,
1001+ "Amp Selector Capture Switch", 0);
1002+ if (err < 0)
1003+ return err;
1004+ }
1005+ return stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_VOL,
1006+ "Amp Capture Volume",
1007+ HDA_COMPOSE_AMP_VAL(spec->amp_nids[0], 3, 0, HDA_INPUT));
1008+}
1009+
1010+
1011+/* create PC beep volume controls */
1012+static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
1013+ hda_nid_t nid)
1014+{
1015+ struct sigmatel_spec *spec = codec->spec;
1016+ u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
1017+ int err;
1018+
1019+ /* check for mute support for the the amp */
1020+ if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
1021+ err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
1022+ "PC Beep Playback Switch",
1023+ HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
1024+ if (err < 0)
1025+ return err;
1026+ }
1027+
1028+ /* check to see if there is volume support for the amp */
1029+ if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
1030+ err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
1031+ "PC Beep Playback Volume",
1032+ HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
1033+ if (err < 0)
1034+ return err;
1035+ }
1036+ return 0;
1037+}
1038+
1039+static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
1040+{
1041+ struct sigmatel_spec *spec = codec->spec;
1042+ int wcaps, nid, i, err = 0;
1043+
1044+ for (i = 0; i < spec->num_muxes; i++) {
1045+ nid = spec->mux_nids[i];
1046+ wcaps = get_wcaps(codec, nid);
1047+
1048+ if (wcaps & AC_WCAP_OUT_AMP) {
1049+ err = stac92xx_add_control_idx(spec,
1050+ STAC_CTL_WIDGET_VOL, i, "Mux Capture Volume",
1051+ HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
1052+ if (err < 0)
1053+ return err;
1054+ }
1055+ }
1056+ return 0;
1057+};
1058+
1059+static const char *stac92xx_spdif_labels[3] = {
1060+ "Digital Playback", "Analog Mux 1", "Analog Mux 2",
1061+};
1062+
1063+static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
1064+{
1065+ struct sigmatel_spec *spec = codec->spec;
1066+ struct hda_input_mux *spdif_mux = &spec->private_smux;
1067+ const char **labels = spec->spdif_labels;
1068+ int i, num_cons;
1069+ hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
1070+
1071+ num_cons = snd_hda_get_connections(codec,
1072+ spec->smux_nids[0],
1073+ con_lst,
1074+ HDA_MAX_NUM_INPUTS);
1075+ if (!num_cons)
1076+ return -EINVAL;
1077+
1078+ if (!labels)
1079+ labels = stac92xx_spdif_labels;
1080+
1081+ for (i = 0; i < num_cons; i++) {
1082+ spdif_mux->items[spdif_mux->num_items].label = labels[i];
1083+ spdif_mux->items[spdif_mux->num_items].index = i;
1084+ spdif_mux->num_items++;
1085+ }
1086+
1087+ return 0;
1088+}
1089+
1090 /* labels for dmic mux inputs */
1091 static const char *stac92xx_dmic_labels[5] = {
1092 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
1093@@ -2697,16 +3165,19 @@ static int stac92xx_auto_create_dmic_inp
1094 }
1095 continue;
1096 found:
1097- wcaps = get_wcaps(codec, nid);
1098+ wcaps = get_wcaps(codec, nid) &
1099+ (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
1100
1101- if (wcaps & AC_WCAP_OUT_AMP) {
1102+ if (wcaps) {
1103 sprintf(name, "%s Capture Volume",
1104 stac92xx_dmic_labels[dimux->num_items]);
1105
1106 err = stac92xx_add_control(spec,
1107 STAC_CTL_WIDGET_VOL,
1108 name,
1109- HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
1110+ HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1111+ (wcaps & AC_WCAP_OUT_AMP) ?
1112+ HDA_OUTPUT : HDA_INPUT));
1113 if (err < 0)
1114 return err;
1115 }
1116@@ -2830,8 +3301,8 @@ static int stac92xx_parse_auto_config(st
1117 hp_speaker_swap = 1;
1118 }
1119 if (spec->autocfg.mono_out_pin) {
1120- int dir = (get_wcaps(codec, spec->autocfg.mono_out_pin)
1121- & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
1122+ int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
1123+ (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
1124 u32 caps = query_amp_caps(codec,
1125 spec->autocfg.mono_out_pin, dir);
1126 hda_nid_t conn_list[1];
1127@@ -2853,21 +3324,26 @@ static int stac92xx_parse_auto_config(st
1128 !(wcaps & AC_WCAP_LR_SWAP))
1129 spec->mono_nid = conn_list[0];
1130 }
1131- /* all mono outs have a least a mute/unmute switch */
1132- err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
1133- "Mono Playback Switch",
1134- HDA_COMPOSE_AMP_VAL(spec->autocfg.mono_out_pin,
1135- 1, 0, dir));
1136- if (err < 0)
1137- return err;
1138- /* check to see if there is volume support for the amp */
1139- if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
1140- err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
1141- "Mono Playback Volume",
1142- HDA_COMPOSE_AMP_VAL(spec->autocfg.mono_out_pin,
1143- 1, 0, dir));
1144+ if (dir) {
1145+ hda_nid_t nid = spec->autocfg.mono_out_pin;
1146+
1147+ /* most mono outs have a least a mute/unmute switch */
1148+ dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
1149+ err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
1150+ "Mono Playback Switch",
1151+ HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
1152 if (err < 0)
1153 return err;
1154+ /* check for volume support for the amp */
1155+ if ((caps & AC_AMPCAP_NUM_STEPS)
1156+ >> AC_AMPCAP_NUM_STEPS_SHIFT) {
1157+ err = stac92xx_add_control(spec,
1158+ STAC_CTL_WIDGET_VOL,
1159+ "Mono Playback Volume",
1160+ HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
1161+ if (err < 0)
1162+ return err;
1163+ }
1164 }
1165
1166 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
1167@@ -2885,6 +3361,28 @@ static int stac92xx_parse_auto_config(st
1168 if (err < 0)
1169 return err;
1170
1171+ /* setup analog beep controls */
1172+ if (spec->anabeep_nid > 0) {
1173+ err = stac92xx_auto_create_beep_ctls(codec,
1174+ spec->anabeep_nid);
1175+ if (err < 0)
1176+ return err;
1177+ }
1178+
1179+ /* setup digital beep controls and input device */
1180+#ifdef CONFIG_SND_HDA_INPUT_BEEP
1181+ if (spec->digbeep_nid > 0) {
1182+ hda_nid_t nid = spec->digbeep_nid;
1183+
1184+ err = stac92xx_auto_create_beep_ctls(codec, nid);
1185+ if (err < 0)
1186+ return err;
1187+ err = snd_hda_attach_beep_device(codec, nid);
1188+ if (err < 0)
1189+ return err;
1190+ }
1191+#endif
1192+
1193 if (hp_speaker_swap == 1) {
1194 /* Restore the hp_outs and line_outs */
1195 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
1196@@ -2913,11 +3411,25 @@ static int stac92xx_parse_auto_config(st
1197 if (err < 0)
1198 return err;
1199 }
1200-
1201- if (spec->num_dmics > 0)
1202+ if (spec->num_amps > 0) {
1203+ err = stac92xx_auto_create_amp_output_ctls(codec);
1204+ if (err < 0)
1205+ return err;
1206+ }
1207+ if (spec->num_dmics > 0 && !spec->dinput_mux)
1208 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
1209 &spec->autocfg)) < 0)
1210 return err;
1211+ if (spec->num_muxes > 0) {
1212+ err = stac92xx_auto_create_mux_input_ctls(codec);
1213+ if (err < 0)
1214+ return err;
1215+ }
1216+ if (spec->num_smuxes > 0) {
1217+ err = stac92xx_auto_create_spdif_mux_ctls(codec);
1218+ if (err < 0)
1219+ return err;
1220+ }
1221
1222 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1223 if (spec->multiout.max_channels > 2)
1224@@ -2925,17 +3437,17 @@ static int stac92xx_parse_auto_config(st
1225
1226 if (spec->autocfg.dig_out_pin)
1227 spec->multiout.dig_out_nid = dig_out;
1228- if (spec->autocfg.dig_in_pin)
1229+ if (dig_in && spec->autocfg.dig_in_pin)
1230 spec->dig_in_nid = dig_in;
1231
1232 if (spec->kctl_alloc)
1233 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
1234
1235 spec->input_mux = &spec->private_imux;
1236- if (!spec->dinput_mux)
1237- spec->dinput_mux = &spec->private_dimux;
1238+ spec->dinput_mux = &spec->private_dimux;
1239+ spec->sinput_mux = &spec->private_smux;
1240 spec->mono_mux = &spec->private_mono_mux;
1241-
1242+ spec->amp_mux = &spec->private_amp_mux;
1243 return 1;
1244 }
1245
1246@@ -3115,6 +3627,12 @@ static int stac92xx_init(struct hda_code
1247
1248 snd_hda_sequence_write(codec, spec->init);
1249
1250+ /* power down adcs initially */
1251+ if (spec->powerdown_adcs)
1252+ for (i = 0; i < spec->num_adcs; i++)
1253+ snd_hda_codec_write_cache(codec,
1254+ spec->adc_nids[i], 0,
1255+ AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
1256 /* set up pins */
1257 if (spec->hp_detect) {
1258 /* Enable unsolicited responses on the HP widget */
1259@@ -3136,7 +3654,12 @@ static int stac92xx_init(struct hda_code
1260 for (i = 0; i < AUTO_PIN_LAST; i++) {
1261 hda_nid_t nid = cfg->input_pins[i];
1262 if (nid) {
1263- unsigned int pinctl = AC_PINCTL_IN_EN;
1264+ unsigned int pinctl = snd_hda_codec_read(codec, nid,
1265+ 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
1266+ /* if PINCTL already set then skip */
1267+ if (pinctl & AC_PINCAP_IN)
1268+ continue;
1269+ pinctl = AC_PINCTL_IN_EN;
1270 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC)
1271 pinctl |= stac92xx_get_vref(codec, nid);
1272 stac92xx_auto_set_pinctl(codec, nid, pinctl);
1273@@ -3199,6 +3722,7 @@ static void stac92xx_free(struct hda_cod
1274 kfree(spec->bios_pin_configs);
1275
1276 kfree(spec);
1277+ snd_hda_detach_beep_device(codec);
1278 }
1279
1280 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
1281@@ -3320,7 +3844,12 @@ static void stac92xx_pin_sense(struct hd
1282 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0)
1283 & 0x000000ff;
1284 presence = get_hp_pin_presence(codec, nid);
1285- idx = 1 << idx;
1286+
1287+ /* several codecs have two power down bits */
1288+ if (spec->pwr_mapping)
1289+ idx = spec->pwr_mapping[idx];
1290+ else
1291+ idx = 1 << idx;
1292
1293 if (presence)
1294 val &= ~idx;
1295@@ -3336,13 +3865,22 @@ static void stac92xx_unsol_event(struct
1296 struct sigmatel_spec *spec = codec->spec;
1297 int idx = res >> 26 & 0x0f;
1298
1299- switch ((res >> 26) & 0x30) {
1300+ switch ((res >> 26) & 0x70) {
1301 case STAC_HP_EVENT:
1302 stac92xx_hp_detect(codec, res);
1303 /* fallthru */
1304 case STAC_PWR_EVENT:
1305 if (spec->num_pwrs > 0)
1306 stac92xx_pin_sense(codec, idx);
1307+ break;
1308+ case STAC_VREF_EVENT: {
1309+ int data = snd_hda_codec_read(codec, codec->afg, 0,
1310+ AC_VERB_GET_GPIO_DATA, 0);
1311+ /* toggle VREF state based on GPIOx status */
1312+ snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
1313+ !!(data & (1 << idx)));
1314+ break;
1315+ }
1316 }
1317 }
1318
1319@@ -3519,9 +4057,9 @@ static struct hda_input_mux stac92hd73xx
1320 .num_items = 4,
1321 .items = {
1322 { "Analog Inputs", 0x0b },
1323- { "CD", 0x08 },
1324 { "Digital Mic 1", 0x09 },
1325 { "Digital Mic 2", 0x0a },
1326+ { "CD", 0x08 },
1327 }
1328 };
1329
1330@@ -3536,6 +4074,7 @@ static int patch_stac92hd73xx(struct hda
1331 return -ENOMEM;
1332
1333 codec->spec = spec;
1334+ codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
1335 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
1336 spec->pin_nids = stac92hd73xx_pin_nids;
1337 spec->board_config = snd_hda_check_board_config(codec,
1338@@ -3568,17 +4107,14 @@ again:
1339
1340 switch (spec->multiout.num_dacs) {
1341 case 0x3: /* 6 Channel */
1342- spec->multiout.hp_nid = 0x17;
1343 spec->mixer = stac92hd73xx_6ch_mixer;
1344 spec->init = stac92hd73xx_6ch_core_init;
1345 break;
1346 case 0x4: /* 8 Channel */
1347- spec->multiout.hp_nid = 0x18;
1348 spec->mixer = stac92hd73xx_8ch_mixer;
1349 spec->init = stac92hd73xx_8ch_core_init;
1350 break;
1351 case 0x5: /* 10 Channel */
1352- spec->multiout.hp_nid = 0x19;
1353 spec->mixer = stac92hd73xx_10ch_mixer;
1354 spec->init = stac92hd73xx_10ch_core_init;
1355 };
1356@@ -3587,18 +4123,20 @@ again:
1357 spec->aloopback_mask = 0x01;
1358 spec->aloopback_shift = 8;
1359
1360+ spec->digbeep_nid = 0x1c;
1361 spec->mux_nids = stac92hd73xx_mux_nids;
1362 spec->adc_nids = stac92hd73xx_adc_nids;
1363 spec->dmic_nids = stac92hd73xx_dmic_nids;
1364 spec->dmux_nids = stac92hd73xx_dmux_nids;
1365+ spec->smux_nids = stac92hd73xx_smux_nids;
1366+ spec->amp_nids = stac92hd73xx_amp_nids;
1367+ spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
1368
1369 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
1370 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
1371 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
1372- spec->dinput_mux = &stac92hd73xx_dmux;
1373- /* GPIO0 High = Enable EAPD */
1374- spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
1375- spec->gpio_data = 0x01;
1376+ memcpy(&spec->private_dimux, &stac92hd73xx_dmux,
1377+ sizeof(stac92hd73xx_dmux));
1378
1379 switch (spec->board_config) {
1380 case STAC_DELL_EQ:
1381@@ -3607,11 +4145,16 @@ again:
1382 case STAC_DELL_M6:
1383 if (!spec->init)
1384 spec->init = dell_m6_core_init;
1385+ spec->num_smuxes = 0;
1386+ spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
1387+ spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
1388+ spec->num_amps = 1;
1389 switch (codec->subsystem_id) {
1390 case 0x1028025e: /* Analog Mics */
1391 case 0x1028025f:
1392 stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
1393 spec->num_dmics = 0;
1394+ spec->private_dimux.num_items = 1;
1395 break;
1396 case 0x10280271: /* Digital Mics */
1397 case 0x10280272:
1398@@ -3619,23 +4162,32 @@ again:
1399 case 0x10280255:
1400 stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
1401 spec->num_dmics = 1;
1402+ spec->private_dimux.num_items = 2;
1403 break;
1404 case 0x10280256: /* Both */
1405 case 0x10280057:
1406 stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
1407 stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
1408 spec->num_dmics = 1;
1409+ spec->private_dimux.num_items = 2;
1410 break;
1411 }
1412 break;
1413 default:
1414 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
1415+ spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
1416 }
1417+ if (spec->board_config > STAC_92HD73XX_REF) {
1418+ /* GPIO0 High = Enable EAPD */
1419+ spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
1420+ spec->gpio_data = 0x01;
1421+ }
1422+ spec->dinput_mux = &spec->private_dimux;
1423
1424 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
1425 spec->pwr_nids = stac92hd73xx_pwr_nids;
1426
1427- err = stac92xx_parse_auto_config(codec, 0x22, 0x24);
1428+ err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
1429
1430 if (!err) {
1431 if (spec->board_config < 0) {
1432@@ -3657,6 +4209,146 @@ again:
1433 return 0;
1434 }
1435
1436+static struct hda_input_mux stac92hd83xxx_dmux = {
1437+ .num_items = 3,
1438+ .items = {
1439+ { "Analog Inputs", 0x03 },
1440+ { "Digital Mic 1", 0x04 },
1441+ { "Digital Mic 2", 0x05 },
1442+ }
1443+};
1444+
1445+static int patch_stac92hd83xxx(struct hda_codec *codec)
1446+{
1447+ struct sigmatel_spec *spec;
1448+ int err;
1449+
1450+ spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1451+ if (spec == NULL)
1452+ return -ENOMEM;
1453+
1454+ codec->spec = spec;
1455+ codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
1456+ spec->mono_nid = 0x19;
1457+ spec->digbeep_nid = 0x21;
1458+ spec->dmic_nids = stac92hd83xxx_dmic_nids;
1459+ spec->dmux_nids = stac92hd83xxx_dmux_nids;
1460+ spec->adc_nids = stac92hd83xxx_adc_nids;
1461+ spec->pwr_nids = stac92hd83xxx_pwr_nids;
1462+ spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
1463+ spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
1464+ spec->multiout.dac_nids = stac92hd83xxx_dac_nids;
1465+
1466+ spec->init = stac92hd83xxx_core_init;
1467+ switch (codec->vendor_id) {
1468+ case 0x111d7605:
1469+ spec->multiout.num_dacs = STAC92HD81_DAC_COUNT;
1470+ break;
1471+ default:
1472+ spec->num_pwrs--;
1473+ spec->init++; /* switch to config #2 */
1474+ spec->multiout.num_dacs = STAC92HD83_DAC_COUNT;
1475+ }
1476+
1477+ spec->mixer = stac92hd83xxx_mixer;
1478+ spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
1479+ spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
1480+ spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
1481+ spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
1482+ spec->dinput_mux = &stac92hd83xxx_dmux;
1483+ spec->pin_nids = stac92hd83xxx_pin_nids;
1484+ spec->board_config = snd_hda_check_board_config(codec,
1485+ STAC_92HD83XXX_MODELS,
1486+ stac92hd83xxx_models,
1487+ stac92hd83xxx_cfg_tbl);
1488+again:
1489+ if (spec->board_config < 0) {
1490+ snd_printdd(KERN_INFO "hda_codec: Unknown model for"
1491+ " STAC92HD83XXX, using BIOS defaults\n");
1492+ err = stac92xx_save_bios_config_regs(codec);
1493+ if (err < 0) {
1494+ stac92xx_free(codec);
1495+ return err;
1496+ }
1497+ spec->pin_configs = spec->bios_pin_configs;
1498+ } else {
1499+ spec->pin_configs = stac92hd83xxx_brd_tbl[spec->board_config];
1500+ stac92xx_set_config_regs(codec);
1501+ }
1502+
1503+ err = stac92xx_parse_auto_config(codec, 0x1d, 0);
1504+ if (!err) {
1505+ if (spec->board_config < 0) {
1506+ printk(KERN_WARNING "hda_codec: No auto-config is "
1507+ "available, default to model=ref\n");
1508+ spec->board_config = STAC_92HD83XXX_REF;
1509+ goto again;
1510+ }
1511+ err = -EINVAL;
1512+ }
1513+
1514+ if (err < 0) {
1515+ stac92xx_free(codec);
1516+ return err;
1517+ }
1518+
1519+ codec->patch_ops = stac92xx_patch_ops;
1520+
1521+ return 0;
1522+}
1523+
1524+#ifdef SND_HDA_NEEDS_RESUME
1525+static void stac92hd71xx_set_power_state(struct hda_codec *codec, int pwr)
1526+{
1527+ struct sigmatel_spec *spec = codec->spec;
1528+ int i;
1529+ snd_hda_codec_write_cache(codec, codec->afg, 0,
1530+ AC_VERB_SET_POWER_STATE, pwr);
1531+
1532+ msleep(1);
1533+ for (i = 0; i < spec->num_adcs; i++) {
1534+ snd_hda_codec_write_cache(codec,
1535+ spec->adc_nids[i], 0,
1536+ AC_VERB_SET_POWER_STATE, pwr);
1537+ }
1538+};
1539+
1540+static int stac92hd71xx_resume(struct hda_codec *codec)
1541+{
1542+ stac92hd71xx_set_power_state(codec, AC_PWRST_D0);
1543+ return stac92xx_resume(codec);
1544+}
1545+
1546+static int stac92hd71xx_suspend(struct hda_codec *codec, pm_message_t state)
1547+{
1548+ stac92hd71xx_set_power_state(codec, AC_PWRST_D3);
1549+ return 0;
1550+};
1551+
1552+#endif
1553+
1554+static struct hda_codec_ops stac92hd71bxx_patch_ops = {
1555+ .build_controls = stac92xx_build_controls,
1556+ .build_pcms = stac92xx_build_pcms,
1557+ .init = stac92xx_init,
1558+ .free = stac92xx_free,
1559+ .unsol_event = stac92xx_unsol_event,
1560+#ifdef SND_HDA_NEEDS_RESUME
1561+ .resume = stac92hd71xx_resume,
1562+ .suspend = stac92hd71xx_suspend,
1563+#endif
1564+};
1565+
1566+static struct hda_input_mux stac92hd71bxx_dmux = {
1567+ .num_items = 4,
1568+ .items = {
1569+ { "Analog Inputs", 0x00 },
1570+ { "Mixer", 0x01 },
1571+ { "Digital Mic 1", 0x02 },
1572+ { "Digital Mic 2", 0x03 },
1573+ }
1574+};
1575+
1576 static int patch_stac92hd71bxx(struct hda_codec *codec)
1577 {
1578 struct sigmatel_spec *spec;
1579@@ -3667,9 +4359,12 @@ static int patch_stac92hd71bxx(struct hd
1580 return -ENOMEM;
1581
1582 codec->spec = spec;
1583+ codec->patch_ops = stac92xx_patch_ops;
1584 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
1585 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
1586 spec->pin_nids = stac92hd71bxx_pin_nids;
1587+ memcpy(&spec->private_dimux, &stac92hd71bxx_dmux,
1588+ sizeof(stac92hd71bxx_dmux));
1589 spec->board_config = snd_hda_check_board_config(codec,
1590 STAC_92HD71BXX_MODELS,
1591 stac92hd71bxx_models,
1592@@ -3696,47 +4391,101 @@ again:
1593 case 0x111d76b5:
1594 spec->mixer = stac92hd71bxx_mixer;
1595 spec->init = stac92hd71bxx_core_init;
1596+ codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
1597 break;
1598 case 0x111d7608: /* 5 Port with Analog Mixer */
1599+ switch (codec->subsystem_id) {
1600+ case 0x103c361a:
1601+ /* Enable VREF power saving on GPIO1 detect */
1602+ snd_hda_codec_write(codec, codec->afg, 0,
1603+ AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
1604+ snd_hda_codec_write_cache(codec, codec->afg, 0,
1605+ AC_VERB_SET_UNSOLICITED_ENABLE,
1606+ (AC_USRSP_EN | STAC_VREF_EVENT | 0x01));
1607+ spec->gpio_mask |= 0x02;
1608+ break;
1609+ }
1610+ if ((codec->revision_id & 0xf) == 0 ||
1611+ (codec->revision_id & 0xf) == 1) {
1612+#ifdef SND_HDA_NEEDS_RESUME
1613+ codec->patch_ops = stac92hd71bxx_patch_ops;
1614+#endif
1615+ spec->stream_delay = 40; /* 40 milliseconds */
1616+ }
1617+
1618 /* no output amps */
1619 spec->num_pwrs = 0;
1620 spec->mixer = stac92hd71bxx_analog_mixer;
1621+ spec->dinput_mux = &spec->private_dimux;
1622
1623 /* disable VSW */
1624 spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
1625 stac92xx_set_config_reg(codec, 0xf, 0x40f000f0);
1626 break;
1627 case 0x111d7603: /* 6 Port with Analog Mixer */
1628+ if ((codec->revision_id & 0xf) == 1) {
1629+#ifdef SND_HDA_NEEDS_RESUME
1630+ codec->patch_ops = stac92hd71bxx_patch_ops;
1631+#endif
1632+ spec->stream_delay = 40; /* 40 milliseconds */
1633+ }
1634+
1635 /* no output amps */
1636 spec->num_pwrs = 0;
1637 /* fallthru */
1638 default:
1639+ spec->dinput_mux = &spec->private_dimux;
1640 spec->mixer = stac92hd71bxx_analog_mixer;
1641 spec->init = stac92hd71bxx_analog_core_init;
1642+ codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
1643 }
1644
1645- spec->aloopback_mask = 0x20;
1646+ spec->aloopback_mask = 0x50;
1647 spec->aloopback_shift = 0;
1648
1649- /* GPIO0 High = EAPD */
1650- spec->gpio_mask = 0x01;
1651- spec->gpio_dir = 0x01;
1652- spec->gpio_data = 0x01;
1653+ if (spec->board_config > STAC_92HD71BXX_REF) {
1654+ /* GPIO0 = EAPD */
1655+ spec->gpio_mask = 0x01;
1656+ spec->gpio_dir = 0x01;
1657+ spec->gpio_data = 0x01;
1658+ }
1659
1660+ spec->powerdown_adcs = 1;
1661+ spec->digbeep_nid = 0x26;
1662 spec->mux_nids = stac92hd71bxx_mux_nids;
1663 spec->adc_nids = stac92hd71bxx_adc_nids;
1664 spec->dmic_nids = stac92hd71bxx_dmic_nids;
1665 spec->dmux_nids = stac92hd71bxx_dmux_nids;
1666+ spec->smux_nids = stac92hd71bxx_smux_nids;
1667 spec->pwr_nids = stac92hd71bxx_pwr_nids;
1668
1669 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
1670 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
1671- spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
1672- spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
1673+
1674+ switch (spec->board_config) {
1675+ case STAC_HP_M4:
1676+ spec->num_dmics = 0;
1677+ spec->num_smuxes = 0;
1678+ spec->num_dmuxes = 0;
1679+
1680+ /* enable internal microphone */
1681+ stac92xx_set_config_reg(codec, 0x0e, 0x01813040);
1682+ stac92xx_auto_set_pinctl(codec, 0x0e,
1683+ AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
1684+ break;
1685+ default:
1686+ spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
1687+ spec->num_smuxes = ARRAY_SIZE(stac92hd71bxx_smux_nids);
1688+ spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
1689+ };
1690
1691 spec->multiout.num_dacs = 1;
1692 spec->multiout.hp_nid = 0x11;
1693 spec->multiout.dac_nids = stac92hd71bxx_dac_nids;
1694+ if (spec->dinput_mux)
1695+ spec->private_dimux.num_items +=
1696+ spec->num_dmics -
1697+ (ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1);
1698
1699 err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
1700 if (!err) {
1701@@ -3754,8 +4503,6 @@ again:
1702 return err;
1703 }
1704
1705- codec->patch_ops = stac92xx_patch_ops;
1706-
1707 return 0;
1708 };
1709
1710@@ -3897,10 +4644,14 @@ static int patch_stac927x(struct hda_cod
1711 stac92xx_set_config_regs(codec);
1712 }
1713
1714+ spec->digbeep_nid = 0x23;
1715 spec->adc_nids = stac927x_adc_nids;
1716 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
1717 spec->mux_nids = stac927x_mux_nids;
1718 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
1719+ spec->smux_nids = stac927x_smux_nids;
1720+ spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
1721+ spec->spdif_labels = stac927x_spdif_labels;
1722 spec->dac_list = stac927x_dac_nids;
1723 spec->multiout.dac_nids = spec->dac_nids;
1724
1725@@ -3943,9 +4694,11 @@ static int patch_stac927x(struct hda_cod
1726 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
1727 break;
1728 default:
1729- /* GPIO0 High = Enable EAPD */
1730- spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
1731- spec->gpio_data = 0x01;
1732+ if (spec->board_config > STAC_D965_REF) {
1733+ /* GPIO0 High = Enable EAPD */
1734+ spec->eapd_mask = spec->gpio_mask = 0x01;
1735+ spec->gpio_dir = spec->gpio_data = 0x01;
1736+ }
1737 spec->num_dmics = 0;
1738
1739 spec->init = stac927x_core_init;
1740@@ -4017,10 +4770,13 @@ static int patch_stac9205(struct hda_cod
1741 stac92xx_set_config_regs(codec);
1742 }
1743
1744+ spec->digbeep_nid = 0x23;
1745 spec->adc_nids = stac9205_adc_nids;
1746 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
1747 spec->mux_nids = stac9205_mux_nids;
1748 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
1749+ spec->smux_nids = stac9205_smux_nids;
1750+ spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
1751 spec->dmic_nids = stac9205_dmic_nids;
1752 spec->num_dmics = STAC9205_NUM_DMICS;
1753 spec->dmux_nids = stac9205_dmux_nids;
1754@@ -4056,6 +4812,9 @@ static int patch_stac9205(struct hda_cod
1755 */
1756 spec->gpio_data = 0x01;
1757 break;
1758+ case STAC_9205_REF:
1759+ /* SPDIF-In enabled */
1760+ break;
1761 default:
1762 /* GPIO0 High = EAPD */
1763 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
1764@@ -4375,6 +5134,8 @@ struct hda_codec_preset snd_hda_preset_s
1765 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
1766 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
1767 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
1768+ { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
1769+ { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
1770 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
1771 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
1772 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
Peter's tree of IPFire 2.x