?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
eeepc-laptop: right parent device
[linux-2.6/linux-acpi-2.6.git] / sound / pci / hda / patch_conexant.c
blobac868c59f9e334ad0dad50b00f0bb77b9bf59cdb
1 /*
2 * HD audio interface patch for Conexant HDA audio codec
3 *
4 * Copyright (c) 2006 Pototskiy Akex <alex.pototskiy@gmail.com>
5 * Takashi Iwai <tiwai@suse.de>
6 * Tobin Davis <tdavis@dsl-only.net>
7 *
8 * This driver is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This driver is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23 #include <linux/init.h>
24 #include <linux/delay.h>
25 #include <linux/slab.h>
26 #include <linux/pci.h>
27 #include <sound/core.h>
28 #include <sound/jack.h>
29
30 #include "hda_codec.h"
31 #include "hda_local.h"
32
33 #define CXT_PIN_DIR_IN 0x00
34 #define CXT_PIN_DIR_OUT 0x01
35 #define CXT_PIN_DIR_INOUT 0x02
36 #define CXT_PIN_DIR_IN_NOMICBIAS 0x03
37 #define CXT_PIN_DIR_INOUT_NOMICBIAS 0x04
38
39 #define CONEXANT_HP_EVENT 0x37
40 #define CONEXANT_MIC_EVENT 0x38
41
42 /* Conexant 5051 specific */
43
44 #define CXT5051_SPDIF_OUT 0x1C
45 #define CXT5051_PORTB_EVENT 0x38
46 #define CXT5051_PORTC_EVENT 0x39
47
48
49 struct conexant_jack {
50
51 hda_nid_t nid;
52 int type;
53 struct snd_jack *jack;
54
55 };
56
57 struct conexant_spec {
58
59 struct snd_kcontrol_new *mixers[5];
60 int num_mixers;
61 hda_nid_t vmaster_nid;
62
63 const struct hda_verb *init_verbs[5]; /* initialization verbs
64 * don't forget NULL
65 * termination!
66 */
67 unsigned int num_init_verbs;
68
69 /* playback */
70 struct hda_multi_out multiout; /* playback set-up
71 * max_channels, dacs must be set
72 * dig_out_nid and hp_nid are optional
73 */
74 unsigned int cur_eapd;
75 unsigned int hp_present;
76 unsigned int no_auto_mic;
77 unsigned int need_dac_fix;
78
79 /* capture */
80 unsigned int num_adc_nids;
81 hda_nid_t *adc_nids;
82 hda_nid_t dig_in_nid; /* digital-in NID; optional */
83
84 unsigned int cur_adc_idx;
85 hda_nid_t cur_adc;
86 unsigned int cur_adc_stream_tag;
87 unsigned int cur_adc_format;
88
89 /* capture source */
90 const struct hda_input_mux *input_mux;
91 hda_nid_t *capsrc_nids;
92 unsigned int cur_mux[3];
93
94 /* channel model */
95 const struct hda_channel_mode *channel_mode;
96 int num_channel_mode;
97
98 /* PCM information */
99 struct hda_pcm pcm_rec[2]; /* used in build_pcms() */
100
101 unsigned int spdif_route;
102
103 /* jack detection */
104 struct snd_array jacks;
105
106 /* dynamic controls, init_verbs and input_mux */
107 struct auto_pin_cfg autocfg;
108 struct hda_input_mux private_imux;
109 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
110
111 };
112
113 static int conexant_playback_pcm_open(struct hda_pcm_stream *hinfo,
114 struct hda_codec *codec,
115 struct snd_pcm_substream *substream)
116 {
117 struct conexant_spec *spec = codec->spec;
118 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
119 hinfo);
120 }
121
122 static int conexant_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
123 struct hda_codec *codec,
124 unsigned int stream_tag,
125 unsigned int format,
126 struct snd_pcm_substream *substream)
127 {
128 struct conexant_spec *spec = codec->spec;
129 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
130 stream_tag,
131 format, substream);
132 }
133
134 static int conexant_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
135 struct hda_codec *codec,
136 struct snd_pcm_substream *substream)
137 {
138 struct conexant_spec *spec = codec->spec;
139 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
140 }
141
142 /*
143 * Digital out
144 */
145 static int conexant_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
146 struct hda_codec *codec,
147 struct snd_pcm_substream *substream)
148 {
149 struct conexant_spec *spec = codec->spec;
150 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
151 }
152
153 static int conexant_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
154 struct hda_codec *codec,
155 struct snd_pcm_substream *substream)
156 {
157 struct conexant_spec *spec = codec->spec;
158 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
159 }
160
161 static int conexant_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
162 struct hda_codec *codec,
163 unsigned int stream_tag,
164 unsigned int format,
165 struct snd_pcm_substream *substream)
166 {
167 struct conexant_spec *spec = codec->spec;
168 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
169 stream_tag,
170 format, substream);
171 }
172
173 /*
174 * Analog capture
175 */
176 static int conexant_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
177 struct hda_codec *codec,
178 unsigned int stream_tag,
179 unsigned int format,
180 struct snd_pcm_substream *substream)
181 {
182 struct conexant_spec *spec = codec->spec;
183 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
184 stream_tag, 0, format);
185 return 0;
186 }
187
188 static int conexant_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
189 struct hda_codec *codec,
190 struct snd_pcm_substream *substream)
191 {
192 struct conexant_spec *spec = codec->spec;
193 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
194 return 0;
195 }
196
197
198
199 static struct hda_pcm_stream conexant_pcm_analog_playback = {
200 .substreams = 1,
201 .channels_min = 2,
202 .channels_max = 2,
203 .nid = 0, /* fill later */
204 .ops = {
205 .open = conexant_playback_pcm_open,
206 .prepare = conexant_playback_pcm_prepare,
207 .cleanup = conexant_playback_pcm_cleanup
208 },
209 };
210
211 static struct hda_pcm_stream conexant_pcm_analog_capture = {
212 .substreams = 1,
213 .channels_min = 2,
214 .channels_max = 2,
215 .nid = 0, /* fill later */
216 .ops = {
217 .prepare = conexant_capture_pcm_prepare,
218 .cleanup = conexant_capture_pcm_cleanup
219 },
220 };
221
222
223 static struct hda_pcm_stream conexant_pcm_digital_playback = {
224 .substreams = 1,
225 .channels_min = 2,
226 .channels_max = 2,
227 .nid = 0, /* fill later */
228 .ops = {
229 .open = conexant_dig_playback_pcm_open,
230 .close = conexant_dig_playback_pcm_close,
231 .prepare = conexant_dig_playback_pcm_prepare
232 },
233 };
234
235 static struct hda_pcm_stream conexant_pcm_digital_capture = {
236 .substreams = 1,
237 .channels_min = 2,
238 .channels_max = 2,
239 /* NID is set in alc_build_pcms */
240 };
241
242 static int cx5051_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
243 struct hda_codec *codec,
244 unsigned int stream_tag,
245 unsigned int format,
246 struct snd_pcm_substream *substream)
247 {
248 struct conexant_spec *spec = codec->spec;
249 spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
250 spec->cur_adc_stream_tag = stream_tag;
251 spec->cur_adc_format = format;
252 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
253 return 0;
254 }
255
256 static int cx5051_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
257 struct hda_codec *codec,
258 struct snd_pcm_substream *substream)
259 {
260 struct conexant_spec *spec = codec->spec;
261 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
262 spec->cur_adc = 0;
263 return 0;
264 }
265
266 static struct hda_pcm_stream cx5051_pcm_analog_capture = {
267 .substreams = 1,
268 .channels_min = 2,
269 .channels_max = 2,
270 .nid = 0, /* fill later */
271 .ops = {
272 .prepare = cx5051_capture_pcm_prepare,
273 .cleanup = cx5051_capture_pcm_cleanup
274 },
275 };
276
277 static int conexant_build_pcms(struct hda_codec *codec)
278 {
279 struct conexant_spec *spec = codec->spec;
280 struct hda_pcm *info = spec->pcm_rec;
281
282 codec->num_pcms = 1;
283 codec->pcm_info = info;
284
285 info->name = "CONEXANT Analog";
286 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = conexant_pcm_analog_playback;
287 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
288 spec->multiout.max_channels;
289 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
290 spec->multiout.dac_nids[0];
291 if (codec->vendor_id == 0x14f15051)
292 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
293 cx5051_pcm_analog_capture;
294 else
295 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
296 conexant_pcm_analog_capture;
297 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
298 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
299
300 if (spec->multiout.dig_out_nid) {
301 info++;
302 codec->num_pcms++;
303 info->name = "Conexant Digital";
304 info->pcm_type = HDA_PCM_TYPE_SPDIF;
305 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
306 conexant_pcm_digital_playback;
307 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
308 spec->multiout.dig_out_nid;
309 if (spec->dig_in_nid) {
310 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
311 conexant_pcm_digital_capture;
312 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
313 spec->dig_in_nid;
314 }
315 }
316
317 return 0;
318 }
319
320 static int conexant_mux_enum_info(struct snd_kcontrol *kcontrol,
321 struct snd_ctl_elem_info *uinfo)
322 {
323 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
324 struct conexant_spec *spec = codec->spec;
325
326 return snd_hda_input_mux_info(spec->input_mux, uinfo);
327 }
328
329 static int conexant_mux_enum_get(struct snd_kcontrol *kcontrol,
330 struct snd_ctl_elem_value *ucontrol)
331 {
332 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
333 struct conexant_spec *spec = codec->spec;
334 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
335
336 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
337 return 0;
338 }
339
340 static int conexant_mux_enum_put(struct snd_kcontrol *kcontrol,
341 struct snd_ctl_elem_value *ucontrol)
342 {
343 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
344 struct conexant_spec *spec = codec->spec;
345 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
346
347 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
348 spec->capsrc_nids[adc_idx],
349 &spec->cur_mux[adc_idx]);
350 }
351
352 #ifdef CONFIG_SND_HDA_INPUT_JACK
353 static void conexant_free_jack_priv(struct snd_jack *jack)
354 {
355 struct conexant_jack *jacks = jack->private_data;
356 jacks->nid = 0;
357 jacks->jack = NULL;
358 }
359
360 static int conexant_add_jack(struct hda_codec *codec,
361 hda_nid_t nid, int type)
362 {
363 struct conexant_spec *spec;
364 struct conexant_jack *jack;
365 const char *name;
366 int err;
367
368 spec = codec->spec;
369 snd_array_init(&spec->jacks, sizeof(*jack), 32);
370 jack = snd_array_new(&spec->jacks);
371 name = (type == SND_JACK_HEADPHONE) ? "Headphone" : "Mic" ;
372
373 if (!jack)
374 return -ENOMEM;
375
376 jack->nid = nid;
377 jack->type = type;
378
379 err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
380 if (err < 0)
381 return err;
382 jack->jack->private_data = jack;
383 jack->jack->private_free = conexant_free_jack_priv;
384 return 0;
385 }
386
387 static void conexant_report_jack(struct hda_codec *codec, hda_nid_t nid)
388 {
389 struct conexant_spec *spec = codec->spec;
390 struct conexant_jack *jacks = spec->jacks.list;
391
392 if (jacks) {
393 int i;
394 for (i = 0; i < spec->jacks.used; i++) {
395 if (jacks->nid == nid) {
396 unsigned int present;
397 present = snd_hda_codec_read(codec, nid, 0,
398 AC_VERB_GET_PIN_SENSE, 0) &
399 AC_PINSENSE_PRESENCE;
400
401 present = (present) ? jacks->type : 0 ;
402
403 snd_jack_report(jacks->jack,
404 present);
405 }
406 jacks++;
407 }
408 }
409 }
410
411 static int conexant_init_jacks(struct hda_codec *codec)
412 {
413 struct conexant_spec *spec = codec->spec;
414 int i;
415
416 for (i = 0; i < spec->num_init_verbs; i++) {
417 const struct hda_verb *hv;
418
419 hv = spec->init_verbs[i];
420 while (hv->nid) {
421 int err = 0;
422 switch (hv->param ^ AC_USRSP_EN) {
423 case CONEXANT_HP_EVENT:
424 err = conexant_add_jack(codec, hv->nid,
425 SND_JACK_HEADPHONE);
426 conexant_report_jack(codec, hv->nid);
427 break;
428 case CXT5051_PORTC_EVENT:
429 case CONEXANT_MIC_EVENT:
430 err = conexant_add_jack(codec, hv->nid,
431 SND_JACK_MICROPHONE);
432 conexant_report_jack(codec, hv->nid);
433 break;
434 }
435 if (err < 0)
436 return err;
437 ++hv;
438 }
439 }
440 return 0;
441
442 }
443 #else
444 static inline void conexant_report_jack(struct hda_codec *codec, hda_nid_t nid)
445 {
446 }
447
448 static inline int conexant_init_jacks(struct hda_codec *codec)
449 {
450 return 0;
451 }
452 #endif
453
454 static int conexant_init(struct hda_codec *codec)
455 {
456 struct conexant_spec *spec = codec->spec;
457 int i;
458
459 for (i = 0; i < spec->num_init_verbs; i++)
460 snd_hda_sequence_write(codec, spec->init_verbs[i]);
461 return 0;
462 }
463
464 static void conexant_free(struct hda_codec *codec)
465 {
466 #ifdef CONFIG_SND_HDA_INPUT_JACK
467 struct conexant_spec *spec = codec->spec;
468 if (spec->jacks.list) {
469 struct conexant_jack *jacks = spec->jacks.list;
470 int i;
471 for (i = 0; i < spec->jacks.used; i++, jacks++) {
472 if (jacks->jack)
473 snd_device_free(codec->bus->card, jacks->jack);
474 }
475 snd_array_free(&spec->jacks);
476 }
477 #endif
478 kfree(codec->spec);
479 }
480
481 static struct snd_kcontrol_new cxt_capture_mixers[] = {
482 {
483 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
484 .name = "Capture Source",
485 .info = conexant_mux_enum_info,
486 .get = conexant_mux_enum_get,
487 .put = conexant_mux_enum_put
488 },
489 {}
490 };
491
492 static const char *slave_vols[] = {
493 "Headphone Playback Volume",
494 "Speaker Playback Volume",
495 NULL
496 };
497
498 static const char *slave_sws[] = {
499 "Headphone Playback Switch",
500 "Speaker Playback Switch",
501 NULL
502 };
503
504 static int conexant_build_controls(struct hda_codec *codec)
505 {
506 struct conexant_spec *spec = codec->spec;
507 unsigned int i;
508 int err;
509
510 for (i = 0; i < spec->num_mixers; i++) {
511 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
512 if (err < 0)
513 return err;
514 }
515 if (spec->multiout.dig_out_nid) {
516 err = snd_hda_create_spdif_out_ctls(codec,
517 spec->multiout.dig_out_nid);
518 if (err < 0)
519 return err;
520 err = snd_hda_create_spdif_share_sw(codec,
521 &spec->multiout);
522 if (err < 0)
523 return err;
524 spec->multiout.share_spdif = 1;
525 }
526 if (spec->dig_in_nid) {
527 err = snd_hda_create_spdif_in_ctls(codec,spec->dig_in_nid);
528 if (err < 0)
529 return err;
530 }
531
532 /* if we have no master control, let's create it */
533 if (spec->vmaster_nid &&
534 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
535 unsigned int vmaster_tlv[4];
536 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
537 HDA_OUTPUT, vmaster_tlv);
538 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
539 vmaster_tlv, slave_vols);
540 if (err < 0)
541 return err;
542 }
543 if (spec->vmaster_nid &&
544 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
545 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
546 NULL, slave_sws);
547 if (err < 0)
548 return err;
549 }
550
551 if (spec->input_mux) {
552 err = snd_hda_add_new_ctls(codec, cxt_capture_mixers);
553 if (err < 0)
554 return err;
555 }
556
557 return 0;
558 }
559
560 static struct hda_codec_ops conexant_patch_ops = {
561 .build_controls = conexant_build_controls,
562 .build_pcms = conexant_build_pcms,
563 .init = conexant_init,
564 .free = conexant_free,
565 };
566
567 /*
568 * EAPD control
569 * the private value = nid | (invert << 8)
570 */
571
572 #define cxt_eapd_info snd_ctl_boolean_mono_info
573
574 static int cxt_eapd_get(struct snd_kcontrol *kcontrol,
575 struct snd_ctl_elem_value *ucontrol)
576 {
577 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
578 struct conexant_spec *spec = codec->spec;
579 int invert = (kcontrol->private_value >> 8) & 1;
580 if (invert)
581 ucontrol->value.integer.value[0] = !spec->cur_eapd;
582 else
583 ucontrol->value.integer.value[0] = spec->cur_eapd;
584 return 0;
585
586 }
587
588 static int cxt_eapd_put(struct snd_kcontrol *kcontrol,
589 struct snd_ctl_elem_value *ucontrol)
590 {
591 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
592 struct conexant_spec *spec = codec->spec;
593 int invert = (kcontrol->private_value >> 8) & 1;
594 hda_nid_t nid = kcontrol->private_value & 0xff;
595 unsigned int eapd;
596
597 eapd = !!ucontrol->value.integer.value[0];
598 if (invert)
599 eapd = !eapd;
600 if (eapd == spec->cur_eapd)
601 return 0;
602
603 spec->cur_eapd = eapd;
604 snd_hda_codec_write_cache(codec, nid,
605 0, AC_VERB_SET_EAPD_BTLENABLE,
606 eapd ? 0x02 : 0x00);
607 return 1;
608 }
609
610 /* controls for test mode */
611 #ifdef CONFIG_SND_DEBUG
612
613 #define CXT_EAPD_SWITCH(xname, nid, mask) \
614 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
615 .info = cxt_eapd_info, \
616 .get = cxt_eapd_get, \
617 .put = cxt_eapd_put, \
618 .private_value = nid | (mask<<16) }
619
620
621
622 static int conexant_ch_mode_info(struct snd_kcontrol *kcontrol,
623 struct snd_ctl_elem_info *uinfo)
624 {
625 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
626 struct conexant_spec *spec = codec->spec;
627 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
628 spec->num_channel_mode);
629 }
630
631 static int conexant_ch_mode_get(struct snd_kcontrol *kcontrol,
632 struct snd_ctl_elem_value *ucontrol)
633 {
634 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
635 struct conexant_spec *spec = codec->spec;
636 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
637 spec->num_channel_mode,
638 spec->multiout.max_channels);
639 }
640
641 static int conexant_ch_mode_put(struct snd_kcontrol *kcontrol,
642 struct snd_ctl_elem_value *ucontrol)
643 {
644 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
645 struct conexant_spec *spec = codec->spec;
646 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
647 spec->num_channel_mode,
648 &spec->multiout.max_channels);
649 if (err >= 0 && spec->need_dac_fix)
650 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
651 return err;
652 }
653
654 #define CXT_PIN_MODE(xname, nid, dir) \
655 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
656 .info = conexant_ch_mode_info, \
657 .get = conexant_ch_mode_get, \
658 .put = conexant_ch_mode_put, \
659 .private_value = nid | (dir<<16) }
660
661 #endif /* CONFIG_SND_DEBUG */
662
663 /* Conexant 5045 specific */
664
665 static hda_nid_t cxt5045_dac_nids[1] = { 0x19 };
666 static hda_nid_t cxt5045_adc_nids[1] = { 0x1a };
667 static hda_nid_t cxt5045_capsrc_nids[1] = { 0x1a };
668 #define CXT5045_SPDIF_OUT 0x18
669
670 static struct hda_channel_mode cxt5045_modes[1] = {
671 { 2, NULL },
672 };
673
674 static struct hda_input_mux cxt5045_capture_source = {
675 .num_items = 2,
676 .items = {
677 { "IntMic", 0x1 },
678 { "ExtMic", 0x2 },
679 }
680 };
681
682 static struct hda_input_mux cxt5045_capture_source_benq = {
683 .num_items = 3,
684 .items = {
685 { "IntMic", 0x1 },
686 { "ExtMic", 0x2 },
687 { "LineIn", 0x3 },
688 }
689 };
690
691 static struct hda_input_mux cxt5045_capture_source_hp530 = {
692 .num_items = 2,
693 .items = {
694 { "ExtMic", 0x1 },
695 { "IntMic", 0x2 },
696 }
697 };
698
699 /* turn on/off EAPD (+ mute HP) as a master switch */
700 static int cxt5045_hp_master_sw_put(struct snd_kcontrol *kcontrol,
701 struct snd_ctl_elem_value *ucontrol)
702 {
703 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
704 struct conexant_spec *spec = codec->spec;
705 unsigned int bits;
706
707 if (!cxt_eapd_put(kcontrol, ucontrol))
708 return 0;
709
710 /* toggle internal speakers mute depending of presence of
711 * the headphone jack
712 */
713 bits = (!spec->hp_present && spec->cur_eapd) ? 0 : HDA_AMP_MUTE;
714 snd_hda_codec_amp_stereo(codec, 0x10, HDA_OUTPUT, 0,
715 HDA_AMP_MUTE, bits);
716
717 bits = spec->cur_eapd ? 0 : HDA_AMP_MUTE;
718 snd_hda_codec_amp_stereo(codec, 0x11, HDA_OUTPUT, 0,
719 HDA_AMP_MUTE, bits);
720 return 1;
721 }
722
723 /* bind volumes of both NID 0x10 and 0x11 */
724 static struct hda_bind_ctls cxt5045_hp_bind_master_vol = {
725 .ops = &snd_hda_bind_vol,
726 .values = {
727 HDA_COMPOSE_AMP_VAL(0x10, 3, 0, HDA_OUTPUT),
728 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
729 0
730 },
731 };
732
733 /* toggle input of built-in and mic jack appropriately */
734 static void cxt5045_hp_automic(struct hda_codec *codec)
735 {
736 static struct hda_verb mic_jack_on[] = {
737 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
738 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
739 {}
740 };
741 static struct hda_verb mic_jack_off[] = {
742 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
743 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
744 {}
745 };
746 unsigned int present;
747
748 present = snd_hda_codec_read(codec, 0x12, 0,
749 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
750 if (present)
751 snd_hda_sequence_write(codec, mic_jack_on);
752 else
753 snd_hda_sequence_write(codec, mic_jack_off);
754 }
755
756
757 /* mute internal speaker if HP is plugged */
758 static void cxt5045_hp_automute(struct hda_codec *codec)
759 {
760 struct conexant_spec *spec = codec->spec;
761 unsigned int bits;
762
763 spec->hp_present = snd_hda_codec_read(codec, 0x11, 0,
764 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
765
766 bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0;
767 snd_hda_codec_amp_stereo(codec, 0x10, HDA_OUTPUT, 0,
768 HDA_AMP_MUTE, bits);
769 }
770
771 /* unsolicited event for HP jack sensing */
772 static void cxt5045_hp_unsol_event(struct hda_codec *codec,
773 unsigned int res)
774 {
775 res >>= 26;
776 switch (res) {
777 case CONEXANT_HP_EVENT:
778 cxt5045_hp_automute(codec);
779 break;
780 case CONEXANT_MIC_EVENT:
781 cxt5045_hp_automic(codec);
782 break;
783
784 }
785 }
786
787 static struct snd_kcontrol_new cxt5045_mixers[] = {
788 HDA_CODEC_VOLUME("Int Mic Capture Volume", 0x1a, 0x01, HDA_INPUT),
789 HDA_CODEC_MUTE("Int Mic Capture Switch", 0x1a, 0x01, HDA_INPUT),
790 HDA_CODEC_VOLUME("Ext Mic Capture Volume", 0x1a, 0x02, HDA_INPUT),
791 HDA_CODEC_MUTE("Ext Mic Capture Switch", 0x1a, 0x02, HDA_INPUT),
792 HDA_CODEC_VOLUME("PCM Playback Volume", 0x17, 0x0, HDA_INPUT),
793 HDA_CODEC_MUTE("PCM Playback Switch", 0x17, 0x0, HDA_INPUT),
794 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x17, 0x1, HDA_INPUT),
795 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x17, 0x1, HDA_INPUT),
796 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x17, 0x2, HDA_INPUT),
797 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x17, 0x2, HDA_INPUT),
798 HDA_BIND_VOL("Master Playback Volume", &cxt5045_hp_bind_master_vol),
799 {
800 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
801 .name = "Master Playback Switch",
802 .info = cxt_eapd_info,
803 .get = cxt_eapd_get,
804 .put = cxt5045_hp_master_sw_put,
805 .private_value = 0x10,
806 },
807
808 {}
809 };
810
811 static struct snd_kcontrol_new cxt5045_benq_mixers[] = {
812 HDA_CODEC_VOLUME("Line In Capture Volume", 0x1a, 0x03, HDA_INPUT),
813 HDA_CODEC_MUTE("Line In Capture Switch", 0x1a, 0x03, HDA_INPUT),
814 HDA_CODEC_VOLUME("Line In Playback Volume", 0x17, 0x3, HDA_INPUT),
815 HDA_CODEC_MUTE("Line In Playback Switch", 0x17, 0x3, HDA_INPUT),
816
817 {}
818 };
819
820 static struct snd_kcontrol_new cxt5045_mixers_hp530[] = {
821 HDA_CODEC_VOLUME("Int Mic Capture Volume", 0x1a, 0x02, HDA_INPUT),
822 HDA_CODEC_MUTE("Int Mic Capture Switch", 0x1a, 0x02, HDA_INPUT),
823 HDA_CODEC_VOLUME("Ext Mic Capture Volume", 0x1a, 0x01, HDA_INPUT),
824 HDA_CODEC_MUTE("Ext Mic Capture Switch", 0x1a, 0x01, HDA_INPUT),
825 HDA_CODEC_VOLUME("PCM Playback Volume", 0x17, 0x0, HDA_INPUT),
826 HDA_CODEC_MUTE("PCM Playback Switch", 0x17, 0x0, HDA_INPUT),
827 HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x17, 0x2, HDA_INPUT),
828 HDA_CODEC_MUTE("Int Mic Playback Switch", 0x17, 0x2, HDA_INPUT),
829 HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x17, 0x1, HDA_INPUT),
830 HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x17, 0x1, HDA_INPUT),
831 HDA_BIND_VOL("Master Playback Volume", &cxt5045_hp_bind_master_vol),
832 {
833 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
834 .name = "Master Playback Switch",
835 .info = cxt_eapd_info,
836 .get = cxt_eapd_get,
837 .put = cxt5045_hp_master_sw_put,
838 .private_value = 0x10,
839 },
840
841 {}
842 };
843
844 static struct hda_verb cxt5045_init_verbs[] = {
845 /* Line in, Mic */
846 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 },
847 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 },
848 /* HP, Amp */
849 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
850 {0x10, AC_VERB_SET_CONNECT_SEL, 0x1},
851 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
852 {0x11, AC_VERB_SET_CONNECT_SEL, 0x1},
853 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
854 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
855 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
856 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
857 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
858 /* Record selector: Int mic */
859 {0x1a, AC_VERB_SET_CONNECT_SEL,0x1},
860 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE,
861 AC_AMP_SET_INPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x17},
862 /* SPDIF route: PCM */
863 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
864 { 0x13, AC_VERB_SET_CONNECT_SEL, 0x0 },
865 /* EAPD */
866 {0x10, AC_VERB_SET_EAPD_BTLENABLE, 0x2 }, /* default on */
867 { } /* end */
868 };
869
870 static struct hda_verb cxt5045_benq_init_verbs[] = {
871 /* Int Mic, Mic */
872 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 },
873 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 },
874 /* Line In,HP, Amp */
875 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
876 {0x10, AC_VERB_SET_CONNECT_SEL, 0x1},
877 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
878 {0x11, AC_VERB_SET_CONNECT_SEL, 0x1},
879 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
880 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
881 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
882 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
883 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
884 /* Record selector: Int mic */
885 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x1},
886 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE,
887 AC_AMP_SET_INPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x17},
888 /* SPDIF route: PCM */
889 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
890 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
891 /* EAPD */
892 {0x10, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
893 { } /* end */
894 };
895
896 static struct hda_verb cxt5045_hp_sense_init_verbs[] = {
897 /* pin sensing on HP jack */
898 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
899 { } /* end */
900 };
901
902 static struct hda_verb cxt5045_mic_sense_init_verbs[] = {
903 /* pin sensing on HP jack */
904 {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
905 { } /* end */
906 };
907
908 #ifdef CONFIG_SND_DEBUG
909 /* Test configuration for debugging, modelled after the ALC260 test
910 * configuration.
911 */
912 static struct hda_input_mux cxt5045_test_capture_source = {
913 .num_items = 5,
914 .items = {
915 { "MIXER", 0x0 },
916 { "MIC1 pin", 0x1 },
917 { "LINE1 pin", 0x2 },
918 { "HP-OUT pin", 0x3 },
919 { "CD pin", 0x4 },
920 },
921 };
922
923 static struct snd_kcontrol_new cxt5045_test_mixer[] = {
924
925 /* Output controls */
926 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x10, 0x0, HDA_OUTPUT),
927 HDA_CODEC_MUTE("Speaker Playback Switch", 0x10, 0x0, HDA_OUTPUT),
928 HDA_CODEC_VOLUME("Node 11 Playback Volume", 0x11, 0x0, HDA_OUTPUT),
929 HDA_CODEC_MUTE("Node 11 Playback Switch", 0x11, 0x0, HDA_OUTPUT),
930 HDA_CODEC_VOLUME("Node 12 Playback Volume", 0x12, 0x0, HDA_OUTPUT),
931 HDA_CODEC_MUTE("Node 12 Playback Switch", 0x12, 0x0, HDA_OUTPUT),
932
933 /* Modes for retasking pin widgets */
934 CXT_PIN_MODE("HP-OUT pin mode", 0x11, CXT_PIN_DIR_INOUT),
935 CXT_PIN_MODE("LINE1 pin mode", 0x12, CXT_PIN_DIR_INOUT),
936
937 /* EAPD Switch Control */
938 CXT_EAPD_SWITCH("External Amplifier", 0x10, 0x0),
939
940 /* Loopback mixer controls */
941
942 HDA_CODEC_VOLUME("Mixer-1 Volume", 0x17, 0x0, HDA_INPUT),
943 HDA_CODEC_MUTE("Mixer-1 Switch", 0x17, 0x0, HDA_INPUT),
944 HDA_CODEC_VOLUME("Mixer-2 Volume", 0x17, 0x1, HDA_INPUT),
945 HDA_CODEC_MUTE("Mixer-2 Switch", 0x17, 0x1, HDA_INPUT),
946 HDA_CODEC_VOLUME("Mixer-3 Volume", 0x17, 0x2, HDA_INPUT),
947 HDA_CODEC_MUTE("Mixer-3 Switch", 0x17, 0x2, HDA_INPUT),
948 HDA_CODEC_VOLUME("Mixer-4 Volume", 0x17, 0x3, HDA_INPUT),
949 HDA_CODEC_MUTE("Mixer-4 Switch", 0x17, 0x3, HDA_INPUT),
950 HDA_CODEC_VOLUME("Mixer-5 Volume", 0x17, 0x4, HDA_INPUT),
951 HDA_CODEC_MUTE("Mixer-5 Switch", 0x17, 0x4, HDA_INPUT),
952 {
953 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
954 .name = "Input Source",
955 .info = conexant_mux_enum_info,
956 .get = conexant_mux_enum_get,
957 .put = conexant_mux_enum_put,
958 },
959 /* Audio input controls */
960 HDA_CODEC_VOLUME("Input-1 Volume", 0x1a, 0x0, HDA_INPUT),
961 HDA_CODEC_MUTE("Input-1 Switch", 0x1a, 0x0, HDA_INPUT),
962 HDA_CODEC_VOLUME("Input-2 Volume", 0x1a, 0x1, HDA_INPUT),
963 HDA_CODEC_MUTE("Input-2 Switch", 0x1a, 0x1, HDA_INPUT),
964 HDA_CODEC_VOLUME("Input-3 Volume", 0x1a, 0x2, HDA_INPUT),
965 HDA_CODEC_MUTE("Input-3 Switch", 0x1a, 0x2, HDA_INPUT),
966 HDA_CODEC_VOLUME("Input-4 Volume", 0x1a, 0x3, HDA_INPUT),
967 HDA_CODEC_MUTE("Input-4 Switch", 0x1a, 0x3, HDA_INPUT),
968 HDA_CODEC_VOLUME("Input-5 Volume", 0x1a, 0x4, HDA_INPUT),
969 HDA_CODEC_MUTE("Input-5 Switch", 0x1a, 0x4, HDA_INPUT),
970 { } /* end */
971 };
972
973 static struct hda_verb cxt5045_test_init_verbs[] = {
974 /* Set connections */
975 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
976 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x0 },
977 { 0x12, AC_VERB_SET_CONNECT_SEL, 0x0 },
978 /* Enable retasking pins as output, initially without power amp */
979 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
980 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
981
982 /* Disable digital (SPDIF) pins initially, but users can enable
983 * them via a mixer switch. In the case of SPDIF-out, this initverb
984 * payload also sets the generation to 0, output to be in "consumer"
985 * PCM format, copyright asserted, no pre-emphasis and no validity
986 * control.
987 */
988 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
989 {0x18, AC_VERB_SET_DIGI_CONVERT_1, 0},
990
991 /* Start with output sum widgets muted and their output gains at min */
992 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
993 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
994
995 /* Unmute retasking pin widget output buffers since the default
996 * state appears to be output. As the pin mode is changed by the
997 * user the pin mode control will take care of enabling the pin's
998 * input/output buffers as needed.
999 */
1000 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1001 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1002
1003 /* Mute capture amp left and right */
1004 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1005
1006 /* Set ADC connection select to match default mixer setting (mic1
1007 * pin)
1008 */
1009 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
1010 {0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1011
1012 /* Mute all inputs to mixer widget (even unconnected ones) */
1013 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* Mixer pin */
1014 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* Mic1 pin */
1015 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* Line pin */
1016 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* HP pin */
1017 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
1018
1019 { }
1020 };
1021 #endif
1022
1023
1024 /* initialize jack-sensing, too */
1025 static int cxt5045_init(struct hda_codec *codec)
1026 {
1027 conexant_init(codec);
1028 cxt5045_hp_automute(codec);
1029 return 0;
1030 }
1031
1032
1033 enum {
1034 CXT5045_LAPTOP_HPSENSE,
1035 CXT5045_LAPTOP_MICSENSE,
1036 CXT5045_LAPTOP_HPMICSENSE,
1037 CXT5045_BENQ,
1038 CXT5045_LAPTOP_HP530,
1039 #ifdef CONFIG_SND_DEBUG
1040 CXT5045_TEST,
1041 #endif
1042 CXT5045_MODELS
1043 };
1044
1045 static const char *cxt5045_models[CXT5045_MODELS] = {
1046 [CXT5045_LAPTOP_HPSENSE] = "laptop-hpsense",
1047 [CXT5045_LAPTOP_MICSENSE] = "laptop-micsense",
1048 [CXT5045_LAPTOP_HPMICSENSE] = "laptop-hpmicsense",
1049 [CXT5045_BENQ] = "benq",
1050 [CXT5045_LAPTOP_HP530] = "laptop-hp530",
1051 #ifdef CONFIG_SND_DEBUG
1052 [CXT5045_TEST] = "test",
1053 #endif
1054 };
1055
1056 static struct snd_pci_quirk cxt5045_cfg_tbl[] = {
1057 SND_PCI_QUIRK(0x103c, 0x30d5, "HP 530", CXT5045_LAPTOP_HP530),
1058 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP DV Series",
1059 CXT5045_LAPTOP_HPSENSE),
1060 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba P105", CXT5045_LAPTOP_MICSENSE),
1061 SND_PCI_QUIRK(0x152d, 0x0753, "Benq R55E", CXT5045_BENQ),
1062 SND_PCI_QUIRK(0x1734, 0x10ad, "Fujitsu Si1520", CXT5045_LAPTOP_MICSENSE),
1063 SND_PCI_QUIRK(0x1734, 0x10cb, "Fujitsu Si3515", CXT5045_LAPTOP_HPMICSENSE),
1064 SND_PCI_QUIRK(0x1734, 0x110e, "Fujitsu V5505",
1065 CXT5045_LAPTOP_HPMICSENSE),
1066 SND_PCI_QUIRK(0x1509, 0x1e40, "FIC", CXT5045_LAPTOP_HPMICSENSE),
1067 SND_PCI_QUIRK(0x1509, 0x2f05, "FIC", CXT5045_LAPTOP_HPMICSENSE),
1068 SND_PCI_QUIRK(0x1509, 0x2f06, "FIC", CXT5045_LAPTOP_HPMICSENSE),
1069 SND_PCI_QUIRK_MASK(0x1631, 0xff00, 0xc100, "Packard Bell",
1070 CXT5045_LAPTOP_HPMICSENSE),
1071 SND_PCI_QUIRK(0x8086, 0x2111, "Conexant Reference board", CXT5045_LAPTOP_HPSENSE),
1072 {}
1073 };
1074
1075 static int patch_cxt5045(struct hda_codec *codec)
1076 {
1077 struct conexant_spec *spec;
1078 int board_config;
1079
1080 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1081 if (!spec)
1082 return -ENOMEM;
1083 codec->spec = spec;
1084 codec->pin_amp_workaround = 1;
1085
1086 spec->multiout.max_channels = 2;
1087 spec->multiout.num_dacs = ARRAY_SIZE(cxt5045_dac_nids);
1088 spec->multiout.dac_nids = cxt5045_dac_nids;
1089 spec->multiout.dig_out_nid = CXT5045_SPDIF_OUT;
1090 spec->num_adc_nids = 1;
1091 spec->adc_nids = cxt5045_adc_nids;
1092 spec->capsrc_nids = cxt5045_capsrc_nids;
1093 spec->input_mux = &cxt5045_capture_source;
1094 spec->num_mixers = 1;
1095 spec->mixers[0] = cxt5045_mixers;
1096 spec->num_init_verbs = 1;
1097 spec->init_verbs[0] = cxt5045_init_verbs;
1098 spec->spdif_route = 0;
1099 spec->num_channel_mode = ARRAY_SIZE(cxt5045_modes),
1100 spec->channel_mode = cxt5045_modes,
1101
1102
1103 codec->patch_ops = conexant_patch_ops;
1104
1105 board_config = snd_hda_check_board_config(codec, CXT5045_MODELS,
1106 cxt5045_models,
1107 cxt5045_cfg_tbl);
1108 switch (board_config) {
1109 case CXT5045_LAPTOP_HPSENSE:
1110 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
1111 spec->input_mux = &cxt5045_capture_source;
1112 spec->num_init_verbs = 2;
1113 spec->init_verbs[1] = cxt5045_hp_sense_init_verbs;
1114 spec->mixers[0] = cxt5045_mixers;
1115 codec->patch_ops.init = cxt5045_init;
1116 break;
1117 case CXT5045_LAPTOP_MICSENSE:
1118 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
1119 spec->input_mux = &cxt5045_capture_source;
1120 spec->num_init_verbs = 2;
1121 spec->init_verbs[1] = cxt5045_mic_sense_init_verbs;
1122 spec->mixers[0] = cxt5045_mixers;
1123 codec->patch_ops.init = cxt5045_init;
1124 break;
1125 default:
1126 case CXT5045_LAPTOP_HPMICSENSE:
1127 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
1128 spec->input_mux = &cxt5045_capture_source;
1129 spec->num_init_verbs = 3;
1130 spec->init_verbs[1] = cxt5045_hp_sense_init_verbs;
1131 spec->init_verbs[2] = cxt5045_mic_sense_init_verbs;
1132 spec->mixers[0] = cxt5045_mixers;
1133 codec->patch_ops.init = cxt5045_init;
1134 break;
1135 case CXT5045_BENQ:
1136 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
1137 spec->input_mux = &cxt5045_capture_source_benq;
1138 spec->num_init_verbs = 1;
1139 spec->init_verbs[0] = cxt5045_benq_init_verbs;
1140 spec->mixers[0] = cxt5045_mixers;
1141 spec->mixers[1] = cxt5045_benq_mixers;
1142 spec->num_mixers = 2;
1143 codec->patch_ops.init = cxt5045_init;
1144 break;
1145 case CXT5045_LAPTOP_HP530:
1146 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event;
1147 spec->input_mux = &cxt5045_capture_source_hp530;
1148 spec->num_init_verbs = 2;
1149 spec->init_verbs[1] = cxt5045_hp_sense_init_verbs;
1150 spec->mixers[0] = cxt5045_mixers_hp530;
1151 codec->patch_ops.init = cxt5045_init;
1152 break;
1153 #ifdef CONFIG_SND_DEBUG
1154 case CXT5045_TEST:
1155 spec->input_mux = &cxt5045_test_capture_source;
1156 spec->mixers[0] = cxt5045_test_mixer;
1157 spec->init_verbs[0] = cxt5045_test_init_verbs;
1158 break;
1159
1160 #endif
1161 }
1162
1163 switch (codec->subsystem_id >> 16) {
1164 case 0x103c:
1165 /* HP laptop has a really bad sound over 0dB on NID 0x17.
1166 * Fix max PCM level to 0 dB
1167 * (originall it has 0x2b steps with 0dB offset 0x14)
1168 */
1169 snd_hda_override_amp_caps(codec, 0x17, HDA_INPUT,
1170 (0x14 << AC_AMPCAP_OFFSET_SHIFT) |
1171 (0x14 << AC_AMPCAP_NUM_STEPS_SHIFT) |
1172 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
1173 (1 << AC_AMPCAP_MUTE_SHIFT));
1174 break;
1175 }
1176
1177 return 0;
1178 }
1179
1180
1181 /* Conexant 5047 specific */
1182 #define CXT5047_SPDIF_OUT 0x11
1183
1184 static hda_nid_t cxt5047_dac_nids[1] = { 0x10 }; /* 0x1c */
1185 static hda_nid_t cxt5047_adc_nids[1] = { 0x12 };
1186 static hda_nid_t cxt5047_capsrc_nids[1] = { 0x1a };
1187
1188 static struct hda_channel_mode cxt5047_modes[1] = {
1189 { 2, NULL },
1190 };
1191
1192 static struct hda_input_mux cxt5047_toshiba_capture_source = {
1193 .num_items = 2,
1194 .items = {
1195 { "ExtMic", 0x2 },
1196 { "Line-In", 0x1 },
1197 }
1198 };
1199
1200 /* turn on/off EAPD (+ mute HP) as a master switch */
1201 static int cxt5047_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1202 struct snd_ctl_elem_value *ucontrol)
1203 {
1204 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1205 struct conexant_spec *spec = codec->spec;
1206 unsigned int bits;
1207
1208 if (!cxt_eapd_put(kcontrol, ucontrol))
1209 return 0;
1210
1211 /* toggle internal speakers mute depending of presence of
1212 * the headphone jack
1213 */
1214 bits = (!spec->hp_present && spec->cur_eapd) ? 0 : HDA_AMP_MUTE;
1215 /* NOTE: Conexat codec needs the index for *OUTPUT* amp of
1216 * pin widgets unlike other codecs. In this case, we need to
1217 * set index 0x01 for the volume from the mixer amp 0x19.
1218 */
1219 snd_hda_codec_amp_stereo(codec, 0x1d, HDA_OUTPUT, 0x01,
1220 HDA_AMP_MUTE, bits);
1221 bits = spec->cur_eapd ? 0 : HDA_AMP_MUTE;
1222 snd_hda_codec_amp_stereo(codec, 0x13, HDA_OUTPUT, 0,
1223 HDA_AMP_MUTE, bits);
1224 return 1;
1225 }
1226
1227 /* mute internal speaker if HP is plugged */
1228 static void cxt5047_hp_automute(struct hda_codec *codec)
1229 {
1230 struct conexant_spec *spec = codec->spec;
1231 unsigned int bits;
1232
1233 spec->hp_present = snd_hda_codec_read(codec, 0x13, 0,
1234 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1235
1236 bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0;
1237 /* See the note in cxt5047_hp_master_sw_put */
1238 snd_hda_codec_amp_stereo(codec, 0x1d, HDA_OUTPUT, 0x01,
1239 HDA_AMP_MUTE, bits);
1240 }
1241
1242 /* toggle input of built-in and mic jack appropriately */
1243 static void cxt5047_hp_automic(struct hda_codec *codec)
1244 {
1245 static struct hda_verb mic_jack_on[] = {
1246 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1247 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1248 {}
1249 };
1250 static struct hda_verb mic_jack_off[] = {
1251 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1252 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1253 {}
1254 };
1255 unsigned int present;
1256
1257 present = snd_hda_codec_read(codec, 0x15, 0,
1258 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1259 if (present)
1260 snd_hda_sequence_write(codec, mic_jack_on);
1261 else
1262 snd_hda_sequence_write(codec, mic_jack_off);
1263 }
1264
1265 /* unsolicited event for HP jack sensing */
1266 static void cxt5047_hp_unsol_event(struct hda_codec *codec,
1267 unsigned int res)
1268 {
1269 switch (res >> 26) {
1270 case CONEXANT_HP_EVENT:
1271 cxt5047_hp_automute(codec);
1272 break;
1273 case CONEXANT_MIC_EVENT:
1274 cxt5047_hp_automic(codec);
1275 break;
1276 }
1277 }
1278
1279 static struct snd_kcontrol_new cxt5047_base_mixers[] = {
1280 HDA_CODEC_VOLUME("Mic Playback Volume", 0x19, 0x02, HDA_INPUT),
1281 HDA_CODEC_MUTE("Mic Playback Switch", 0x19, 0x02, HDA_INPUT),
1282 HDA_CODEC_VOLUME("Mic Boost", 0x1a, 0x0, HDA_OUTPUT),
1283 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x03, HDA_INPUT),
1284 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x03, HDA_INPUT),
1285 HDA_CODEC_VOLUME("PCM Volume", 0x10, 0x00, HDA_OUTPUT),
1286 HDA_CODEC_MUTE("PCM Switch", 0x10, 0x00, HDA_OUTPUT),
1287 {
1288 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1289 .name = "Master Playback Switch",
1290 .info = cxt_eapd_info,
1291 .get = cxt_eapd_get,
1292 .put = cxt5047_hp_master_sw_put,
1293 .private_value = 0x13,
1294 },
1295
1296 {}
1297 };
1298
1299 static struct snd_kcontrol_new cxt5047_hp_spk_mixers[] = {
1300 /* See the note in cxt5047_hp_master_sw_put */
1301 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x1d, 0x01, HDA_OUTPUT),
1302 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x13, 0x00, HDA_OUTPUT),
1303 {}
1304 };
1305
1306 static struct snd_kcontrol_new cxt5047_hp_only_mixers[] = {
1307 HDA_CODEC_VOLUME("Master Playback Volume", 0x13, 0x00, HDA_OUTPUT),
1308 { } /* end */
1309 };
1310
1311 static struct hda_verb cxt5047_init_verbs[] = {
1312 /* Line in, Mic, Built-in Mic */
1313 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1314 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_50 },
1315 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_50 },
1316 /* HP, Speaker */
1317 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
1318 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0}, /* mixer(0x19) */
1319 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mixer(0x19) */
1320 /* Record selector: Mic */
1321 {0x12, AC_VERB_SET_CONNECT_SEL,0x03},
1322 {0x19, AC_VERB_SET_AMP_GAIN_MUTE,
1323 AC_AMP_SET_INPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x17},
1324 {0x1A, AC_VERB_SET_CONNECT_SEL,0x02},
1325 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE,
1326 AC_AMP_SET_OUTPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x00},
1327 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE,
1328 AC_AMP_SET_OUTPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x03},
1329 /* SPDIF route: PCM */
1330 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x0 },
1331 /* Enable unsolicited events */
1332 {0x13, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT},
1333 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT},
1334 { } /* end */
1335 };
1336
1337 /* configuration for Toshiba Laptops */
1338 static struct hda_verb cxt5047_toshiba_init_verbs[] = {
1339 {0x13, AC_VERB_SET_EAPD_BTLENABLE, 0x0}, /* default off */
1340 {}
1341 };
1342
1343 /* Test configuration for debugging, modelled after the ALC260 test
1344 * configuration.
1345 */
1346 #ifdef CONFIG_SND_DEBUG
1347 static struct hda_input_mux cxt5047_test_capture_source = {
1348 .num_items = 4,
1349 .items = {
1350 { "LINE1 pin", 0x0 },
1351 { "MIC1 pin", 0x1 },
1352 { "MIC2 pin", 0x2 },
1353 { "CD pin", 0x3 },
1354 },
1355 };
1356
1357 static struct snd_kcontrol_new cxt5047_test_mixer[] = {
1358
1359 /* Output only controls */
1360 HDA_CODEC_VOLUME("OutAmp-1 Volume", 0x10, 0x0, HDA_OUTPUT),
1361 HDA_CODEC_MUTE("OutAmp-1 Switch", 0x10,0x0, HDA_OUTPUT),
1362 HDA_CODEC_VOLUME("OutAmp-2 Volume", 0x1c, 0x0, HDA_OUTPUT),
1363 HDA_CODEC_MUTE("OutAmp-2 Switch", 0x1c, 0x0, HDA_OUTPUT),
1364 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1365 HDA_CODEC_MUTE("Speaker Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1366 HDA_CODEC_VOLUME("HeadPhone Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1367 HDA_CODEC_MUTE("HeadPhone Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1368 HDA_CODEC_VOLUME("Line1-Out Playback Volume", 0x14, 0x0, HDA_OUTPUT),
1369 HDA_CODEC_MUTE("Line1-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1370 HDA_CODEC_VOLUME("Line2-Out Playback Volume", 0x15, 0x0, HDA_OUTPUT),
1371 HDA_CODEC_MUTE("Line2-Out Playback Switch", 0x15, 0x0, HDA_OUTPUT),
1372
1373 /* Modes for retasking pin widgets */
1374 CXT_PIN_MODE("LINE1 pin mode", 0x14, CXT_PIN_DIR_INOUT),
1375 CXT_PIN_MODE("MIC1 pin mode", 0x15, CXT_PIN_DIR_INOUT),
1376
1377 /* EAPD Switch Control */
1378 CXT_EAPD_SWITCH("External Amplifier", 0x13, 0x0),
1379
1380 /* Loopback mixer controls */
1381 HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x12, 0x01, HDA_INPUT),
1382 HDA_CODEC_MUTE("MIC1 Playback Switch", 0x12, 0x01, HDA_INPUT),
1383 HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x12, 0x02, HDA_INPUT),
1384 HDA_CODEC_MUTE("MIC2 Playback Switch", 0x12, 0x02, HDA_INPUT),
1385 HDA_CODEC_VOLUME("LINE Playback Volume", 0x12, 0x0, HDA_INPUT),
1386 HDA_CODEC_MUTE("LINE Playback Switch", 0x12, 0x0, HDA_INPUT),
1387 HDA_CODEC_VOLUME("CD Playback Volume", 0x12, 0x04, HDA_INPUT),
1388 HDA_CODEC_MUTE("CD Playback Switch", 0x12, 0x04, HDA_INPUT),
1389
1390 HDA_CODEC_VOLUME("Capture-1 Volume", 0x19, 0x0, HDA_INPUT),
1391 HDA_CODEC_MUTE("Capture-1 Switch", 0x19, 0x0, HDA_INPUT),
1392 HDA_CODEC_VOLUME("Capture-2 Volume", 0x19, 0x1, HDA_INPUT),
1393 HDA_CODEC_MUTE("Capture-2 Switch", 0x19, 0x1, HDA_INPUT),
1394 HDA_CODEC_VOLUME("Capture-3 Volume", 0x19, 0x2, HDA_INPUT),
1395 HDA_CODEC_MUTE("Capture-3 Switch", 0x19, 0x2, HDA_INPUT),
1396 HDA_CODEC_VOLUME("Capture-4 Volume", 0x19, 0x3, HDA_INPUT),
1397 HDA_CODEC_MUTE("Capture-4 Switch", 0x19, 0x3, HDA_INPUT),
1398 {
1399 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1400 .name = "Input Source",
1401 .info = conexant_mux_enum_info,
1402 .get = conexant_mux_enum_get,
1403 .put = conexant_mux_enum_put,
1404 },
1405 HDA_CODEC_VOLUME("Input-1 Volume", 0x1a, 0x0, HDA_INPUT),
1406 HDA_CODEC_MUTE("Input-1 Switch", 0x1a, 0x0, HDA_INPUT),
1407 HDA_CODEC_VOLUME("Input-2 Volume", 0x1a, 0x1, HDA_INPUT),
1408 HDA_CODEC_MUTE("Input-2 Switch", 0x1a, 0x1, HDA_INPUT),
1409 HDA_CODEC_VOLUME("Input-3 Volume", 0x1a, 0x2, HDA_INPUT),
1410 HDA_CODEC_MUTE("Input-3 Switch", 0x1a, 0x2, HDA_INPUT),
1411 HDA_CODEC_VOLUME("Input-4 Volume", 0x1a, 0x3, HDA_INPUT),
1412 HDA_CODEC_MUTE("Input-4 Switch", 0x1a, 0x3, HDA_INPUT),
1413 HDA_CODEC_VOLUME("Input-5 Volume", 0x1a, 0x4, HDA_INPUT),
1414 HDA_CODEC_MUTE("Input-5 Switch", 0x1a, 0x4, HDA_INPUT),
1415
1416 { } /* end */
1417 };
1418
1419 static struct hda_verb cxt5047_test_init_verbs[] = {
1420 /* Enable retasking pins as output, initially without power amp */
1421 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1422 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1423 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1424
1425 /* Disable digital (SPDIF) pins initially, but users can enable
1426 * them via a mixer switch. In the case of SPDIF-out, this initverb
1427 * payload also sets the generation to 0, output to be in "consumer"
1428 * PCM format, copyright asserted, no pre-emphasis and no validity
1429 * control.
1430 */
1431 {0x18, AC_VERB_SET_DIGI_CONVERT_1, 0},
1432
1433 /* Ensure mic1, mic2, line1 pin widgets take input from the
1434 * OUT1 sum bus when acting as an output.
1435 */
1436 {0x1a, AC_VERB_SET_CONNECT_SEL, 0},
1437 {0x1b, AC_VERB_SET_CONNECT_SEL, 0},
1438
1439 /* Start with output sum widgets muted and their output gains at min */
1440 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1441 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1442
1443 /* Unmute retasking pin widget output buffers since the default
1444 * state appears to be output. As the pin mode is changed by the
1445 * user the pin mode control will take care of enabling the pin's
1446 * input/output buffers as needed.
1447 */
1448 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1449 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1450 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1451
1452 /* Mute capture amp left and right */
1453 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1454
1455 /* Set ADC connection select to match default mixer setting (mic1
1456 * pin)
1457 */
1458 {0x12, AC_VERB_SET_CONNECT_SEL, 0x00},
1459
1460 /* Mute all inputs to mixer widget (even unconnected ones) */
1461 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
1462 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
1463 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
1464 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
1465 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
1466 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
1467 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
1468 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
1469
1470 { }
1471 };
1472 #endif
1473
1474
1475 /* initialize jack-sensing, too */
1476 static int cxt5047_hp_init(struct hda_codec *codec)
1477 {
1478 conexant_init(codec);
1479 cxt5047_hp_automute(codec);
1480 return 0;
1481 }
1482
1483
1484 enum {
1485 CXT5047_LAPTOP, /* Laptops w/o EAPD support */
1486 CXT5047_LAPTOP_HP, /* Some HP laptops */
1487 CXT5047_LAPTOP_EAPD, /* Laptops with EAPD support */
1488 #ifdef CONFIG_SND_DEBUG
1489 CXT5047_TEST,
1490 #endif
1491 CXT5047_MODELS
1492 };
1493
1494 static const char *cxt5047_models[CXT5047_MODELS] = {
1495 [CXT5047_LAPTOP] = "laptop",
1496 [CXT5047_LAPTOP_HP] = "laptop-hp",
1497 [CXT5047_LAPTOP_EAPD] = "laptop-eapd",
1498 #ifdef CONFIG_SND_DEBUG
1499 [CXT5047_TEST] = "test",
1500 #endif
1501 };
1502
1503 static struct snd_pci_quirk cxt5047_cfg_tbl[] = {
1504 SND_PCI_QUIRK(0x103c, 0x30a5, "HP DV5200T/DV8000T", CXT5047_LAPTOP_HP),
1505 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP DV Series",
1506 CXT5047_LAPTOP),
1507 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba P100", CXT5047_LAPTOP_EAPD),
1508 {}
1509 };
1510
1511 static int patch_cxt5047(struct hda_codec *codec)
1512 {
1513 struct conexant_spec *spec;
1514 int board_config;
1515
1516 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1517 if (!spec)
1518 return -ENOMEM;
1519 codec->spec = spec;
1520 codec->pin_amp_workaround = 1;
1521
1522 spec->multiout.max_channels = 2;
1523 spec->multiout.num_dacs = ARRAY_SIZE(cxt5047_dac_nids);
1524 spec->multiout.dac_nids = cxt5047_dac_nids;
1525 spec->multiout.dig_out_nid = CXT5047_SPDIF_OUT;
1526 spec->num_adc_nids = 1;
1527 spec->adc_nids = cxt5047_adc_nids;
1528 spec->capsrc_nids = cxt5047_capsrc_nids;
1529 spec->num_mixers = 1;
1530 spec->mixers[0] = cxt5047_base_mixers;
1531 spec->num_init_verbs = 1;
1532 spec->init_verbs[0] = cxt5047_init_verbs;
1533 spec->spdif_route = 0;
1534 spec->num_channel_mode = ARRAY_SIZE(cxt5047_modes),
1535 spec->channel_mode = cxt5047_modes,
1536
1537 codec->patch_ops = conexant_patch_ops;
1538
1539 board_config = snd_hda_check_board_config(codec, CXT5047_MODELS,
1540 cxt5047_models,
1541 cxt5047_cfg_tbl);
1542 switch (board_config) {
1543 case CXT5047_LAPTOP:
1544 spec->num_mixers = 2;
1545 spec->mixers[1] = cxt5047_hp_spk_mixers;
1546 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
1547 break;
1548 case CXT5047_LAPTOP_HP:
1549 spec->num_mixers = 2;
1550 spec->mixers[1] = cxt5047_hp_only_mixers;
1551 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
1552 codec->patch_ops.init = cxt5047_hp_init;
1553 break;
1554 case CXT5047_LAPTOP_EAPD:
1555 spec->input_mux = &cxt5047_toshiba_capture_source;
1556 spec->num_mixers = 2;
1557 spec->mixers[1] = cxt5047_hp_spk_mixers;
1558 spec->num_init_verbs = 2;
1559 spec->init_verbs[1] = cxt5047_toshiba_init_verbs;
1560 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
1561 break;
1562 #ifdef CONFIG_SND_DEBUG
1563 case CXT5047_TEST:
1564 spec->input_mux = &cxt5047_test_capture_source;
1565 spec->mixers[0] = cxt5047_test_mixer;
1566 spec->init_verbs[0] = cxt5047_test_init_verbs;
1567 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event;
1568 #endif
1569 }
1570 spec->vmaster_nid = 0x13;
1571 return 0;
1572 }
1573
1574 /* Conexant 5051 specific */
1575 static hda_nid_t cxt5051_dac_nids[1] = { 0x10 };
1576 static hda_nid_t cxt5051_adc_nids[2] = { 0x14, 0x15 };
1577
1578 static struct hda_channel_mode cxt5051_modes[1] = {
1579 { 2, NULL },
1580 };
1581
1582 static void cxt5051_update_speaker(struct hda_codec *codec)
1583 {
1584 struct conexant_spec *spec = codec->spec;
1585 unsigned int pinctl;
1586 pinctl = (!spec->hp_present && spec->cur_eapd) ? PIN_OUT : 0;
1587 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
1588 pinctl);
1589 }
1590
1591 /* turn on/off EAPD (+ mute HP) as a master switch */
1592 static int cxt5051_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1593 struct snd_ctl_elem_value *ucontrol)
1594 {
1595 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1596
1597 if (!cxt_eapd_put(kcontrol, ucontrol))
1598 return 0;
1599 cxt5051_update_speaker(codec);
1600 return 1;
1601 }
1602
1603 /* toggle input of built-in and mic jack appropriately */
1604 static void cxt5051_portb_automic(struct hda_codec *codec)
1605 {
1606 struct conexant_spec *spec = codec->spec;
1607 unsigned int present;
1608
1609 if (spec->no_auto_mic)
1610 return;
1611 present = snd_hda_codec_read(codec, 0x17, 0,
1612 AC_VERB_GET_PIN_SENSE, 0) &
1613 AC_PINSENSE_PRESENCE;
1614 snd_hda_codec_write(codec, 0x14, 0,
1615 AC_VERB_SET_CONNECT_SEL,
1616 present ? 0x01 : 0x00);
1617 }
1618
1619 /* switch the current ADC according to the jack state */
1620 static void cxt5051_portc_automic(struct hda_codec *codec)
1621 {
1622 struct conexant_spec *spec = codec->spec;
1623 unsigned int present;
1624 hda_nid_t new_adc;
1625
1626 if (spec->no_auto_mic)
1627 return;
1628 present = snd_hda_codec_read(codec, 0x18, 0,
1629 AC_VERB_GET_PIN_SENSE, 0) &
1630 AC_PINSENSE_PRESENCE;
1631 if (present)
1632 spec->cur_adc_idx = 1;
1633 else
1634 spec->cur_adc_idx = 0;
1635 new_adc = spec->adc_nids[spec->cur_adc_idx];
1636 if (spec->cur_adc && spec->cur_adc != new_adc) {
1637 /* stream is running, let's swap the current ADC */
1638 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
1639 spec->cur_adc = new_adc;
1640 snd_hda_codec_setup_stream(codec, new_adc,
1641 spec->cur_adc_stream_tag, 0,
1642 spec->cur_adc_format);
1643 }
1644 }
1645
1646 /* mute internal speaker if HP is plugged */
1647 static void cxt5051_hp_automute(struct hda_codec *codec)
1648 {
1649 struct conexant_spec *spec = codec->spec;
1650
1651 spec->hp_present = snd_hda_codec_read(codec, 0x16, 0,
1652 AC_VERB_GET_PIN_SENSE, 0) &
1653 AC_PINSENSE_PRESENCE;
1654 cxt5051_update_speaker(codec);
1655 }
1656
1657 /* unsolicited event for HP jack sensing */
1658 static void cxt5051_hp_unsol_event(struct hda_codec *codec,
1659 unsigned int res)
1660 {
1661 int nid = (res & AC_UNSOL_RES_SUBTAG) >> 20;
1662 switch (res >> 26) {
1663 case CONEXANT_HP_EVENT:
1664 cxt5051_hp_automute(codec);
1665 break;
1666 case CXT5051_PORTB_EVENT:
1667 cxt5051_portb_automic(codec);
1668 break;
1669 case CXT5051_PORTC_EVENT:
1670 cxt5051_portc_automic(codec);
1671 break;
1672 }
1673 conexant_report_jack(codec, nid);
1674 }
1675
1676 static struct snd_kcontrol_new cxt5051_mixers[] = {
1677 HDA_CODEC_VOLUME("Internal Mic Volume", 0x14, 0x00, HDA_INPUT),
1678 HDA_CODEC_MUTE("Internal Mic Switch", 0x14, 0x00, HDA_INPUT),
1679 HDA_CODEC_VOLUME("External Mic Volume", 0x14, 0x01, HDA_INPUT),
1680 HDA_CODEC_MUTE("External Mic Switch", 0x14, 0x01, HDA_INPUT),
1681 HDA_CODEC_VOLUME("Docking Mic Volume", 0x15, 0x00, HDA_INPUT),
1682 HDA_CODEC_MUTE("Docking Mic Switch", 0x15, 0x00, HDA_INPUT),
1683 HDA_CODEC_VOLUME("Master Playback Volume", 0x10, 0x00, HDA_OUTPUT),
1684 {
1685 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1686 .name = "Master Playback Switch",
1687 .info = cxt_eapd_info,
1688 .get = cxt_eapd_get,
1689 .put = cxt5051_hp_master_sw_put,
1690 .private_value = 0x1a,
1691 },
1692
1693 {}
1694 };
1695
1696 static struct snd_kcontrol_new cxt5051_hp_mixers[] = {
1697 HDA_CODEC_VOLUME("Internal Mic Volume", 0x14, 0x00, HDA_INPUT),
1698 HDA_CODEC_MUTE("Internal Mic Switch", 0x14, 0x00, HDA_INPUT),
1699 HDA_CODEC_VOLUME("External Mic Volume", 0x15, 0x00, HDA_INPUT),
1700 HDA_CODEC_MUTE("External Mic Switch", 0x15, 0x00, HDA_INPUT),
1701 HDA_CODEC_VOLUME("Master Playback Volume", 0x10, 0x00, HDA_OUTPUT),
1702 {
1703 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1704 .name = "Master Playback Switch",
1705 .info = cxt_eapd_info,
1706 .get = cxt_eapd_get,
1707 .put = cxt5051_hp_master_sw_put,
1708 .private_value = 0x1a,
1709 },
1710
1711 {}
1712 };
1713
1714 static struct snd_kcontrol_new cxt5051_hp_dv6736_mixers[] = {
1715 HDA_CODEC_VOLUME("Mic Volume", 0x14, 0x00, HDA_INPUT),
1716 HDA_CODEC_MUTE("Mic Switch", 0x14, 0x00, HDA_INPUT),
1717 HDA_CODEC_VOLUME("Master Playback Volume", 0x10, 0x00, HDA_OUTPUT),
1718 {
1719 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1720 .name = "Master Playback Switch",
1721 .info = cxt_eapd_info,
1722 .get = cxt_eapd_get,
1723 .put = cxt5051_hp_master_sw_put,
1724 .private_value = 0x1a,
1725 },
1726
1727 {}
1728 };
1729
1730 static struct hda_verb cxt5051_init_verbs[] = {
1731 /* Line in, Mic */
1732 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
1733 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1734 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
1735 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1736 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1737 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
1738 /* SPK */
1739 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1740 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
1741 /* HP, Amp */
1742 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1743 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
1744 /* DAC1 */
1745 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1746 /* Record selector: Int mic */
1747 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x44},
1748 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1) | 0x44},
1749 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x44},
1750 /* SPDIF route: PCM */
1751 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x0},
1752 /* EAPD */
1753 {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
1754 {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
1755 {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTB_EVENT},
1756 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTC_EVENT},
1757 { } /* end */
1758 };
1759
1760 static struct hda_verb cxt5051_hp_dv6736_init_verbs[] = {
1761 /* Line in, Mic */
1762 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
1763 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1764 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0},
1765 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0},
1766 /* SPK */
1767 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1768 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
1769 /* HP, Amp */
1770 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1771 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
1772 /* DAC1 */
1773 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1774 /* Record selector: Int mic */
1775 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1) | 0x44},
1776 {0x14, AC_VERB_SET_CONNECT_SEL, 0x1},
1777 /* SPDIF route: PCM */
1778 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x0},
1779 /* EAPD */
1780 {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
1781 {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
1782 {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTB_EVENT},
1783 { } /* end */
1784 };
1785
1786 static struct hda_verb cxt5051_lenovo_x200_init_verbs[] = {
1787 /* Line in, Mic */
1788 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
1789 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1790 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
1791 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1792 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1793 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03},
1794 /* SPK */
1795 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1796 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
1797 /* HP, Amp */
1798 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1799 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
1800 /* Docking HP */
1801 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1802 {0x19, AC_VERB_SET_CONNECT_SEL, 0x00},
1803 /* DAC1 */
1804 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1805 /* Record selector: Int mic */
1806 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x44},
1807 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1) | 0x44},
1808 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x44},
1809 /* SPDIF route: PCM */
1810 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x0},
1811 /* EAPD */
1812 {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */
1813 {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
1814 {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTB_EVENT},
1815 {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CXT5051_PORTC_EVENT},
1816 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT},
1817 { } /* end */
1818 };
1819
1820 /* initialize jack-sensing, too */
1821 static int cxt5051_init(struct hda_codec *codec)
1822 {
1823 conexant_init(codec);
1824 conexant_init_jacks(codec);
1825 if (codec->patch_ops.unsol_event) {
1826 cxt5051_hp_automute(codec);
1827 cxt5051_portb_automic(codec);
1828 cxt5051_portc_automic(codec);
1829 }
1830 return 0;
1831 }
1832
1833
1834 enum {
1835 CXT5051_LAPTOP, /* Laptops w/ EAPD support */
1836 CXT5051_HP, /* no docking */
1837 CXT5051_HP_DV6736, /* HP without mic switch */
1838 CXT5051_LENOVO_X200, /* Lenovo X200 laptop */
1839 CXT5051_MODELS
1840 };
1841
1842 static const char *cxt5051_models[CXT5051_MODELS] = {
1843 [CXT5051_LAPTOP] = "laptop",
1844 [CXT5051_HP] = "hp",
1845 [CXT5051_HP_DV6736] = "hp-dv6736",
1846 [CXT5051_LENOVO_X200] = "lenovo-x200",
1847 };
1848
1849 static struct snd_pci_quirk cxt5051_cfg_tbl[] = {
1850 SND_PCI_QUIRK(0x103c, 0x30cf, "HP DV6736", CXT5051_HP_DV6736),
1851 SND_PCI_QUIRK(0x103c, 0x360b, "Compaq Presario CQ60", CXT5051_HP),
1852 SND_PCI_QUIRK(0x14f1, 0x0101, "Conexant Reference board",
1853 CXT5051_LAPTOP),
1854 SND_PCI_QUIRK(0x14f1, 0x5051, "HP Spartan 1.1", CXT5051_HP),
1855 SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo X200", CXT5051_LENOVO_X200),
1856 {}
1857 };
1858
1859 static int patch_cxt5051(struct hda_codec *codec)
1860 {
1861 struct conexant_spec *spec;
1862 int board_config;
1863
1864 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1865 if (!spec)
1866 return -ENOMEM;
1867 codec->spec = spec;
1868 codec->pin_amp_workaround = 1;
1869
1870 codec->patch_ops = conexant_patch_ops;
1871 codec->patch_ops.init = cxt5051_init;
1872
1873 spec->multiout.max_channels = 2;
1874 spec->multiout.num_dacs = ARRAY_SIZE(cxt5051_dac_nids);
1875 spec->multiout.dac_nids = cxt5051_dac_nids;
1876 spec->multiout.dig_out_nid = CXT5051_SPDIF_OUT;
1877 spec->num_adc_nids = 1; /* not 2; via auto-mic switch */
1878 spec->adc_nids = cxt5051_adc_nids;
1879 spec->num_mixers = 1;
1880 spec->mixers[0] = cxt5051_mixers;
1881 spec->num_init_verbs = 1;
1882 spec->init_verbs[0] = cxt5051_init_verbs;
1883 spec->spdif_route = 0;
1884 spec->num_channel_mode = ARRAY_SIZE(cxt5051_modes);
1885 spec->channel_mode = cxt5051_modes;
1886 spec->cur_adc = 0;
1887 spec->cur_adc_idx = 0;
1888
1889 codec->patch_ops.unsol_event = cxt5051_hp_unsol_event;
1890
1891 board_config = snd_hda_check_board_config(codec, CXT5051_MODELS,
1892 cxt5051_models,
1893 cxt5051_cfg_tbl);
1894 switch (board_config) {
1895 case CXT5051_HP:
1896 spec->mixers[0] = cxt5051_hp_mixers;
1897 break;
1898 case CXT5051_HP_DV6736:
1899 spec->init_verbs[0] = cxt5051_hp_dv6736_init_verbs;
1900 spec->mixers[0] = cxt5051_hp_dv6736_mixers;
1901 spec->no_auto_mic = 1;
1902 break;
1903 case CXT5051_LENOVO_X200:
1904 spec->init_verbs[0] = cxt5051_lenovo_x200_init_verbs;
1905 break;
1906 }
1907
1908 return 0;
1909 }
1910
1911
1912 /*
1913 */
1914
1915 static struct hda_codec_preset snd_hda_preset_conexant[] = {
1916 { .id = 0x14f15045, .name = "CX20549 (Venice)",
1917 .patch = patch_cxt5045 },
1918 { .id = 0x14f15047, .name = "CX20551 (Waikiki)",
1919 .patch = patch_cxt5047 },
1920 { .id = 0x14f15051, .name = "CX20561 (Hermosa)",
1921 .patch = patch_cxt5051 },
1922 {} /* terminator */
1923 };
1924
1925 MODULE_ALIAS("snd-hda-codec-id:14f15045");
1926 MODULE_ALIAS("snd-hda-codec-id:14f15047");
1927 MODULE_ALIAS("snd-hda-codec-id:14f15051");
1928
1929 MODULE_LICENSE("GPL");
1930 MODULE_DESCRIPTION("Conexant HD-audio codec");
1931
1932 static struct hda_codec_preset_list conexant_list = {
1933 .preset = snd_hda_preset_conexant,
1934 .owner = THIS_MODULE,
1935 };
1936
1937 static int __init patch_conexant_init(void)
1938 {
1939 return snd_hda_add_codec_preset(&conexant_list);
1940 }
1941
1942 static void __exit patch_conexant_exit(void)
1943 {
1944 snd_hda_delete_codec_preset(&conexant_list);
1945 }
1946
1947 module_init(patch_conexant_init)
1948 module_exit(patch_conexant_exit)
Linux ACPI git tree (mirror)