]>
Commit | Line | Data |
---|---|---|
e5f14248 TI |
1 | /* |
2 | * HD audio interface patch for Cirrus Logic CS420x chip | |
3 | * | |
4 | * Copyright (c) 2009 Takashi Iwai <tiwai@suse.de> | |
5 | * | |
6 | * This driver is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation; either version 2 of the License, or | |
9 | * (at your option) any later version. | |
10 | * | |
11 | * This driver is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
17 | * along with this program; if not, write to the Free Software | |
18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
19 | */ | |
20 | ||
21 | #include <linux/init.h> | |
22 | #include <linux/delay.h> | |
23 | #include <linux/slab.h> | |
24 | #include <linux/pci.h> | |
25 | #include <sound/core.h> | |
26 | #include "hda_codec.h" | |
27 | #include "hda_local.h" | |
28 | ||
29 | /* | |
30 | */ | |
31 | ||
32 | struct cs_spec { | |
a6bae205 | 33 | int board_config; |
e5f14248 TI |
34 | struct auto_pin_cfg autocfg; |
35 | struct hda_multi_out multiout; | |
36 | struct snd_kcontrol *vmaster_sw; | |
37 | struct snd_kcontrol *vmaster_vol; | |
38 | ||
39 | hda_nid_t dac_nid[AUTO_CFG_MAX_OUTS]; | |
40 | hda_nid_t slave_dig_outs[2]; | |
41 | ||
42 | unsigned int input_idx[AUTO_PIN_LAST]; | |
43 | unsigned int capsrc_idx[AUTO_PIN_LAST]; | |
44 | hda_nid_t adc_nid[AUTO_PIN_LAST]; | |
45 | unsigned int adc_idx[AUTO_PIN_LAST]; | |
46 | unsigned int num_inputs; | |
47 | unsigned int cur_input; | |
48 | unsigned int automic_idx; | |
49 | hda_nid_t cur_adc; | |
50 | unsigned int cur_adc_stream_tag; | |
51 | unsigned int cur_adc_format; | |
52 | hda_nid_t dig_in; | |
53 | ||
54 | struct hda_bind_ctls *capture_bind[2]; | |
55 | ||
ed208255 TI |
56 | unsigned int gpio_mask; |
57 | unsigned int gpio_dir; | |
58 | unsigned int gpio_data; | |
59 | ||
e5f14248 TI |
60 | struct hda_pcm pcm_rec[2]; /* PCM information */ |
61 | ||
62 | unsigned int hp_detect:1; | |
63 | unsigned int mic_detect:1; | |
e5f14248 TI |
64 | }; |
65 | ||
a6bae205 TI |
66 | /* available models */ |
67 | enum { | |
68 | CS420X_MBP55, | |
69 | CS420X_AUTO, | |
70 | CS420X_MODELS | |
71 | }; | |
72 | ||
40c20fa0 TI |
73 | /* Vendor-specific processing widget */ |
74 | #define CS420X_VENDOR_NID 0x11 | |
75 | #define CS_DIG_OUT1_PIN_NID 0x10 | |
76 | #define CS_DIG_OUT2_PIN_NID 0x15 | |
77 | #define CS_DMIC1_PIN_NID 0x12 | |
78 | #define CS_DMIC2_PIN_NID 0x0e | |
79 | ||
80 | /* coef indices */ | |
81 | #define IDX_SPDIF_STAT 0x0000 | |
82 | #define IDX_SPDIF_CTL 0x0001 | |
83 | #define IDX_ADC_CFG 0x0002 | |
84 | /* SZC bitmask, 4 modes below: | |
85 | * 0 = immediate, | |
86 | * 1 = digital immediate, analog zero-cross | |
87 | * 2 = digtail & analog soft-ramp | |
88 | * 3 = digital soft-ramp, analog zero-cross | |
89 | */ | |
90 | #define CS_COEF_ADC_SZC_MASK (3 << 0) | |
91 | #define CS_COEF_ADC_MIC_SZC_MODE (3 << 0) /* SZC setup for mic */ | |
92 | #define CS_COEF_ADC_LI_SZC_MODE (3 << 0) /* SZC setup for line-in */ | |
93 | /* PGA mode: 0 = differential, 1 = signle-ended */ | |
94 | #define CS_COEF_ADC_MIC_PGA_MODE (1 << 5) /* PGA setup for mic */ | |
95 | #define CS_COEF_ADC_LI_PGA_MODE (1 << 6) /* PGA setup for line-in */ | |
96 | #define IDX_DAC_CFG 0x0003 | |
97 | /* SZC bitmask, 4 modes below: | |
98 | * 0 = Immediate | |
99 | * 1 = zero-cross | |
100 | * 2 = soft-ramp | |
101 | * 3 = soft-ramp on zero-cross | |
102 | */ | |
103 | #define CS_COEF_DAC_HP_SZC_MODE (3 << 0) /* nid 0x02 */ | |
104 | #define CS_COEF_DAC_LO_SZC_MODE (3 << 2) /* nid 0x03 */ | |
105 | #define CS_COEF_DAC_SPK_SZC_MODE (3 << 4) /* nid 0x04 */ | |
106 | ||
107 | #define IDX_BEEP_CFG 0x0004 | |
108 | /* 0x0008 - test reg key */ | |
109 | /* 0x0009 - 0x0014 -> 12 test regs */ | |
110 | /* 0x0015 - visibility reg */ | |
111 | ||
112 | ||
277a57c7 | 113 | static inline int cs_vendor_coef_get(struct hda_codec *codec, unsigned int idx) |
40c20fa0 TI |
114 | { |
115 | snd_hda_codec_write(codec, CS420X_VENDOR_NID, 0, | |
116 | AC_VERB_SET_COEF_INDEX, idx); | |
117 | return snd_hda_codec_read(codec, CS420X_VENDOR_NID, 0, | |
118 | AC_VERB_GET_PROC_COEF, 0); | |
119 | } | |
120 | ||
277a57c7 TI |
121 | static inline void cs_vendor_coef_set(struct hda_codec *codec, unsigned int idx, |
122 | unsigned int coef) | |
40c20fa0 TI |
123 | { |
124 | snd_hda_codec_write(codec, CS420X_VENDOR_NID, 0, | |
125 | AC_VERB_SET_COEF_INDEX, idx); | |
126 | snd_hda_codec_write(codec, CS420X_VENDOR_NID, 0, | |
127 | AC_VERB_SET_PROC_COEF, coef); | |
128 | } | |
129 | ||
130 | ||
e5f14248 TI |
131 | #define HP_EVENT 1 |
132 | #define MIC_EVENT 2 | |
133 | ||
134 | /* | |
135 | * PCM callbacks | |
136 | */ | |
137 | static int cs_playback_pcm_open(struct hda_pcm_stream *hinfo, | |
138 | struct hda_codec *codec, | |
139 | struct snd_pcm_substream *substream) | |
140 | { | |
141 | struct cs_spec *spec = codec->spec; | |
142 | return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, | |
143 | hinfo); | |
144 | } | |
145 | ||
146 | static int cs_playback_pcm_prepare(struct hda_pcm_stream *hinfo, | |
147 | struct hda_codec *codec, | |
148 | unsigned int stream_tag, | |
149 | unsigned int format, | |
150 | struct snd_pcm_substream *substream) | |
151 | { | |
152 | struct cs_spec *spec = codec->spec; | |
153 | return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, | |
154 | stream_tag, format, substream); | |
155 | } | |
156 | ||
157 | static int cs_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, | |
158 | struct hda_codec *codec, | |
159 | struct snd_pcm_substream *substream) | |
160 | { | |
161 | struct cs_spec *spec = codec->spec; | |
162 | return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); | |
163 | } | |
164 | ||
165 | /* | |
166 | * Digital out | |
167 | */ | |
168 | static int cs_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, | |
169 | struct hda_codec *codec, | |
170 | struct snd_pcm_substream *substream) | |
171 | { | |
172 | struct cs_spec *spec = codec->spec; | |
173 | return snd_hda_multi_out_dig_open(codec, &spec->multiout); | |
174 | } | |
175 | ||
176 | static int cs_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, | |
177 | struct hda_codec *codec, | |
178 | struct snd_pcm_substream *substream) | |
179 | { | |
180 | struct cs_spec *spec = codec->spec; | |
181 | return snd_hda_multi_out_dig_close(codec, &spec->multiout); | |
182 | } | |
183 | ||
184 | static int cs_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, | |
185 | struct hda_codec *codec, | |
186 | unsigned int stream_tag, | |
187 | unsigned int format, | |
188 | struct snd_pcm_substream *substream) | |
189 | { | |
190 | struct cs_spec *spec = codec->spec; | |
191 | return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag, | |
192 | format, substream); | |
193 | } | |
194 | ||
195 | static int cs_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, | |
196 | struct hda_codec *codec, | |
197 | struct snd_pcm_substream *substream) | |
198 | { | |
199 | struct cs_spec *spec = codec->spec; | |
200 | return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout); | |
201 | } | |
202 | ||
203 | /* | |
204 | * Analog capture | |
205 | */ | |
206 | static int cs_capture_pcm_prepare(struct hda_pcm_stream *hinfo, | |
207 | struct hda_codec *codec, | |
208 | unsigned int stream_tag, | |
209 | unsigned int format, | |
210 | struct snd_pcm_substream *substream) | |
211 | { | |
212 | struct cs_spec *spec = codec->spec; | |
213 | spec->cur_adc = spec->adc_nid[spec->cur_input]; | |
214 | spec->cur_adc_stream_tag = stream_tag; | |
215 | spec->cur_adc_format = format; | |
216 | snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format); | |
217 | return 0; | |
218 | } | |
219 | ||
220 | static int cs_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, | |
221 | struct hda_codec *codec, | |
222 | struct snd_pcm_substream *substream) | |
223 | { | |
224 | struct cs_spec *spec = codec->spec; | |
225 | snd_hda_codec_cleanup_stream(codec, spec->cur_adc); | |
226 | spec->cur_adc = 0; | |
227 | return 0; | |
228 | } | |
229 | ||
230 | /* | |
231 | */ | |
232 | static struct hda_pcm_stream cs_pcm_analog_playback = { | |
233 | .substreams = 1, | |
234 | .channels_min = 2, | |
235 | .channels_max = 2, | |
236 | .ops = { | |
237 | .open = cs_playback_pcm_open, | |
238 | .prepare = cs_playback_pcm_prepare, | |
239 | .cleanup = cs_playback_pcm_cleanup | |
240 | }, | |
241 | }; | |
242 | ||
243 | static struct hda_pcm_stream cs_pcm_analog_capture = { | |
244 | .substreams = 1, | |
245 | .channels_min = 2, | |
246 | .channels_max = 2, | |
247 | .ops = { | |
248 | .prepare = cs_capture_pcm_prepare, | |
249 | .cleanup = cs_capture_pcm_cleanup | |
250 | }, | |
251 | }; | |
252 | ||
253 | static struct hda_pcm_stream cs_pcm_digital_playback = { | |
254 | .substreams = 1, | |
255 | .channels_min = 2, | |
256 | .channels_max = 2, | |
257 | .ops = { | |
258 | .open = cs_dig_playback_pcm_open, | |
259 | .close = cs_dig_playback_pcm_close, | |
260 | .prepare = cs_dig_playback_pcm_prepare, | |
261 | .cleanup = cs_dig_playback_pcm_cleanup | |
262 | }, | |
263 | }; | |
264 | ||
265 | static struct hda_pcm_stream cs_pcm_digital_capture = { | |
266 | .substreams = 1, | |
267 | .channels_min = 2, | |
268 | .channels_max = 2, | |
269 | }; | |
270 | ||
271 | static int cs_build_pcms(struct hda_codec *codec) | |
272 | { | |
273 | struct cs_spec *spec = codec->spec; | |
274 | struct hda_pcm *info = spec->pcm_rec; | |
275 | ||
276 | codec->pcm_info = info; | |
277 | codec->num_pcms = 0; | |
278 | ||
279 | info->name = "Cirrus Analog"; | |
280 | info->stream[SNDRV_PCM_STREAM_PLAYBACK] = cs_pcm_analog_playback; | |
281 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dac_nid[0]; | |
282 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = | |
283 | spec->multiout.max_channels; | |
284 | info->stream[SNDRV_PCM_STREAM_CAPTURE] = cs_pcm_analog_capture; | |
e5f14248 TI |
285 | info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = |
286 | spec->adc_nid[spec->cur_input]; | |
287 | codec->num_pcms++; | |
288 | ||
289 | if (!spec->multiout.dig_out_nid && !spec->dig_in) | |
290 | return 0; | |
291 | ||
292 | info++; | |
293 | info->name = "Cirrus Digital"; | |
294 | info->pcm_type = spec->autocfg.dig_out_type[0]; | |
295 | if (!info->pcm_type) | |
296 | info->pcm_type = HDA_PCM_TYPE_SPDIF; | |
297 | if (spec->multiout.dig_out_nid) { | |
298 | info->stream[SNDRV_PCM_STREAM_PLAYBACK] = | |
299 | cs_pcm_digital_playback; | |
300 | info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = | |
301 | spec->multiout.dig_out_nid; | |
302 | } | |
303 | if (spec->dig_in) { | |
304 | info->stream[SNDRV_PCM_STREAM_CAPTURE] = | |
305 | cs_pcm_digital_capture; | |
306 | info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in; | |
307 | } | |
308 | codec->num_pcms++; | |
309 | ||
310 | return 0; | |
311 | } | |
312 | ||
21a4dc43 TI |
313 | /* |
314 | * parse codec topology | |
315 | */ | |
316 | ||
e5f14248 TI |
317 | static hda_nid_t get_dac(struct hda_codec *codec, hda_nid_t pin) |
318 | { | |
319 | hda_nid_t dac; | |
320 | if (!pin) | |
321 | return 0; | |
322 | if (snd_hda_get_connections(codec, pin, &dac, 1) != 1) | |
323 | return 0; | |
324 | return dac; | |
325 | } | |
326 | ||
21a4dc43 TI |
327 | static int is_ext_mic(struct hda_codec *codec, unsigned int idx) |
328 | { | |
329 | struct cs_spec *spec = codec->spec; | |
330 | struct auto_pin_cfg *cfg = &spec->autocfg; | |
331 | hda_nid_t pin = cfg->input_pins[idx]; | |
332 | unsigned int val = snd_hda_query_pin_caps(codec, pin); | |
333 | if (!(val & AC_PINCAP_PRES_DETECT)) | |
334 | return 0; | |
335 | val = snd_hda_codec_get_pincfg(codec, pin); | |
336 | return (get_defcfg_connect(val) == AC_JACK_PORT_COMPLEX); | |
337 | } | |
338 | ||
339 | static hda_nid_t get_adc(struct hda_codec *codec, hda_nid_t pin, | |
340 | unsigned int *idxp) | |
341 | { | |
342 | int i; | |
343 | hda_nid_t nid; | |
344 | ||
345 | nid = codec->start_nid; | |
346 | for (i = 0; i < codec->num_nodes; i++, nid++) { | |
347 | hda_nid_t pins[2]; | |
348 | unsigned int type; | |
349 | int j, nums; | |
350 | type = (get_wcaps(codec, nid) & AC_WCAP_TYPE) | |
351 | >> AC_WCAP_TYPE_SHIFT; | |
352 | if (type != AC_WID_AUD_IN) | |
353 | continue; | |
354 | nums = snd_hda_get_connections(codec, nid, pins, | |
355 | ARRAY_SIZE(pins)); | |
356 | if (nums <= 0) | |
357 | continue; | |
358 | for (j = 0; j < nums; j++) { | |
359 | if (pins[j] == pin) { | |
360 | *idxp = j; | |
361 | return nid; | |
362 | } | |
363 | } | |
364 | } | |
365 | return 0; | |
366 | } | |
367 | ||
40c20fa0 TI |
368 | static int is_active_pin(struct hda_codec *codec, hda_nid_t nid) |
369 | { | |
40c20fa0 TI |
370 | unsigned int val; |
371 | val = snd_hda_codec_get_pincfg(codec, nid); | |
372 | return (get_defcfg_connect(val) != AC_JACK_PORT_NONE); | |
373 | } | |
374 | ||
21a4dc43 TI |
375 | static int parse_output(struct hda_codec *codec) |
376 | { | |
377 | struct cs_spec *spec = codec->spec; | |
378 | struct auto_pin_cfg *cfg = &spec->autocfg; | |
277a57c7 | 379 | int i, extra_nids; |
21a4dc43 TI |
380 | hda_nid_t dac; |
381 | ||
382 | for (i = 0; i < cfg->line_outs; i++) { | |
383 | dac = get_dac(codec, cfg->line_out_pins[i]); | |
384 | if (!dac) | |
385 | break; | |
386 | spec->dac_nid[i] = dac; | |
387 | } | |
388 | spec->multiout.num_dacs = i; | |
389 | spec->multiout.dac_nids = spec->dac_nid; | |
390 | spec->multiout.max_channels = i * 2; | |
391 | ||
392 | /* add HP and speakers */ | |
393 | extra_nids = 0; | |
394 | for (i = 0; i < cfg->hp_outs; i++) { | |
395 | dac = get_dac(codec, cfg->hp_pins[i]); | |
396 | if (!dac) | |
397 | break; | |
398 | if (!i) | |
399 | spec->multiout.hp_nid = dac; | |
400 | else | |
401 | spec->multiout.extra_out_nid[extra_nids++] = dac; | |
402 | } | |
403 | for (i = 0; i < cfg->speaker_outs; i++) { | |
404 | dac = get_dac(codec, cfg->speaker_pins[i]); | |
405 | if (!dac) | |
406 | break; | |
407 | spec->multiout.extra_out_nid[extra_nids++] = dac; | |
408 | } | |
409 | ||
410 | if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) { | |
411 | cfg->speaker_outs = cfg->line_outs; | |
412 | memcpy(cfg->speaker_pins, cfg->line_out_pins, | |
413 | sizeof(cfg->speaker_pins)); | |
414 | cfg->line_outs = 0; | |
415 | } | |
416 | ||
417 | return 0; | |
418 | } | |
419 | ||
420 | static int parse_input(struct hda_codec *codec) | |
421 | { | |
422 | struct cs_spec *spec = codec->spec; | |
423 | struct auto_pin_cfg *cfg = &spec->autocfg; | |
277a57c7 | 424 | int i; |
21a4dc43 TI |
425 | |
426 | for (i = 0; i < AUTO_PIN_LAST; i++) { | |
427 | hda_nid_t pin = cfg->input_pins[i]; | |
21a4dc43 TI |
428 | if (!pin) |
429 | continue; | |
430 | spec->input_idx[spec->num_inputs] = i; | |
431 | spec->capsrc_idx[i] = spec->num_inputs++; | |
432 | spec->cur_input = i; | |
433 | spec->adc_nid[i] = get_adc(codec, pin, &spec->adc_idx[i]); | |
434 | } | |
435 | if (!spec->num_inputs) | |
436 | return 0; | |
437 | ||
438 | /* check whether the automatic mic switch is available */ | |
439 | if (spec->num_inputs == 2 && | |
440 | spec->adc_nid[AUTO_PIN_MIC] && spec->adc_nid[AUTO_PIN_FRONT_MIC]) { | |
441 | if (is_ext_mic(codec, cfg->input_pins[AUTO_PIN_FRONT_MIC])) { | |
442 | if (!is_ext_mic(codec, cfg->input_pins[AUTO_PIN_MIC])) { | |
443 | spec->mic_detect = 1; | |
444 | spec->automic_idx = AUTO_PIN_FRONT_MIC; | |
445 | } | |
446 | } else { | |
447 | if (is_ext_mic(codec, cfg->input_pins[AUTO_PIN_MIC])) { | |
448 | spec->mic_detect = 1; | |
449 | spec->automic_idx = AUTO_PIN_MIC; | |
450 | } | |
451 | } | |
452 | } | |
453 | return 0; | |
454 | } | |
455 | ||
456 | ||
457 | static int parse_digital_output(struct hda_codec *codec) | |
458 | { | |
459 | struct cs_spec *spec = codec->spec; | |
460 | struct auto_pin_cfg *cfg = &spec->autocfg; | |
461 | hda_nid_t nid; | |
21a4dc43 TI |
462 | |
463 | if (!cfg->dig_outs) | |
464 | return 0; | |
465 | if (snd_hda_get_connections(codec, cfg->dig_out_pins[0], &nid, 1) < 1) | |
466 | return 0; | |
467 | spec->multiout.dig_out_nid = nid; | |
468 | spec->multiout.share_spdif = 1; | |
469 | if (cfg->dig_outs > 1 && | |
470 | snd_hda_get_connections(codec, cfg->dig_out_pins[1], &nid, 1) > 0) { | |
471 | spec->slave_dig_outs[0] = nid; | |
472 | codec->slave_dig_outs = spec->slave_dig_outs; | |
473 | } | |
474 | return 0; | |
475 | } | |
476 | ||
477 | static int parse_digital_input(struct hda_codec *codec) | |
478 | { | |
479 | struct cs_spec *spec = codec->spec; | |
480 | struct auto_pin_cfg *cfg = &spec->autocfg; | |
481 | int idx; | |
482 | ||
60e53882 TI |
483 | if (cfg->dig_in_pin) |
484 | spec->dig_in = get_adc(codec, cfg->dig_in_pin, &idx); | |
485 | return 0; | |
21a4dc43 TI |
486 | } |
487 | ||
488 | /* | |
489 | * create mixer controls | |
490 | */ | |
491 | ||
e5f14248 TI |
492 | static const char *dir_sfx[2] = { "Playback", "Capture" }; |
493 | ||
494 | static int add_mute(struct hda_codec *codec, const char *name, int index, | |
495 | unsigned int pval, int dir, struct snd_kcontrol **kctlp) | |
496 | { | |
b4dabfc4 | 497 | char tmp[44]; |
e5f14248 TI |
498 | struct snd_kcontrol_new knew = |
499 | HDA_CODEC_MUTE_IDX(tmp, index, 0, 0, HDA_OUTPUT); | |
500 | knew.private_value = pval; | |
501 | snprintf(tmp, sizeof(tmp), "%s %s Switch", name, dir_sfx[dir]); | |
502 | *kctlp = snd_ctl_new1(&knew, codec); | |
9e3fd871 | 503 | (*kctlp)->id.subdevice = HDA_SUBDEV_AMP_FLAG; |
5e26dfd0 | 504 | return snd_hda_ctl_add(codec, 0, *kctlp); |
e5f14248 TI |
505 | } |
506 | ||
507 | static int add_volume(struct hda_codec *codec, const char *name, | |
508 | int index, unsigned int pval, int dir, | |
509 | struct snd_kcontrol **kctlp) | |
510 | { | |
511 | char tmp[32]; | |
512 | struct snd_kcontrol_new knew = | |
513 | HDA_CODEC_VOLUME_IDX(tmp, index, 0, 0, HDA_OUTPUT); | |
514 | knew.private_value = pval; | |
515 | snprintf(tmp, sizeof(tmp), "%s %s Volume", name, dir_sfx[dir]); | |
516 | *kctlp = snd_ctl_new1(&knew, codec); | |
9e3fd871 | 517 | (*kctlp)->id.subdevice = HDA_SUBDEV_AMP_FLAG; |
5e26dfd0 | 518 | return snd_hda_ctl_add(codec, 0, *kctlp); |
e5f14248 TI |
519 | } |
520 | ||
521 | static void fix_volume_caps(struct hda_codec *codec, hda_nid_t dac) | |
522 | { | |
523 | unsigned int caps; | |
524 | ||
525 | /* set the upper-limit for mixer amp to 0dB */ | |
526 | caps = query_amp_caps(codec, dac, HDA_OUTPUT); | |
527 | caps &= ~(0x7f << AC_AMPCAP_NUM_STEPS_SHIFT); | |
528 | caps |= ((caps >> AC_AMPCAP_OFFSET_SHIFT) & 0x7f) | |
529 | << AC_AMPCAP_NUM_STEPS_SHIFT; | |
530 | snd_hda_override_amp_caps(codec, dac, HDA_OUTPUT, caps); | |
531 | } | |
532 | ||
533 | static int add_vmaster(struct hda_codec *codec, hda_nid_t dac) | |
534 | { | |
535 | struct cs_spec *spec = codec->spec; | |
536 | unsigned int tlv[4]; | |
537 | int err; | |
538 | ||
539 | spec->vmaster_sw = | |
540 | snd_ctl_make_virtual_master("Master Playback Switch", NULL); | |
3911a4c1 | 541 | err = snd_hda_ctl_add(codec, dac, spec->vmaster_sw); |
e5f14248 TI |
542 | if (err < 0) |
543 | return err; | |
544 | ||
545 | snd_hda_set_vmaster_tlv(codec, dac, HDA_OUTPUT, tlv); | |
546 | spec->vmaster_vol = | |
547 | snd_ctl_make_virtual_master("Master Playback Volume", tlv); | |
3911a4c1 | 548 | err = snd_hda_ctl_add(codec, dac, spec->vmaster_vol); |
e5f14248 TI |
549 | if (err < 0) |
550 | return err; | |
551 | return 0; | |
552 | } | |
553 | ||
554 | static int add_output(struct hda_codec *codec, hda_nid_t dac, int idx, | |
555 | int num_ctls, int type) | |
556 | { | |
557 | struct cs_spec *spec = codec->spec; | |
558 | const char *name; | |
559 | int err, index; | |
560 | struct snd_kcontrol *kctl; | |
561 | static char *speakers[] = { | |
562 | "Front Speaker", "Surround Speaker", "Bass Speaker" | |
563 | }; | |
564 | static char *line_outs[] = { | |
565 | "Front Line-Out", "Surround Line-Out", "Bass Line-Out" | |
566 | }; | |
567 | ||
568 | fix_volume_caps(codec, dac); | |
569 | if (!spec->vmaster_sw) { | |
570 | err = add_vmaster(codec, dac); | |
571 | if (err < 0) | |
572 | return err; | |
573 | } | |
574 | ||
575 | index = 0; | |
576 | switch (type) { | |
577 | case AUTO_PIN_HP_OUT: | |
578 | name = "Headphone"; | |
579 | index = idx; | |
580 | break; | |
581 | case AUTO_PIN_SPEAKER_OUT: | |
582 | if (num_ctls > 1) | |
583 | name = speakers[idx]; | |
584 | else | |
585 | name = "Speaker"; | |
586 | break; | |
587 | default: | |
588 | if (num_ctls > 1) | |
589 | name = line_outs[idx]; | |
590 | else | |
591 | name = "Line-Out"; | |
592 | break; | |
593 | } | |
594 | ||
595 | err = add_mute(codec, name, index, | |
596 | HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl); | |
597 | if (err < 0) | |
598 | return err; | |
599 | err = snd_ctl_add_slave(spec->vmaster_sw, kctl); | |
600 | if (err < 0) | |
601 | return err; | |
602 | ||
603 | err = add_volume(codec, name, index, | |
604 | HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl); | |
605 | if (err < 0) | |
606 | return err; | |
607 | err = snd_ctl_add_slave(spec->vmaster_vol, kctl); | |
608 | if (err < 0) | |
609 | return err; | |
610 | ||
611 | return 0; | |
612 | } | |
613 | ||
614 | static int build_output(struct hda_codec *codec) | |
615 | { | |
616 | struct cs_spec *spec = codec->spec; | |
617 | struct auto_pin_cfg *cfg = &spec->autocfg; | |
21a4dc43 | 618 | int i, err; |
e5f14248 TI |
619 | |
620 | for (i = 0; i < cfg->line_outs; i++) { | |
21a4dc43 TI |
621 | err = add_output(codec, get_dac(codec, cfg->line_out_pins[i]), |
622 | i, cfg->line_outs, cfg->line_out_type); | |
e5f14248 TI |
623 | if (err < 0) |
624 | return err; | |
625 | } | |
e5f14248 | 626 | for (i = 0; i < cfg->hp_outs; i++) { |
21a4dc43 TI |
627 | err = add_output(codec, get_dac(codec, cfg->hp_pins[i]), |
628 | i, cfg->hp_outs, AUTO_PIN_HP_OUT); | |
e5f14248 TI |
629 | if (err < 0) |
630 | return err; | |
631 | } | |
632 | for (i = 0; i < cfg->speaker_outs; i++) { | |
21a4dc43 TI |
633 | err = add_output(codec, get_dac(codec, cfg->speaker_pins[i]), |
634 | i, cfg->speaker_outs, AUTO_PIN_SPEAKER_OUT); | |
e5f14248 TI |
635 | if (err < 0) |
636 | return err; | |
637 | } | |
e5f14248 TI |
638 | return 0; |
639 | } | |
640 | ||
641 | /* | |
642 | */ | |
643 | ||
644 | static struct snd_kcontrol_new cs_capture_ctls[] = { | |
645 | HDA_BIND_SW("Capture Switch", 0), | |
646 | HDA_BIND_VOL("Capture Volume", 0), | |
647 | }; | |
648 | ||
ea35929b TI |
649 | static int change_cur_input(struct hda_codec *codec, unsigned int idx, |
650 | int force) | |
e5f14248 TI |
651 | { |
652 | struct cs_spec *spec = codec->spec; | |
e5f14248 | 653 | |
ea35929b | 654 | if (spec->cur_input == idx && !force) |
e5f14248 TI |
655 | return 0; |
656 | if (spec->cur_adc && spec->cur_adc != spec->adc_nid[idx]) { | |
657 | /* stream is running, let's swap the current ADC */ | |
658 | snd_hda_codec_cleanup_stream(codec, spec->cur_adc); | |
659 | spec->cur_adc = spec->adc_nid[idx]; | |
660 | snd_hda_codec_setup_stream(codec, spec->cur_adc, | |
661 | spec->cur_adc_stream_tag, 0, | |
662 | spec->cur_adc_format); | |
663 | } | |
664 | snd_hda_codec_write(codec, spec->cur_adc, 0, | |
665 | AC_VERB_SET_CONNECT_SEL, | |
666 | spec->adc_idx[idx]); | |
667 | spec->cur_input = idx; | |
668 | return 1; | |
669 | } | |
670 | ||
671 | static int cs_capture_source_info(struct snd_kcontrol *kcontrol, | |
672 | struct snd_ctl_elem_info *uinfo) | |
673 | { | |
674 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | |
675 | struct cs_spec *spec = codec->spec; | |
676 | unsigned int idx; | |
677 | ||
678 | uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | |
679 | uinfo->count = 1; | |
680 | uinfo->value.enumerated.items = spec->num_inputs; | |
681 | if (uinfo->value.enumerated.item >= spec->num_inputs) | |
682 | uinfo->value.enumerated.item = spec->num_inputs - 1; | |
683 | idx = spec->input_idx[uinfo->value.enumerated.item]; | |
684 | strcpy(uinfo->value.enumerated.name, auto_pin_cfg_labels[idx]); | |
685 | return 0; | |
686 | } | |
687 | ||
688 | static int cs_capture_source_get(struct snd_kcontrol *kcontrol, | |
689 | struct snd_ctl_elem_value *ucontrol) | |
690 | { | |
691 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | |
692 | struct cs_spec *spec = codec->spec; | |
693 | ucontrol->value.enumerated.item[0] = spec->capsrc_idx[spec->cur_input]; | |
694 | return 0; | |
695 | } | |
696 | ||
697 | static int cs_capture_source_put(struct snd_kcontrol *kcontrol, | |
698 | struct snd_ctl_elem_value *ucontrol) | |
699 | { | |
700 | struct hda_codec *codec = snd_kcontrol_chip(kcontrol); | |
701 | struct cs_spec *spec = codec->spec; | |
702 | unsigned int idx = ucontrol->value.enumerated.item[0]; | |
703 | ||
704 | if (idx >= spec->num_inputs) | |
705 | return -EINVAL; | |
706 | idx = spec->input_idx[idx]; | |
ea35929b | 707 | return change_cur_input(codec, idx, 0); |
e5f14248 TI |
708 | } |
709 | ||
710 | static struct snd_kcontrol_new cs_capture_source = { | |
711 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | |
712 | .name = "Capture Source", | |
713 | .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, | |
714 | .info = cs_capture_source_info, | |
715 | .get = cs_capture_source_get, | |
716 | .put = cs_capture_source_put, | |
717 | }; | |
718 | ||
e5f14248 TI |
719 | static struct hda_bind_ctls *make_bind_capture(struct hda_codec *codec, |
720 | struct hda_ctl_ops *ops) | |
721 | { | |
722 | struct cs_spec *spec = codec->spec; | |
723 | struct hda_bind_ctls *bind; | |
724 | int i, n; | |
725 | ||
726 | bind = kzalloc(sizeof(*bind) + sizeof(long) * (spec->num_inputs + 1), | |
727 | GFP_KERNEL); | |
728 | if (!bind) | |
729 | return NULL; | |
730 | bind->ops = ops; | |
731 | n = 0; | |
732 | for (i = 0; i < AUTO_PIN_LAST; i++) { | |
733 | if (!spec->adc_nid[i]) | |
734 | continue; | |
735 | bind->values[n++] = | |
736 | HDA_COMPOSE_AMP_VAL(spec->adc_nid[i], 3, | |
737 | spec->adc_idx[i], HDA_INPUT); | |
738 | } | |
739 | return bind; | |
740 | } | |
741 | ||
742 | static int build_input(struct hda_codec *codec) | |
743 | { | |
744 | struct cs_spec *spec = codec->spec; | |
21a4dc43 | 745 | int i, err; |
e5f14248 | 746 | |
e5f14248 TI |
747 | if (!spec->num_inputs) |
748 | return 0; | |
749 | ||
e5f14248 TI |
750 | /* make bind-capture */ |
751 | spec->capture_bind[0] = make_bind_capture(codec, &snd_hda_bind_sw); | |
752 | spec->capture_bind[1] = make_bind_capture(codec, &snd_hda_bind_vol); | |
753 | for (i = 0; i < 2; i++) { | |
754 | struct snd_kcontrol *kctl; | |
755 | if (!spec->capture_bind[i]) | |
756 | return -ENOMEM; | |
757 | kctl = snd_ctl_new1(&cs_capture_ctls[i], codec); | |
758 | if (!kctl) | |
759 | return -ENOMEM; | |
760 | kctl->private_value = (long)spec->capture_bind[i]; | |
3911a4c1 | 761 | err = snd_hda_ctl_add(codec, 0, kctl); |
e5f14248 TI |
762 | if (err < 0) |
763 | return err; | |
5b0cb1d8 JK |
764 | err = snd_hda_add_nids(codec, kctl, 0, spec->adc_nid, |
765 | spec->num_inputs); | |
766 | if (err < 0) | |
767 | return err; | |
e5f14248 TI |
768 | } |
769 | ||
770 | if (spec->num_inputs > 1 && !spec->mic_detect) { | |
3911a4c1 | 771 | err = snd_hda_ctl_add(codec, 0, |
e5f14248 TI |
772 | snd_ctl_new1(&cs_capture_source, codec)); |
773 | if (err < 0) | |
774 | return err; | |
775 | } | |
776 | ||
777 | return 0; | |
778 | } | |
779 | ||
21a4dc43 TI |
780 | /* |
781 | */ | |
782 | ||
e5f14248 TI |
783 | static int build_digital_output(struct hda_codec *codec) |
784 | { | |
785 | struct cs_spec *spec = codec->spec; | |
e5f14248 TI |
786 | int err; |
787 | ||
63b2413b TI |
788 | if (!spec->multiout.dig_out_nid) |
789 | return 0; | |
790 | ||
e5f14248 TI |
791 | err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid); |
792 | if (err < 0) | |
793 | return err; | |
794 | err = snd_hda_create_spdif_share_sw(codec, &spec->multiout); | |
795 | if (err < 0) | |
796 | return err; | |
e5f14248 TI |
797 | return 0; |
798 | } | |
799 | ||
800 | static int build_digital_input(struct hda_codec *codec) | |
801 | { | |
802 | struct cs_spec *spec = codec->spec; | |
21a4dc43 TI |
803 | if (spec->dig_in) |
804 | return snd_hda_create_spdif_in_ctls(codec, spec->dig_in); | |
805 | return 0; | |
e5f14248 TI |
806 | } |
807 | ||
21a4dc43 TI |
808 | /* |
809 | * auto-mute and auto-mic switching | |
810 | */ | |
811 | ||
e5f14248 TI |
812 | static void cs_automute(struct hda_codec *codec) |
813 | { | |
814 | struct cs_spec *spec = codec->spec; | |
815 | struct auto_pin_cfg *cfg = &spec->autocfg; | |
864f92be | 816 | unsigned int caps, hp_present; |
e5f14248 TI |
817 | hda_nid_t nid; |
818 | int i; | |
819 | ||
820 | hp_present = 0; | |
821 | for (i = 0; i < cfg->hp_outs; i++) { | |
822 | nid = cfg->hp_pins[i]; | |
823 | caps = snd_hda_query_pin_caps(codec, nid); | |
824 | if (!(caps & AC_PINCAP_PRES_DETECT)) | |
825 | continue; | |
864f92be | 826 | hp_present = snd_hda_jack_detect(codec, nid); |
e5f14248 TI |
827 | if (hp_present) |
828 | break; | |
829 | } | |
830 | for (i = 0; i < cfg->speaker_outs; i++) { | |
831 | nid = cfg->speaker_pins[i]; | |
832 | snd_hda_codec_write(codec, nid, 0, | |
833 | AC_VERB_SET_PIN_WIDGET_CONTROL, | |
834 | hp_present ? 0 : PIN_OUT); | |
835 | } | |
3a385167 SP |
836 | if (spec->board_config == CS420X_MBP55) { |
837 | unsigned int gpio = hp_present ? 0x02 : 0x08; | |
838 | snd_hda_codec_write(codec, 0x01, 0, | |
839 | AC_VERB_SET_GPIO_DATA, gpio); | |
840 | } | |
e5f14248 TI |
841 | } |
842 | ||
843 | static void cs_automic(struct hda_codec *codec) | |
844 | { | |
845 | struct cs_spec *spec = codec->spec; | |
846 | struct auto_pin_cfg *cfg = &spec->autocfg; | |
847 | hda_nid_t nid; | |
864f92be | 848 | unsigned int present; |
e5f14248 TI |
849 | |
850 | nid = cfg->input_pins[spec->automic_idx]; | |
864f92be WF |
851 | present = snd_hda_jack_detect(codec, nid); |
852 | if (present) | |
ea35929b | 853 | change_cur_input(codec, spec->automic_idx, 0); |
e5f14248 TI |
854 | else { |
855 | unsigned int imic = (spec->automic_idx == AUTO_PIN_MIC) ? | |
856 | AUTO_PIN_FRONT_MIC : AUTO_PIN_MIC; | |
ea35929b | 857 | change_cur_input(codec, imic, 0); |
e5f14248 TI |
858 | } |
859 | } | |
860 | ||
861 | /* | |
862 | */ | |
863 | ||
864 | static void init_output(struct hda_codec *codec) | |
865 | { | |
866 | struct cs_spec *spec = codec->spec; | |
867 | struct auto_pin_cfg *cfg = &spec->autocfg; | |
868 | int i; | |
869 | ||
870 | /* mute first */ | |
871 | for (i = 0; i < spec->multiout.num_dacs; i++) | |
872 | snd_hda_codec_write(codec, spec->multiout.dac_nids[i], 0, | |
873 | AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); | |
874 | if (spec->multiout.hp_nid) | |
875 | snd_hda_codec_write(codec, spec->multiout.hp_nid, 0, | |
876 | AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); | |
877 | for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) { | |
878 | if (!spec->multiout.extra_out_nid[i]) | |
879 | break; | |
880 | snd_hda_codec_write(codec, spec->multiout.extra_out_nid[i], 0, | |
881 | AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); | |
882 | } | |
883 | ||
884 | /* set appropriate pin controls */ | |
885 | for (i = 0; i < cfg->line_outs; i++) | |
886 | snd_hda_codec_write(codec, cfg->line_out_pins[i], 0, | |
887 | AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); | |
888 | for (i = 0; i < cfg->hp_outs; i++) { | |
889 | hda_nid_t nid = cfg->hp_pins[i]; | |
890 | snd_hda_codec_write(codec, nid, 0, | |
891 | AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP); | |
892 | if (!cfg->speaker_outs) | |
893 | continue; | |
894 | if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) { | |
895 | snd_hda_codec_write(codec, nid, 0, | |
896 | AC_VERB_SET_UNSOLICITED_ENABLE, | |
897 | AC_USRSP_EN | HP_EVENT); | |
898 | spec->hp_detect = 1; | |
899 | } | |
900 | } | |
901 | for (i = 0; i < cfg->speaker_outs; i++) | |
902 | snd_hda_codec_write(codec, cfg->speaker_pins[i], 0, | |
903 | AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); | |
904 | if (spec->hp_detect) | |
905 | cs_automute(codec); | |
906 | } | |
907 | ||
908 | static void init_input(struct hda_codec *codec) | |
909 | { | |
910 | struct cs_spec *spec = codec->spec; | |
911 | struct auto_pin_cfg *cfg = &spec->autocfg; | |
40c20fa0 | 912 | unsigned int coef; |
e5f14248 TI |
913 | int i; |
914 | ||
915 | for (i = 0; i < AUTO_PIN_LAST; i++) { | |
916 | unsigned int ctl; | |
917 | hda_nid_t pin = cfg->input_pins[i]; | |
918 | if (!pin || !spec->adc_nid[i]) | |
919 | continue; | |
920 | /* set appropriate pin control and mute first */ | |
921 | ctl = PIN_IN; | |
922 | if (i <= AUTO_PIN_FRONT_MIC) { | |
923 | unsigned int caps = snd_hda_query_pin_caps(codec, pin); | |
924 | caps >>= AC_PINCAP_VREF_SHIFT; | |
925 | if (caps & AC_PINCAP_VREF_80) | |
926 | ctl = PIN_VREF80; | |
927 | } | |
928 | snd_hda_codec_write(codec, pin, 0, | |
929 | AC_VERB_SET_PIN_WIDGET_CONTROL, ctl); | |
930 | snd_hda_codec_write(codec, spec->adc_nid[i], 0, | |
931 | AC_VERB_SET_AMP_GAIN_MUTE, | |
932 | AMP_IN_MUTE(spec->adc_idx[i])); | |
933 | if (spec->mic_detect && spec->automic_idx == i) | |
934 | snd_hda_codec_write(codec, pin, 0, | |
935 | AC_VERB_SET_UNSOLICITED_ENABLE, | |
936 | AC_USRSP_EN | MIC_EVENT); | |
937 | } | |
ea35929b | 938 | change_cur_input(codec, spec->cur_input, 1); |
e5f14248 TI |
939 | if (spec->mic_detect) |
940 | cs_automic(codec); | |
40c20fa0 TI |
941 | |
942 | coef = 0x000a; /* ADC1/2 - Digital and Analog Soft Ramp */ | |
943 | if (is_active_pin(codec, CS_DMIC2_PIN_NID)) | |
944 | coef |= 0x0500; /* DMIC2 enable 2 channels, disable GPIO1 */ | |
945 | if (is_active_pin(codec, CS_DMIC1_PIN_NID)) | |
946 | coef |= 0x1800; /* DMIC1 enable 2 channels, disable GPIO0 | |
b71a8eb0 | 947 | * No effect if SPDIF_OUT2 is selected in |
40c20fa0 TI |
948 | * IDX_SPDIF_CTL. |
949 | */ | |
950 | cs_vendor_coef_set(codec, IDX_ADC_CFG, coef); | |
951 | } | |
952 | ||
953 | static struct hda_verb cs_coef_init_verbs[] = { | |
954 | {0x11, AC_VERB_SET_PROC_STATE, 1}, | |
955 | {0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG}, | |
956 | {0x11, AC_VERB_SET_PROC_COEF, | |
957 | (0x002a /* DAC1/2/3 SZCMode Soft Ramp */ | |
958 | | 0x0040 /* Mute DACs on FIFO error */ | |
959 | | 0x1000 /* Enable DACs High Pass Filter */ | |
960 | | 0x0400 /* Disable Coefficient Auto increment */ | |
961 | )}, | |
962 | /* Beep */ | |
963 | {0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG}, | |
964 | {0x11, AC_VERB_SET_PROC_COEF, 0x0007}, /* Enable Beep thru DAC1/2/3 */ | |
965 | ||
966 | {} /* terminator */ | |
967 | }; | |
968 | ||
969 | /* SPDIF setup */ | |
970 | static void init_digital(struct hda_codec *codec) | |
971 | { | |
972 | unsigned int coef; | |
973 | ||
974 | coef = 0x0002; /* SRC_MUTE soft-mute on SPDIF (if no lock) */ | |
975 | coef |= 0x0008; /* Replace with mute on error */ | |
976 | if (is_active_pin(codec, CS_DIG_OUT2_PIN_NID)) | |
977 | coef |= 0x4000; /* RX to TX1 or TX2 Loopthru / SPDIF2 | |
978 | * SPDIF_OUT2 is shared with GPIO1 and | |
979 | * DMIC_SDA2. | |
980 | */ | |
981 | cs_vendor_coef_set(codec, IDX_SPDIF_CTL, coef); | |
e5f14248 TI |
982 | } |
983 | ||
984 | static int cs_init(struct hda_codec *codec) | |
985 | { | |
986 | struct cs_spec *spec = codec->spec; | |
987 | ||
40c20fa0 | 988 | snd_hda_sequence_write(codec, cs_coef_init_verbs); |
ed208255 TI |
989 | |
990 | if (spec->gpio_mask) { | |
991 | snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK, | |
992 | spec->gpio_mask); | |
993 | snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION, | |
994 | spec->gpio_dir); | |
995 | snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, | |
996 | spec->gpio_data); | |
997 | } | |
998 | ||
e5f14248 TI |
999 | init_output(codec); |
1000 | init_input(codec); | |
40c20fa0 | 1001 | init_digital(codec); |
e5f14248 TI |
1002 | return 0; |
1003 | } | |
1004 | ||
1005 | static int cs_build_controls(struct hda_codec *codec) | |
1006 | { | |
e5f14248 TI |
1007 | int err; |
1008 | ||
1009 | err = build_output(codec); | |
1010 | if (err < 0) | |
1011 | return err; | |
1012 | err = build_input(codec); | |
1013 | if (err < 0) | |
1014 | return err; | |
1015 | err = build_digital_output(codec); | |
1016 | if (err < 0) | |
1017 | return err; | |
1018 | err = build_digital_input(codec); | |
1019 | if (err < 0) | |
1020 | return err; | |
e5f14248 TI |
1021 | return cs_init(codec); |
1022 | } | |
1023 | ||
1024 | static void cs_free(struct hda_codec *codec) | |
1025 | { | |
1026 | struct cs_spec *spec = codec->spec; | |
1027 | kfree(spec->capture_bind[0]); | |
1028 | kfree(spec->capture_bind[1]); | |
1029 | kfree(codec->spec); | |
1030 | } | |
1031 | ||
1032 | static void cs_unsol_event(struct hda_codec *codec, unsigned int res) | |
1033 | { | |
1034 | switch ((res >> 26) & 0x7f) { | |
1035 | case HP_EVENT: | |
1036 | cs_automute(codec); | |
1037 | break; | |
1038 | case MIC_EVENT: | |
1039 | cs_automic(codec); | |
1040 | break; | |
1041 | } | |
1042 | } | |
1043 | ||
1044 | static struct hda_codec_ops cs_patch_ops = { | |
1045 | .build_controls = cs_build_controls, | |
1046 | .build_pcms = cs_build_pcms, | |
1047 | .init = cs_init, | |
1048 | .free = cs_free, | |
1049 | .unsol_event = cs_unsol_event, | |
1050 | }; | |
1051 | ||
1052 | static int cs_parse_auto_config(struct hda_codec *codec) | |
1053 | { | |
1054 | struct cs_spec *spec = codec->spec; | |
1055 | int err; | |
1056 | ||
1057 | err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); | |
ed208255 TI |
1058 | if (err < 0) |
1059 | return err; | |
1060 | ||
1061 | err = parse_output(codec); | |
1062 | if (err < 0) | |
1063 | return err; | |
1064 | err = parse_input(codec); | |
1065 | if (err < 0) | |
1066 | return err; | |
1067 | err = parse_digital_output(codec); | |
1068 | if (err < 0) | |
1069 | return err; | |
1070 | err = parse_digital_input(codec); | |
e5f14248 TI |
1071 | if (err < 0) |
1072 | return err; | |
1073 | return 0; | |
1074 | } | |
1075 | ||
a6bae205 TI |
1076 | static const char *cs420x_models[CS420X_MODELS] = { |
1077 | [CS420X_MBP55] = "mbp55", | |
1078 | [CS420X_AUTO] = "auto", | |
1079 | }; | |
1080 | ||
1081 | ||
1082 | static struct snd_pci_quirk cs420x_cfg_tbl[] = { | |
1083 | SND_PCI_QUIRK(0x10de, 0xcb79, "MacBookPro 5,5", CS420X_MBP55), | |
1084 | {} /* terminator */ | |
1085 | }; | |
1086 | ||
1087 | struct cs_pincfg { | |
1088 | hda_nid_t nid; | |
1089 | u32 val; | |
1090 | }; | |
1091 | ||
1092 | static struct cs_pincfg mbp55_pincfgs[] = { | |
1093 | { 0x09, 0x012b4030 }, | |
1094 | { 0x0a, 0x90100121 }, | |
1095 | { 0x0b, 0x90100120 }, | |
1096 | { 0x0c, 0x400000f0 }, | |
1097 | { 0x0d, 0x90a00110 }, | |
1098 | { 0x0e, 0x400000f0 }, | |
1099 | { 0x0f, 0x400000f0 }, | |
1100 | { 0x10, 0x014be040 }, | |
1101 | { 0x12, 0x400000f0 }, | |
1102 | { 0x15, 0x400000f0 }, | |
1103 | {} /* terminator */ | |
1104 | }; | |
1105 | ||
1106 | static struct cs_pincfg *cs_pincfgs[CS420X_MODELS] = { | |
1107 | [CS420X_MBP55] = mbp55_pincfgs, | |
1108 | }; | |
1109 | ||
1110 | static void fix_pincfg(struct hda_codec *codec, int model) | |
1111 | { | |
1112 | const struct cs_pincfg *cfg = cs_pincfgs[model]; | |
1113 | if (!cfg) | |
1114 | return; | |
1115 | for (; cfg->nid; cfg++) | |
1116 | snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val); | |
1117 | } | |
1118 | ||
e5f14248 TI |
1119 | |
1120 | static int patch_cs420x(struct hda_codec *codec) | |
1121 | { | |
1122 | struct cs_spec *spec; | |
1123 | int err; | |
1124 | ||
1125 | spec = kzalloc(sizeof(*spec), GFP_KERNEL); | |
1126 | if (!spec) | |
1127 | return -ENOMEM; | |
1128 | codec->spec = spec; | |
1129 | ||
a6bae205 TI |
1130 | spec->board_config = |
1131 | snd_hda_check_board_config(codec, CS420X_MODELS, | |
1132 | cs420x_models, cs420x_cfg_tbl); | |
1133 | if (spec->board_config >= 0) | |
1134 | fix_pincfg(codec, spec->board_config); | |
1135 | ||
ed208255 TI |
1136 | switch (spec->board_config) { |
1137 | case CS420X_MBP55: | |
3a385167 SP |
1138 | /* GPIO1 = headphones */ |
1139 | /* GPIO3 = speakers */ | |
1140 | spec->gpio_mask = 0x0a; | |
1141 | spec->gpio_dir = 0x0a; | |
ed208255 TI |
1142 | break; |
1143 | } | |
e5f14248 | 1144 | |
ed208255 | 1145 | err = cs_parse_auto_config(codec); |
21a4dc43 TI |
1146 | if (err < 0) |
1147 | goto error; | |
1148 | ||
e5f14248 TI |
1149 | codec->patch_ops = cs_patch_ops; |
1150 | ||
1151 | return 0; | |
1152 | ||
1153 | error: | |
1154 | kfree(codec->spec); | |
1155 | codec->spec = NULL; | |
1156 | return err; | |
1157 | } | |
1158 | ||
1159 | ||
1160 | /* | |
1161 | * patch entries | |
1162 | */ | |
1163 | static struct hda_codec_preset snd_hda_preset_cirrus[] = { | |
1164 | { .id = 0x10134206, .name = "CS4206", .patch = patch_cs420x }, | |
1165 | { .id = 0x10134207, .name = "CS4207", .patch = patch_cs420x }, | |
1166 | {} /* terminator */ | |
1167 | }; | |
1168 | ||
1169 | MODULE_ALIAS("snd-hda-codec-id:10134206"); | |
1170 | MODULE_ALIAS("snd-hda-codec-id:10134207"); | |
1171 | ||
1172 | MODULE_LICENSE("GPL"); | |
1173 | MODULE_DESCRIPTION("Cirrus Logic HD-audio codec"); | |
1174 | ||
1175 | static struct hda_codec_preset_list cirrus_list = { | |
1176 | .preset = snd_hda_preset_cirrus, | |
1177 | .owner = THIS_MODULE, | |
1178 | }; | |
1179 | ||
1180 | static int __init patch_cirrus_init(void) | |
1181 | { | |
1182 | return snd_hda_add_codec_preset(&cirrus_list); | |
1183 | } | |
1184 | ||
1185 | static void __exit patch_cirrus_exit(void) | |
1186 | { | |
1187 | snd_hda_delete_codec_preset(&cirrus_list); | |
1188 | } | |
1189 | ||
1190 | module_init(patch_cirrus_init) | |
1191 | module_exit(patch_cirrus_exit) |