2 * HD audio interface patch for Cirrus Logic CS420x chip
4 * Copyright (c) 2009 Takashi Iwai <tiwai@suse.de>
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.
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.
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
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"
34 struct auto_pin_cfg autocfg
;
35 struct hda_multi_out multiout
;
36 struct snd_kcontrol
*vmaster_sw
;
37 struct snd_kcontrol
*vmaster_vol
;
39 hda_nid_t dac_nid
[AUTO_CFG_MAX_OUTS
];
40 hda_nid_t slave_dig_outs
[2];
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
;
50 unsigned int cur_adc_stream_tag
;
51 unsigned int cur_adc_format
;
54 struct hda_bind_ctls
*capture_bind
[2];
56 unsigned int gpio_mask
;
57 unsigned int gpio_dir
;
58 unsigned int gpio_data
;
60 struct hda_pcm pcm_rec
[2]; /* PCM information */
62 unsigned int hp_detect
:1;
63 unsigned int mic_detect
:1;
66 /* available models */
74 /* Vendor-specific processing widget */
75 #define CS420X_VENDOR_NID 0x11
76 #define CS_DIG_OUT1_PIN_NID 0x10
77 #define CS_DIG_OUT2_PIN_NID 0x15
78 #define CS_DMIC1_PIN_NID 0x12
79 #define CS_DMIC2_PIN_NID 0x0e
82 #define IDX_SPDIF_STAT 0x0000
83 #define IDX_SPDIF_CTL 0x0001
84 #define IDX_ADC_CFG 0x0002
85 /* SZC bitmask, 4 modes below:
87 * 1 = digital immediate, analog zero-cross
88 * 2 = digtail & analog soft-ramp
89 * 3 = digital soft-ramp, analog zero-cross
91 #define CS_COEF_ADC_SZC_MASK (3 << 0)
92 #define CS_COEF_ADC_MIC_SZC_MODE (3 << 0) /* SZC setup for mic */
93 #define CS_COEF_ADC_LI_SZC_MODE (3 << 0) /* SZC setup for line-in */
94 /* PGA mode: 0 = differential, 1 = signle-ended */
95 #define CS_COEF_ADC_MIC_PGA_MODE (1 << 5) /* PGA setup for mic */
96 #define CS_COEF_ADC_LI_PGA_MODE (1 << 6) /* PGA setup for line-in */
97 #define IDX_DAC_CFG 0x0003
98 /* SZC bitmask, 4 modes below:
102 * 3 = soft-ramp on zero-cross
104 #define CS_COEF_DAC_HP_SZC_MODE (3 << 0) /* nid 0x02 */
105 #define CS_COEF_DAC_LO_SZC_MODE (3 << 2) /* nid 0x03 */
106 #define CS_COEF_DAC_SPK_SZC_MODE (3 << 4) /* nid 0x04 */
108 #define IDX_BEEP_CFG 0x0004
109 /* 0x0008 - test reg key */
110 /* 0x0009 - 0x0014 -> 12 test regs */
111 /* 0x0015 - visibility reg */
114 static inline int cs_vendor_coef_get(struct hda_codec
*codec
, unsigned int idx
)
116 snd_hda_codec_write(codec
, CS420X_VENDOR_NID
, 0,
117 AC_VERB_SET_COEF_INDEX
, idx
);
118 return snd_hda_codec_read(codec
, CS420X_VENDOR_NID
, 0,
119 AC_VERB_GET_PROC_COEF
, 0);
122 static inline void cs_vendor_coef_set(struct hda_codec
*codec
, unsigned int idx
,
125 snd_hda_codec_write(codec
, CS420X_VENDOR_NID
, 0,
126 AC_VERB_SET_COEF_INDEX
, idx
);
127 snd_hda_codec_write(codec
, CS420X_VENDOR_NID
, 0,
128 AC_VERB_SET_PROC_COEF
, coef
);
138 static int cs_playback_pcm_open(struct hda_pcm_stream
*hinfo
,
139 struct hda_codec
*codec
,
140 struct snd_pcm_substream
*substream
)
142 struct cs_spec
*spec
= codec
->spec
;
143 return snd_hda_multi_out_analog_open(codec
, &spec
->multiout
, substream
,
147 static int cs_playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
148 struct hda_codec
*codec
,
149 unsigned int stream_tag
,
151 struct snd_pcm_substream
*substream
)
153 struct cs_spec
*spec
= codec
->spec
;
154 return snd_hda_multi_out_analog_prepare(codec
, &spec
->multiout
,
155 stream_tag
, format
, substream
);
158 static int cs_playback_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
159 struct hda_codec
*codec
,
160 struct snd_pcm_substream
*substream
)
162 struct cs_spec
*spec
= codec
->spec
;
163 return snd_hda_multi_out_analog_cleanup(codec
, &spec
->multiout
);
169 static int cs_dig_playback_pcm_open(struct hda_pcm_stream
*hinfo
,
170 struct hda_codec
*codec
,
171 struct snd_pcm_substream
*substream
)
173 struct cs_spec
*spec
= codec
->spec
;
174 return snd_hda_multi_out_dig_open(codec
, &spec
->multiout
);
177 static int cs_dig_playback_pcm_close(struct hda_pcm_stream
*hinfo
,
178 struct hda_codec
*codec
,
179 struct snd_pcm_substream
*substream
)
181 struct cs_spec
*spec
= codec
->spec
;
182 return snd_hda_multi_out_dig_close(codec
, &spec
->multiout
);
185 static int cs_dig_playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
186 struct hda_codec
*codec
,
187 unsigned int stream_tag
,
189 struct snd_pcm_substream
*substream
)
191 struct cs_spec
*spec
= codec
->spec
;
192 return snd_hda_multi_out_dig_prepare(codec
, &spec
->multiout
, stream_tag
,
196 static int cs_dig_playback_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
197 struct hda_codec
*codec
,
198 struct snd_pcm_substream
*substream
)
200 struct cs_spec
*spec
= codec
->spec
;
201 return snd_hda_multi_out_dig_cleanup(codec
, &spec
->multiout
);
207 static int cs_capture_pcm_prepare(struct hda_pcm_stream
*hinfo
,
208 struct hda_codec
*codec
,
209 unsigned int stream_tag
,
211 struct snd_pcm_substream
*substream
)
213 struct cs_spec
*spec
= codec
->spec
;
214 spec
->cur_adc
= spec
->adc_nid
[spec
->cur_input
];
215 spec
->cur_adc_stream_tag
= stream_tag
;
216 spec
->cur_adc_format
= format
;
217 snd_hda_codec_setup_stream(codec
, spec
->cur_adc
, stream_tag
, 0, format
);
221 static int cs_capture_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
222 struct hda_codec
*codec
,
223 struct snd_pcm_substream
*substream
)
225 struct cs_spec
*spec
= codec
->spec
;
226 snd_hda_codec_cleanup_stream(codec
, spec
->cur_adc
);
233 static struct hda_pcm_stream cs_pcm_analog_playback
= {
238 .open
= cs_playback_pcm_open
,
239 .prepare
= cs_playback_pcm_prepare
,
240 .cleanup
= cs_playback_pcm_cleanup
244 static struct hda_pcm_stream cs_pcm_analog_capture
= {
249 .prepare
= cs_capture_pcm_prepare
,
250 .cleanup
= cs_capture_pcm_cleanup
254 static struct hda_pcm_stream cs_pcm_digital_playback
= {
259 .open
= cs_dig_playback_pcm_open
,
260 .close
= cs_dig_playback_pcm_close
,
261 .prepare
= cs_dig_playback_pcm_prepare
,
262 .cleanup
= cs_dig_playback_pcm_cleanup
266 static struct hda_pcm_stream cs_pcm_digital_capture
= {
272 static int cs_build_pcms(struct hda_codec
*codec
)
274 struct cs_spec
*spec
= codec
->spec
;
275 struct hda_pcm
*info
= spec
->pcm_rec
;
277 codec
->pcm_info
= info
;
280 info
->name
= "Cirrus Analog";
281 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] = cs_pcm_analog_playback
;
282 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].nid
= spec
->dac_nid
[0];
283 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].channels_max
=
284 spec
->multiout
.max_channels
;
285 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] = cs_pcm_analog_capture
;
286 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
=
287 spec
->adc_nid
[spec
->cur_input
];
290 if (!spec
->multiout
.dig_out_nid
&& !spec
->dig_in
)
294 info
->name
= "Cirrus Digital";
295 info
->pcm_type
= spec
->autocfg
.dig_out_type
[0];
297 info
->pcm_type
= HDA_PCM_TYPE_SPDIF
;
298 if (spec
->multiout
.dig_out_nid
) {
299 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
] =
300 cs_pcm_digital_playback
;
301 info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
].nid
=
302 spec
->multiout
.dig_out_nid
;
305 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
] =
306 cs_pcm_digital_capture
;
307 info
->stream
[SNDRV_PCM_STREAM_CAPTURE
].nid
= spec
->dig_in
;
315 * parse codec topology
318 static hda_nid_t
get_dac(struct hda_codec
*codec
, hda_nid_t pin
)
323 if (snd_hda_get_connections(codec
, pin
, &dac
, 1) != 1)
328 static int is_ext_mic(struct hda_codec
*codec
, unsigned int idx
)
330 struct cs_spec
*spec
= codec
->spec
;
331 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
332 hda_nid_t pin
= cfg
->inputs
[idx
].pin
;
333 unsigned int val
= snd_hda_query_pin_caps(codec
, pin
);
334 if (!(val
& AC_PINCAP_PRES_DETECT
))
336 val
= snd_hda_codec_get_pincfg(codec
, pin
);
337 return (get_defcfg_connect(val
) == AC_JACK_PORT_COMPLEX
);
340 static hda_nid_t
get_adc(struct hda_codec
*codec
, hda_nid_t pin
,
346 nid
= codec
->start_nid
;
347 for (i
= 0; i
< codec
->num_nodes
; i
++, nid
++) {
351 type
= (get_wcaps(codec
, nid
) & AC_WCAP_TYPE
)
352 >> AC_WCAP_TYPE_SHIFT
;
353 if (type
!= AC_WID_AUD_IN
)
355 nums
= snd_hda_get_connections(codec
, nid
, pins
,
359 for (j
= 0; j
< nums
; j
++) {
360 if (pins
[j
] == pin
) {
369 static int is_active_pin(struct hda_codec
*codec
, hda_nid_t nid
)
372 val
= snd_hda_codec_get_pincfg(codec
, nid
);
373 return (get_defcfg_connect(val
) != AC_JACK_PORT_NONE
);
376 static int parse_output(struct hda_codec
*codec
)
378 struct cs_spec
*spec
= codec
->spec
;
379 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
383 for (i
= 0; i
< cfg
->line_outs
; i
++) {
384 dac
= get_dac(codec
, cfg
->line_out_pins
[i
]);
387 spec
->dac_nid
[i
] = dac
;
389 spec
->multiout
.num_dacs
= i
;
390 spec
->multiout
.dac_nids
= spec
->dac_nid
;
391 spec
->multiout
.max_channels
= i
* 2;
393 /* add HP and speakers */
395 for (i
= 0; i
< cfg
->hp_outs
; i
++) {
396 dac
= get_dac(codec
, cfg
->hp_pins
[i
]);
400 spec
->multiout
.hp_nid
= dac
;
402 spec
->multiout
.extra_out_nid
[extra_nids
++] = dac
;
404 for (i
= 0; i
< cfg
->speaker_outs
; i
++) {
405 dac
= get_dac(codec
, cfg
->speaker_pins
[i
]);
408 spec
->multiout
.extra_out_nid
[extra_nids
++] = dac
;
411 if (cfg
->line_out_type
== AUTO_PIN_SPEAKER_OUT
) {
412 cfg
->speaker_outs
= cfg
->line_outs
;
413 memcpy(cfg
->speaker_pins
, cfg
->line_out_pins
,
414 sizeof(cfg
->speaker_pins
));
421 static int parse_input(struct hda_codec
*codec
)
423 struct cs_spec
*spec
= codec
->spec
;
424 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
427 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
428 hda_nid_t pin
= cfg
->inputs
[i
].pin
;
429 spec
->input_idx
[spec
->num_inputs
] = i
;
430 spec
->capsrc_idx
[i
] = spec
->num_inputs
++;
432 spec
->adc_nid
[i
] = get_adc(codec
, pin
, &spec
->adc_idx
[i
]);
434 if (!spec
->num_inputs
)
437 /* check whether the automatic mic switch is available */
438 if (spec
->num_inputs
== 2 &&
439 cfg
->inputs
[0].type
<= AUTO_PIN_FRONT_MIC
&&
440 cfg
->inputs
[1].type
== AUTO_PIN_FRONT_MIC
) {
441 if (is_ext_mic(codec
, cfg
->inputs
[0].pin
)) {
442 if (!is_ext_mic(codec
, cfg
->inputs
[1].pin
)) {
443 spec
->mic_detect
= 1;
444 spec
->automic_idx
= 0;
447 if (is_ext_mic(codec
, cfg
->inputs
[1].pin
)) {
448 spec
->mic_detect
= 1;
449 spec
->automic_idx
= 1;
457 static int parse_digital_output(struct hda_codec
*codec
)
459 struct cs_spec
*spec
= codec
->spec
;
460 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
465 if (snd_hda_get_connections(codec
, cfg
->dig_out_pins
[0], &nid
, 1) < 1)
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
;
477 static int parse_digital_input(struct hda_codec
*codec
)
479 struct cs_spec
*spec
= codec
->spec
;
480 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
484 spec
->dig_in
= get_adc(codec
, cfg
->dig_in_pin
, &idx
);
489 * create mixer controls
492 static const char *dir_sfx
[2] = { "Playback", "Capture" };
494 static int add_mute(struct hda_codec
*codec
, const char *name
, int index
,
495 unsigned int pval
, int dir
, struct snd_kcontrol
**kctlp
)
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
);
503 (*kctlp
)->id
.subdevice
= HDA_SUBDEV_AMP_FLAG
;
504 return snd_hda_ctl_add(codec
, 0, *kctlp
);
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
)
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
);
517 (*kctlp
)->id
.subdevice
= HDA_SUBDEV_AMP_FLAG
;
518 return snd_hda_ctl_add(codec
, 0, *kctlp
);
521 static void fix_volume_caps(struct hda_codec
*codec
, hda_nid_t dac
)
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
);
533 static int add_vmaster(struct hda_codec
*codec
, hda_nid_t dac
)
535 struct cs_spec
*spec
= codec
->spec
;
540 snd_ctl_make_virtual_master("Master Playback Switch", NULL
);
541 err
= snd_hda_ctl_add(codec
, dac
, spec
->vmaster_sw
);
545 snd_hda_set_vmaster_tlv(codec
, dac
, HDA_OUTPUT
, tlv
);
547 snd_ctl_make_virtual_master("Master Playback Volume", tlv
);
548 err
= snd_hda_ctl_add(codec
, dac
, spec
->vmaster_vol
);
554 static int add_output(struct hda_codec
*codec
, hda_nid_t dac
, int idx
,
555 int num_ctls
, int type
)
557 struct cs_spec
*spec
= codec
->spec
;
560 struct snd_kcontrol
*kctl
;
561 static char *speakers
[] = {
562 "Front Speaker", "Surround Speaker", "Bass Speaker"
564 static char *line_outs
[] = {
565 "Front Line-Out", "Surround Line-Out", "Bass Line-Out"
568 fix_volume_caps(codec
, dac
);
569 if (!spec
->vmaster_sw
) {
570 err
= add_vmaster(codec
, dac
);
577 case AUTO_PIN_HP_OUT
:
581 case AUTO_PIN_SPEAKER_OUT
:
583 name
= speakers
[idx
];
589 name
= line_outs
[idx
];
595 err
= add_mute(codec
, name
, index
,
596 HDA_COMPOSE_AMP_VAL(dac
, 3, 0, HDA_OUTPUT
), 0, &kctl
);
599 err
= snd_ctl_add_slave(spec
->vmaster_sw
, kctl
);
603 err
= add_volume(codec
, name
, index
,
604 HDA_COMPOSE_AMP_VAL(dac
, 3, 0, HDA_OUTPUT
), 0, &kctl
);
607 err
= snd_ctl_add_slave(spec
->vmaster_vol
, kctl
);
614 static int build_output(struct hda_codec
*codec
)
616 struct cs_spec
*spec
= codec
->spec
;
617 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
620 for (i
= 0; i
< cfg
->line_outs
; i
++) {
621 err
= add_output(codec
, get_dac(codec
, cfg
->line_out_pins
[i
]),
622 i
, cfg
->line_outs
, cfg
->line_out_type
);
626 for (i
= 0; i
< cfg
->hp_outs
; i
++) {
627 err
= add_output(codec
, get_dac(codec
, cfg
->hp_pins
[i
]),
628 i
, cfg
->hp_outs
, AUTO_PIN_HP_OUT
);
632 for (i
= 0; i
< cfg
->speaker_outs
; i
++) {
633 err
= add_output(codec
, get_dac(codec
, cfg
->speaker_pins
[i
]),
634 i
, cfg
->speaker_outs
, AUTO_PIN_SPEAKER_OUT
);
644 static struct snd_kcontrol_new cs_capture_ctls
[] = {
645 HDA_BIND_SW("Capture Switch", 0),
646 HDA_BIND_VOL("Capture Volume", 0),
649 static int change_cur_input(struct hda_codec
*codec
, unsigned int idx
,
652 struct cs_spec
*spec
= codec
->spec
;
654 if (spec
->cur_input
== idx
&& !force
)
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
, 1);
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
);
664 snd_hda_codec_write(codec
, spec
->cur_adc
, 0,
665 AC_VERB_SET_CONNECT_SEL
,
667 spec
->cur_input
= idx
;
671 static int cs_capture_source_info(struct snd_kcontrol
*kcontrol
,
672 struct snd_ctl_elem_info
*uinfo
)
674 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
675 struct cs_spec
*spec
= codec
->spec
;
678 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
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
]);
688 static int cs_capture_source_get(struct snd_kcontrol
*kcontrol
,
689 struct snd_ctl_elem_value
*ucontrol
)
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
];
697 static int cs_capture_source_put(struct snd_kcontrol
*kcontrol
,
698 struct snd_ctl_elem_value
*ucontrol
)
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];
704 if (idx
>= spec
->num_inputs
)
706 idx
= spec
->input_idx
[idx
];
707 return change_cur_input(codec
, idx
, 0);
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
,
719 static struct hda_bind_ctls
*make_bind_capture(struct hda_codec
*codec
,
720 struct hda_ctl_ops
*ops
)
722 struct cs_spec
*spec
= codec
->spec
;
723 struct hda_bind_ctls
*bind
;
726 bind
= kzalloc(sizeof(*bind
) + sizeof(long) * (spec
->num_inputs
+ 1),
732 for (i
= 0; i
< AUTO_PIN_LAST
; i
++) {
733 if (!spec
->adc_nid
[i
])
736 HDA_COMPOSE_AMP_VAL(spec
->adc_nid
[i
], 3,
737 spec
->adc_idx
[i
], HDA_INPUT
);
742 static int build_input(struct hda_codec
*codec
)
744 struct cs_spec
*spec
= codec
->spec
;
747 if (!spec
->num_inputs
)
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
;
756 if (!spec
->capture_bind
[i
])
758 kctl
= snd_ctl_new1(&cs_capture_ctls
[i
], codec
);
761 kctl
->private_value
= (long)spec
->capture_bind
[i
];
762 err
= snd_hda_ctl_add(codec
, 0, kctl
);
765 for (n
= 0; n
< AUTO_PIN_LAST
; n
++) {
766 if (!spec
->adc_nid
[n
])
768 err
= snd_hda_add_nid(codec
, kctl
, 0, spec
->adc_nid
[n
]);
774 if (spec
->num_inputs
> 1 && !spec
->mic_detect
) {
775 err
= snd_hda_ctl_add(codec
, 0,
776 snd_ctl_new1(&cs_capture_source
, codec
));
787 static int build_digital_output(struct hda_codec
*codec
)
789 struct cs_spec
*spec
= codec
->spec
;
792 if (!spec
->multiout
.dig_out_nid
)
795 err
= snd_hda_create_spdif_out_ctls(codec
, spec
->multiout
.dig_out_nid
);
798 err
= snd_hda_create_spdif_share_sw(codec
, &spec
->multiout
);
804 static int build_digital_input(struct hda_codec
*codec
)
806 struct cs_spec
*spec
= codec
->spec
;
808 return snd_hda_create_spdif_in_ctls(codec
, spec
->dig_in
);
813 * auto-mute and auto-mic switching
816 static void cs_automute(struct hda_codec
*codec
)
818 struct cs_spec
*spec
= codec
->spec
;
819 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
820 unsigned int caps
, hp_present
;
825 for (i
= 0; i
< cfg
->hp_outs
; i
++) {
826 nid
= cfg
->hp_pins
[i
];
827 caps
= snd_hda_query_pin_caps(codec
, nid
);
828 if (!(caps
& AC_PINCAP_PRES_DETECT
))
830 hp_present
= snd_hda_jack_detect(codec
, nid
);
834 for (i
= 0; i
< cfg
->speaker_outs
; i
++) {
835 nid
= cfg
->speaker_pins
[i
];
836 snd_hda_codec_write(codec
, nid
, 0,
837 AC_VERB_SET_PIN_WIDGET_CONTROL
,
838 hp_present
? 0 : PIN_OUT
);
840 if (spec
->board_config
== CS420X_MBP55
||
841 spec
->board_config
== CS420X_IMAC27
) {
842 unsigned int gpio
= hp_present
? 0x02 : 0x08;
843 snd_hda_codec_write(codec
, 0x01, 0,
844 AC_VERB_SET_GPIO_DATA
, gpio
);
848 static void cs_automic(struct hda_codec
*codec
)
850 struct cs_spec
*spec
= codec
->spec
;
851 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
853 unsigned int present
;
855 nid
= cfg
->inputs
[spec
->automic_idx
].pin
;
856 present
= snd_hda_jack_detect(codec
, nid
);
858 change_cur_input(codec
, spec
->automic_idx
, 0);
860 change_cur_input(codec
, !spec
->automic_idx
, 0);
866 static void init_output(struct hda_codec
*codec
)
868 struct cs_spec
*spec
= codec
->spec
;
869 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
873 for (i
= 0; i
< spec
->multiout
.num_dacs
; i
++)
874 snd_hda_codec_write(codec
, spec
->multiout
.dac_nids
[i
], 0,
875 AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
);
876 if (spec
->multiout
.hp_nid
)
877 snd_hda_codec_write(codec
, spec
->multiout
.hp_nid
, 0,
878 AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
);
879 for (i
= 0; i
< ARRAY_SIZE(spec
->multiout
.extra_out_nid
); i
++) {
880 if (!spec
->multiout
.extra_out_nid
[i
])
882 snd_hda_codec_write(codec
, spec
->multiout
.extra_out_nid
[i
], 0,
883 AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_MUTE
);
886 /* set appropriate pin controls */
887 for (i
= 0; i
< cfg
->line_outs
; i
++)
888 snd_hda_codec_write(codec
, cfg
->line_out_pins
[i
], 0,
889 AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
);
890 for (i
= 0; i
< cfg
->hp_outs
; i
++) {
891 hda_nid_t nid
= cfg
->hp_pins
[i
];
892 snd_hda_codec_write(codec
, nid
, 0,
893 AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_HP
);
894 if (!cfg
->speaker_outs
)
896 if (get_wcaps(codec
, nid
) & AC_WCAP_UNSOL_CAP
) {
897 snd_hda_codec_write(codec
, nid
, 0,
898 AC_VERB_SET_UNSOLICITED_ENABLE
,
899 AC_USRSP_EN
| HP_EVENT
);
903 for (i
= 0; i
< cfg
->speaker_outs
; i
++)
904 snd_hda_codec_write(codec
, cfg
->speaker_pins
[i
], 0,
905 AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
);
910 static void init_input(struct hda_codec
*codec
)
912 struct cs_spec
*spec
= codec
->spec
;
913 struct auto_pin_cfg
*cfg
= &spec
->autocfg
;
917 for (i
= 0; i
< cfg
->num_inputs
; i
++) {
919 hda_nid_t pin
= cfg
->inputs
[i
].pin
;
920 if (!spec
->adc_nid
[i
])
922 /* set appropriate pin control and mute first */
924 if (cfg
->inputs
[i
].type
<= AUTO_PIN_FRONT_MIC
) {
925 unsigned int caps
= snd_hda_query_pin_caps(codec
, pin
);
926 caps
>>= AC_PINCAP_VREF_SHIFT
;
927 if (caps
& AC_PINCAP_VREF_80
)
930 snd_hda_codec_write(codec
, pin
, 0,
931 AC_VERB_SET_PIN_WIDGET_CONTROL
, ctl
);
932 snd_hda_codec_write(codec
, spec
->adc_nid
[i
], 0,
933 AC_VERB_SET_AMP_GAIN_MUTE
,
934 AMP_IN_MUTE(spec
->adc_idx
[i
]));
935 if (spec
->mic_detect
&& spec
->automic_idx
== i
)
936 snd_hda_codec_write(codec
, pin
, 0,
937 AC_VERB_SET_UNSOLICITED_ENABLE
,
938 AC_USRSP_EN
| MIC_EVENT
);
940 change_cur_input(codec
, spec
->cur_input
, 1);
941 if (spec
->mic_detect
)
944 coef
= 0x000a; /* ADC1/2 - Digital and Analog Soft Ramp */
945 if (is_active_pin(codec
, CS_DMIC2_PIN_NID
))
946 coef
|= 0x0500; /* DMIC2 enable 2 channels, disable GPIO1 */
947 if (is_active_pin(codec
, CS_DMIC1_PIN_NID
))
948 coef
|= 0x1800; /* DMIC1 enable 2 channels, disable GPIO0
949 * No effect if SPDIF_OUT2 is selected in
952 cs_vendor_coef_set(codec
, IDX_ADC_CFG
, coef
);
955 static struct hda_verb cs_coef_init_verbs
[] = {
956 {0x11, AC_VERB_SET_PROC_STATE
, 1},
957 {0x11, AC_VERB_SET_COEF_INDEX
, IDX_DAC_CFG
},
958 {0x11, AC_VERB_SET_PROC_COEF
,
959 (0x002a /* DAC1/2/3 SZCMode Soft Ramp */
960 | 0x0040 /* Mute DACs on FIFO error */
961 | 0x1000 /* Enable DACs High Pass Filter */
962 | 0x0400 /* Disable Coefficient Auto increment */
965 {0x11, AC_VERB_SET_COEF_INDEX
, IDX_DAC_CFG
},
966 {0x11, AC_VERB_SET_PROC_COEF
, 0x0007}, /* Enable Beep thru DAC1/2/3 */
972 static void init_digital(struct hda_codec
*codec
)
976 coef
= 0x0002; /* SRC_MUTE soft-mute on SPDIF (if no lock) */
977 coef
|= 0x0008; /* Replace with mute on error */
978 if (is_active_pin(codec
, CS_DIG_OUT2_PIN_NID
))
979 coef
|= 0x4000; /* RX to TX1 or TX2 Loopthru / SPDIF2
980 * SPDIF_OUT2 is shared with GPIO1 and
983 cs_vendor_coef_set(codec
, IDX_SPDIF_CTL
, coef
);
986 static int cs_init(struct hda_codec
*codec
)
988 struct cs_spec
*spec
= codec
->spec
;
990 snd_hda_sequence_write(codec
, cs_coef_init_verbs
);
992 if (spec
->gpio_mask
) {
993 snd_hda_codec_write(codec
, 0x01, 0, AC_VERB_SET_GPIO_MASK
,
995 snd_hda_codec_write(codec
, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION
,
997 snd_hda_codec_write(codec
, 0x01, 0, AC_VERB_SET_GPIO_DATA
,
1003 init_digital(codec
);
1007 static int cs_build_controls(struct hda_codec
*codec
)
1011 err
= build_output(codec
);
1014 err
= build_input(codec
);
1017 err
= build_digital_output(codec
);
1020 err
= build_digital_input(codec
);
1023 return cs_init(codec
);
1026 static void cs_free(struct hda_codec
*codec
)
1028 struct cs_spec
*spec
= codec
->spec
;
1029 kfree(spec
->capture_bind
[0]);
1030 kfree(spec
->capture_bind
[1]);
1034 static void cs_unsol_event(struct hda_codec
*codec
, unsigned int res
)
1036 switch ((res
>> 26) & 0x7f) {
1046 static struct hda_codec_ops cs_patch_ops
= {
1047 .build_controls
= cs_build_controls
,
1048 .build_pcms
= cs_build_pcms
,
1051 .unsol_event
= cs_unsol_event
,
1054 static int cs_parse_auto_config(struct hda_codec
*codec
)
1056 struct cs_spec
*spec
= codec
->spec
;
1059 err
= snd_hda_parse_pin_def_config(codec
, &spec
->autocfg
, NULL
);
1063 err
= parse_output(codec
);
1066 err
= parse_input(codec
);
1069 err
= parse_digital_output(codec
);
1072 err
= parse_digital_input(codec
);
1078 static const char *cs420x_models
[CS420X_MODELS
] = {
1079 [CS420X_MBP55
] = "mbp55",
1080 [CS420X_IMAC27
] = "imac27",
1081 [CS420X_AUTO
] = "auto",
1085 static struct snd_pci_quirk cs420x_cfg_tbl
[] = {
1086 SND_PCI_QUIRK(0x10de, 0xcb79, "MacBookPro 5,5", CS420X_MBP55
),
1087 SND_PCI_QUIRK(0x8086, 0x7270, "IMac 27 Inch", CS420X_IMAC27
),
1096 static struct cs_pincfg mbp55_pincfgs
[] = {
1097 { 0x09, 0x012b4030 },
1098 { 0x0a, 0x90100121 },
1099 { 0x0b, 0x90100120 },
1100 { 0x0c, 0x400000f0 },
1101 { 0x0d, 0x90a00110 },
1102 { 0x0e, 0x400000f0 },
1103 { 0x0f, 0x400000f0 },
1104 { 0x10, 0x014be040 },
1105 { 0x12, 0x400000f0 },
1106 { 0x15, 0x400000f0 },
1110 static struct cs_pincfg imac27_pincfgs
[] = {
1111 { 0x09, 0x012b4050 },
1112 { 0x0a, 0x90100140 },
1113 { 0x0b, 0x90100142 },
1114 { 0x0c, 0x018b3020 },
1115 { 0x0d, 0x90a00110 },
1116 { 0x0e, 0x400000f0 },
1117 { 0x0f, 0x01cbe030 },
1118 { 0x10, 0x014be060 },
1119 { 0x12, 0x01ab9070 },
1120 { 0x15, 0x400000f0 },
1124 static struct cs_pincfg
*cs_pincfgs
[CS420X_MODELS
] = {
1125 [CS420X_MBP55
] = mbp55_pincfgs
,
1126 [CS420X_IMAC27
] = imac27_pincfgs
,
1129 static void fix_pincfg(struct hda_codec
*codec
, int model
)
1131 const struct cs_pincfg
*cfg
= cs_pincfgs
[model
];
1134 for (; cfg
->nid
; cfg
++)
1135 snd_hda_codec_set_pincfg(codec
, cfg
->nid
, cfg
->val
);
1139 static int patch_cs420x(struct hda_codec
*codec
)
1141 struct cs_spec
*spec
;
1144 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
1149 spec
->board_config
=
1150 snd_hda_check_board_config(codec
, CS420X_MODELS
,
1151 cs420x_models
, cs420x_cfg_tbl
);
1152 if (spec
->board_config
>= 0)
1153 fix_pincfg(codec
, spec
->board_config
);
1155 switch (spec
->board_config
) {
1158 /* GPIO1 = headphones */
1159 /* GPIO3 = speakers */
1160 spec
->gpio_mask
= 0x0a;
1161 spec
->gpio_dir
= 0x0a;
1165 err
= cs_parse_auto_config(codec
);
1169 codec
->patch_ops
= cs_patch_ops
;
1183 static struct hda_codec_preset snd_hda_preset_cirrus
[] = {
1184 { .id
= 0x10134206, .name
= "CS4206", .patch
= patch_cs420x
},
1185 { .id
= 0x10134207, .name
= "CS4207", .patch
= patch_cs420x
},
1189 MODULE_ALIAS("snd-hda-codec-id:10134206");
1190 MODULE_ALIAS("snd-hda-codec-id:10134207");
1192 MODULE_LICENSE("GPL");
1193 MODULE_DESCRIPTION("Cirrus Logic HD-audio codec");
1195 static struct hda_codec_preset_list cirrus_list
= {
1196 .preset
= snd_hda_preset_cirrus
,
1197 .owner
= THIS_MODULE
,
1200 static int __init
patch_cirrus_init(void)
1202 return snd_hda_add_codec_preset(&cirrus_list
);
1205 static void __exit
patch_cirrus_exit(void)
1207 snd_hda_delete_codec_preset(&cirrus_list
);
1210 module_init(patch_cirrus_init
)
1211 module_exit(patch_cirrus_exit
)