Commit | Line | Data |
---|---|---|
2f2f4251 M |
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@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 <sound/driver.h> | |
28 | #include <linux/init.h> | |
29 | #include <linux/delay.h> | |
30 | #include <linux/slab.h> | |
31 | #include <linux/pci.h> | |
32 | #include <sound/core.h> | |
c7d4b2fa | 33 | #include <sound/asoundef.h> |
2f2f4251 M |
34 | #include "hda_codec.h" |
35 | #include "hda_local.h" | |
36 | ||
37 | #undef STAC_TEST | |
38 | ||
4e55096e M |
39 | #define NUM_CONTROL_ALLOC 32 |
40 | #define STAC_HP_EVENT 0x37 | |
41 | #define STAC_UNSOL_ENABLE (AC_USRSP_EN | STAC_HP_EVENT) | |
42 | ||
2f2f4251 | 43 | struct sigmatel_spec { |
c8b6bf9b | 44 | struct snd_kcontrol_new *mixers[4]; |
c7d4b2fa M |
45 | unsigned int num_mixers; |
46 | ||
47 | unsigned int surr_switch: 1; | |
48 | ||
2f2f4251 M |
49 | /* playback */ |
50 | struct hda_multi_out multiout; | |
c7d4b2fa | 51 | hda_nid_t dac_nids[4]; |
2f2f4251 M |
52 | |
53 | /* capture */ | |
54 | hda_nid_t *adc_nids; | |
2f2f4251 | 55 | unsigned int num_adcs; |
dabbed6f M |
56 | hda_nid_t *mux_nids; |
57 | unsigned int num_muxes; | |
dabbed6f | 58 | hda_nid_t dig_in_nid; |
2f2f4251 | 59 | |
c7d4b2fa | 60 | #ifdef STAC_TEST |
2f2f4251 M |
61 | /* pin widgets */ |
62 | hda_nid_t *pin_nids; | |
63 | unsigned int num_pins; | |
2f2f4251 M |
64 | unsigned int *pin_configs; |
65 | #endif | |
66 | ||
67 | /* codec specific stuff */ | |
68 | struct hda_verb *init; | |
c8b6bf9b | 69 | struct snd_kcontrol_new *mixer; |
2f2f4251 M |
70 | |
71 | /* capture source */ | |
c7d4b2fa | 72 | struct hda_input_mux *input_mux; |
2f2f4251 M |
73 | unsigned int cur_mux[2]; |
74 | ||
75 | /* channel mode */ | |
76 | unsigned int num_ch_modes; | |
77 | unsigned int cur_ch_mode; | |
2f2f4251 | 78 | |
c7d4b2fa M |
79 | struct hda_pcm pcm_rec[2]; /* PCM information */ |
80 | ||
81 | /* dynamic controls and input_mux */ | |
82 | struct auto_pin_cfg autocfg; | |
83 | unsigned int num_kctl_alloc, num_kctl_used; | |
c8b6bf9b | 84 | struct snd_kcontrol_new *kctl_alloc; |
c7d4b2fa | 85 | struct hda_input_mux private_imux; |
2f2f4251 M |
86 | }; |
87 | ||
88 | static hda_nid_t stac9200_adc_nids[1] = { | |
89 | 0x03, | |
90 | }; | |
91 | ||
92 | static hda_nid_t stac9200_mux_nids[1] = { | |
93 | 0x0c, | |
94 | }; | |
95 | ||
96 | static hda_nid_t stac9200_dac_nids[1] = { | |
97 | 0x02, | |
98 | }; | |
99 | ||
2f2f4251 M |
100 | static hda_nid_t stac922x_adc_nids[2] = { |
101 | 0x06, 0x07, | |
102 | }; | |
103 | ||
104 | static hda_nid_t stac922x_mux_nids[2] = { | |
105 | 0x12, 0x13, | |
106 | }; | |
107 | ||
c7d4b2fa M |
108 | #ifdef STAC_TEST |
109 | static hda_nid_t stac9200_pin_nids[8] = { | |
110 | 0x08, 0x09, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, | |
2f2f4251 M |
111 | }; |
112 | ||
113 | static hda_nid_t stac922x_pin_nids[10] = { | |
114 | 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, | |
115 | 0x0f, 0x10, 0x11, 0x15, 0x1b, | |
116 | }; | |
c7d4b2fa | 117 | #endif |
2f2f4251 | 118 | |
c8b6bf9b | 119 | static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) |
2f2f4251 M |
120 | { |
121 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | |
122 | struct sigmatel_spec *spec = codec->spec; | |
c7d4b2fa | 123 | return snd_hda_input_mux_info(spec->input_mux, uinfo); |
2f2f4251 M |
124 | } |
125 | ||
c8b6bf9b | 126 | static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) |
2f2f4251 M |
127 | { |
128 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | |
129 | struct sigmatel_spec *spec = codec->spec; | |
130 | unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); | |
131 | ||
132 | ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; | |
133 | return 0; | |
134 | } | |
135 | ||
c8b6bf9b | 136 | static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) |
2f2f4251 M |
137 | { |
138 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | |
139 | struct sigmatel_spec *spec = codec->spec; | |
140 | unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); | |
141 | ||
c7d4b2fa | 142 | return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, |
2f2f4251 M |
143 | spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]); |
144 | } | |
145 | ||
c7d4b2fa | 146 | static struct hda_verb stac9200_core_init[] = { |
2f2f4251 | 147 | /* set dac0mux for dac converter */ |
c7d4b2fa | 148 | { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, |
2f2f4251 M |
149 | {} |
150 | }; | |
151 | ||
c7d4b2fa | 152 | static struct hda_verb stac922x_core_init[] = { |
2f2f4251 | 153 | /* set master volume and direct control */ |
c7d4b2fa | 154 | { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, |
2f2f4251 M |
155 | {} |
156 | }; | |
157 | ||
c7d4b2fa M |
158 | static int stac922x_channel_modes[3] = {2, 6, 8}; |
159 | ||
c8b6bf9b | 160 | static int stac922x_ch_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) |
c7d4b2fa M |
161 | { |
162 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | |
163 | struct sigmatel_spec *spec = codec->spec; | |
164 | ||
165 | uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | |
166 | uinfo->count = 1; | |
167 | uinfo->value.enumerated.items = spec->num_ch_modes; | |
168 | if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) | |
169 | uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; | |
170 | sprintf(uinfo->value.enumerated.name, "%dch", | |
171 | stac922x_channel_modes[uinfo->value.enumerated.item]); | |
172 | return 0; | |
173 | } | |
174 | ||
c8b6bf9b | 175 | static int stac922x_ch_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) |
c7d4b2fa M |
176 | { |
177 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | |
178 | struct sigmatel_spec *spec = codec->spec; | |
179 | ||
180 | ucontrol->value.enumerated.item[0] = spec->cur_ch_mode; | |
181 | return 0; | |
182 | } | |
183 | ||
c8b6bf9b | 184 | static int stac922x_ch_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) |
c7d4b2fa M |
185 | { |
186 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | |
187 | struct sigmatel_spec *spec = codec->spec; | |
188 | ||
189 | if (ucontrol->value.enumerated.item[0] >= spec->num_ch_modes) | |
190 | ucontrol->value.enumerated.item[0] = spec->num_ch_modes; | |
191 | if (ucontrol->value.enumerated.item[0] == spec->cur_ch_mode && | |
192 | ! codec->in_resume) | |
193 | return 0; | |
194 | ||
195 | spec->cur_ch_mode = ucontrol->value.enumerated.item[0]; | |
196 | spec->multiout.max_channels = stac922x_channel_modes[spec->cur_ch_mode]; | |
197 | ||
198 | return 1; | |
199 | } | |
2f2f4251 | 200 | |
c8b6bf9b | 201 | static struct snd_kcontrol_new stac9200_mixer[] = { |
2f2f4251 M |
202 | HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT), |
203 | HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT), | |
204 | { | |
205 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | |
206 | .name = "Input Source", | |
207 | .count = 1, | |
208 | .info = stac92xx_mux_enum_info, | |
209 | .get = stac92xx_mux_enum_get, | |
210 | .put = stac92xx_mux_enum_put, | |
211 | }, | |
212 | HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT), | |
213 | HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT), | |
c7d4b2fa | 214 | HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT), |
2f2f4251 M |
215 | { } /* end */ |
216 | }; | |
217 | ||
c7d4b2fa | 218 | /* This needs to be generated dynamically based on sequence */ |
c8b6bf9b | 219 | static struct snd_kcontrol_new stac922x_mixer[] = { |
2f2f4251 M |
220 | { |
221 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | |
222 | .name = "Input Source", | |
223 | .count = 1, | |
224 | .info = stac92xx_mux_enum_info, | |
225 | .get = stac92xx_mux_enum_get, | |
226 | .put = stac92xx_mux_enum_put, | |
227 | }, | |
228 | HDA_CODEC_VOLUME("Capture Volume", 0x17, 0x0, HDA_INPUT), | |
229 | HDA_CODEC_MUTE("Capture Switch", 0x17, 0x0, HDA_INPUT), | |
230 | HDA_CODEC_VOLUME("Mux Capture Volume", 0x12, 0x0, HDA_OUTPUT), | |
231 | { } /* end */ | |
232 | }; | |
233 | ||
c8b6bf9b | 234 | static struct snd_kcontrol_new stac922x_ch_mode_mixer[] = { |
c7d4b2fa M |
235 | { |
236 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | |
237 | .name = "Channel Mode", | |
238 | .info = stac922x_ch_mode_info, | |
239 | .get = stac922x_ch_mode_get, | |
240 | .put = stac922x_ch_mode_put, | |
241 | }, | |
242 | { } /* end */ | |
243 | }; | |
244 | ||
2f2f4251 M |
245 | static int stac92xx_build_controls(struct hda_codec *codec) |
246 | { | |
247 | struct sigmatel_spec *spec = codec->spec; | |
248 | int err; | |
c7d4b2fa | 249 | int i; |
2f2f4251 M |
250 | |
251 | err = snd_hda_add_new_ctls(codec, spec->mixer); | |
252 | if (err < 0) | |
253 | return err; | |
c7d4b2fa M |
254 | |
255 | for (i = 0; i < spec->num_mixers; i++) { | |
256 | err = snd_hda_add_new_ctls(codec, spec->mixers[i]); | |
257 | if (err < 0) | |
258 | return err; | |
259 | } | |
260 | ||
261 | if (spec->surr_switch) { | |
262 | err = snd_hda_add_new_ctls(codec, stac922x_ch_mode_mixer); | |
263 | if (err < 0) | |
264 | return err; | |
265 | } | |
dabbed6f M |
266 | if (spec->multiout.dig_out_nid) { |
267 | err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid); | |
268 | if (err < 0) | |
269 | return err; | |
270 | } | |
271 | if (spec->dig_in_nid) { | |
272 | err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); | |
273 | if (err < 0) | |
274 | return err; | |
275 | } | |
276 | return 0; | |
2f2f4251 M |
277 | } |
278 | ||
279 | #ifdef STAC_TEST | |
280 | static unsigned int stac9200_pin_configs[8] = { | |
dabbed6f | 281 | 0x01c47010, 0x01447010, 0x0221401f, 0x01114010, |
2f2f4251 M |
282 | 0x02a19020, 0x01a19021, 0x90100140, 0x01813122, |
283 | }; | |
284 | ||
c7d4b2fa M |
285 | static unsigned int stac922x_pin_configs[10] = { |
286 | 0x01014010, 0x01014011, 0x01014012, 0x0221401f, | |
287 | 0x01813122, 0x01014014, 0x01441030, 0x01c41030, | |
2f2f4251 M |
288 | 0x40000100, 0x40000100, |
289 | }; | |
290 | ||
291 | static void stac92xx_set_config_regs(struct hda_codec *codec) | |
292 | { | |
293 | int i; | |
294 | struct sigmatel_spec *spec = codec->spec; | |
295 | unsigned int pin_cfg; | |
296 | ||
297 | for (i=0; i < spec->num_pins; i++) { | |
298 | snd_hda_codec_write(codec, spec->pin_nids[i], 0, | |
299 | AC_VERB_SET_CONFIG_DEFAULT_BYTES_0, | |
300 | spec->pin_configs[i] & 0x000000ff); | |
301 | snd_hda_codec_write(codec, spec->pin_nids[i], 0, | |
302 | AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, | |
303 | (spec->pin_configs[i] & 0x0000ff00) >> 8); | |
304 | snd_hda_codec_write(codec, spec->pin_nids[i], 0, | |
305 | AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, | |
306 | (spec->pin_configs[i] & 0x00ff0000) >> 16); | |
307 | snd_hda_codec_write(codec, spec->pin_nids[i], 0, | |
308 | AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, | |
309 | spec->pin_configs[i] >> 24); | |
310 | pin_cfg = snd_hda_codec_read(codec, spec->pin_nids[i], 0, | |
311 | AC_VERB_GET_CONFIG_DEFAULT, | |
312 | 0x00); | |
313 | printk("pin nid %2.2x pin config %8.8x\n", spec->pin_nids[i], pin_cfg); | |
314 | } | |
315 | } | |
316 | #endif | |
317 | ||
dabbed6f | 318 | /* |
c7d4b2fa | 319 | * Analog playback callbacks |
dabbed6f | 320 | */ |
c7d4b2fa M |
321 | static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo, |
322 | struct hda_codec *codec, | |
c8b6bf9b | 323 | struct snd_pcm_substream *substream) |
2f2f4251 | 324 | { |
dabbed6f | 325 | struct sigmatel_spec *spec = codec->spec; |
c7d4b2fa | 326 | return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream); |
2f2f4251 M |
327 | } |
328 | ||
c7d4b2fa M |
329 | /* |
330 | * set up the i/o for analog out | |
331 | * when the digital out is available, copy the front out to digital out, too. | |
332 | */ | |
333 | static int stac92xx_multi_out_analog_prepare(struct hda_codec *codec, struct hda_multi_out *mout, | |
334 | unsigned int stream_tag, | |
335 | unsigned int format, | |
c8b6bf9b | 336 | struct snd_pcm_substream *substream) |
2f2f4251 | 337 | { |
c7d4b2fa M |
338 | hda_nid_t *nids = mout->dac_nids; |
339 | int chs = substream->runtime->channels; | |
2f2f4251 | 340 | int i; |
2f2f4251 | 341 | |
c7d4b2fa M |
342 | down(&codec->spdif_mutex); |
343 | if (mout->dig_out_nid && mout->dig_out_used != HDA_DIG_EXCLUSIVE) { | |
344 | if (chs == 2 && | |
345 | snd_hda_is_supported_format(codec, mout->dig_out_nid, format) && | |
346 | ! (codec->spdif_status & IEC958_AES0_NONAUDIO)) { | |
347 | mout->dig_out_used = HDA_DIG_ANALOG_DUP; | |
348 | /* setup digital receiver */ | |
349 | snd_hda_codec_setup_stream(codec, mout->dig_out_nid, | |
350 | stream_tag, 0, format); | |
351 | } else { | |
352 | mout->dig_out_used = 0; | |
353 | snd_hda_codec_setup_stream(codec, mout->dig_out_nid, 0, 0, 0); | |
354 | } | |
2f2f4251 | 355 | } |
c7d4b2fa M |
356 | up(&codec->spdif_mutex); |
357 | ||
358 | /* front */ | |
359 | snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag, 0, format); | |
360 | if (mout->hp_nid) | |
361 | /* headphone out will just decode front left/right (stereo) */ | |
362 | snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag, 0, format); | |
363 | /* surrounds */ | |
364 | if (mout->max_channels > 2) | |
365 | for (i = 1; i < mout->num_dacs; i++) { | |
366 | if ((mout->max_channels == 6) && (i == 3)) | |
367 | break; | |
368 | if (chs >= (i + 1) * 2) /* independent out */ | |
369 | snd_hda_codec_setup_stream(codec, nids[i], stream_tag, i * 2, | |
370 | format); | |
371 | else /* copy front */ | |
372 | snd_hda_codec_setup_stream(codec, nids[i], stream_tag, 0, | |
373 | format); | |
374 | } | |
2f2f4251 M |
375 | return 0; |
376 | } | |
377 | ||
2f2f4251 M |
378 | |
379 | static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo, | |
380 | struct hda_codec *codec, | |
381 | unsigned int stream_tag, | |
382 | unsigned int format, | |
c8b6bf9b | 383 | struct snd_pcm_substream *substream) |
2f2f4251 M |
384 | { |
385 | struct sigmatel_spec *spec = codec->spec; | |
c7d4b2fa | 386 | return stac92xx_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, |
2f2f4251 M |
387 | format, substream); |
388 | } | |
389 | ||
390 | static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, | |
391 | struct hda_codec *codec, | |
c8b6bf9b | 392 | struct snd_pcm_substream *substream) |
2f2f4251 M |
393 | { |
394 | struct sigmatel_spec *spec = codec->spec; | |
395 | return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); | |
396 | } | |
397 | ||
dabbed6f M |
398 | /* |
399 | * Digital playback callbacks | |
400 | */ | |
401 | static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, | |
402 | struct hda_codec *codec, | |
c8b6bf9b | 403 | struct snd_pcm_substream *substream) |
dabbed6f M |
404 | { |
405 | struct sigmatel_spec *spec = codec->spec; | |
406 | return snd_hda_multi_out_dig_open(codec, &spec->multiout); | |
407 | } | |
408 | ||
409 | static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, | |
410 | struct hda_codec *codec, | |
c8b6bf9b | 411 | struct snd_pcm_substream *substream) |
dabbed6f M |
412 | { |
413 | struct sigmatel_spec *spec = codec->spec; | |
414 | return snd_hda_multi_out_dig_close(codec, &spec->multiout); | |
415 | } | |
416 | ||
417 | ||
2f2f4251 M |
418 | /* |
419 | * Analog capture callbacks | |
420 | */ | |
421 | static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo, | |
422 | struct hda_codec *codec, | |
423 | unsigned int stream_tag, | |
424 | unsigned int format, | |
c8b6bf9b | 425 | struct snd_pcm_substream *substream) |
2f2f4251 M |
426 | { |
427 | struct sigmatel_spec *spec = codec->spec; | |
428 | ||
429 | snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], | |
430 | stream_tag, 0, format); | |
431 | return 0; | |
432 | } | |
433 | ||
434 | static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, | |
435 | struct hda_codec *codec, | |
c8b6bf9b | 436 | struct snd_pcm_substream *substream) |
2f2f4251 M |
437 | { |
438 | struct sigmatel_spec *spec = codec->spec; | |
439 | ||
440 | snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0); | |
441 | return 0; | |
442 | } | |
443 | ||
dabbed6f M |
444 | static struct hda_pcm_stream stac92xx_pcm_digital_playback = { |
445 | .substreams = 1, | |
446 | .channels_min = 2, | |
447 | .channels_max = 2, | |
448 | /* NID is set in stac92xx_build_pcms */ | |
449 | .ops = { | |
450 | .open = stac92xx_dig_playback_pcm_open, | |
451 | .close = stac92xx_dig_playback_pcm_close | |
452 | }, | |
453 | }; | |
454 | ||
455 | static struct hda_pcm_stream stac92xx_pcm_digital_capture = { | |
456 | .substreams = 1, | |
457 | .channels_min = 2, | |
458 | .channels_max = 2, | |
459 | /* NID is set in stac92xx_build_pcms */ | |
460 | }; | |
461 | ||
2f2f4251 M |
462 | static struct hda_pcm_stream stac92xx_pcm_analog_playback = { |
463 | .substreams = 1, | |
464 | .channels_min = 2, | |
c7d4b2fa | 465 | .channels_max = 8, |
2f2f4251 M |
466 | .nid = 0x02, /* NID to query formats and rates */ |
467 | .ops = { | |
468 | .open = stac92xx_playback_pcm_open, | |
469 | .prepare = stac92xx_playback_pcm_prepare, | |
470 | .cleanup = stac92xx_playback_pcm_cleanup | |
471 | }, | |
472 | }; | |
473 | ||
474 | static struct hda_pcm_stream stac92xx_pcm_analog_capture = { | |
475 | .substreams = 2, | |
476 | .channels_min = 2, | |
477 | .channels_max = 2, | |
478 | .nid = 0x06, /* NID to query formats and rates */ | |
479 | .ops = { | |
480 | .prepare = stac92xx_capture_pcm_prepare, | |
481 | .cleanup = stac92xx_capture_pcm_cleanup | |
482 | }, | |
483 | }; | |
484 | ||
485 | static int stac92xx_build_pcms(struct hda_codec *codec) | |
486 | { | |
487 | struct sigmatel_spec *spec = codec->spec; | |
488 | struct hda_pcm *info = spec->pcm_rec; | |
489 | ||
490 | codec->num_pcms = 1; | |
491 | codec->pcm_info = info; | |
492 | ||
c7d4b2fa | 493 | info->name = "STAC92xx Analog"; |
2f2f4251 | 494 | info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback; |
2f2f4251 | 495 | info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture; |
2f2f4251 | 496 | |
dabbed6f M |
497 | if (spec->multiout.dig_out_nid || spec->dig_in_nid) { |
498 | codec->num_pcms++; | |
499 | info++; | |
500 | info->name = "STAC92xx Digital"; | |
501 | if (spec->multiout.dig_out_nid) { | |
502 | info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback; | |
503 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; | |
504 | } | |
505 | if (spec->dig_in_nid) { | |
506 | info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture; | |
507 | info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; | |
508 | } | |
509 | } | |
510 | ||
2f2f4251 M |
511 | return 0; |
512 | } | |
513 | ||
c7d4b2fa M |
514 | enum { |
515 | STAC_CTL_WIDGET_VOL, | |
516 | STAC_CTL_WIDGET_MUTE, | |
517 | }; | |
518 | ||
c8b6bf9b | 519 | static struct snd_kcontrol_new stac92xx_control_templates[] = { |
c7d4b2fa M |
520 | HDA_CODEC_VOLUME(NULL, 0, 0, 0), |
521 | HDA_CODEC_MUTE(NULL, 0, 0, 0), | |
522 | }; | |
523 | ||
524 | /* add dynamic controls */ | |
525 | static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val) | |
526 | { | |
c8b6bf9b | 527 | struct snd_kcontrol_new *knew; |
c7d4b2fa M |
528 | |
529 | if (spec->num_kctl_used >= spec->num_kctl_alloc) { | |
530 | int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC; | |
531 | ||
532 | knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */ | |
533 | if (! knew) | |
534 | return -ENOMEM; | |
535 | if (spec->kctl_alloc) { | |
536 | memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc); | |
537 | kfree(spec->kctl_alloc); | |
538 | } | |
539 | spec->kctl_alloc = knew; | |
540 | spec->num_kctl_alloc = num; | |
541 | } | |
542 | ||
543 | knew = &spec->kctl_alloc[spec->num_kctl_used]; | |
544 | *knew = stac92xx_control_templates[type]; | |
82fe0c58 | 545 | knew->name = kstrdup(name, GFP_KERNEL); |
c7d4b2fa M |
546 | if (! knew->name) |
547 | return -ENOMEM; | |
548 | knew->private_value = val; | |
549 | spec->num_kctl_used++; | |
550 | return 0; | |
551 | } | |
552 | ||
553 | /* fill in the dac_nids table from the parsed pin configuration */ | |
554 | static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec, const struct auto_pin_cfg *cfg) | |
555 | { | |
556 | struct sigmatel_spec *spec = codec->spec; | |
557 | hda_nid_t nid; | |
558 | int i; | |
559 | ||
560 | /* check the pins hardwired to audio widget */ | |
561 | for (i = 0; i < cfg->line_outs; i++) { | |
562 | nid = cfg->line_out_pins[i]; | |
563 | spec->multiout.dac_nids[i] = snd_hda_codec_read(codec, nid, 0, | |
564 | AC_VERB_GET_CONNECT_LIST, 0) & 0xff; | |
565 | } | |
566 | ||
567 | spec->multiout.num_dacs = cfg->line_outs; | |
568 | ||
569 | return 0; | |
570 | } | |
571 | ||
572 | /* add playback controls from the parsed DAC table */ | |
573 | static int stac92xx_auto_create_multi_out_ctls(struct sigmatel_spec *spec, const struct auto_pin_cfg *cfg) | |
574 | { | |
575 | char name[32]; | |
576 | static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" }; | |
577 | hda_nid_t nid; | |
578 | int i, err; | |
579 | ||
580 | for (i = 0; i < cfg->line_outs; i++) { | |
581 | if (! spec->multiout.dac_nids[i]) | |
582 | continue; | |
583 | ||
584 | nid = spec->multiout.dac_nids[i]; | |
585 | ||
586 | if (i == 2) { | |
587 | /* Center/LFE */ | |
588 | if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, "Center Playback Volume", | |
589 | HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0) | |
590 | return err; | |
591 | if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, "LFE Playback Volume", | |
592 | HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0) | |
593 | return err; | |
594 | if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, "Center Playback Switch", | |
595 | HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0) | |
596 | return err; | |
597 | if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, "LFE Playback Switch", | |
598 | HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0) | |
599 | return err; | |
600 | } else { | |
601 | sprintf(name, "%s Playback Volume", chname[i]); | |
602 | if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name, | |
603 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0) | |
604 | return err; | |
605 | sprintf(name, "%s Playback Switch", chname[i]); | |
606 | if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name, | |
607 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0) | |
608 | return err; | |
609 | } | |
610 | } | |
611 | ||
612 | return 0; | |
613 | } | |
614 | ||
615 | /* add playback controls for HP output */ | |
616 | static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec, struct auto_pin_cfg *cfg) | |
617 | { | |
618 | struct sigmatel_spec *spec = codec->spec; | |
619 | hda_nid_t pin = cfg->hp_pin; | |
620 | hda_nid_t nid; | |
621 | int i, err; | |
4e55096e | 622 | unsigned int wid_caps; |
c7d4b2fa M |
623 | |
624 | if (! pin) | |
625 | return 0; | |
626 | ||
4e55096e M |
627 | wid_caps = snd_hda_param_read(codec, pin, AC_PAR_AUDIO_WIDGET_CAP); |
628 | if (wid_caps & AC_WCAP_UNSOL_CAP) | |
629 | /* Enable unsolicited responses on the HP widget */ | |
630 | snd_hda_codec_write(codec, pin, 0, | |
631 | AC_VERB_SET_UNSOLICITED_ENABLE, | |
632 | STAC_UNSOL_ENABLE); | |
633 | ||
c7d4b2fa M |
634 | nid = snd_hda_codec_read(codec, pin, 0, AC_VERB_GET_CONNECT_LIST, 0) & 0xff; |
635 | for (i = 0; i < cfg->line_outs; i++) { | |
636 | if (! spec->multiout.dac_nids[i]) | |
637 | continue; | |
638 | if (spec->multiout.dac_nids[i] == nid) | |
639 | return 0; | |
640 | } | |
641 | ||
642 | spec->multiout.hp_nid = nid; | |
643 | ||
644 | /* control HP volume/switch on the output mixer amp */ | |
645 | if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, "Headphone Playback Volume", | |
646 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0) | |
647 | return err; | |
648 | if ((err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, "Headphone Playback Switch", | |
649 | HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0) | |
650 | return err; | |
651 | ||
652 | return 0; | |
653 | } | |
654 | ||
655 | /* create playback/capture controls for input pins */ | |
656 | static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) | |
657 | { | |
658 | struct sigmatel_spec *spec = codec->spec; | |
659 | static char *labels[AUTO_PIN_LAST] = { | |
660 | "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux" | |
661 | }; | |
662 | struct hda_input_mux *imux = &spec->private_imux; | |
663 | hda_nid_t con_lst[HDA_MAX_NUM_INPUTS]; | |
664 | int i, j, k; | |
665 | ||
666 | for (i = 0; i < AUTO_PIN_LAST; i++) { | |
667 | int index = -1; | |
668 | if (cfg->input_pins[i]) { | |
669 | imux->items[imux->num_items].label = labels[i]; | |
670 | ||
671 | for (j=0; j<spec->num_muxes; j++) { | |
672 | int num_cons = snd_hda_get_connections(codec, spec->mux_nids[j], con_lst, HDA_MAX_NUM_INPUTS); | |
673 | for (k=0; k<num_cons; k++) | |
674 | if (con_lst[k] == cfg->input_pins[i]) { | |
675 | index = k; | |
676 | break; | |
677 | } | |
678 | if (index >= 0) | |
679 | break; | |
680 | } | |
681 | imux->items[imux->num_items].index = index; | |
682 | imux->num_items++; | |
683 | } | |
684 | } | |
685 | ||
686 | return 0; | |
687 | } | |
688 | ||
689 | static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type) | |
690 | ||
691 | { | |
692 | snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type); | |
693 | } | |
694 | ||
695 | static void stac92xx_auto_init_multi_out(struct hda_codec *codec) | |
696 | { | |
697 | struct sigmatel_spec *spec = codec->spec; | |
698 | int i; | |
699 | ||
700 | for (i = 0; i < spec->autocfg.line_outs; i++) { | |
701 | hda_nid_t nid = spec->autocfg.line_out_pins[i]; | |
702 | stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN); | |
703 | } | |
704 | } | |
705 | ||
706 | static void stac92xx_auto_init_hp_out(struct hda_codec *codec) | |
707 | { | |
708 | struct sigmatel_spec *spec = codec->spec; | |
709 | hda_nid_t pin; | |
710 | ||
711 | pin = spec->autocfg.hp_pin; | |
712 | if (pin) /* connect to front */ | |
713 | stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN); | |
714 | } | |
715 | ||
716 | static int stac922x_parse_auto_config(struct hda_codec *codec) | |
717 | { | |
718 | struct sigmatel_spec *spec = codec->spec; | |
719 | int err; | |
720 | ||
721 | if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg)) < 0) | |
722 | return err; | |
723 | if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0) | |
724 | return err; | |
725 | if (! spec->autocfg.line_outs && ! spec->autocfg.hp_pin) | |
726 | return 0; /* can't find valid pin config */ | |
727 | ||
728 | if ((err = stac92xx_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 || | |
729 | (err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg)) < 0 || | |
730 | (err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0) | |
731 | return err; | |
732 | ||
733 | spec->multiout.max_channels = spec->multiout.num_dacs * 2; | |
734 | if (spec->multiout.max_channels > 2) { | |
735 | spec->surr_switch = 1; | |
736 | spec->cur_ch_mode = 1; | |
737 | spec->num_ch_modes = 2; | |
738 | if (spec->multiout.max_channels == 8) { | |
739 | spec->cur_ch_mode++; | |
740 | spec->num_ch_modes++; | |
741 | } | |
742 | } | |
743 | ||
744 | if (spec->autocfg.dig_out_pin) { | |
745 | spec->multiout.dig_out_nid = 0x08; | |
746 | stac92xx_auto_set_pinctl(codec, spec->autocfg.dig_out_pin, AC_PINCTL_OUT_EN); | |
747 | } | |
748 | if (spec->autocfg.dig_in_pin) { | |
749 | spec->dig_in_nid = 0x09; | |
750 | stac92xx_auto_set_pinctl(codec, spec->autocfg.dig_in_pin, AC_PINCTL_IN_EN); | |
751 | } | |
752 | ||
753 | if (spec->kctl_alloc) | |
754 | spec->mixers[spec->num_mixers++] = spec->kctl_alloc; | |
755 | ||
756 | spec->input_mux = &spec->private_imux; | |
757 | ||
758 | return 1; | |
759 | } | |
760 | ||
761 | static int stac9200_parse_auto_config(struct hda_codec *codec) | |
762 | { | |
763 | struct sigmatel_spec *spec = codec->spec; | |
764 | int err; | |
765 | ||
766 | if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg)) < 0) | |
767 | return err; | |
768 | ||
769 | if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0) | |
770 | return err; | |
771 | ||
772 | if (spec->autocfg.dig_out_pin) { | |
773 | spec->multiout.dig_out_nid = 0x05; | |
774 | stac92xx_auto_set_pinctl(codec, spec->autocfg.dig_out_pin, AC_PINCTL_OUT_EN); | |
775 | } | |
776 | if (spec->autocfg.dig_in_pin) { | |
777 | spec->dig_in_nid = 0x04; | |
778 | stac92xx_auto_set_pinctl(codec, spec->autocfg.dig_in_pin, AC_PINCTL_IN_EN); | |
779 | } | |
780 | ||
781 | if (spec->kctl_alloc) | |
782 | spec->mixers[spec->num_mixers++] = spec->kctl_alloc; | |
783 | ||
784 | spec->input_mux = &spec->private_imux; | |
785 | ||
786 | return 1; | |
787 | } | |
788 | ||
789 | static int stac92xx_init_pstate(struct hda_codec *codec) | |
790 | { | |
791 | hda_nid_t nid, nid_start; | |
792 | int nodes; | |
793 | ||
794 | snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_POWER_STATE, 0x00); | |
795 | ||
796 | nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid_start); | |
797 | for (nid = nid_start; nid < nodes + nid_start; nid++) { | |
798 | unsigned int wid_caps = snd_hda_param_read(codec, nid, | |
799 | AC_PAR_AUDIO_WIDGET_CAP); | |
800 | if (wid_caps & AC_WCAP_POWER) | |
801 | snd_hda_codec_write(codec, nid, 0, | |
802 | AC_VERB_SET_POWER_STATE, 0x00); | |
803 | } | |
804 | ||
805 | mdelay(100); | |
806 | ||
807 | return 0; | |
808 | } | |
809 | ||
810 | static int stac92xx_init(struct hda_codec *codec) | |
811 | { | |
812 | struct sigmatel_spec *spec = codec->spec; | |
813 | ||
814 | stac92xx_init_pstate(codec); | |
815 | ||
816 | snd_hda_sequence_write(codec, spec->init); | |
817 | ||
818 | stac92xx_auto_init_multi_out(codec); | |
819 | stac92xx_auto_init_hp_out(codec); | |
820 | ||
821 | return 0; | |
822 | } | |
823 | ||
2f2f4251 M |
824 | static void stac92xx_free(struct hda_codec *codec) |
825 | { | |
c7d4b2fa M |
826 | struct sigmatel_spec *spec = codec->spec; |
827 | int i; | |
828 | ||
829 | if (! spec) | |
830 | return; | |
831 | ||
832 | if (spec->kctl_alloc) { | |
833 | for (i = 0; i < spec->num_kctl_used; i++) | |
834 | kfree(spec->kctl_alloc[i].name); | |
835 | kfree(spec->kctl_alloc); | |
836 | } | |
837 | ||
838 | kfree(spec); | |
2f2f4251 M |
839 | } |
840 | ||
4e55096e M |
841 | static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid, |
842 | unsigned int flag) | |
843 | { | |
844 | unsigned int pin_ctl = snd_hda_codec_read(codec, nid, | |
845 | 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00); | |
846 | snd_hda_codec_write(codec, nid, 0, | |
847 | AC_VERB_SET_PIN_WIDGET_CONTROL, | |
848 | pin_ctl | flag); | |
849 | } | |
850 | ||
851 | static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid, | |
852 | unsigned int flag) | |
853 | { | |
854 | unsigned int pin_ctl = snd_hda_codec_read(codec, nid, | |
855 | 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00); | |
856 | snd_hda_codec_write(codec, nid, 0, | |
857 | AC_VERB_SET_PIN_WIDGET_CONTROL, | |
858 | pin_ctl & ~flag); | |
859 | } | |
860 | ||
861 | static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res) | |
862 | { | |
863 | struct sigmatel_spec *spec = codec->spec; | |
864 | struct auto_pin_cfg *cfg = &spec->autocfg; | |
865 | int i, presence; | |
866 | ||
867 | if ((res >> 26) != STAC_HP_EVENT) | |
868 | return; | |
869 | ||
870 | presence = snd_hda_codec_read(codec, cfg->hp_pin, 0, | |
871 | AC_VERB_GET_PIN_SENSE, 0x00) >> 31; | |
872 | ||
873 | if (presence) { | |
874 | /* disable lineouts, enable hp */ | |
875 | for (i = 0; i < cfg->line_outs; i++) | |
876 | stac92xx_reset_pinctl(codec, cfg->line_out_pins[i], | |
877 | AC_PINCTL_OUT_EN); | |
878 | stac92xx_set_pinctl(codec, cfg->hp_pin, AC_PINCTL_OUT_EN); | |
879 | } else { | |
880 | /* enable lineouts, disable hp */ | |
881 | for (i = 0; i < cfg->line_outs; i++) | |
882 | stac92xx_set_pinctl(codec, cfg->line_out_pins[i], | |
883 | AC_PINCTL_OUT_EN); | |
884 | stac92xx_reset_pinctl(codec, cfg->hp_pin, AC_PINCTL_OUT_EN); | |
885 | } | |
886 | } | |
887 | ||
ff6fdc37 M |
888 | #ifdef CONFIG_PM |
889 | static int stac92xx_resume(struct hda_codec *codec) | |
890 | { | |
891 | struct sigmatel_spec *spec = codec->spec; | |
892 | int i; | |
893 | ||
894 | stac92xx_init(codec); | |
895 | for (i = 0; i < spec->num_mixers; i++) | |
896 | snd_hda_resume_ctls(codec, spec->mixers[i]); | |
897 | if (spec->multiout.dig_out_nid) | |
898 | snd_hda_resume_spdif_out(codec); | |
899 | if (spec->dig_in_nid) | |
900 | snd_hda_resume_spdif_in(codec); | |
901 | ||
902 | return 0; | |
903 | } | |
904 | #endif | |
905 | ||
2f2f4251 M |
906 | static struct hda_codec_ops stac92xx_patch_ops = { |
907 | .build_controls = stac92xx_build_controls, | |
908 | .build_pcms = stac92xx_build_pcms, | |
909 | .init = stac92xx_init, | |
910 | .free = stac92xx_free, | |
4e55096e | 911 | .unsol_event = stac92xx_unsol_event, |
ff6fdc37 M |
912 | #ifdef CONFIG_PM |
913 | .resume = stac92xx_resume, | |
914 | #endif | |
2f2f4251 M |
915 | }; |
916 | ||
917 | static int patch_stac9200(struct hda_codec *codec) | |
918 | { | |
919 | struct sigmatel_spec *spec; | |
c7d4b2fa | 920 | int err; |
2f2f4251 | 921 | |
e560d8d8 | 922 | spec = kzalloc(sizeof(*spec), GFP_KERNEL); |
2f2f4251 M |
923 | if (spec == NULL) |
924 | return -ENOMEM; | |
925 | ||
926 | codec->spec = spec; | |
927 | ||
c7d4b2fa M |
928 | #ifdef STAC_TEST |
929 | spec->pin_nids = stac9200_pin_nids; | |
930 | spec->num_pins = 8; | |
931 | spec->pin_configs = stac9200_pin_configs; | |
932 | stac92xx_set_config_regs(codec); | |
933 | #endif | |
2f2f4251 M |
934 | spec->multiout.max_channels = 2; |
935 | spec->multiout.num_dacs = 1; | |
936 | spec->multiout.dac_nids = stac9200_dac_nids; | |
937 | spec->adc_nids = stac9200_adc_nids; | |
938 | spec->mux_nids = stac9200_mux_nids; | |
dabbed6f | 939 | spec->num_muxes = 1; |
c7d4b2fa M |
940 | |
941 | spec->init = stac9200_core_init; | |
2f2f4251 | 942 | spec->mixer = stac9200_mixer; |
c7d4b2fa M |
943 | |
944 | err = stac9200_parse_auto_config(codec); | |
945 | if (err < 0) { | |
946 | stac92xx_free(codec); | |
947 | return err; | |
948 | } | |
2f2f4251 M |
949 | |
950 | codec->patch_ops = stac92xx_patch_ops; | |
951 | ||
952 | return 0; | |
953 | } | |
954 | ||
955 | static int patch_stac922x(struct hda_codec *codec) | |
956 | { | |
957 | struct sigmatel_spec *spec; | |
c7d4b2fa | 958 | int err; |
2f2f4251 | 959 | |
e560d8d8 | 960 | spec = kzalloc(sizeof(*spec), GFP_KERNEL); |
2f2f4251 M |
961 | if (spec == NULL) |
962 | return -ENOMEM; | |
963 | ||
964 | codec->spec = spec; | |
965 | ||
2f2f4251 | 966 | #ifdef STAC_TEST |
c7d4b2fa M |
967 | spec->num_pins = 10; |
968 | spec->pin_nids = stac922x_pin_nids; | |
2f2f4251 | 969 | spec->pin_configs = stac922x_pin_configs; |
c7d4b2fa | 970 | stac92xx_set_config_regs(codec); |
2f2f4251 | 971 | #endif |
c7d4b2fa M |
972 | spec->adc_nids = stac922x_adc_nids; |
973 | spec->mux_nids = stac922x_mux_nids; | |
974 | spec->num_muxes = 2; | |
975 | ||
976 | spec->init = stac922x_core_init; | |
2f2f4251 | 977 | spec->mixer = stac922x_mixer; |
c7d4b2fa M |
978 | |
979 | spec->multiout.dac_nids = spec->dac_nids; | |
980 | ||
981 | err = stac922x_parse_auto_config(codec); | |
982 | if (err < 0) { | |
983 | stac92xx_free(codec); | |
984 | return err; | |
985 | } | |
2f2f4251 M |
986 | |
987 | codec->patch_ops = stac92xx_patch_ops; | |
988 | ||
989 | return 0; | |
990 | } | |
991 | ||
992 | /* | |
993 | * patch entries | |
994 | */ | |
995 | struct hda_codec_preset snd_hda_preset_sigmatel[] = { | |
996 | { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 }, | |
997 | { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x }, | |
998 | { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x }, | |
999 | { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x }, | |
1000 | { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x }, | |
1001 | { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x }, | |
1002 | { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x }, | |
1003 | {} /* terminator */ | |
1004 | }; |