?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.8-rc7
[cris-mirror.git] / sound / pci / hda / patch_cirrus.c
bloba2537b2f87240ae20f2d75d5d3cb7a0ebdc81510
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 <linux/module.h>
26 #include <sound/core.h>
27 #include "hda_codec.h"
28 #include "hda_local.h"
29 #include "hda_auto_parser.h"
30 #include "hda_jack.h"
31 #include <sound/tlv.h>
32
33 /*
34 */
35
36 struct cs_spec {
37 struct hda_gen_spec gen;
38
39 struct auto_pin_cfg autocfg;
40 struct hda_multi_out multiout;
41 struct snd_kcontrol *vmaster_sw;
42 struct snd_kcontrol *vmaster_vol;
43
44 hda_nid_t dac_nid[AUTO_CFG_MAX_OUTS];
45 hda_nid_t slave_dig_outs[2];
46
47 unsigned int input_idx[AUTO_PIN_LAST];
48 unsigned int capsrc_idx[AUTO_PIN_LAST];
49 hda_nid_t adc_nid[AUTO_PIN_LAST];
50 unsigned int adc_idx[AUTO_PIN_LAST];
51 unsigned int num_inputs;
52 unsigned int cur_input;
53 unsigned int automic_idx;
54 hda_nid_t cur_adc;
55 unsigned int cur_adc_stream_tag;
56 unsigned int cur_adc_format;
57 hda_nid_t dig_in;
58
59 const struct hda_bind_ctls *capture_bind[2];
60
61 unsigned int gpio_mask;
62 unsigned int gpio_dir;
63 unsigned int gpio_data;
64 unsigned int gpio_eapd_hp; /* EAPD GPIO bit for headphones */
65 unsigned int gpio_eapd_speaker; /* EAPD GPIO bit for speakers */
66
67 struct hda_pcm pcm_rec[2]; /* PCM information */
68
69 unsigned int hp_detect:1;
70 unsigned int mic_detect:1;
71 unsigned int speaker_2_1:1;
72 /* CS421x */
73 unsigned int spdif_detect:1;
74 unsigned int sense_b:1;
75 hda_nid_t vendor_nid;
76 struct hda_input_mux input_mux;
77 unsigned int last_input;
78 };
79
80 /* available models with CS420x */
81 enum {
82 CS420X_MBP53,
83 CS420X_MBP55,
84 CS420X_IMAC27,
85 CS420X_GPIO_13,
86 CS420X_GPIO_23,
87 CS420X_MBP101,
88 CS420X_MBP81,
89 CS420X_AUTO,
90 /* aliases */
91 CS420X_IMAC27_122 = CS420X_GPIO_23,
92 CS420X_APPLE = CS420X_GPIO_13,
93 };
94
95 /* CS421x boards */
96 enum {
97 CS421X_CDB4210,
98 CS421X_SENSE_B,
99 };
100
101 /* Vendor-specific processing widget */
102 #define CS420X_VENDOR_NID 0x11
103 #define CS_DIG_OUT1_PIN_NID 0x10
104 #define CS_DIG_OUT2_PIN_NID 0x15
105 #define CS_DMIC1_PIN_NID 0x0e
106 #define CS_DMIC2_PIN_NID 0x12
107
108 /* coef indices */
109 #define IDX_SPDIF_STAT 0x0000
110 #define IDX_SPDIF_CTL 0x0001
111 #define IDX_ADC_CFG 0x0002
112 /* SZC bitmask, 4 modes below:
113 * 0 = immediate,
114 * 1 = digital immediate, analog zero-cross
115 * 2 = digtail & analog soft-ramp
116 * 3 = digital soft-ramp, analog zero-cross
117 */
118 #define CS_COEF_ADC_SZC_MASK (3 << 0)
119 #define CS_COEF_ADC_MIC_SZC_MODE (3 << 0) /* SZC setup for mic */
120 #define CS_COEF_ADC_LI_SZC_MODE (3 << 0) /* SZC setup for line-in */
121 /* PGA mode: 0 = differential, 1 = signle-ended */
122 #define CS_COEF_ADC_MIC_PGA_MODE (1 << 5) /* PGA setup for mic */
123 #define CS_COEF_ADC_LI_PGA_MODE (1 << 6) /* PGA setup for line-in */
124 #define IDX_DAC_CFG 0x0003
125 /* SZC bitmask, 4 modes below:
126 * 0 = Immediate
127 * 1 = zero-cross
128 * 2 = soft-ramp
129 * 3 = soft-ramp on zero-cross
130 */
131 #define CS_COEF_DAC_HP_SZC_MODE (3 << 0) /* nid 0x02 */
132 #define CS_COEF_DAC_LO_SZC_MODE (3 << 2) /* nid 0x03 */
133 #define CS_COEF_DAC_SPK_SZC_MODE (3 << 4) /* nid 0x04 */
134
135 #define IDX_BEEP_CFG 0x0004
136 /* 0x0008 - test reg key */
137 /* 0x0009 - 0x0014 -> 12 test regs */
138 /* 0x0015 - visibility reg */
139
140 /*
141 * Cirrus Logic CS4210
142 *
143 * 1 DAC => HP(sense) / Speakers,
144 * 1 ADC <= LineIn(sense) / MicIn / DMicIn,
145 * 1 SPDIF OUT => SPDIF Trasmitter(sense)
146 */
147 #define CS4210_DAC_NID 0x02
148 #define CS4210_ADC_NID 0x03
149 #define CS4210_VENDOR_NID 0x0B
150 #define CS421X_DMIC_PIN_NID 0x09 /* Port E */
151 #define CS421X_SPDIF_PIN_NID 0x0A /* Port H */
152
153 #define CS421X_IDX_DEV_CFG 0x01
154 #define CS421X_IDX_ADC_CFG 0x02
155 #define CS421X_IDX_DAC_CFG 0x03
156 #define CS421X_IDX_SPK_CTL 0x04
157
158 #define SPDIF_EVENT 0x04
159
160 /* Cirrus Logic CS4213 is like CS4210 but does not have SPDIF input/output */
161 #define CS4213_VENDOR_NID 0x09
162
163
164 static inline int cs_vendor_coef_get(struct hda_codec *codec, unsigned int idx)
165 {
166 struct cs_spec *spec = codec->spec;
167 snd_hda_codec_write(codec, spec->vendor_nid, 0,
168 AC_VERB_SET_COEF_INDEX, idx);
169 return snd_hda_codec_read(codec, spec->vendor_nid, 0,
170 AC_VERB_GET_PROC_COEF, 0);
171 }
172
173 static inline void cs_vendor_coef_set(struct hda_codec *codec, unsigned int idx,
174 unsigned int coef)
175 {
176 struct cs_spec *spec = codec->spec;
177 snd_hda_codec_write(codec, spec->vendor_nid, 0,
178 AC_VERB_SET_COEF_INDEX, idx);
179 snd_hda_codec_write(codec, spec->vendor_nid, 0,
180 AC_VERB_SET_PROC_COEF, coef);
181 }
182
183
184 #define HP_EVENT 1
185 #define MIC_EVENT 2
186
187 /*
188 * PCM callbacks
189 */
190 static int cs_playback_pcm_open(struct hda_pcm_stream *hinfo,
191 struct hda_codec *codec,
192 struct snd_pcm_substream *substream)
193 {
194 struct cs_spec *spec = codec->spec;
195 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
196 hinfo);
197 }
198
199 static int cs_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
200 struct hda_codec *codec,
201 unsigned int stream_tag,
202 unsigned int format,
203 struct snd_pcm_substream *substream)
204 {
205 struct cs_spec *spec = codec->spec;
206 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
207 stream_tag, format, substream);
208 }
209
210 static int cs_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
211 struct hda_codec *codec,
212 struct snd_pcm_substream *substream)
213 {
214 struct cs_spec *spec = codec->spec;
215 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
216 }
217
218 /*
219 * Digital out
220 */
221 static int cs_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
222 struct hda_codec *codec,
223 struct snd_pcm_substream *substream)
224 {
225 struct cs_spec *spec = codec->spec;
226 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
227 }
228
229 static int cs_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
230 struct hda_codec *codec,
231 struct snd_pcm_substream *substream)
232 {
233 struct cs_spec *spec = codec->spec;
234 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
235 }
236
237 static int cs_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
238 struct hda_codec *codec,
239 unsigned int stream_tag,
240 unsigned int format,
241 struct snd_pcm_substream *substream)
242 {
243 struct cs_spec *spec = codec->spec;
244 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
245 format, substream);
246 }
247
248 static int cs_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
249 struct hda_codec *codec,
250 struct snd_pcm_substream *substream)
251 {
252 struct cs_spec *spec = codec->spec;
253 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
254 }
255
256 static void cs_update_input_select(struct hda_codec *codec)
257 {
258 struct cs_spec *spec = codec->spec;
259 if (spec->cur_adc)
260 snd_hda_codec_write(codec, spec->cur_adc, 0,
261 AC_VERB_SET_CONNECT_SEL,
262 spec->adc_idx[spec->cur_input]);
263 }
264
265 /*
266 * Analog capture
267 */
268 static int cs_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
269 struct hda_codec *codec,
270 unsigned int stream_tag,
271 unsigned int format,
272 struct snd_pcm_substream *substream)
273 {
274 struct cs_spec *spec = codec->spec;
275 spec->cur_adc = spec->adc_nid[spec->cur_input];
276 spec->cur_adc_stream_tag = stream_tag;
277 spec->cur_adc_format = format;
278 cs_update_input_select(codec);
279 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
280 return 0;
281 }
282
283 static int cs_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
284 struct hda_codec *codec,
285 struct snd_pcm_substream *substream)
286 {
287 struct cs_spec *spec = codec->spec;
288 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
289 spec->cur_adc = 0;
290 return 0;
291 }
292
293 /*
294 */
295 static const struct hda_pcm_stream cs_pcm_analog_playback = {
296 .substreams = 1,
297 .channels_min = 2,
298 .channels_max = 2,
299 .ops = {
300 .open = cs_playback_pcm_open,
301 .prepare = cs_playback_pcm_prepare,
302 .cleanup = cs_playback_pcm_cleanup
303 },
304 };
305
306 static const struct hda_pcm_stream cs_pcm_analog_capture = {
307 .substreams = 1,
308 .channels_min = 2,
309 .channels_max = 2,
310 .ops = {
311 .prepare = cs_capture_pcm_prepare,
312 .cleanup = cs_capture_pcm_cleanup
313 },
314 };
315
316 static const struct hda_pcm_stream cs_pcm_digital_playback = {
317 .substreams = 1,
318 .channels_min = 2,
319 .channels_max = 2,
320 .ops = {
321 .open = cs_dig_playback_pcm_open,
322 .close = cs_dig_playback_pcm_close,
323 .prepare = cs_dig_playback_pcm_prepare,
324 .cleanup = cs_dig_playback_pcm_cleanup
325 },
326 };
327
328 static const struct hda_pcm_stream cs_pcm_digital_capture = {
329 .substreams = 1,
330 .channels_min = 2,
331 .channels_max = 2,
332 };
333
334 static int cs_build_pcms(struct hda_codec *codec)
335 {
336 struct cs_spec *spec = codec->spec;
337 struct hda_pcm *info = spec->pcm_rec;
338
339 codec->pcm_info = info;
340 codec->num_pcms = 0;
341
342 info->name = "Cirrus Analog";
343 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = cs_pcm_analog_playback;
344 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dac_nid[0];
345 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
346 spec->multiout.max_channels;
347 if (spec->speaker_2_1)
348 info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
349 snd_pcm_2_1_chmaps;
350 info->stream[SNDRV_PCM_STREAM_CAPTURE] = cs_pcm_analog_capture;
351 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
352 spec->adc_nid[spec->cur_input];
353 codec->num_pcms++;
354
355 if (!spec->multiout.dig_out_nid && !spec->dig_in)
356 return 0;
357
358 info++;
359 info->name = "Cirrus Digital";
360 info->pcm_type = spec->autocfg.dig_out_type[0];
361 if (!info->pcm_type)
362 info->pcm_type = HDA_PCM_TYPE_SPDIF;
363 if (spec->multiout.dig_out_nid) {
364 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
365 cs_pcm_digital_playback;
366 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
367 spec->multiout.dig_out_nid;
368 }
369 if (spec->dig_in) {
370 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
371 cs_pcm_digital_capture;
372 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in;
373 }
374 codec->num_pcms++;
375
376 return 0;
377 }
378
379 /*
380 * parse codec topology
381 */
382
383 static hda_nid_t get_dac(struct hda_codec *codec, hda_nid_t pin)
384 {
385 hda_nid_t dac;
386 if (!pin)
387 return 0;
388 if (snd_hda_get_connections(codec, pin, &dac, 1) != 1)
389 return 0;
390 return dac;
391 }
392
393 static int is_ext_mic(struct hda_codec *codec, unsigned int idx)
394 {
395 struct cs_spec *spec = codec->spec;
396 struct auto_pin_cfg *cfg = &spec->autocfg;
397 hda_nid_t pin = cfg->inputs[idx].pin;
398 unsigned int val;
399 if (!is_jack_detectable(codec, pin))
400 return 0;
401 val = snd_hda_codec_get_pincfg(codec, pin);
402 return (snd_hda_get_input_pin_attr(val) != INPUT_PIN_ATTR_INT);
403 }
404
405 static hda_nid_t get_adc(struct hda_codec *codec, hda_nid_t pin,
406 unsigned int *idxp)
407 {
408 int i, idx;
409 hda_nid_t nid;
410
411 nid = codec->start_nid;
412 for (i = 0; i < codec->num_nodes; i++, nid++) {
413 unsigned int type;
414 type = get_wcaps_type(get_wcaps(codec, nid));
415 if (type != AC_WID_AUD_IN)
416 continue;
417 idx = snd_hda_get_conn_index(codec, nid, pin, false);
418 if (idx >= 0) {
419 *idxp = idx;
420 return nid;
421 }
422 }
423 return 0;
424 }
425
426 static int is_active_pin(struct hda_codec *codec, hda_nid_t nid)
427 {
428 unsigned int val;
429 val = snd_hda_codec_get_pincfg(codec, nid);
430 return (get_defcfg_connect(val) != AC_JACK_PORT_NONE);
431 }
432
433 static int parse_output(struct hda_codec *codec)
434 {
435 struct cs_spec *spec = codec->spec;
436 struct auto_pin_cfg *cfg = &spec->autocfg;
437 int i, extra_nids;
438 hda_nid_t dac;
439
440 for (i = 0; i < cfg->line_outs; i++) {
441 dac = get_dac(codec, cfg->line_out_pins[i]);
442 if (!dac)
443 break;
444 spec->dac_nid[i] = dac;
445 }
446 spec->multiout.num_dacs = i;
447 spec->multiout.dac_nids = spec->dac_nid;
448 spec->multiout.max_channels = i * 2;
449
450 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT && i == 2)
451 spec->speaker_2_1 = 1; /* assume 2.1 speakers */
452
453 /* add HP and speakers */
454 extra_nids = 0;
455 for (i = 0; i < cfg->hp_outs; i++) {
456 dac = get_dac(codec, cfg->hp_pins[i]);
457 if (!dac)
458 break;
459 if (!i)
460 spec->multiout.hp_nid = dac;
461 else
462 spec->multiout.extra_out_nid[extra_nids++] = dac;
463 }
464 for (i = 0; i < cfg->speaker_outs; i++) {
465 dac = get_dac(codec, cfg->speaker_pins[i]);
466 if (!dac)
467 break;
468 spec->multiout.extra_out_nid[extra_nids++] = dac;
469 }
470
471 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
472 cfg->speaker_outs = cfg->line_outs;
473 memcpy(cfg->speaker_pins, cfg->line_out_pins,
474 sizeof(cfg->speaker_pins));
475 cfg->line_outs = 0;
476 memset(cfg->line_out_pins, 0, sizeof(cfg->line_out_pins));
477 }
478
479 return 0;
480 }
481
482 static int parse_input(struct hda_codec *codec)
483 {
484 struct cs_spec *spec = codec->spec;
485 struct auto_pin_cfg *cfg = &spec->autocfg;
486 int i;
487
488 for (i = 0; i < cfg->num_inputs; i++) {
489 hda_nid_t pin = cfg->inputs[i].pin;
490 spec->input_idx[spec->num_inputs] = i;
491 spec->capsrc_idx[i] = spec->num_inputs++;
492 spec->cur_input = i;
493 spec->adc_nid[i] = get_adc(codec, pin, &spec->adc_idx[i]);
494 }
495 if (!spec->num_inputs)
496 return 0;
497
498 /* check whether the automatic mic switch is available */
499 if (spec->num_inputs == 2 &&
500 cfg->inputs[0].type == AUTO_PIN_MIC &&
501 cfg->inputs[1].type == AUTO_PIN_MIC) {
502 if (is_ext_mic(codec, cfg->inputs[0].pin)) {
503 if (!is_ext_mic(codec, cfg->inputs[1].pin)) {
504 spec->mic_detect = 1;
505 spec->automic_idx = 0;
506 }
507 } else {
508 if (is_ext_mic(codec, cfg->inputs[1].pin)) {
509 spec->mic_detect = 1;
510 spec->automic_idx = 1;
511 }
512 }
513 }
514 return 0;
515 }
516
517
518 static int parse_digital_output(struct hda_codec *codec)
519 {
520 struct cs_spec *spec = codec->spec;
521 struct auto_pin_cfg *cfg = &spec->autocfg;
522 hda_nid_t nid;
523
524 if (!cfg->dig_outs)
525 return 0;
526 if (snd_hda_get_connections(codec, cfg->dig_out_pins[0], &nid, 1) < 1)
527 return 0;
528 spec->multiout.dig_out_nid = nid;
529 spec->multiout.share_spdif = 1;
530 if (cfg->dig_outs > 1 &&
531 snd_hda_get_connections(codec, cfg->dig_out_pins[1], &nid, 1) > 0) {
532 spec->slave_dig_outs[0] = nid;
533 codec->slave_dig_outs = spec->slave_dig_outs;
534 }
535 return 0;
536 }
537
538 static int parse_digital_input(struct hda_codec *codec)
539 {
540 struct cs_spec *spec = codec->spec;
541 struct auto_pin_cfg *cfg = &spec->autocfg;
542 int idx;
543
544 if (cfg->dig_in_pin)
545 spec->dig_in = get_adc(codec, cfg->dig_in_pin, &idx);
546 return 0;
547 }
548
549 /*
550 * create mixer controls
551 */
552
553 static const char * const dir_sfx[2] = { "Playback", "Capture" };
554
555 static int add_mute(struct hda_codec *codec, const char *name, int index,
556 unsigned int pval, int dir, struct snd_kcontrol **kctlp)
557 {
558 char tmp[44];
559 struct snd_kcontrol_new knew =
560 HDA_CODEC_MUTE_IDX(tmp, index, 0, 0, HDA_OUTPUT);
561 knew.private_value = pval;
562 snprintf(tmp, sizeof(tmp), "%s %s Switch", name, dir_sfx[dir]);
563 *kctlp = snd_ctl_new1(&knew, codec);
564 (*kctlp)->id.subdevice = HDA_SUBDEV_AMP_FLAG;
565 return snd_hda_ctl_add(codec, 0, *kctlp);
566 }
567
568 static int add_volume(struct hda_codec *codec, const char *name,
569 int index, unsigned int pval, int dir,
570 struct snd_kcontrol **kctlp)
571 {
572 char tmp[44];
573 struct snd_kcontrol_new knew =
574 HDA_CODEC_VOLUME_IDX(tmp, index, 0, 0, HDA_OUTPUT);
575 knew.private_value = pval;
576 snprintf(tmp, sizeof(tmp), "%s %s Volume", name, dir_sfx[dir]);
577 *kctlp = snd_ctl_new1(&knew, codec);
578 (*kctlp)->id.subdevice = HDA_SUBDEV_AMP_FLAG;
579 return snd_hda_ctl_add(codec, 0, *kctlp);
580 }
581
582 static void fix_volume_caps(struct hda_codec *codec, hda_nid_t dac)
583 {
584 unsigned int caps;
585
586 /* set the upper-limit for mixer amp to 0dB */
587 caps = query_amp_caps(codec, dac, HDA_OUTPUT);
588 caps &= ~(0x7f << AC_AMPCAP_NUM_STEPS_SHIFT);
589 caps |= ((caps >> AC_AMPCAP_OFFSET_SHIFT) & 0x7f)
590 << AC_AMPCAP_NUM_STEPS_SHIFT;
591 snd_hda_override_amp_caps(codec, dac, HDA_OUTPUT, caps);
592 }
593
594 static int add_vmaster(struct hda_codec *codec, hda_nid_t dac)
595 {
596 struct cs_spec *spec = codec->spec;
597 unsigned int tlv[4];
598 int err;
599
600 spec->vmaster_sw =
601 snd_ctl_make_virtual_master("Master Playback Switch", NULL);
602 err = snd_hda_ctl_add(codec, dac, spec->vmaster_sw);
603 if (err < 0)
604 return err;
605
606 snd_hda_set_vmaster_tlv(codec, dac, HDA_OUTPUT, tlv);
607 spec->vmaster_vol =
608 snd_ctl_make_virtual_master("Master Playback Volume", tlv);
609 err = snd_hda_ctl_add(codec, dac, spec->vmaster_vol);
610 if (err < 0)
611 return err;
612 return 0;
613 }
614
615 static int add_output(struct hda_codec *codec, hda_nid_t dac, int idx,
616 int num_ctls, int type)
617 {
618 struct cs_spec *spec = codec->spec;
619 const char *name;
620 int err, index;
621 struct snd_kcontrol *kctl;
622 static const char * const speakers[] = {
623 "Front Speaker", "Surround Speaker", "Bass Speaker"
624 };
625 static const char * const line_outs[] = {
626 "Front Line Out", "Surround Line Out", "Bass Line Out"
627 };
628
629 fix_volume_caps(codec, dac);
630 if (!spec->vmaster_sw) {
631 err = add_vmaster(codec, dac);
632 if (err < 0)
633 return err;
634 }
635
636 index = 0;
637 switch (type) {
638 case AUTO_PIN_HP_OUT:
639 name = "Headphone";
640 index = idx;
641 break;
642 case AUTO_PIN_SPEAKER_OUT:
643 if (spec->speaker_2_1)
644 name = idx ? "Bass Speaker" : "Speaker";
645 else if (num_ctls > 1)
646 name = speakers[idx];
647 else
648 name = "Speaker";
649 break;
650 default:
651 if (num_ctls > 1)
652 name = line_outs[idx];
653 else
654 name = "Line Out";
655 break;
656 }
657
658 err = add_mute(codec, name, index,
659 HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
660 if (err < 0)
661 return err;
662 err = snd_ctl_add_slave(spec->vmaster_sw, kctl);
663 if (err < 0)
664 return err;
665
666 err = add_volume(codec, name, index,
667 HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
668 if (err < 0)
669 return err;
670 err = snd_ctl_add_slave(spec->vmaster_vol, kctl);
671 if (err < 0)
672 return err;
673
674 return 0;
675 }
676
677 static int build_output(struct hda_codec *codec)
678 {
679 struct cs_spec *spec = codec->spec;
680 struct auto_pin_cfg *cfg = &spec->autocfg;
681 int i, err;
682
683 for (i = 0; i < cfg->line_outs; i++) {
684 err = add_output(codec, get_dac(codec, cfg->line_out_pins[i]),
685 i, cfg->line_outs, cfg->line_out_type);
686 if (err < 0)
687 return err;
688 }
689 for (i = 0; i < cfg->hp_outs; i++) {
690 err = add_output(codec, get_dac(codec, cfg->hp_pins[i]),
691 i, cfg->hp_outs, AUTO_PIN_HP_OUT);
692 if (err < 0)
693 return err;
694 }
695 for (i = 0; i < cfg->speaker_outs; i++) {
696 err = add_output(codec, get_dac(codec, cfg->speaker_pins[i]),
697 i, cfg->speaker_outs, AUTO_PIN_SPEAKER_OUT);
698 if (err < 0)
699 return err;
700 }
701 return 0;
702 }
703
704 /*
705 */
706
707 static const struct snd_kcontrol_new cs_capture_ctls[] = {
708 HDA_BIND_SW("Capture Switch", 0),
709 HDA_BIND_VOL("Capture Volume", 0),
710 };
711
712 static int change_cur_input(struct hda_codec *codec, unsigned int idx,
713 int force)
714 {
715 struct cs_spec *spec = codec->spec;
716
717 if (spec->cur_input == idx && !force)
718 return 0;
719 if (spec->cur_adc && spec->cur_adc != spec->adc_nid[idx]) {
720 /* stream is running, let's swap the current ADC */
721 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
722 spec->cur_adc = spec->adc_nid[idx];
723 snd_hda_codec_setup_stream(codec, spec->cur_adc,
724 spec->cur_adc_stream_tag, 0,
725 spec->cur_adc_format);
726 }
727 spec->cur_input = idx;
728 cs_update_input_select(codec);
729 return 1;
730 }
731
732 static int cs_capture_source_info(struct snd_kcontrol *kcontrol,
733 struct snd_ctl_elem_info *uinfo)
734 {
735 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
736 struct cs_spec *spec = codec->spec;
737 struct auto_pin_cfg *cfg = &spec->autocfg;
738 unsigned int idx;
739
740 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
741 uinfo->count = 1;
742 uinfo->value.enumerated.items = spec->num_inputs;
743 if (uinfo->value.enumerated.item >= spec->num_inputs)
744 uinfo->value.enumerated.item = spec->num_inputs - 1;
745 idx = spec->input_idx[uinfo->value.enumerated.item];
746 snd_hda_get_pin_label(codec, cfg->inputs[idx].pin, cfg,
747 uinfo->value.enumerated.name,
748 sizeof(uinfo->value.enumerated.name), NULL);
749 return 0;
750 }
751
752 static int cs_capture_source_get(struct snd_kcontrol *kcontrol,
753 struct snd_ctl_elem_value *ucontrol)
754 {
755 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
756 struct cs_spec *spec = codec->spec;
757 ucontrol->value.enumerated.item[0] = spec->capsrc_idx[spec->cur_input];
758 return 0;
759 }
760
761 static int cs_capture_source_put(struct snd_kcontrol *kcontrol,
762 struct snd_ctl_elem_value *ucontrol)
763 {
764 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
765 struct cs_spec *spec = codec->spec;
766 unsigned int idx = ucontrol->value.enumerated.item[0];
767
768 if (idx >= spec->num_inputs)
769 return -EINVAL;
770 idx = spec->input_idx[idx];
771 return change_cur_input(codec, idx, 0);
772 }
773
774 static const struct snd_kcontrol_new cs_capture_source = {
775 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
776 .name = "Capture Source",
777 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
778 .info = cs_capture_source_info,
779 .get = cs_capture_source_get,
780 .put = cs_capture_source_put,
781 };
782
783 static const struct hda_bind_ctls *make_bind_capture(struct hda_codec *codec,
784 struct hda_ctl_ops *ops)
785 {
786 struct cs_spec *spec = codec->spec;
787 struct hda_bind_ctls *bind;
788 int i, n;
789
790 bind = kzalloc(sizeof(*bind) + sizeof(long) * (spec->num_inputs + 1),
791 GFP_KERNEL);
792 if (!bind)
793 return NULL;
794 bind->ops = ops;
795 n = 0;
796 for (i = 0; i < AUTO_PIN_LAST; i++) {
797 if (!spec->adc_nid[i])
798 continue;
799 bind->values[n++] =
800 HDA_COMPOSE_AMP_VAL(spec->adc_nid[i], 3,
801 spec->adc_idx[i], HDA_INPUT);
802 }
803 return bind;
804 }
805
806 /* add a (input-boost) volume control to the given input pin */
807 static int add_input_volume_control(struct hda_codec *codec,
808 struct auto_pin_cfg *cfg,
809 int item)
810 {
811 hda_nid_t pin = cfg->inputs[item].pin;
812 u32 caps;
813 const char *label;
814 struct snd_kcontrol *kctl;
815
816 if (!(get_wcaps(codec, pin) & AC_WCAP_IN_AMP))
817 return 0;
818 caps = query_amp_caps(codec, pin, HDA_INPUT);
819 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
820 if (caps <= 1)
821 return 0;
822 label = hda_get_autocfg_input_label(codec, cfg, item);
823 return add_volume(codec, label, 0,
824 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT), 1, &kctl);
825 }
826
827 static int build_input(struct hda_codec *codec)
828 {
829 struct cs_spec *spec = codec->spec;
830 int i, err;
831
832 if (!spec->num_inputs)
833 return 0;
834
835 /* make bind-capture */
836 spec->capture_bind[0] = make_bind_capture(codec, &snd_hda_bind_sw);
837 spec->capture_bind[1] = make_bind_capture(codec, &snd_hda_bind_vol);
838 for (i = 0; i < 2; i++) {
839 struct snd_kcontrol *kctl;
840 int n;
841 if (!spec->capture_bind[i])
842 return -ENOMEM;
843 kctl = snd_ctl_new1(&cs_capture_ctls[i], codec);
844 if (!kctl)
845 return -ENOMEM;
846 kctl->private_value = (long)spec->capture_bind[i];
847 err = snd_hda_ctl_add(codec, 0, kctl);
848 if (err < 0)
849 return err;
850 for (n = 0; n < AUTO_PIN_LAST; n++) {
851 if (!spec->adc_nid[n])
852 continue;
853 err = snd_hda_add_nid(codec, kctl, 0, spec->adc_nid[n]);
854 if (err < 0)
855 return err;
856 }
857 }
858
859 if (spec->num_inputs > 1 && !spec->mic_detect) {
860 err = snd_hda_ctl_add(codec, 0,
861 snd_ctl_new1(&cs_capture_source, codec));
862 if (err < 0)
863 return err;
864 }
865
866 for (i = 0; i < spec->num_inputs; i++) {
867 err = add_input_volume_control(codec, &spec->autocfg, i);
868 if (err < 0)
869 return err;
870 }
871
872 return 0;
873 }
874
875 /*
876 */
877
878 static int build_digital_output(struct hda_codec *codec)
879 {
880 struct cs_spec *spec = codec->spec;
881 int err;
882
883 if (!spec->multiout.dig_out_nid)
884 return 0;
885
886 err = snd_hda_create_dig_out_ctls(codec, spec->multiout.dig_out_nid,
887 spec->multiout.dig_out_nid,
888 spec->pcm_rec[1].pcm_type);
889 if (err < 0)
890 return err;
891 err = snd_hda_create_spdif_share_sw(codec, &spec->multiout);
892 if (err < 0)
893 return err;
894 return 0;
895 }
896
897 static int build_digital_input(struct hda_codec *codec)
898 {
899 struct cs_spec *spec = codec->spec;
900 if (spec->dig_in)
901 return snd_hda_create_spdif_in_ctls(codec, spec->dig_in);
902 return 0;
903 }
904
905 /*
906 * auto-mute and auto-mic switching
907 * CS421x auto-output redirecting
908 * HP/SPK/SPDIF
909 */
910
911 static void cs_automute(struct hda_codec *codec, struct hda_jack_tbl *tbl)
912 {
913 struct cs_spec *spec = codec->spec;
914 struct auto_pin_cfg *cfg = &spec->autocfg;
915 unsigned int hp_present;
916 unsigned int spdif_present;
917 hda_nid_t nid;
918 int i;
919
920 spdif_present = 0;
921 if (cfg->dig_outs) {
922 nid = cfg->dig_out_pins[0];
923 if (is_jack_detectable(codec, nid)) {
924 /*
925 TODO: SPDIF output redirect when SENSE_B is enabled.
926 Shared (SENSE_A) jack (e.g HP/mini-TOSLINK)
927 assumed.
928 */
929 if (snd_hda_jack_detect(codec, nid)
930 /* && spec->sense_b */)
931 spdif_present = 1;
932 }
933 }
934
935 hp_present = 0;
936 for (i = 0; i < cfg->hp_outs; i++) {
937 nid = cfg->hp_pins[i];
938 if (!is_jack_detectable(codec, nid))
939 continue;
940 hp_present = snd_hda_jack_detect(codec, nid);
941 if (hp_present)
942 break;
943 }
944
945 /* mute speakers if spdif or hp jack is plugged in */
946 for (i = 0; i < cfg->speaker_outs; i++) {
947 int pin_ctl = hp_present ? 0 : PIN_OUT;
948 /* detect on spdif is specific to CS4210 */
949 if (spdif_present && (spec->vendor_nid == CS4210_VENDOR_NID))
950 pin_ctl = 0;
951
952 nid = cfg->speaker_pins[i];
953 snd_hda_set_pin_ctl(codec, nid, pin_ctl);
954 }
955 if (spec->gpio_eapd_hp) {
956 unsigned int gpio = hp_present ?
957 spec->gpio_eapd_hp : spec->gpio_eapd_speaker;
958 snd_hda_codec_write(codec, 0x01, 0,
959 AC_VERB_SET_GPIO_DATA, gpio);
960 }
961
962 /* specific to CS4210 */
963 if (spec->vendor_nid == CS4210_VENDOR_NID) {
964 /* mute HPs if spdif jack (SENSE_B) is present */
965 for (i = 0; i < cfg->hp_outs; i++) {
966 nid = cfg->hp_pins[i];
967 snd_hda_set_pin_ctl(codec, nid,
968 (spdif_present && spec->sense_b) ? 0 : PIN_HP);
969 }
970
971 /* SPDIF TX on/off */
972 if (cfg->dig_outs) {
973 nid = cfg->dig_out_pins[0];
974 snd_hda_set_pin_ctl(codec, nid,
975 spdif_present ? PIN_OUT : 0);
976
977 }
978 /* Update board GPIOs if neccessary ... */
979 }
980 }
981
982 /*
983 * Auto-input redirect for CS421x
984 * Switch max 3 inputs of a single ADC (nid 3)
985 */
986
987 static void cs_automic(struct hda_codec *codec, struct hda_jack_tbl *tbl)
988 {
989 struct cs_spec *spec = codec->spec;
990 struct auto_pin_cfg *cfg = &spec->autocfg;
991 hda_nid_t nid;
992 unsigned int present;
993
994 nid = cfg->inputs[spec->automic_idx].pin;
995 present = snd_hda_jack_detect(codec, nid);
996
997 /* specific to CS421x, single ADC */
998 if (spec->vendor_nid == CS420X_VENDOR_NID) {
999 if (present)
1000 change_cur_input(codec, spec->automic_idx, 0);
1001 else
1002 change_cur_input(codec, !spec->automic_idx, 0);
1003 } else {
1004 if (present) {
1005 if (spec->cur_input != spec->automic_idx) {
1006 spec->last_input = spec->cur_input;
1007 spec->cur_input = spec->automic_idx;
1008 }
1009 } else {
1010 spec->cur_input = spec->last_input;
1011 }
1012 cs_update_input_select(codec);
1013 }
1014 }
1015
1016 /*
1017 */
1018
1019 static void init_output(struct hda_codec *codec)
1020 {
1021 struct cs_spec *spec = codec->spec;
1022 struct auto_pin_cfg *cfg = &spec->autocfg;
1023 int i;
1024
1025 /* mute first */
1026 for (i = 0; i < spec->multiout.num_dacs; i++)
1027 snd_hda_codec_write(codec, spec->multiout.dac_nids[i], 0,
1028 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
1029 if (spec->multiout.hp_nid)
1030 snd_hda_codec_write(codec, spec->multiout.hp_nid, 0,
1031 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
1032 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
1033 if (!spec->multiout.extra_out_nid[i])
1034 break;
1035 snd_hda_codec_write(codec, spec->multiout.extra_out_nid[i], 0,
1036 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
1037 }
1038
1039 /* set appropriate pin controls */
1040 for (i = 0; i < cfg->line_outs; i++)
1041 snd_hda_set_pin_ctl(codec, cfg->line_out_pins[i], PIN_OUT);
1042 /* HP */
1043 for (i = 0; i < cfg->hp_outs; i++) {
1044 hda_nid_t nid = cfg->hp_pins[i];
1045 snd_hda_set_pin_ctl(codec, nid, PIN_HP);
1046 if (!cfg->speaker_outs)
1047 continue;
1048 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
1049 snd_hda_jack_detect_enable_callback(codec, nid, HP_EVENT, cs_automute);
1050 spec->hp_detect = 1;
1051 }
1052 }
1053
1054 /* Speaker */
1055 for (i = 0; i < cfg->speaker_outs; i++)
1056 snd_hda_set_pin_ctl(codec, cfg->speaker_pins[i], PIN_OUT);
1057
1058 /* SPDIF is enabled on presence detect for CS421x */
1059 if (spec->hp_detect || spec->spdif_detect)
1060 cs_automute(codec, NULL);
1061 }
1062
1063 static void init_input(struct hda_codec *codec)
1064 {
1065 struct cs_spec *spec = codec->spec;
1066 struct auto_pin_cfg *cfg = &spec->autocfg;
1067 unsigned int coef;
1068 int i;
1069
1070 for (i = 0; i < cfg->num_inputs; i++) {
1071 unsigned int ctl;
1072 hda_nid_t pin = cfg->inputs[i].pin;
1073 if (!spec->adc_nid[i])
1074 continue;
1075 /* set appropriate pin control and mute first */
1076 ctl = PIN_IN;
1077 if (cfg->inputs[i].type == AUTO_PIN_MIC)
1078 ctl |= snd_hda_get_default_vref(codec, pin);
1079 snd_hda_set_pin_ctl(codec, pin, ctl);
1080 snd_hda_codec_write(codec, spec->adc_nid[i], 0,
1081 AC_VERB_SET_AMP_GAIN_MUTE,
1082 AMP_IN_MUTE(spec->adc_idx[i]));
1083 if (spec->mic_detect && spec->automic_idx == i)
1084 snd_hda_jack_detect_enable_callback(codec, pin, MIC_EVENT, cs_automic);
1085 }
1086 /* CS420x has multiple ADC, CS421x has single ADC */
1087 if (spec->vendor_nid == CS420X_VENDOR_NID) {
1088 change_cur_input(codec, spec->cur_input, 1);
1089 if (spec->mic_detect)
1090 cs_automic(codec, NULL);
1091
1092 coef = cs_vendor_coef_get(codec, IDX_BEEP_CFG);
1093 if (is_active_pin(codec, CS_DMIC2_PIN_NID))
1094 coef |= 1 << 4; /* DMIC2 2 chan on, GPIO1 off */
1095 if (is_active_pin(codec, CS_DMIC1_PIN_NID))
1096 coef |= 1 << 3; /* DMIC1 2 chan on, GPIO0 off
1097 * No effect if SPDIF_OUT2 is
1098 * selected in IDX_SPDIF_CTL.
1099 */
1100
1101 cs_vendor_coef_set(codec, IDX_BEEP_CFG, coef);
1102 } else {
1103 if (spec->mic_detect)
1104 cs_automic(codec, NULL);
1105 else {
1106 spec->cur_adc = spec->adc_nid[spec->cur_input];
1107 cs_update_input_select(codec);
1108 }
1109 }
1110 }
1111
1112 static const struct hda_verb cs_coef_init_verbs[] = {
1113 {0x11, AC_VERB_SET_PROC_STATE, 1},
1114 {0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG},
1115 {0x11, AC_VERB_SET_PROC_COEF,
1116 (0x002a /* DAC1/2/3 SZCMode Soft Ramp */
1117 | 0x0040 /* Mute DACs on FIFO error */
1118 | 0x1000 /* Enable DACs High Pass Filter */
1119 | 0x0400 /* Disable Coefficient Auto increment */
1120 )},
1121 /* ADC1/2 - Digital and Analog Soft Ramp */
1122 {0x11, AC_VERB_SET_COEF_INDEX, IDX_ADC_CFG},
1123 {0x11, AC_VERB_SET_PROC_COEF, 0x000a},
1124 /* Beep */
1125 {0x11, AC_VERB_SET_COEF_INDEX, IDX_BEEP_CFG},
1126 {0x11, AC_VERB_SET_PROC_COEF, 0x0007}, /* Enable Beep thru DAC1/2/3 */
1127
1128 {} /* terminator */
1129 };
1130
1131 /* Errata: CS4207 rev C0/C1/C2 Silicon
1132 *
1133 * http://www.cirrus.com/en/pubs/errata/ER880C3.pdf
1134 *
1135 * 6. At high temperature (TA > +85°C), the digital supply current (IVD)
1136 * may be excessive (up to an additional 200 μA), which is most easily
1137 * observed while the part is being held in reset (RESET# active low).
1138 *
1139 * Root Cause: At initial powerup of the device, the logic that drives
1140 * the clock and write enable to the S/PDIF SRC RAMs is not properly
1141 * initialized.
1142 * Certain random patterns will cause a steady leakage current in those
1143 * RAM cells. The issue will resolve once the SRCs are used (turned on).
1144 *
1145 * Workaround: The following verb sequence briefly turns on the S/PDIF SRC
1146 * blocks, which will alleviate the issue.
1147 */
1148
1149 static const struct hda_verb cs_errata_init_verbs[] = {
1150 {0x01, AC_VERB_SET_POWER_STATE, 0x00}, /* AFG: D0 */
1151 {0x11, AC_VERB_SET_PROC_STATE, 0x01}, /* VPW: processing on */
1152
1153 {0x11, AC_VERB_SET_COEF_INDEX, 0x0008},
1154 {0x11, AC_VERB_SET_PROC_COEF, 0x9999},
1155 {0x11, AC_VERB_SET_COEF_INDEX, 0x0017},
1156 {0x11, AC_VERB_SET_PROC_COEF, 0xa412},
1157 {0x11, AC_VERB_SET_COEF_INDEX, 0x0001},
1158 {0x11, AC_VERB_SET_PROC_COEF, 0x0009},
1159
1160 {0x07, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Rx: D0 */
1161 {0x08, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Tx: D0 */
1162
1163 {0x11, AC_VERB_SET_COEF_INDEX, 0x0017},
1164 {0x11, AC_VERB_SET_PROC_COEF, 0x2412},
1165 {0x11, AC_VERB_SET_COEF_INDEX, 0x0008},
1166 {0x11, AC_VERB_SET_PROC_COEF, 0x0000},
1167 {0x11, AC_VERB_SET_COEF_INDEX, 0x0001},
1168 {0x11, AC_VERB_SET_PROC_COEF, 0x0008},
1169 {0x11, AC_VERB_SET_PROC_STATE, 0x00},
1170
1171 #if 0 /* Don't to set to D3 as we are in power-up sequence */
1172 {0x07, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Rx: D3 */
1173 {0x08, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Tx: D3 */
1174 /*{0x01, AC_VERB_SET_POWER_STATE, 0x03},*/ /* AFG: D3 This is already handled */
1175 #endif
1176
1177 {} /* terminator */
1178 };
1179
1180 /* SPDIF setup */
1181 static void init_digital(struct hda_codec *codec)
1182 {
1183 unsigned int coef;
1184
1185 coef = 0x0002; /* SRC_MUTE soft-mute on SPDIF (if no lock) */
1186 coef |= 0x0008; /* Replace with mute on error */
1187 if (is_active_pin(codec, CS_DIG_OUT2_PIN_NID))
1188 coef |= 0x4000; /* RX to TX1 or TX2 Loopthru / SPDIF2
1189 * SPDIF_OUT2 is shared with GPIO1 and
1190 * DMIC_SDA2.
1191 */
1192 cs_vendor_coef_set(codec, IDX_SPDIF_CTL, coef);
1193 }
1194
1195 static int cs_init(struct hda_codec *codec)
1196 {
1197 struct cs_spec *spec = codec->spec;
1198
1199 /* init_verb sequence for C0/C1/C2 errata*/
1200 snd_hda_sequence_write(codec, cs_errata_init_verbs);
1201
1202 snd_hda_sequence_write(codec, cs_coef_init_verbs);
1203
1204 snd_hda_gen_apply_verbs(codec);
1205
1206 if (spec->gpio_mask) {
1207 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
1208 spec->gpio_mask);
1209 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
1210 spec->gpio_dir);
1211 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1212 spec->gpio_data);
1213 }
1214
1215 init_output(codec);
1216 init_input(codec);
1217 init_digital(codec);
1218
1219 return 0;
1220 }
1221
1222 static int cs_build_controls(struct hda_codec *codec)
1223 {
1224 struct cs_spec *spec = codec->spec;
1225 int err;
1226
1227 err = build_output(codec);
1228 if (err < 0)
1229 return err;
1230 err = build_input(codec);
1231 if (err < 0)
1232 return err;
1233 err = build_digital_output(codec);
1234 if (err < 0)
1235 return err;
1236 err = build_digital_input(codec);
1237 if (err < 0)
1238 return err;
1239 err = cs_init(codec);
1240 if (err < 0)
1241 return err;
1242
1243 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
1244 if (err < 0)
1245 return err;
1246
1247 return 0;
1248 }
1249
1250 static void cs_free(struct hda_codec *codec)
1251 {
1252 struct cs_spec *spec = codec->spec;
1253 kfree(spec->capture_bind[0]);
1254 kfree(spec->capture_bind[1]);
1255 snd_hda_gen_free(&spec->gen);
1256 kfree(codec->spec);
1257 }
1258
1259 static const struct hda_codec_ops cs_patch_ops = {
1260 .build_controls = cs_build_controls,
1261 .build_pcms = cs_build_pcms,
1262 .init = cs_init,
1263 .free = cs_free,
1264 .unsol_event = snd_hda_jack_unsol_event,
1265 };
1266
1267 static int cs_parse_auto_config(struct hda_codec *codec)
1268 {
1269 struct cs_spec *spec = codec->spec;
1270 int err;
1271
1272 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1273 if (err < 0)
1274 return err;
1275
1276 err = parse_output(codec);
1277 if (err < 0)
1278 return err;
1279 err = parse_input(codec);
1280 if (err < 0)
1281 return err;
1282 err = parse_digital_output(codec);
1283 if (err < 0)
1284 return err;
1285 err = parse_digital_input(codec);
1286 if (err < 0)
1287 return err;
1288 return 0;
1289 }
1290
1291 static const struct hda_model_fixup cs420x_models[] = {
1292 { .id = CS420X_MBP53, .name = "mbp53" },
1293 { .id = CS420X_MBP55, .name = "mbp55" },
1294 { .id = CS420X_IMAC27, .name = "imac27" },
1295 { .id = CS420X_IMAC27_122, .name = "imac27_122" },
1296 { .id = CS420X_APPLE, .name = "apple" },
1297 { .id = CS420X_MBP101, .name = "mbp101" },
1298 { .id = CS420X_MBP81, .name = "mbp81" },
1299 {}
1300 };
1301
1302 static const struct snd_pci_quirk cs420x_fixup_tbl[] = {
1303 SND_PCI_QUIRK(0x10de, 0x0ac0, "MacBookPro 5,3", CS420X_MBP53),
1304 SND_PCI_QUIRK(0x10de, 0x0d94, "MacBookAir 3,1(2)", CS420X_MBP55),
1305 SND_PCI_QUIRK(0x10de, 0xcb79, "MacBookPro 5,5", CS420X_MBP55),
1306 SND_PCI_QUIRK(0x10de, 0xcb89, "MacBookPro 7,1", CS420X_MBP55),
1307 /* this conflicts with too many other models */
1308 /*SND_PCI_QUIRK(0x8086, 0x7270, "IMac 27 Inch", CS420X_IMAC27),*/
1309
1310 /* codec SSID */
1311 SND_PCI_QUIRK(0x106b, 0x1c00, "MacBookPro 8,1", CS420X_MBP81),
1312 SND_PCI_QUIRK(0x106b, 0x2000, "iMac 12,2", CS420X_IMAC27_122),
1313 SND_PCI_QUIRK(0x106b, 0x2800, "MacBookPro 10,1", CS420X_MBP101),
1314 SND_PCI_QUIRK_VENDOR(0x106b, "Apple", CS420X_APPLE),
1315 {} /* terminator */
1316 };
1317
1318 static const struct hda_pintbl mbp53_pincfgs[] = {
1319 { 0x09, 0x012b4050 },
1320 { 0x0a, 0x90100141 },
1321 { 0x0b, 0x90100140 },
1322 { 0x0c, 0x018b3020 },
1323 { 0x0d, 0x90a00110 },
1324 { 0x0e, 0x400000f0 },
1325 { 0x0f, 0x01cbe030 },
1326 { 0x10, 0x014be060 },
1327 { 0x12, 0x400000f0 },
1328 { 0x15, 0x400000f0 },
1329 {} /* terminator */
1330 };
1331
1332 static const struct hda_pintbl mbp55_pincfgs[] = {
1333 { 0x09, 0x012b4030 },
1334 { 0x0a, 0x90100121 },
1335 { 0x0b, 0x90100120 },
1336 { 0x0c, 0x400000f0 },
1337 { 0x0d, 0x90a00110 },
1338 { 0x0e, 0x400000f0 },
1339 { 0x0f, 0x400000f0 },
1340 { 0x10, 0x014be040 },
1341 { 0x12, 0x400000f0 },
1342 { 0x15, 0x400000f0 },
1343 {} /* terminator */
1344 };
1345
1346 static const struct hda_pintbl imac27_pincfgs[] = {
1347 { 0x09, 0x012b4050 },
1348 { 0x0a, 0x90100140 },
1349 { 0x0b, 0x90100142 },
1350 { 0x0c, 0x018b3020 },
1351 { 0x0d, 0x90a00110 },
1352 { 0x0e, 0x400000f0 },
1353 { 0x0f, 0x01cbe030 },
1354 { 0x10, 0x014be060 },
1355 { 0x12, 0x01ab9070 },
1356 { 0x15, 0x400000f0 },
1357 {} /* terminator */
1358 };
1359
1360 static const struct hda_pintbl mbp101_pincfgs[] = {
1361 { 0x0d, 0x40ab90f0 },
1362 { 0x0e, 0x90a600f0 },
1363 { 0x12, 0x50a600f0 },
1364 {} /* terminator */
1365 };
1366
1367 static void cs420x_fixup_gpio_13(struct hda_codec *codec,
1368 const struct hda_fixup *fix, int action)
1369 {
1370 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1371 struct cs_spec *spec = codec->spec;
1372 spec->gpio_eapd_hp = 2; /* GPIO1 = headphones */
1373 spec->gpio_eapd_speaker = 8; /* GPIO3 = speakers */
1374 spec->gpio_mask = spec->gpio_dir =
1375 spec->gpio_eapd_hp | spec->gpio_eapd_speaker;
1376 }
1377 }
1378
1379 static void cs420x_fixup_gpio_23(struct hda_codec *codec,
1380 const struct hda_fixup *fix, int action)
1381 {
1382 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1383 struct cs_spec *spec = codec->spec;
1384 spec->gpio_eapd_hp = 4; /* GPIO2 = headphones */
1385 spec->gpio_eapd_speaker = 8; /* GPIO3 = speakers */
1386 spec->gpio_mask = spec->gpio_dir =
1387 spec->gpio_eapd_hp | spec->gpio_eapd_speaker;
1388 }
1389 }
1390
1391 static const struct hda_fixup cs420x_fixups[] = {
1392 [CS420X_MBP53] = {
1393 .type = HDA_FIXUP_PINS,
1394 .v.pins = mbp53_pincfgs,
1395 .chained = true,
1396 .chain_id = CS420X_APPLE,
1397 },
1398 [CS420X_MBP55] = {
1399 .type = HDA_FIXUP_PINS,
1400 .v.pins = mbp55_pincfgs,
1401 .chained = true,
1402 .chain_id = CS420X_GPIO_13,
1403 },
1404 [CS420X_IMAC27] = {
1405 .type = HDA_FIXUP_PINS,
1406 .v.pins = imac27_pincfgs,
1407 .chained = true,
1408 .chain_id = CS420X_GPIO_13,
1409 },
1410 [CS420X_GPIO_13] = {
1411 .type = HDA_FIXUP_FUNC,
1412 .v.func = cs420x_fixup_gpio_13,
1413 },
1414 [CS420X_GPIO_23] = {
1415 .type = HDA_FIXUP_FUNC,
1416 .v.func = cs420x_fixup_gpio_23,
1417 },
1418 [CS420X_MBP101] = {
1419 .type = HDA_FIXUP_PINS,
1420 .v.pins = mbp101_pincfgs,
1421 .chained = true,
1422 .chain_id = CS420X_GPIO_13,
1423 },
1424 [CS420X_MBP81] = {
1425 .type = HDA_FIXUP_VERBS,
1426 .v.verbs = (const struct hda_verb[]) {
1427 /* internal mic ADC2: right only, single ended */
1428 {0x11, AC_VERB_SET_COEF_INDEX, IDX_ADC_CFG},
1429 {0x11, AC_VERB_SET_PROC_COEF, 0x102a},
1430 {}
1431 },
1432 .chained = true,
1433 .chain_id = CS420X_GPIO_13,
1434 },
1435 };
1436
1437 static int patch_cs420x(struct hda_codec *codec)
1438 {
1439 struct cs_spec *spec;
1440 int err;
1441
1442 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1443 if (!spec)
1444 return -ENOMEM;
1445 codec->spec = spec;
1446 snd_hda_gen_init(&spec->gen);
1447
1448 spec->vendor_nid = CS420X_VENDOR_NID;
1449
1450 snd_hda_pick_fixup(codec, cs420x_models, cs420x_fixup_tbl,
1451 cs420x_fixups);
1452 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1453
1454 err = cs_parse_auto_config(codec);
1455 if (err < 0)
1456 goto error;
1457
1458 codec->patch_ops = cs_patch_ops;
1459
1460 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1461
1462 return 0;
1463
1464 error:
1465 cs_free(codec);
1466 codec->spec = NULL;
1467 return err;
1468 }
1469
1470 /*
1471 * Cirrus Logic CS4210
1472 *
1473 * 1 DAC => HP(sense) / Speakers,
1474 * 1 ADC <= LineIn(sense) / MicIn / DMicIn,
1475 * 1 SPDIF OUT => SPDIF Trasmitter(sense)
1476 */
1477
1478 /* CS4210 board names */
1479 static const struct hda_model_fixup cs421x_models[] = {
1480 { .id = CS421X_CDB4210, .name = "cdb4210" },
1481 {}
1482 };
1483
1484 static const struct snd_pci_quirk cs421x_fixup_tbl[] = {
1485 /* Test Intel board + CDB2410 */
1486 SND_PCI_QUIRK(0x8086, 0x5001, "DP45SG/CDB4210", CS421X_CDB4210),
1487 {} /* terminator */
1488 };
1489
1490 /* CS4210 board pinconfigs */
1491 /* Default CS4210 (CDB4210)*/
1492 static const struct hda_pintbl cdb4210_pincfgs[] = {
1493 { 0x05, 0x0321401f },
1494 { 0x06, 0x90170010 },
1495 { 0x07, 0x03813031 },
1496 { 0x08, 0xb7a70037 },
1497 { 0x09, 0xb7a6003e },
1498 { 0x0a, 0x034510f0 },
1499 {} /* terminator */
1500 };
1501
1502 /* Setup GPIO/SENSE for each board (if used) */
1503 static void cs421x_fixup_sense_b(struct hda_codec *codec,
1504 const struct hda_fixup *fix, int action)
1505 {
1506 struct cs_spec *spec = codec->spec;
1507 if (action == HDA_FIXUP_ACT_PRE_PROBE)
1508 spec->sense_b = 1;
1509 }
1510
1511 static const struct hda_fixup cs421x_fixups[] = {
1512 [CS421X_CDB4210] = {
1513 .type = HDA_FIXUP_PINS,
1514 .v.pins = cdb4210_pincfgs,
1515 .chained = true,
1516 .chain_id = CS421X_SENSE_B,
1517 },
1518 [CS421X_SENSE_B] = {
1519 .type = HDA_FIXUP_FUNC,
1520 .v.func = cs421x_fixup_sense_b,
1521 }
1522 };
1523
1524 static const struct hda_verb cs421x_coef_init_verbs[] = {
1525 {0x0B, AC_VERB_SET_PROC_STATE, 1},
1526 {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_DEV_CFG},
1527 /*
1528 Disable Coefficient Index Auto-Increment(DAI)=1,
1529 PDREF=0
1530 */
1531 {0x0B, AC_VERB_SET_PROC_COEF, 0x0001 },
1532
1533 {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_ADC_CFG},
1534 /* ADC SZCMode = Digital Soft Ramp */
1535 {0x0B, AC_VERB_SET_PROC_COEF, 0x0002 },
1536
1537 {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_DAC_CFG},
1538 {0x0B, AC_VERB_SET_PROC_COEF,
1539 (0x0002 /* DAC SZCMode = Digital Soft Ramp */
1540 | 0x0004 /* Mute DAC on FIFO error */
1541 | 0x0008 /* Enable DAC High Pass Filter */
1542 )},
1543 {} /* terminator */
1544 };
1545
1546 /* Errata: CS4210 rev A1 Silicon
1547 *
1548 * http://www.cirrus.com/en/pubs/errata/
1549 *
1550 * Description:
1551 * 1. Performance degredation is present in the ADC.
1552 * 2. Speaker output is not completely muted upon HP detect.
1553 * 3. Noise is present when clipping occurs on the amplified
1554 * speaker outputs.
1555 *
1556 * Workaround:
1557 * The following verb sequence written to the registers during
1558 * initialization will correct the issues listed above.
1559 */
1560
1561 static const struct hda_verb cs421x_coef_init_verbs_A1_silicon_fixes[] = {
1562 {0x0B, AC_VERB_SET_PROC_STATE, 0x01}, /* VPW: processing on */
1563
1564 {0x0B, AC_VERB_SET_COEF_INDEX, 0x0006},
1565 {0x0B, AC_VERB_SET_PROC_COEF, 0x9999}, /* Test mode: on */
1566
1567 {0x0B, AC_VERB_SET_COEF_INDEX, 0x000A},
1568 {0x0B, AC_VERB_SET_PROC_COEF, 0x14CB}, /* Chop double */
1569
1570 {0x0B, AC_VERB_SET_COEF_INDEX, 0x0011},
1571 {0x0B, AC_VERB_SET_PROC_COEF, 0xA2D0}, /* Increase ADC current */
1572
1573 {0x0B, AC_VERB_SET_COEF_INDEX, 0x001A},
1574 {0x0B, AC_VERB_SET_PROC_COEF, 0x02A9}, /* Mute speaker */
1575
1576 {0x0B, AC_VERB_SET_COEF_INDEX, 0x001B},
1577 {0x0B, AC_VERB_SET_PROC_COEF, 0X1006}, /* Remove noise */
1578
1579 {} /* terminator */
1580 };
1581
1582 /* Speaker Amp Gain is controlled by the vendor widget's coef 4 */
1583 static const DECLARE_TLV_DB_SCALE(cs421x_speaker_boost_db_scale, 900, 300, 0);
1584
1585 static int cs421x_boost_vol_info(struct snd_kcontrol *kcontrol,
1586 struct snd_ctl_elem_info *uinfo)
1587 {
1588 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1589 uinfo->count = 1;
1590 uinfo->value.integer.min = 0;
1591 uinfo->value.integer.max = 3;
1592 return 0;
1593 }
1594
1595 static int cs421x_boost_vol_get(struct snd_kcontrol *kcontrol,
1596 struct snd_ctl_elem_value *ucontrol)
1597 {
1598 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1599
1600 ucontrol->value.integer.value[0] =
1601 cs_vendor_coef_get(codec, CS421X_IDX_SPK_CTL) & 0x0003;
1602 return 0;
1603 }
1604
1605 static int cs421x_boost_vol_put(struct snd_kcontrol *kcontrol,
1606 struct snd_ctl_elem_value *ucontrol)
1607 {
1608 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1609
1610 unsigned int vol = ucontrol->value.integer.value[0];
1611 unsigned int coef =
1612 cs_vendor_coef_get(codec, CS421X_IDX_SPK_CTL);
1613 unsigned int original_coef = coef;
1614
1615 coef &= ~0x0003;
1616 coef |= (vol & 0x0003);
1617 if (original_coef == coef)
1618 return 0;
1619 else {
1620 cs_vendor_coef_set(codec, CS421X_IDX_SPK_CTL, coef);
1621 return 1;
1622 }
1623 }
1624
1625 static const struct snd_kcontrol_new cs421x_speaker_bost_ctl = {
1626
1627 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1628 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
1629 SNDRV_CTL_ELEM_ACCESS_TLV_READ),
1630 .name = "Speaker Boost Playback Volume",
1631 .info = cs421x_boost_vol_info,
1632 .get = cs421x_boost_vol_get,
1633 .put = cs421x_boost_vol_put,
1634 .tlv = { .p = cs421x_speaker_boost_db_scale },
1635 };
1636
1637 static void cs4210_pinmux_init(struct hda_codec *codec)
1638 {
1639 struct cs_spec *spec = codec->spec;
1640 unsigned int def_conf, coef;
1641
1642 /* GPIO, DMIC_SCL, DMIC_SDA and SENSE_B are multiplexed */
1643 coef = cs_vendor_coef_get(codec, CS421X_IDX_DEV_CFG);
1644
1645 if (spec->gpio_mask)
1646 coef |= 0x0008; /* B1,B2 are GPIOs */
1647 else
1648 coef &= ~0x0008;
1649
1650 if (spec->sense_b)
1651 coef |= 0x0010; /* B2 is SENSE_B, not inverted */
1652 else
1653 coef &= ~0x0010;
1654
1655 cs_vendor_coef_set(codec, CS421X_IDX_DEV_CFG, coef);
1656
1657 if ((spec->gpio_mask || spec->sense_b) &&
1658 is_active_pin(codec, CS421X_DMIC_PIN_NID)) {
1659
1660 /*
1661 GPIO or SENSE_B forced - disconnect the DMIC pin.
1662 */
1663 def_conf = snd_hda_codec_get_pincfg(codec, CS421X_DMIC_PIN_NID);
1664 def_conf &= ~AC_DEFCFG_PORT_CONN;
1665 def_conf |= (AC_JACK_PORT_NONE << AC_DEFCFG_PORT_CONN_SHIFT);
1666 snd_hda_codec_set_pincfg(codec, CS421X_DMIC_PIN_NID, def_conf);
1667 }
1668 }
1669
1670 static void init_cs421x_digital(struct hda_codec *codec)
1671 {
1672 struct cs_spec *spec = codec->spec;
1673 struct auto_pin_cfg *cfg = &spec->autocfg;
1674 int i;
1675
1676
1677 for (i = 0; i < cfg->dig_outs; i++) {
1678 hda_nid_t nid = cfg->dig_out_pins[i];
1679 if (!cfg->speaker_outs)
1680 continue;
1681 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
1682 snd_hda_jack_detect_enable_callback(codec, nid, SPDIF_EVENT, cs_automute);
1683 spec->spdif_detect = 1;
1684 }
1685 }
1686 }
1687
1688 static int cs421x_init(struct hda_codec *codec)
1689 {
1690 struct cs_spec *spec = codec->spec;
1691
1692 if (spec->vendor_nid == CS4210_VENDOR_NID) {
1693 snd_hda_sequence_write(codec, cs421x_coef_init_verbs);
1694 snd_hda_sequence_write(codec, cs421x_coef_init_verbs_A1_silicon_fixes);
1695 cs4210_pinmux_init(codec);
1696 }
1697
1698 if (spec->gpio_mask) {
1699 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
1700 spec->gpio_mask);
1701 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
1702 spec->gpio_dir);
1703 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1704 spec->gpio_data);
1705 }
1706
1707 init_output(codec);
1708 init_input(codec);
1709 init_cs421x_digital(codec);
1710
1711 return 0;
1712 }
1713
1714 /*
1715 * CS4210 Input MUX (1 ADC)
1716 */
1717 static int cs421x_mux_enum_info(struct snd_kcontrol *kcontrol,
1718 struct snd_ctl_elem_info *uinfo)
1719 {
1720 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1721 struct cs_spec *spec = codec->spec;
1722
1723 return snd_hda_input_mux_info(&spec->input_mux, uinfo);
1724 }
1725
1726 static int cs421x_mux_enum_get(struct snd_kcontrol *kcontrol,
1727 struct snd_ctl_elem_value *ucontrol)
1728 {
1729 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1730 struct cs_spec *spec = codec->spec;
1731
1732 ucontrol->value.enumerated.item[0] = spec->cur_input;
1733 return 0;
1734 }
1735
1736 static int cs421x_mux_enum_put(struct snd_kcontrol *kcontrol,
1737 struct snd_ctl_elem_value *ucontrol)
1738 {
1739 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1740 struct cs_spec *spec = codec->spec;
1741
1742 return snd_hda_input_mux_put(codec, &spec->input_mux, ucontrol,
1743 spec->adc_nid[0], &spec->cur_input);
1744
1745 }
1746
1747 static const struct snd_kcontrol_new cs421x_capture_source = {
1748 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1749 .name = "Capture Source",
1750 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1751 .info = cs421x_mux_enum_info,
1752 .get = cs421x_mux_enum_get,
1753 .put = cs421x_mux_enum_put,
1754 };
1755
1756 static int cs421x_add_input_volume_control(struct hda_codec *codec, int item)
1757 {
1758 struct cs_spec *spec = codec->spec;
1759 struct auto_pin_cfg *cfg = &spec->autocfg;
1760 const struct hda_input_mux *imux = &spec->input_mux;
1761 hda_nid_t pin = cfg->inputs[item].pin;
1762 struct snd_kcontrol *kctl;
1763 u32 caps;
1764
1765 if (!(get_wcaps(codec, pin) & AC_WCAP_IN_AMP))
1766 return 0;
1767
1768 caps = query_amp_caps(codec, pin, HDA_INPUT);
1769 caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1770 if (caps <= 1)
1771 return 0;
1772
1773 return add_volume(codec, imux->items[item].label, 0,
1774 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT), 1, &kctl);
1775 }
1776
1777 /* add a (input-boost) volume control to the given input pin */
1778 static int build_cs421x_input(struct hda_codec *codec)
1779 {
1780 struct cs_spec *spec = codec->spec;
1781 struct auto_pin_cfg *cfg = &spec->autocfg;
1782 struct hda_input_mux *imux = &spec->input_mux;
1783 int i, err, type_idx;
1784 const char *label;
1785
1786 if (!spec->num_inputs)
1787 return 0;
1788
1789 /* make bind-capture */
1790 spec->capture_bind[0] = make_bind_capture(codec, &snd_hda_bind_sw);
1791 spec->capture_bind[1] = make_bind_capture(codec, &snd_hda_bind_vol);
1792 for (i = 0; i < 2; i++) {
1793 struct snd_kcontrol *kctl;
1794 int n;
1795 if (!spec->capture_bind[i])
1796 return -ENOMEM;
1797 kctl = snd_ctl_new1(&cs_capture_ctls[i], codec);
1798 if (!kctl)
1799 return -ENOMEM;
1800 kctl->private_value = (long)spec->capture_bind[i];
1801 err = snd_hda_ctl_add(codec, 0, kctl);
1802 if (err < 0)
1803 return err;
1804 for (n = 0; n < AUTO_PIN_LAST; n++) {
1805 if (!spec->adc_nid[n])
1806 continue;
1807 err = snd_hda_add_nid(codec, kctl, 0, spec->adc_nid[n]);
1808 if (err < 0)
1809 return err;
1810 }
1811 }
1812
1813 /* Add Input MUX Items + Capture Volume/Switch */
1814 for (i = 0; i < spec->num_inputs; i++) {
1815 label = hda_get_autocfg_input_label(codec, cfg, i);
1816 snd_hda_add_imux_item(imux, label, spec->adc_idx[i], &type_idx);
1817
1818 err = cs421x_add_input_volume_control(codec, i);
1819 if (err < 0)
1820 return err;
1821 }
1822
1823 /*
1824 Add 'Capture Source' Switch if
1825 * 2 inputs and no mic detec
1826 * 3 inputs
1827 */
1828 if ((spec->num_inputs == 2 && !spec->mic_detect) ||
1829 (spec->num_inputs == 3)) {
1830
1831 err = snd_hda_ctl_add(codec, spec->adc_nid[0],
1832 snd_ctl_new1(&cs421x_capture_source, codec));
1833 if (err < 0)
1834 return err;
1835 }
1836
1837 return 0;
1838 }
1839
1840 /* Single DAC (Mute/Gain) */
1841 static int build_cs421x_output(struct hda_codec *codec)
1842 {
1843 hda_nid_t dac = CS4210_DAC_NID;
1844 struct cs_spec *spec = codec->spec;
1845 struct auto_pin_cfg *cfg = &spec->autocfg;
1846 struct snd_kcontrol *kctl;
1847 int err;
1848 char *name = "Master";
1849
1850 fix_volume_caps(codec, dac);
1851
1852 err = add_mute(codec, name, 0,
1853 HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
1854 if (err < 0)
1855 return err;
1856
1857 err = add_volume(codec, name, 0,
1858 HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
1859 if (err < 0)
1860 return err;
1861
1862 if (cfg->speaker_outs && (spec->vendor_nid == CS4210_VENDOR_NID)) {
1863 err = snd_hda_ctl_add(codec, 0,
1864 snd_ctl_new1(&cs421x_speaker_bost_ctl, codec));
1865 if (err < 0)
1866 return err;
1867 }
1868 return err;
1869 }
1870
1871 static int cs421x_build_controls(struct hda_codec *codec)
1872 {
1873 struct cs_spec *spec = codec->spec;
1874 int err;
1875
1876 err = build_cs421x_output(codec);
1877 if (err < 0)
1878 return err;
1879 err = build_cs421x_input(codec);
1880 if (err < 0)
1881 return err;
1882 err = build_digital_output(codec);
1883 if (err < 0)
1884 return err;
1885 err = cs421x_init(codec);
1886 if (err < 0)
1887 return err;
1888
1889 err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
1890 if (err < 0)
1891 return err;
1892
1893 return 0;
1894 }
1895
1896 static int parse_cs421x_input(struct hda_codec *codec)
1897 {
1898 struct cs_spec *spec = codec->spec;
1899 struct auto_pin_cfg *cfg = &spec->autocfg;
1900 int i;
1901
1902 for (i = 0; i < cfg->num_inputs; i++) {
1903 hda_nid_t pin = cfg->inputs[i].pin;
1904 spec->adc_nid[i] = get_adc(codec, pin, &spec->adc_idx[i]);
1905 spec->cur_input = spec->last_input = i;
1906 spec->num_inputs++;
1907
1908 /* check whether the automatic mic switch is available */
1909 if (is_ext_mic(codec, i) && cfg->num_inputs >= 2) {
1910 spec->mic_detect = 1;
1911 spec->automic_idx = i;
1912 }
1913 }
1914 return 0;
1915 }
1916
1917 static int cs421x_parse_auto_config(struct hda_codec *codec)
1918 {
1919 struct cs_spec *spec = codec->spec;
1920 int err;
1921
1922 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1923 if (err < 0)
1924 return err;
1925 err = parse_output(codec);
1926 if (err < 0)
1927 return err;
1928 err = parse_cs421x_input(codec);
1929 if (err < 0)
1930 return err;
1931 err = parse_digital_output(codec);
1932 if (err < 0)
1933 return err;
1934 return 0;
1935 }
1936
1937 #ifdef CONFIG_PM
1938 /*
1939 Manage PDREF, when transitioning to D3hot
1940 (DAC,ADC) -> D3, PDREF=1, AFG->D3
1941 */
1942 static int cs421x_suspend(struct hda_codec *codec)
1943 {
1944 struct cs_spec *spec = codec->spec;
1945 unsigned int coef;
1946
1947 snd_hda_shutup_pins(codec);
1948
1949 snd_hda_codec_write(codec, CS4210_DAC_NID, 0,
1950 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
1951 snd_hda_codec_write(codec, CS4210_ADC_NID, 0,
1952 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
1953
1954 if (spec->vendor_nid == CS4210_VENDOR_NID) {
1955 coef = cs_vendor_coef_get(codec, CS421X_IDX_DEV_CFG);
1956 coef |= 0x0004; /* PDREF */
1957 cs_vendor_coef_set(codec, CS421X_IDX_DEV_CFG, coef);
1958 }
1959
1960 return 0;
1961 }
1962 #endif
1963
1964 static const struct hda_codec_ops cs421x_patch_ops = {
1965 .build_controls = cs421x_build_controls,
1966 .build_pcms = cs_build_pcms,
1967 .init = cs421x_init,
1968 .free = cs_free,
1969 .unsol_event = snd_hda_jack_unsol_event,
1970 #ifdef CONFIG_PM
1971 .suspend = cs421x_suspend,
1972 #endif
1973 };
1974
1975 static int patch_cs4210(struct hda_codec *codec)
1976 {
1977 struct cs_spec *spec;
1978 int err;
1979
1980 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1981 if (!spec)
1982 return -ENOMEM;
1983 codec->spec = spec;
1984 snd_hda_gen_init(&spec->gen);
1985
1986 spec->vendor_nid = CS4210_VENDOR_NID;
1987
1988 snd_hda_pick_fixup(codec, cs421x_models, cs421x_fixup_tbl,
1989 cs421x_fixups);
1990 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1991
1992 /*
1993 Update the GPIO/DMIC/SENSE_B pinmux before the configuration
1994 is auto-parsed. If GPIO or SENSE_B is forced, DMIC input
1995 is disabled.
1996 */
1997 cs4210_pinmux_init(codec);
1998
1999 err = cs421x_parse_auto_config(codec);
2000 if (err < 0)
2001 goto error;
2002
2003 codec->patch_ops = cs421x_patch_ops;
2004
2005 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2006
2007 return 0;
2008
2009 error:
2010 cs_free(codec);
2011 codec->spec = NULL;
2012 return err;
2013 }
2014
2015 static int patch_cs4213(struct hda_codec *codec)
2016 {
2017 struct cs_spec *spec;
2018 int err;
2019
2020 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2021 if (!spec)
2022 return -ENOMEM;
2023 codec->spec = spec;
2024 snd_hda_gen_init(&spec->gen);
2025
2026 spec->vendor_nid = CS4213_VENDOR_NID;
2027
2028 err = cs421x_parse_auto_config(codec);
2029 if (err < 0)
2030 goto error;
2031
2032 codec->patch_ops = cs421x_patch_ops;
2033 return 0;
2034
2035 error:
2036 cs_free(codec);
2037 codec->spec = NULL;
2038 return err;
2039 }
2040
2041
2042 /*
2043 * patch entries
2044 */
2045 static const struct hda_codec_preset snd_hda_preset_cirrus[] = {
2046 { .id = 0x10134206, .name = "CS4206", .patch = patch_cs420x },
2047 { .id = 0x10134207, .name = "CS4207", .patch = patch_cs420x },
2048 { .id = 0x10134210, .name = "CS4210", .patch = patch_cs4210 },
2049 { .id = 0x10134213, .name = "CS4213", .patch = patch_cs4213 },
2050 {} /* terminator */
2051 };
2052
2053 MODULE_ALIAS("snd-hda-codec-id:10134206");
2054 MODULE_ALIAS("snd-hda-codec-id:10134207");
2055 MODULE_ALIAS("snd-hda-codec-id:10134210");
2056 MODULE_ALIAS("snd-hda-codec-id:10134213");
2057
2058 MODULE_LICENSE("GPL");
2059 MODULE_DESCRIPTION("Cirrus Logic HD-audio codec");
2060
2061 static struct hda_codec_preset_list cirrus_list = {
2062 .preset = snd_hda_preset_cirrus,
2063 .owner = THIS_MODULE,
2064 };
2065
2066 static int __init patch_cirrus_init(void)
2067 {
2068 return snd_hda_add_codec_preset(&cirrus_list);
2069 }
2070
2071 static void __exit patch_cirrus_exit(void)
2072 {
2073 snd_hda_delete_codec_preset(&cirrus_list);
2074 }
2075
2076 module_init(patch_cirrus_init)
2077 module_exit(patch_cirrus_exit)
CRIS linux kernel tree