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 <linux/module.h> 28 #include <sound/core.h> 29 #include <sound/jack.h> 30 31 #include "hda_codec.h" 32 #include "hda_local.h" 33 #include "hda_beep.h" 34 35 #define CXT_PIN_DIR_IN 0x00 36 #define CXT_PIN_DIR_OUT 0x01 37 #define CXT_PIN_DIR_INOUT 0x02 38 #define CXT_PIN_DIR_IN_NOMICBIAS 0x03 39 #define CXT_PIN_DIR_INOUT_NOMICBIAS 0x04 40 41 #define CONEXANT_HP_EVENT 0x37 42 #define CONEXANT_MIC_EVENT 0x38 43 #define CONEXANT_LINE_EVENT 0x39 44 45 /* Conexant 5051 specific */ 46 47 #define CXT5051_SPDIF_OUT 0x12 48 #define CXT5051_PORTB_EVENT 0x38 49 #define CXT5051_PORTC_EVENT 0x39 50 51 #define AUTO_MIC_PORTB (1 << 1) 52 #define AUTO_MIC_PORTC (1 << 2) 53 54 struct pin_dac_pair { 55 hda_nid_t pin; 56 hda_nid_t dac; 57 int type; 58 }; 59 60 struct imux_info { 61 hda_nid_t pin; /* input pin NID */ 62 hda_nid_t adc; /* connected ADC NID */ 63 hda_nid_t boost; /* optional boost volume NID */ 64 int index; /* corresponding to autocfg.input */ 65 }; 66 67 struct conexant_spec { 68 69 const struct snd_kcontrol_new *mixers[5]; 70 int num_mixers; 71 hda_nid_t vmaster_nid; 72 73 const struct hda_verb *init_verbs[5]; /* initialization verbs 74 * don't forget NULL 75 * termination! 76 */ 77 unsigned int num_init_verbs; 78 79 /* playback */ 80 struct hda_multi_out multiout; /* playback set-up 81 * max_channels, dacs must be set 82 * dig_out_nid and hp_nid are optional 83 */ 84 unsigned int cur_eapd; 85 unsigned int hp_present; 86 unsigned int line_present; 87 unsigned int auto_mic; 88 int auto_mic_ext; /* imux_pins[] index for ext mic */ 89 int auto_mic_dock; /* imux_pins[] index for dock mic */ 90 int auto_mic_int; /* imux_pins[] index for int mic */ 91 unsigned int need_dac_fix; 92 hda_nid_t slave_dig_outs[2]; 93 94 /* capture */ 95 unsigned int num_adc_nids; 96 const hda_nid_t *adc_nids; 97 hda_nid_t dig_in_nid; /* digital-in NID; optional */ 98 99 unsigned int cur_adc_idx; 100 hda_nid_t cur_adc; 101 unsigned int cur_adc_stream_tag; 102 unsigned int cur_adc_format; 103 104 const struct hda_pcm_stream *capture_stream; 105 106 /* capture source */ 107 const struct hda_input_mux *input_mux; 108 const hda_nid_t *capsrc_nids; 109 unsigned int cur_mux[3]; 110 111 /* channel model */ 112 const struct hda_channel_mode *channel_mode; 113 int num_channel_mode; 114 115 /* PCM information */ 116 struct hda_pcm pcm_rec[2]; /* used in build_pcms() */ 117 118 unsigned int spdif_route; 119 120 /* dynamic controls, init_verbs and input_mux */ 121 struct auto_pin_cfg autocfg; 122 struct hda_input_mux private_imux; 123 struct imux_info imux_info[HDA_MAX_NUM_INPUTS]; 124 hda_nid_t private_adc_nids[HDA_MAX_NUM_INPUTS]; 125 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; 126 struct pin_dac_pair dac_info[8]; 127 int dac_info_filled; 128 129 unsigned int port_d_mode; 130 unsigned int auto_mute:1; /* used in auto-parser */ 131 unsigned int detect_line:1; /* Line-out detection enabled */ 132 unsigned int automute_lines:1; /* automute line-out as well */ 133 unsigned int automute_hp_lo:1; /* both HP and LO available */ 134 unsigned int dell_automute:1; 135 unsigned int dell_vostro:1; 136 unsigned int ideapad:1; 137 unsigned int thinkpad:1; 138 unsigned int hp_laptop:1; 139 unsigned int asus:1; 140 unsigned int pin_eapd_ctrls:1; 141 unsigned int single_adc_amp:1; 142 143 unsigned int adc_switching:1; 144 145 unsigned int ext_mic_present; 146 unsigned int recording; 147 void (*capture_prepare)(struct hda_codec *codec); 148 void (*capture_cleanup)(struct hda_codec *codec); 149 150 /* OLPC XO-1.5 supports DC input mode (e.g. for use with analog sensors) 151 * through the microphone jack. 152 * When the user enables this through a mixer switch, both internal and 153 * external microphones are disabled. Gain is fixed at 0dB. In this mode, 154 * we also allow the bias to be configured through a separate mixer 155 * control. */ 156 unsigned int dc_enable; 157 unsigned int dc_input_bias; /* offset into cxt5066_olpc_dc_bias */ 158 unsigned int mic_boost; /* offset into cxt5066_analog_mic_boost */ 159 160 unsigned int beep_amp; 161 162 /* extra EAPD pins */ 163 unsigned int num_eapds; 164 hda_nid_t eapds[4]; 165 }; 166 167 static int conexant_playback_pcm_open(struct hda_pcm_stream *hinfo, 168 struct hda_codec *codec, 169 struct snd_pcm_substream *substream) 170 { 171 struct conexant_spec *spec = codec->spec; 172 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 173 hinfo); 174 } 175 176 static int conexant_playback_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 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, 184 stream_tag, 185 format, substream); 186 } 187 188 static int conexant_playback_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 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 194 } 195 196 /* 197 * Digital out 198 */ 199 static int conexant_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 200 struct hda_codec *codec, 201 struct snd_pcm_substream *substream) 202 { 203 struct conexant_spec *spec = codec->spec; 204 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 205 } 206 207 static int conexant_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 208 struct hda_codec *codec, 209 struct snd_pcm_substream *substream) 210 { 211 struct conexant_spec *spec = codec->spec; 212 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 213 } 214 215 static int conexant_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 216 struct hda_codec *codec, 217 unsigned int stream_tag, 218 unsigned int format, 219 struct snd_pcm_substream *substream) 220 { 221 struct conexant_spec *spec = codec->spec; 222 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 223 stream_tag, 224 format, substream); 225 } 226 227 /* 228 * Analog capture 229 */ 230 static int conexant_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 231 struct hda_codec *codec, 232 unsigned int stream_tag, 233 unsigned int format, 234 struct snd_pcm_substream *substream) 235 { 236 struct conexant_spec *spec = codec->spec; 237 if (spec->capture_prepare) 238 spec->capture_prepare(codec); 239 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 240 stream_tag, 0, format); 241 return 0; 242 } 243 244 static int conexant_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 245 struct hda_codec *codec, 246 struct snd_pcm_substream *substream) 247 { 248 struct conexant_spec *spec = codec->spec; 249 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]); 250 if (spec->capture_cleanup) 251 spec->capture_cleanup(codec); 252 return 0; 253 } 254 255 256 257 static const struct hda_pcm_stream conexant_pcm_analog_playback = { 258 .substreams = 1, 259 .channels_min = 2, 260 .channels_max = 2, 261 .nid = 0, /* fill later */ 262 .ops = { 263 .open = conexant_playback_pcm_open, 264 .prepare = conexant_playback_pcm_prepare, 265 .cleanup = conexant_playback_pcm_cleanup 266 }, 267 }; 268 269 static const struct hda_pcm_stream conexant_pcm_analog_capture = { 270 .substreams = 1, 271 .channels_min = 2, 272 .channels_max = 2, 273 .nid = 0, /* fill later */ 274 .ops = { 275 .prepare = conexant_capture_pcm_prepare, 276 .cleanup = conexant_capture_pcm_cleanup 277 }, 278 }; 279 280 281 static const struct hda_pcm_stream conexant_pcm_digital_playback = { 282 .substreams = 1, 283 .channels_min = 2, 284 .channels_max = 2, 285 .nid = 0, /* fill later */ 286 .ops = { 287 .open = conexant_dig_playback_pcm_open, 288 .close = conexant_dig_playback_pcm_close, 289 .prepare = conexant_dig_playback_pcm_prepare 290 }, 291 }; 292 293 static const struct hda_pcm_stream conexant_pcm_digital_capture = { 294 .substreams = 1, 295 .channels_min = 2, 296 .channels_max = 2, 297 /* NID is set in alc_build_pcms */ 298 }; 299 300 static int cx5051_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 301 struct hda_codec *codec, 302 unsigned int stream_tag, 303 unsigned int format, 304 struct snd_pcm_substream *substream) 305 { 306 struct conexant_spec *spec = codec->spec; 307 spec->cur_adc = spec->adc_nids[spec->cur_adc_idx]; 308 spec->cur_adc_stream_tag = stream_tag; 309 spec->cur_adc_format = format; 310 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format); 311 return 0; 312 } 313 314 static int cx5051_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 315 struct hda_codec *codec, 316 struct snd_pcm_substream *substream) 317 { 318 struct conexant_spec *spec = codec->spec; 319 snd_hda_codec_cleanup_stream(codec, spec->cur_adc); 320 spec->cur_adc = 0; 321 return 0; 322 } 323 324 static const struct hda_pcm_stream cx5051_pcm_analog_capture = { 325 .substreams = 1, 326 .channels_min = 2, 327 .channels_max = 2, 328 .nid = 0, /* fill later */ 329 .ops = { 330 .prepare = cx5051_capture_pcm_prepare, 331 .cleanup = cx5051_capture_pcm_cleanup 332 }, 333 }; 334 335 static int conexant_build_pcms(struct hda_codec *codec) 336 { 337 struct conexant_spec *spec = codec->spec; 338 struct hda_pcm *info = spec->pcm_rec; 339 340 codec->num_pcms = 1; 341 codec->pcm_info = info; 342 343 info->name = "CONEXANT Analog"; 344 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = conexant_pcm_analog_playback; 345 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 346 spec->multiout.max_channels; 347 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 348 spec->multiout.dac_nids[0]; 349 if (spec->capture_stream) 350 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *spec->capture_stream; 351 else { 352 if (codec->vendor_id == 0x14f15051) 353 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 354 cx5051_pcm_analog_capture; 355 else { 356 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 357 conexant_pcm_analog_capture; 358 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 359 spec->num_adc_nids; 360 } 361 } 362 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 363 364 if (spec->multiout.dig_out_nid) { 365 info++; 366 codec->num_pcms++; 367 info->name = "Conexant Digital"; 368 info->pcm_type = HDA_PCM_TYPE_SPDIF; 369 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 370 conexant_pcm_digital_playback; 371 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 372 spec->multiout.dig_out_nid; 373 if (spec->dig_in_nid) { 374 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 375 conexant_pcm_digital_capture; 376 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 377 spec->dig_in_nid; 378 } 379 if (spec->slave_dig_outs[0]) 380 codec->slave_dig_outs = spec->slave_dig_outs; 381 } 382 383 return 0; 384 } 385 386 static int conexant_mux_enum_info(struct snd_kcontrol *kcontrol, 387 struct snd_ctl_elem_info *uinfo) 388 { 389 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 390 struct conexant_spec *spec = codec->spec; 391 392 return snd_hda_input_mux_info(spec->input_mux, uinfo); 393 } 394 395 static int conexant_mux_enum_get(struct snd_kcontrol *kcontrol, 396 struct snd_ctl_elem_value *ucontrol) 397 { 398 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 399 struct conexant_spec *spec = codec->spec; 400 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 401 402 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 403 return 0; 404 } 405 406 static int conexant_mux_enum_put(struct snd_kcontrol *kcontrol, 407 struct snd_ctl_elem_value *ucontrol) 408 { 409 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 410 struct conexant_spec *spec = codec->spec; 411 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 412 413 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, 414 spec->capsrc_nids[adc_idx], 415 &spec->cur_mux[adc_idx]); 416 } 417 418 static int conexant_init_jacks(struct hda_codec *codec) 419 { 420 #ifdef CONFIG_SND_HDA_INPUT_JACK 421 struct conexant_spec *spec = codec->spec; 422 int i; 423 424 for (i = 0; i < spec->num_init_verbs; i++) { 425 const struct hda_verb *hv; 426 427 hv = spec->init_verbs[i]; 428 while (hv->nid) { 429 int err = 0; 430 switch (hv->param ^ AC_USRSP_EN) { 431 case CONEXANT_HP_EVENT: 432 err = snd_hda_input_jack_add(codec, hv->nid, 433 SND_JACK_HEADPHONE, NULL); 434 snd_hda_input_jack_report(codec, hv->nid); 435 break; 436 case CXT5051_PORTC_EVENT: 437 case CONEXANT_MIC_EVENT: 438 err = snd_hda_input_jack_add(codec, hv->nid, 439 SND_JACK_MICROPHONE, NULL); 440 snd_hda_input_jack_report(codec, hv->nid); 441 break; 442 } 443 if (err < 0) 444 return err; 445 ++hv; 446 } 447 } 448 #endif /* CONFIG_SND_HDA_INPUT_JACK */ 449 return 0; 450 } 451 452 static void conexant_set_power(struct hda_codec *codec, hda_nid_t fg, 453 unsigned int power_state) 454 { 455 if (power_state == AC_PWRST_D3) 456 msleep(100); 457 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE, 458 power_state); 459 /* partial workaround for "azx_get_response timeout" */ 460 if (power_state == AC_PWRST_D0) 461 msleep(10); 462 snd_hda_codec_set_power_to_all(codec, fg, power_state, true); 463 } 464 465 static int conexant_init(struct hda_codec *codec) 466 { 467 struct conexant_spec *spec = codec->spec; 468 int i; 469 470 for (i = 0; i < spec->num_init_verbs; i++) 471 snd_hda_sequence_write(codec, spec->init_verbs[i]); 472 return 0; 473 } 474 475 static void conexant_free(struct hda_codec *codec) 476 { 477 snd_hda_input_jack_free(codec); 478 snd_hda_detach_beep_device(codec); 479 kfree(codec->spec); 480 } 481 482 static const struct snd_kcontrol_new cxt_capture_mixers[] = { 483 { 484 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 485 .name = "Capture Source", 486 .info = conexant_mux_enum_info, 487 .get = conexant_mux_enum_get, 488 .put = conexant_mux_enum_put 489 }, 490 {} 491 }; 492 493 #ifdef CONFIG_SND_HDA_INPUT_BEEP 494 /* additional beep mixers; the actual parameters are overwritten at build */ 495 static const struct snd_kcontrol_new cxt_beep_mixer[] = { 496 HDA_CODEC_VOLUME_MONO("Beep Playback Volume", 0, 1, 0, HDA_OUTPUT), 497 HDA_CODEC_MUTE_BEEP_MONO("Beep Playback Switch", 0, 1, 0, HDA_OUTPUT), 498 { } /* end */ 499 }; 500 #endif 501 502 static const char * const slave_vols[] = { 503 "Headphone Playback Volume", 504 "Speaker Playback Volume", 505 "Front Playback Volume", 506 "Surround Playback Volume", 507 "CLFE Playback Volume", 508 NULL 509 }; 510 511 static const char * const slave_sws[] = { 512 "Headphone Playback Switch", 513 "Speaker Playback Switch", 514 "Front Playback Switch", 515 "Surround Playback Switch", 516 "CLFE Playback Switch", 517 NULL 518 }; 519 520 static int conexant_build_controls(struct hda_codec *codec) 521 { 522 struct conexant_spec *spec = codec->spec; 523 unsigned int i; 524 int err; 525 526 for (i = 0; i < spec->num_mixers; i++) { 527 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 528 if (err < 0) 529 return err; 530 } 531 if (spec->multiout.dig_out_nid) { 532 err = snd_hda_create_spdif_out_ctls(codec, 533 spec->multiout.dig_out_nid, 534 spec->multiout.dig_out_nid); 535 if (err < 0) 536 return err; 537 err = snd_hda_create_spdif_share_sw(codec, 538 &spec->multiout); 539 if (err < 0) 540 return err; 541 spec->multiout.share_spdif = 1; 542 } 543 if (spec->dig_in_nid) { 544 err = snd_hda_create_spdif_in_ctls(codec,spec->dig_in_nid); 545 if (err < 0) 546 return err; 547 } 548 549 /* if we have no master control, let's create it */ 550 if (spec->vmaster_nid && 551 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { 552 unsigned int vmaster_tlv[4]; 553 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid, 554 HDA_OUTPUT, vmaster_tlv); 555 err = snd_hda_add_vmaster(codec, "Master Playback Volume", 556 vmaster_tlv, slave_vols); 557 if (err < 0) 558 return err; 559 } 560 if (spec->vmaster_nid && 561 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { 562 err = snd_hda_add_vmaster(codec, "Master Playback Switch", 563 NULL, slave_sws); 564 if (err < 0) 565 return err; 566 } 567 568 if (spec->input_mux) { 569 err = snd_hda_add_new_ctls(codec, cxt_capture_mixers); 570 if (err < 0) 571 return err; 572 } 573 574 #ifdef CONFIG_SND_HDA_INPUT_BEEP 575 /* create beep controls if needed */ 576 if (spec->beep_amp) { 577 const struct snd_kcontrol_new *knew; 578 for (knew = cxt_beep_mixer; knew->name; knew++) { 579 struct snd_kcontrol *kctl; 580 kctl = snd_ctl_new1(knew, codec); 581 if (!kctl) 582 return -ENOMEM; 583 kctl->private_value = spec->beep_amp; 584 err = snd_hda_ctl_add(codec, 0, kctl); 585 if (err < 0) 586 return err; 587 } 588 } 589 #endif 590 591 return 0; 592 } 593 594 #ifdef CONFIG_SND_HDA_POWER_SAVE 595 static int conexant_suspend(struct hda_codec *codec, pm_message_t state) 596 { 597 snd_hda_shutup_pins(codec); 598 return 0; 599 } 600 #endif 601 602 static const struct hda_codec_ops conexant_patch_ops = { 603 .build_controls = conexant_build_controls, 604 .build_pcms = conexant_build_pcms, 605 .init = conexant_init, 606 .free = conexant_free, 607 .set_power_state = conexant_set_power, 608 #ifdef CONFIG_SND_HDA_POWER_SAVE 609 .suspend = conexant_suspend, 610 #endif 611 .reboot_notify = snd_hda_shutup_pins, 612 }; 613 614 #ifdef CONFIG_SND_HDA_INPUT_BEEP 615 #define set_beep_amp(spec, nid, idx, dir) \ 616 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir)) 617 #else 618 #define set_beep_amp(spec, nid, idx, dir) /* NOP */ 619 #endif 620 621 static int patch_conexant_auto(struct hda_codec *codec); 622 /* 623 * EAPD control 624 * the private value = nid | (invert << 8) 625 */ 626 627 #define cxt_eapd_info snd_ctl_boolean_mono_info 628 629 static int cxt_eapd_get(struct snd_kcontrol *kcontrol, 630 struct snd_ctl_elem_value *ucontrol) 631 { 632 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 633 struct conexant_spec *spec = codec->spec; 634 int invert = (kcontrol->private_value >> 8) & 1; 635 if (invert) 636 ucontrol->value.integer.value[0] = !spec->cur_eapd; 637 else 638 ucontrol->value.integer.value[0] = spec->cur_eapd; 639 return 0; 640 641 } 642 643 static int cxt_eapd_put(struct snd_kcontrol *kcontrol, 644 struct snd_ctl_elem_value *ucontrol) 645 { 646 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 647 struct conexant_spec *spec = codec->spec; 648 int invert = (kcontrol->private_value >> 8) & 1; 649 hda_nid_t nid = kcontrol->private_value & 0xff; 650 unsigned int eapd; 651 652 eapd = !!ucontrol->value.integer.value[0]; 653 if (invert) 654 eapd = !eapd; 655 if (eapd == spec->cur_eapd) 656 return 0; 657 658 spec->cur_eapd = eapd; 659 snd_hda_codec_write_cache(codec, nid, 660 0, AC_VERB_SET_EAPD_BTLENABLE, 661 eapd ? 0x02 : 0x00); 662 return 1; 663 } 664 665 /* controls for test mode */ 666 #ifdef CONFIG_SND_DEBUG 667 668 #define CXT_EAPD_SWITCH(xname, nid, mask) \ 669 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 670 .info = cxt_eapd_info, \ 671 .get = cxt_eapd_get, \ 672 .put = cxt_eapd_put, \ 673 .private_value = nid | (mask<<16) } 674 675 676 677 static int conexant_ch_mode_info(struct snd_kcontrol *kcontrol, 678 struct snd_ctl_elem_info *uinfo) 679 { 680 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 681 struct conexant_spec *spec = codec->spec; 682 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode, 683 spec->num_channel_mode); 684 } 685 686 static int conexant_ch_mode_get(struct snd_kcontrol *kcontrol, 687 struct snd_ctl_elem_value *ucontrol) 688 { 689 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 690 struct conexant_spec *spec = codec->spec; 691 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode, 692 spec->num_channel_mode, 693 spec->multiout.max_channels); 694 } 695 696 static int conexant_ch_mode_put(struct snd_kcontrol *kcontrol, 697 struct snd_ctl_elem_value *ucontrol) 698 { 699 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 700 struct conexant_spec *spec = codec->spec; 701 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode, 702 spec->num_channel_mode, 703 &spec->multiout.max_channels); 704 if (err >= 0 && spec->need_dac_fix) 705 spec->multiout.num_dacs = spec->multiout.max_channels / 2; 706 return err; 707 } 708 709 #define CXT_PIN_MODE(xname, nid, dir) \ 710 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \ 711 .info = conexant_ch_mode_info, \ 712 .get = conexant_ch_mode_get, \ 713 .put = conexant_ch_mode_put, \ 714 .private_value = nid | (dir<<16) } 715 716 #endif /* CONFIG_SND_DEBUG */ 717 718 /* Conexant 5045 specific */ 719 720 static const hda_nid_t cxt5045_dac_nids[1] = { 0x19 }; 721 static const hda_nid_t cxt5045_adc_nids[1] = { 0x1a }; 722 static const hda_nid_t cxt5045_capsrc_nids[1] = { 0x1a }; 723 #define CXT5045_SPDIF_OUT 0x18 724 725 static const struct hda_channel_mode cxt5045_modes[1] = { 726 { 2, NULL }, 727 }; 728 729 static const struct hda_input_mux cxt5045_capture_source = { 730 .num_items = 2, 731 .items = { 732 { "IntMic", 0x1 }, 733 { "ExtMic", 0x2 }, 734 } 735 }; 736 737 static const struct hda_input_mux cxt5045_capture_source_benq = { 738 .num_items = 5, 739 .items = { 740 { "IntMic", 0x1 }, 741 { "ExtMic", 0x2 }, 742 { "LineIn", 0x3 }, 743 { "CD", 0x4 }, 744 { "Mixer", 0x0 }, 745 } 746 }; 747 748 static const struct hda_input_mux cxt5045_capture_source_hp530 = { 749 .num_items = 2, 750 .items = { 751 { "ExtMic", 0x1 }, 752 { "IntMic", 0x2 }, 753 } 754 }; 755 756 /* turn on/off EAPD (+ mute HP) as a master switch */ 757 static int cxt5045_hp_master_sw_put(struct snd_kcontrol *kcontrol, 758 struct snd_ctl_elem_value *ucontrol) 759 { 760 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 761 struct conexant_spec *spec = codec->spec; 762 unsigned int bits; 763 764 if (!cxt_eapd_put(kcontrol, ucontrol)) 765 return 0; 766 767 /* toggle internal speakers mute depending of presence of 768 * the headphone jack 769 */ 770 bits = (!spec->hp_present && spec->cur_eapd) ? 0 : HDA_AMP_MUTE; 771 snd_hda_codec_amp_stereo(codec, 0x10, HDA_OUTPUT, 0, 772 HDA_AMP_MUTE, bits); 773 774 bits = spec->cur_eapd ? 0 : HDA_AMP_MUTE; 775 snd_hda_codec_amp_stereo(codec, 0x11, HDA_OUTPUT, 0, 776 HDA_AMP_MUTE, bits); 777 return 1; 778 } 779 780 /* bind volumes of both NID 0x10 and 0x11 */ 781 static const struct hda_bind_ctls cxt5045_hp_bind_master_vol = { 782 .ops = &snd_hda_bind_vol, 783 .values = { 784 HDA_COMPOSE_AMP_VAL(0x10, 3, 0, HDA_OUTPUT), 785 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT), 786 0 787 }, 788 }; 789 790 /* toggle input of built-in and mic jack appropriately */ 791 static void cxt5045_hp_automic(struct hda_codec *codec) 792 { 793 static const struct hda_verb mic_jack_on[] = { 794 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 795 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 796 {} 797 }; 798 static const struct hda_verb mic_jack_off[] = { 799 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 800 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 801 {} 802 }; 803 unsigned int present; 804 805 present = snd_hda_jack_detect(codec, 0x12); 806 if (present) 807 snd_hda_sequence_write(codec, mic_jack_on); 808 else 809 snd_hda_sequence_write(codec, mic_jack_off); 810 } 811 812 813 /* mute internal speaker if HP is plugged */ 814 static void cxt5045_hp_automute(struct hda_codec *codec) 815 { 816 struct conexant_spec *spec = codec->spec; 817 unsigned int bits; 818 819 spec->hp_present = snd_hda_jack_detect(codec, 0x11); 820 821 bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0; 822 snd_hda_codec_amp_stereo(codec, 0x10, HDA_OUTPUT, 0, 823 HDA_AMP_MUTE, bits); 824 } 825 826 /* unsolicited event for HP jack sensing */ 827 static void cxt5045_hp_unsol_event(struct hda_codec *codec, 828 unsigned int res) 829 { 830 res >>= 26; 831 switch (res) { 832 case CONEXANT_HP_EVENT: 833 cxt5045_hp_automute(codec); 834 break; 835 case CONEXANT_MIC_EVENT: 836 cxt5045_hp_automic(codec); 837 break; 838 839 } 840 } 841 842 static const struct snd_kcontrol_new cxt5045_mixers[] = { 843 HDA_CODEC_VOLUME("Internal Mic Capture Volume", 0x1a, 0x01, HDA_INPUT), 844 HDA_CODEC_MUTE("Internal Mic Capture Switch", 0x1a, 0x01, HDA_INPUT), 845 HDA_CODEC_VOLUME("Mic Capture Volume", 0x1a, 0x02, HDA_INPUT), 846 HDA_CODEC_MUTE("Mic Capture Switch", 0x1a, 0x02, HDA_INPUT), 847 HDA_CODEC_VOLUME("PCM Playback Volume", 0x17, 0x0, HDA_INPUT), 848 HDA_CODEC_MUTE("PCM Playback Switch", 0x17, 0x0, HDA_INPUT), 849 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x1, HDA_INPUT), 850 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x1, HDA_INPUT), 851 HDA_CODEC_VOLUME("Mic Playback Volume", 0x17, 0x2, HDA_INPUT), 852 HDA_CODEC_MUTE("Mic Playback Switch", 0x17, 0x2, HDA_INPUT), 853 HDA_BIND_VOL("Master Playback Volume", &cxt5045_hp_bind_master_vol), 854 { 855 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 856 .name = "Master Playback Switch", 857 .info = cxt_eapd_info, 858 .get = cxt_eapd_get, 859 .put = cxt5045_hp_master_sw_put, 860 .private_value = 0x10, 861 }, 862 863 {} 864 }; 865 866 static const struct snd_kcontrol_new cxt5045_benq_mixers[] = { 867 HDA_CODEC_VOLUME("CD Capture Volume", 0x1a, 0x04, HDA_INPUT), 868 HDA_CODEC_MUTE("CD Capture Switch", 0x1a, 0x04, HDA_INPUT), 869 HDA_CODEC_VOLUME("CD Playback Volume", 0x17, 0x4, HDA_INPUT), 870 HDA_CODEC_MUTE("CD Playback Switch", 0x17, 0x4, HDA_INPUT), 871 872 HDA_CODEC_VOLUME("Line In Capture Volume", 0x1a, 0x03, HDA_INPUT), 873 HDA_CODEC_MUTE("Line In Capture Switch", 0x1a, 0x03, HDA_INPUT), 874 HDA_CODEC_VOLUME("Line In Playback Volume", 0x17, 0x3, HDA_INPUT), 875 HDA_CODEC_MUTE("Line In Playback Switch", 0x17, 0x3, HDA_INPUT), 876 877 HDA_CODEC_VOLUME("Mixer Capture Volume", 0x1a, 0x0, HDA_INPUT), 878 HDA_CODEC_MUTE("Mixer Capture Switch", 0x1a, 0x0, HDA_INPUT), 879 880 {} 881 }; 882 883 static const struct snd_kcontrol_new cxt5045_mixers_hp530[] = { 884 HDA_CODEC_VOLUME("Internal Mic Capture Volume", 0x1a, 0x02, HDA_INPUT), 885 HDA_CODEC_MUTE("Internal Mic Capture Switch", 0x1a, 0x02, HDA_INPUT), 886 HDA_CODEC_VOLUME("Mic Capture Volume", 0x1a, 0x01, HDA_INPUT), 887 HDA_CODEC_MUTE("Mic Capture Switch", 0x1a, 0x01, HDA_INPUT), 888 HDA_CODEC_VOLUME("PCM Playback Volume", 0x17, 0x0, HDA_INPUT), 889 HDA_CODEC_MUTE("PCM Playback Switch", 0x17, 0x0, HDA_INPUT), 890 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x2, HDA_INPUT), 891 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x2, HDA_INPUT), 892 HDA_CODEC_VOLUME("Mic Playback Volume", 0x17, 0x1, HDA_INPUT), 893 HDA_CODEC_MUTE("Mic Playback Switch", 0x17, 0x1, HDA_INPUT), 894 HDA_BIND_VOL("Master Playback Volume", &cxt5045_hp_bind_master_vol), 895 { 896 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 897 .name = "Master Playback Switch", 898 .info = cxt_eapd_info, 899 .get = cxt_eapd_get, 900 .put = cxt5045_hp_master_sw_put, 901 .private_value = 0x10, 902 }, 903 904 {} 905 }; 906 907 static const struct hda_verb cxt5045_init_verbs[] = { 908 /* Line in, Mic */ 909 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 }, 910 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 }, 911 /* HP, Amp */ 912 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 913 {0x10, AC_VERB_SET_CONNECT_SEL, 0x1}, 914 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 915 {0x11, AC_VERB_SET_CONNECT_SEL, 0x1}, 916 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 917 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 918 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 919 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 920 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 921 /* Record selector: Internal mic */ 922 {0x1a, AC_VERB_SET_CONNECT_SEL,0x1}, 923 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 924 AC_AMP_SET_INPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x17}, 925 /* SPDIF route: PCM */ 926 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 927 { 0x13, AC_VERB_SET_CONNECT_SEL, 0x0 }, 928 /* EAPD */ 929 {0x10, AC_VERB_SET_EAPD_BTLENABLE, 0x2 }, /* default on */ 930 { } /* end */ 931 }; 932 933 static const struct hda_verb cxt5045_benq_init_verbs[] = { 934 /* Internal Mic, Mic */ 935 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 }, 936 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_80 }, 937 /* Line In,HP, Amp */ 938 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 939 {0x10, AC_VERB_SET_CONNECT_SEL, 0x1}, 940 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 941 {0x11, AC_VERB_SET_CONNECT_SEL, 0x1}, 942 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 943 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 944 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 945 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 946 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 947 /* Record selector: Internal mic */ 948 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x1}, 949 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 950 AC_AMP_SET_INPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x17}, 951 /* SPDIF route: PCM */ 952 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 953 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0}, 954 /* EAPD */ 955 {0x10, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */ 956 { } /* end */ 957 }; 958 959 static const struct hda_verb cxt5045_hp_sense_init_verbs[] = { 960 /* pin sensing on HP jack */ 961 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT}, 962 { } /* end */ 963 }; 964 965 static const struct hda_verb cxt5045_mic_sense_init_verbs[] = { 966 /* pin sensing on HP jack */ 967 {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT}, 968 { } /* end */ 969 }; 970 971 #ifdef CONFIG_SND_DEBUG 972 /* Test configuration for debugging, modelled after the ALC260 test 973 * configuration. 974 */ 975 static const struct hda_input_mux cxt5045_test_capture_source = { 976 .num_items = 5, 977 .items = { 978 { "MIXER", 0x0 }, 979 { "MIC1 pin", 0x1 }, 980 { "LINE1 pin", 0x2 }, 981 { "HP-OUT pin", 0x3 }, 982 { "CD pin", 0x4 }, 983 }, 984 }; 985 986 static const struct snd_kcontrol_new cxt5045_test_mixer[] = { 987 988 /* Output controls */ 989 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x10, 0x0, HDA_OUTPUT), 990 HDA_CODEC_MUTE("Speaker Playback Switch", 0x10, 0x0, HDA_OUTPUT), 991 HDA_CODEC_VOLUME("Node 11 Playback Volume", 0x11, 0x0, HDA_OUTPUT), 992 HDA_CODEC_MUTE("Node 11 Playback Switch", 0x11, 0x0, HDA_OUTPUT), 993 HDA_CODEC_VOLUME("Node 12 Playback Volume", 0x12, 0x0, HDA_OUTPUT), 994 HDA_CODEC_MUTE("Node 12 Playback Switch", 0x12, 0x0, HDA_OUTPUT), 995 996 /* Modes for retasking pin widgets */ 997 CXT_PIN_MODE("HP-OUT pin mode", 0x11, CXT_PIN_DIR_INOUT), 998 CXT_PIN_MODE("LINE1 pin mode", 0x12, CXT_PIN_DIR_INOUT), 999 1000 /* EAPD Switch Control */ 1001 CXT_EAPD_SWITCH("External Amplifier", 0x10, 0x0), 1002 1003 /* Loopback mixer controls */ 1004 1005 HDA_CODEC_VOLUME("Mixer-1 Volume", 0x17, 0x0, HDA_INPUT), 1006 HDA_CODEC_MUTE("Mixer-1 Switch", 0x17, 0x0, HDA_INPUT), 1007 HDA_CODEC_VOLUME("Mixer-2 Volume", 0x17, 0x1, HDA_INPUT), 1008 HDA_CODEC_MUTE("Mixer-2 Switch", 0x17, 0x1, HDA_INPUT), 1009 HDA_CODEC_VOLUME("Mixer-3 Volume", 0x17, 0x2, HDA_INPUT), 1010 HDA_CODEC_MUTE("Mixer-3 Switch", 0x17, 0x2, HDA_INPUT), 1011 HDA_CODEC_VOLUME("Mixer-4 Volume", 0x17, 0x3, HDA_INPUT), 1012 HDA_CODEC_MUTE("Mixer-4 Switch", 0x17, 0x3, HDA_INPUT), 1013 HDA_CODEC_VOLUME("Mixer-5 Volume", 0x17, 0x4, HDA_INPUT), 1014 HDA_CODEC_MUTE("Mixer-5 Switch", 0x17, 0x4, HDA_INPUT), 1015 { 1016 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1017 .name = "Input Source", 1018 .info = conexant_mux_enum_info, 1019 .get = conexant_mux_enum_get, 1020 .put = conexant_mux_enum_put, 1021 }, 1022 /* Audio input controls */ 1023 HDA_CODEC_VOLUME("Input-1 Volume", 0x1a, 0x0, HDA_INPUT), 1024 HDA_CODEC_MUTE("Input-1 Switch", 0x1a, 0x0, HDA_INPUT), 1025 HDA_CODEC_VOLUME("Input-2 Volume", 0x1a, 0x1, HDA_INPUT), 1026 HDA_CODEC_MUTE("Input-2 Switch", 0x1a, 0x1, HDA_INPUT), 1027 HDA_CODEC_VOLUME("Input-3 Volume", 0x1a, 0x2, HDA_INPUT), 1028 HDA_CODEC_MUTE("Input-3 Switch", 0x1a, 0x2, HDA_INPUT), 1029 HDA_CODEC_VOLUME("Input-4 Volume", 0x1a, 0x3, HDA_INPUT), 1030 HDA_CODEC_MUTE("Input-4 Switch", 0x1a, 0x3, HDA_INPUT), 1031 HDA_CODEC_VOLUME("Input-5 Volume", 0x1a, 0x4, HDA_INPUT), 1032 HDA_CODEC_MUTE("Input-5 Switch", 0x1a, 0x4, HDA_INPUT), 1033 { } /* end */ 1034 }; 1035 1036 static const struct hda_verb cxt5045_test_init_verbs[] = { 1037 /* Set connections */ 1038 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 }, 1039 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x0 }, 1040 { 0x12, AC_VERB_SET_CONNECT_SEL, 0x0 }, 1041 /* Enable retasking pins as output, initially without power amp */ 1042 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1043 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1044 1045 /* Disable digital (SPDIF) pins initially, but users can enable 1046 * them via a mixer switch. In the case of SPDIF-out, this initverb 1047 * payload also sets the generation to 0, output to be in "consumer" 1048 * PCM format, copyright asserted, no pre-emphasis and no validity 1049 * control. 1050 */ 1051 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1052 {0x18, AC_VERB_SET_DIGI_CONVERT_1, 0}, 1053 1054 /* Start with output sum widgets muted and their output gains at min */ 1055 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 1056 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 1057 1058 /* Unmute retasking pin widget output buffers since the default 1059 * state appears to be output. As the pin mode is changed by the 1060 * user the pin mode control will take care of enabling the pin's 1061 * input/output buffers as needed. 1062 */ 1063 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1064 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1065 1066 /* Mute capture amp left and right */ 1067 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 1068 1069 /* Set ADC connection select to match default mixer setting (mic1 1070 * pin) 1071 */ 1072 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00}, 1073 {0x17, AC_VERB_SET_CONNECT_SEL, 0x00}, 1074 1075 /* Mute all inputs to mixer widget (even unconnected ones) */ 1076 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* Mixer pin */ 1077 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* Mic1 pin */ 1078 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* Line pin */ 1079 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* HP pin */ 1080 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 1081 1082 { } 1083 }; 1084 #endif 1085 1086 1087 /* initialize jack-sensing, too */ 1088 static int cxt5045_init(struct hda_codec *codec) 1089 { 1090 conexant_init(codec); 1091 cxt5045_hp_automute(codec); 1092 return 0; 1093 } 1094 1095 1096 enum { 1097 CXT5045_LAPTOP_HPSENSE, 1098 CXT5045_LAPTOP_MICSENSE, 1099 CXT5045_LAPTOP_HPMICSENSE, 1100 CXT5045_BENQ, 1101 CXT5045_LAPTOP_HP530, 1102 #ifdef CONFIG_SND_DEBUG 1103 CXT5045_TEST, 1104 #endif 1105 CXT5045_AUTO, 1106 CXT5045_MODELS 1107 }; 1108 1109 static const char * const cxt5045_models[CXT5045_MODELS] = { 1110 [CXT5045_LAPTOP_HPSENSE] = "laptop-hpsense", 1111 [CXT5045_LAPTOP_MICSENSE] = "laptop-micsense", 1112 [CXT5045_LAPTOP_HPMICSENSE] = "laptop-hpmicsense", 1113 [CXT5045_BENQ] = "benq", 1114 [CXT5045_LAPTOP_HP530] = "laptop-hp530", 1115 #ifdef CONFIG_SND_DEBUG 1116 [CXT5045_TEST] = "test", 1117 #endif 1118 [CXT5045_AUTO] = "auto", 1119 }; 1120 1121 static const struct snd_pci_quirk cxt5045_cfg_tbl[] = { 1122 SND_PCI_QUIRK(0x103c, 0x30d5, "HP 530", CXT5045_LAPTOP_HP530), 1123 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP DV Series", 1124 CXT5045_LAPTOP_HPSENSE), 1125 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba P105", CXT5045_LAPTOP_MICSENSE), 1126 SND_PCI_QUIRK(0x152d, 0x0753, "Benq R55E", CXT5045_BENQ), 1127 SND_PCI_QUIRK(0x1734, 0x10ad, "Fujitsu Si1520", CXT5045_LAPTOP_MICSENSE), 1128 SND_PCI_QUIRK(0x1734, 0x10cb, "Fujitsu Si3515", CXT5045_LAPTOP_HPMICSENSE), 1129 SND_PCI_QUIRK(0x1734, 0x110e, "Fujitsu V5505", 1130 CXT5045_LAPTOP_HPMICSENSE), 1131 SND_PCI_QUIRK(0x1509, 0x1e40, "FIC", CXT5045_LAPTOP_HPMICSENSE), 1132 SND_PCI_QUIRK(0x1509, 0x2f05, "FIC", CXT5045_LAPTOP_HPMICSENSE), 1133 SND_PCI_QUIRK(0x1509, 0x2f06, "FIC", CXT5045_LAPTOP_HPMICSENSE), 1134 SND_PCI_QUIRK_MASK(0x1631, 0xff00, 0xc100, "Packard Bell", 1135 CXT5045_LAPTOP_HPMICSENSE), 1136 SND_PCI_QUIRK(0x8086, 0x2111, "Conexant Reference board", CXT5045_LAPTOP_HPSENSE), 1137 {} 1138 }; 1139 1140 static int patch_cxt5045(struct hda_codec *codec) 1141 { 1142 struct conexant_spec *spec; 1143 int board_config; 1144 1145 board_config = snd_hda_check_board_config(codec, CXT5045_MODELS, 1146 cxt5045_models, 1147 cxt5045_cfg_tbl); 1148 if (board_config < 0) 1149 board_config = CXT5045_AUTO; /* model=auto as default */ 1150 if (board_config == CXT5045_AUTO) 1151 return patch_conexant_auto(codec); 1152 1153 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1154 if (!spec) 1155 return -ENOMEM; 1156 codec->spec = spec; 1157 codec->pin_amp_workaround = 1; 1158 1159 spec->multiout.max_channels = 2; 1160 spec->multiout.num_dacs = ARRAY_SIZE(cxt5045_dac_nids); 1161 spec->multiout.dac_nids = cxt5045_dac_nids; 1162 spec->multiout.dig_out_nid = CXT5045_SPDIF_OUT; 1163 spec->num_adc_nids = 1; 1164 spec->adc_nids = cxt5045_adc_nids; 1165 spec->capsrc_nids = cxt5045_capsrc_nids; 1166 spec->input_mux = &cxt5045_capture_source; 1167 spec->num_mixers = 1; 1168 spec->mixers[0] = cxt5045_mixers; 1169 spec->num_init_verbs = 1; 1170 spec->init_verbs[0] = cxt5045_init_verbs; 1171 spec->spdif_route = 0; 1172 spec->num_channel_mode = ARRAY_SIZE(cxt5045_modes); 1173 spec->channel_mode = cxt5045_modes; 1174 1175 set_beep_amp(spec, 0x16, 0, 1); 1176 1177 codec->patch_ops = conexant_patch_ops; 1178 1179 switch (board_config) { 1180 case CXT5045_LAPTOP_HPSENSE: 1181 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event; 1182 spec->input_mux = &cxt5045_capture_source; 1183 spec->num_init_verbs = 2; 1184 spec->init_verbs[1] = cxt5045_hp_sense_init_verbs; 1185 spec->mixers[0] = cxt5045_mixers; 1186 codec->patch_ops.init = cxt5045_init; 1187 break; 1188 case CXT5045_LAPTOP_MICSENSE: 1189 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event; 1190 spec->input_mux = &cxt5045_capture_source; 1191 spec->num_init_verbs = 2; 1192 spec->init_verbs[1] = cxt5045_mic_sense_init_verbs; 1193 spec->mixers[0] = cxt5045_mixers; 1194 codec->patch_ops.init = cxt5045_init; 1195 break; 1196 default: 1197 case CXT5045_LAPTOP_HPMICSENSE: 1198 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event; 1199 spec->input_mux = &cxt5045_capture_source; 1200 spec->num_init_verbs = 3; 1201 spec->init_verbs[1] = cxt5045_hp_sense_init_verbs; 1202 spec->init_verbs[2] = cxt5045_mic_sense_init_verbs; 1203 spec->mixers[0] = cxt5045_mixers; 1204 codec->patch_ops.init = cxt5045_init; 1205 break; 1206 case CXT5045_BENQ: 1207 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event; 1208 spec->input_mux = &cxt5045_capture_source_benq; 1209 spec->num_init_verbs = 1; 1210 spec->init_verbs[0] = cxt5045_benq_init_verbs; 1211 spec->mixers[0] = cxt5045_mixers; 1212 spec->mixers[1] = cxt5045_benq_mixers; 1213 spec->num_mixers = 2; 1214 codec->patch_ops.init = cxt5045_init; 1215 break; 1216 case CXT5045_LAPTOP_HP530: 1217 codec->patch_ops.unsol_event = cxt5045_hp_unsol_event; 1218 spec->input_mux = &cxt5045_capture_source_hp530; 1219 spec->num_init_verbs = 2; 1220 spec->init_verbs[1] = cxt5045_hp_sense_init_verbs; 1221 spec->mixers[0] = cxt5045_mixers_hp530; 1222 codec->patch_ops.init = cxt5045_init; 1223 break; 1224 #ifdef CONFIG_SND_DEBUG 1225 case CXT5045_TEST: 1226 spec->input_mux = &cxt5045_test_capture_source; 1227 spec->mixers[0] = cxt5045_test_mixer; 1228 spec->init_verbs[0] = cxt5045_test_init_verbs; 1229 break; 1230 1231 #endif 1232 } 1233 1234 switch (codec->subsystem_id >> 16) { 1235 case 0x103c: 1236 case 0x1631: 1237 case 0x1734: 1238 case 0x17aa: 1239 /* HP, Packard Bell, Fujitsu-Siemens & Lenovo laptops have 1240 * really bad sound over 0dB on NID 0x17. Fix max PCM level to 1241 * 0 dB (originally it has 0x2b steps with 0dB offset 0x14) 1242 */ 1243 snd_hda_override_amp_caps(codec, 0x17, HDA_INPUT, 1244 (0x14 << AC_AMPCAP_OFFSET_SHIFT) | 1245 (0x14 << AC_AMPCAP_NUM_STEPS_SHIFT) | 1246 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) | 1247 (1 << AC_AMPCAP_MUTE_SHIFT)); 1248 break; 1249 } 1250 1251 if (spec->beep_amp) 1252 snd_hda_attach_beep_device(codec, spec->beep_amp); 1253 1254 return 0; 1255 } 1256 1257 1258 /* Conexant 5047 specific */ 1259 #define CXT5047_SPDIF_OUT 0x11 1260 1261 static const hda_nid_t cxt5047_dac_nids[1] = { 0x10 }; /* 0x1c */ 1262 static const hda_nid_t cxt5047_adc_nids[1] = { 0x12 }; 1263 static const hda_nid_t cxt5047_capsrc_nids[1] = { 0x1a }; 1264 1265 static const struct hda_channel_mode cxt5047_modes[1] = { 1266 { 2, NULL }, 1267 }; 1268 1269 static const struct hda_input_mux cxt5047_toshiba_capture_source = { 1270 .num_items = 2, 1271 .items = { 1272 { "ExtMic", 0x2 }, 1273 { "Line-In", 0x1 }, 1274 } 1275 }; 1276 1277 /* turn on/off EAPD (+ mute HP) as a master switch */ 1278 static int cxt5047_hp_master_sw_put(struct snd_kcontrol *kcontrol, 1279 struct snd_ctl_elem_value *ucontrol) 1280 { 1281 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1282 struct conexant_spec *spec = codec->spec; 1283 unsigned int bits; 1284 1285 if (!cxt_eapd_put(kcontrol, ucontrol)) 1286 return 0; 1287 1288 /* toggle internal speakers mute depending of presence of 1289 * the headphone jack 1290 */ 1291 bits = (!spec->hp_present && spec->cur_eapd) ? 0 : HDA_AMP_MUTE; 1292 /* NOTE: Conexat codec needs the index for *OUTPUT* amp of 1293 * pin widgets unlike other codecs. In this case, we need to 1294 * set index 0x01 for the volume from the mixer amp 0x19. 1295 */ 1296 snd_hda_codec_amp_stereo(codec, 0x1d, HDA_OUTPUT, 0x01, 1297 HDA_AMP_MUTE, bits); 1298 bits = spec->cur_eapd ? 0 : HDA_AMP_MUTE; 1299 snd_hda_codec_amp_stereo(codec, 0x13, HDA_OUTPUT, 0, 1300 HDA_AMP_MUTE, bits); 1301 return 1; 1302 } 1303 1304 /* mute internal speaker if HP is plugged */ 1305 static void cxt5047_hp_automute(struct hda_codec *codec) 1306 { 1307 struct conexant_spec *spec = codec->spec; 1308 unsigned int bits; 1309 1310 spec->hp_present = snd_hda_jack_detect(codec, 0x13); 1311 1312 bits = (spec->hp_present || !spec->cur_eapd) ? HDA_AMP_MUTE : 0; 1313 /* See the note in cxt5047_hp_master_sw_put */ 1314 snd_hda_codec_amp_stereo(codec, 0x1d, HDA_OUTPUT, 0x01, 1315 HDA_AMP_MUTE, bits); 1316 } 1317 1318 /* toggle input of built-in and mic jack appropriately */ 1319 static void cxt5047_hp_automic(struct hda_codec *codec) 1320 { 1321 static const struct hda_verb mic_jack_on[] = { 1322 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1323 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1324 {} 1325 }; 1326 static const struct hda_verb mic_jack_off[] = { 1327 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 1328 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1329 {} 1330 }; 1331 unsigned int present; 1332 1333 present = snd_hda_jack_detect(codec, 0x15); 1334 if (present) 1335 snd_hda_sequence_write(codec, mic_jack_on); 1336 else 1337 snd_hda_sequence_write(codec, mic_jack_off); 1338 } 1339 1340 /* unsolicited event for HP jack sensing */ 1341 static void cxt5047_hp_unsol_event(struct hda_codec *codec, 1342 unsigned int res) 1343 { 1344 switch (res >> 26) { 1345 case CONEXANT_HP_EVENT: 1346 cxt5047_hp_automute(codec); 1347 break; 1348 case CONEXANT_MIC_EVENT: 1349 cxt5047_hp_automic(codec); 1350 break; 1351 } 1352 } 1353 1354 static const struct snd_kcontrol_new cxt5047_base_mixers[] = { 1355 HDA_CODEC_VOLUME("Mic Playback Volume", 0x19, 0x02, HDA_INPUT), 1356 HDA_CODEC_MUTE("Mic Playback Switch", 0x19, 0x02, HDA_INPUT), 1357 HDA_CODEC_VOLUME("Mic Boost Volume", 0x1a, 0x0, HDA_OUTPUT), 1358 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x03, HDA_INPUT), 1359 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x03, HDA_INPUT), 1360 HDA_CODEC_VOLUME("PCM Volume", 0x10, 0x00, HDA_OUTPUT), 1361 HDA_CODEC_MUTE("PCM Switch", 0x10, 0x00, HDA_OUTPUT), 1362 { 1363 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1364 .name = "Master Playback Switch", 1365 .info = cxt_eapd_info, 1366 .get = cxt_eapd_get, 1367 .put = cxt5047_hp_master_sw_put, 1368 .private_value = 0x13, 1369 }, 1370 1371 {} 1372 }; 1373 1374 static const struct snd_kcontrol_new cxt5047_hp_spk_mixers[] = { 1375 /* See the note in cxt5047_hp_master_sw_put */ 1376 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x1d, 0x01, HDA_OUTPUT), 1377 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x13, 0x00, HDA_OUTPUT), 1378 {} 1379 }; 1380 1381 static const struct snd_kcontrol_new cxt5047_hp_only_mixers[] = { 1382 HDA_CODEC_VOLUME("Master Playback Volume", 0x13, 0x00, HDA_OUTPUT), 1383 { } /* end */ 1384 }; 1385 1386 static const struct hda_verb cxt5047_init_verbs[] = { 1387 /* Line in, Mic, Built-in Mic */ 1388 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 1389 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_50 }, 1390 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN|AC_PINCTL_VREF_50 }, 1391 /* HP, Speaker */ 1392 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, 1393 {0x13, AC_VERB_SET_CONNECT_SEL, 0x0}, /* mixer(0x19) */ 1394 {0x1d, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mixer(0x19) */ 1395 /* Record selector: Mic */ 1396 {0x12, AC_VERB_SET_CONNECT_SEL,0x03}, 1397 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 1398 AC_AMP_SET_INPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x17}, 1399 {0x1A, AC_VERB_SET_CONNECT_SEL,0x02}, 1400 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, 1401 AC_AMP_SET_OUTPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x00}, 1402 {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, 1403 AC_AMP_SET_OUTPUT|AC_AMP_SET_RIGHT|AC_AMP_SET_LEFT|0x03}, 1404 /* SPDIF route: PCM */ 1405 { 0x18, AC_VERB_SET_CONNECT_SEL, 0x0 }, 1406 /* Enable unsolicited events */ 1407 {0x13, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT}, 1408 {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT}, 1409 { } /* end */ 1410 }; 1411 1412 /* configuration for Toshiba Laptops */ 1413 static const struct hda_verb cxt5047_toshiba_init_verbs[] = { 1414 {0x13, AC_VERB_SET_EAPD_BTLENABLE, 0x0}, /* default off */ 1415 {} 1416 }; 1417 1418 /* Test configuration for debugging, modelled after the ALC260 test 1419 * configuration. 1420 */ 1421 #ifdef CONFIG_SND_DEBUG 1422 static const struct hda_input_mux cxt5047_test_capture_source = { 1423 .num_items = 4, 1424 .items = { 1425 { "LINE1 pin", 0x0 }, 1426 { "MIC1 pin", 0x1 }, 1427 { "MIC2 pin", 0x2 }, 1428 { "CD pin", 0x3 }, 1429 }, 1430 }; 1431 1432 static const struct snd_kcontrol_new cxt5047_test_mixer[] = { 1433 1434 /* Output only controls */ 1435 HDA_CODEC_VOLUME("OutAmp-1 Volume", 0x10, 0x0, HDA_OUTPUT), 1436 HDA_CODEC_MUTE("OutAmp-1 Switch", 0x10,0x0, HDA_OUTPUT), 1437 HDA_CODEC_VOLUME("OutAmp-2 Volume", 0x1c, 0x0, HDA_OUTPUT), 1438 HDA_CODEC_MUTE("OutAmp-2 Switch", 0x1c, 0x0, HDA_OUTPUT), 1439 HDA_CODEC_VOLUME("Speaker Playback Volume", 0x1d, 0x0, HDA_OUTPUT), 1440 HDA_CODEC_MUTE("Speaker Playback Switch", 0x1d, 0x0, HDA_OUTPUT), 1441 HDA_CODEC_VOLUME("HeadPhone Playback Volume", 0x13, 0x0, HDA_OUTPUT), 1442 HDA_CODEC_MUTE("HeadPhone Playback Switch", 0x13, 0x0, HDA_OUTPUT), 1443 HDA_CODEC_VOLUME("Line1-Out Playback Volume", 0x14, 0x0, HDA_OUTPUT), 1444 HDA_CODEC_MUTE("Line1-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT), 1445 HDA_CODEC_VOLUME("Line2-Out Playback Volume", 0x15, 0x0, HDA_OUTPUT), 1446 HDA_CODEC_MUTE("Line2-Out Playback Switch", 0x15, 0x0, HDA_OUTPUT), 1447 1448 /* Modes for retasking pin widgets */ 1449 CXT_PIN_MODE("LINE1 pin mode", 0x14, CXT_PIN_DIR_INOUT), 1450 CXT_PIN_MODE("MIC1 pin mode", 0x15, CXT_PIN_DIR_INOUT), 1451 1452 /* EAPD Switch Control */ 1453 CXT_EAPD_SWITCH("External Amplifier", 0x13, 0x0), 1454 1455 /* Loopback mixer controls */ 1456 HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x12, 0x01, HDA_INPUT), 1457 HDA_CODEC_MUTE("MIC1 Playback Switch", 0x12, 0x01, HDA_INPUT), 1458 HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x12, 0x02, HDA_INPUT), 1459 HDA_CODEC_MUTE("MIC2 Playback Switch", 0x12, 0x02, HDA_INPUT), 1460 HDA_CODEC_VOLUME("LINE Playback Volume", 0x12, 0x0, HDA_INPUT), 1461 HDA_CODEC_MUTE("LINE Playback Switch", 0x12, 0x0, HDA_INPUT), 1462 HDA_CODEC_VOLUME("CD Playback Volume", 0x12, 0x04, HDA_INPUT), 1463 HDA_CODEC_MUTE("CD Playback Switch", 0x12, 0x04, HDA_INPUT), 1464 1465 HDA_CODEC_VOLUME("Capture-1 Volume", 0x19, 0x0, HDA_INPUT), 1466 HDA_CODEC_MUTE("Capture-1 Switch", 0x19, 0x0, HDA_INPUT), 1467 HDA_CODEC_VOLUME("Capture-2 Volume", 0x19, 0x1, HDA_INPUT), 1468 HDA_CODEC_MUTE("Capture-2 Switch", 0x19, 0x1, HDA_INPUT), 1469 HDA_CODEC_VOLUME("Capture-3 Volume", 0x19, 0x2, HDA_INPUT), 1470 HDA_CODEC_MUTE("Capture-3 Switch", 0x19, 0x2, HDA_INPUT), 1471 HDA_CODEC_VOLUME("Capture-4 Volume", 0x19, 0x3, HDA_INPUT), 1472 HDA_CODEC_MUTE("Capture-4 Switch", 0x19, 0x3, HDA_INPUT), 1473 { 1474 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1475 .name = "Input Source", 1476 .info = conexant_mux_enum_info, 1477 .get = conexant_mux_enum_get, 1478 .put = conexant_mux_enum_put, 1479 }, 1480 HDA_CODEC_VOLUME("Mic Boost Volume", 0x1a, 0x0, HDA_OUTPUT), 1481 1482 { } /* end */ 1483 }; 1484 1485 static const struct hda_verb cxt5047_test_init_verbs[] = { 1486 /* Enable retasking pins as output, initially without power amp */ 1487 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1488 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1489 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1490 1491 /* Disable digital (SPDIF) pins initially, but users can enable 1492 * them via a mixer switch. In the case of SPDIF-out, this initverb 1493 * payload also sets the generation to 0, output to be in "consumer" 1494 * PCM format, copyright asserted, no pre-emphasis and no validity 1495 * control. 1496 */ 1497 {0x18, AC_VERB_SET_DIGI_CONVERT_1, 0}, 1498 1499 /* Ensure mic1, mic2, line1 pin widgets take input from the 1500 * OUT1 sum bus when acting as an output. 1501 */ 1502 {0x1a, AC_VERB_SET_CONNECT_SEL, 0}, 1503 {0x1b, AC_VERB_SET_CONNECT_SEL, 0}, 1504 1505 /* Start with output sum widgets muted and their output gains at min */ 1506 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 1507 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 1508 1509 /* Unmute retasking pin widget output buffers since the default 1510 * state appears to be output. As the pin mode is changed by the 1511 * user the pin mode control will take care of enabling the pin's 1512 * input/output buffers as needed. 1513 */ 1514 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1515 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1516 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1517 1518 /* Mute capture amp left and right */ 1519 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 1520 1521 /* Set ADC connection select to match default mixer setting (mic1 1522 * pin) 1523 */ 1524 {0x12, AC_VERB_SET_CONNECT_SEL, 0x00}, 1525 1526 /* Mute all inputs to mixer widget (even unconnected ones) */ 1527 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */ 1528 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */ 1529 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */ 1530 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */ 1531 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */ 1532 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */ 1533 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */ 1534 {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */ 1535 1536 { } 1537 }; 1538 #endif 1539 1540 1541 /* initialize jack-sensing, too */ 1542 static int cxt5047_hp_init(struct hda_codec *codec) 1543 { 1544 conexant_init(codec); 1545 cxt5047_hp_automute(codec); 1546 return 0; 1547 } 1548 1549 1550 enum { 1551 CXT5047_LAPTOP, /* Laptops w/o EAPD support */ 1552 CXT5047_LAPTOP_HP, /* Some HP laptops */ 1553 CXT5047_LAPTOP_EAPD, /* Laptops with EAPD support */ 1554 #ifdef CONFIG_SND_DEBUG 1555 CXT5047_TEST, 1556 #endif 1557 CXT5047_AUTO, 1558 CXT5047_MODELS 1559 }; 1560 1561 static const char * const cxt5047_models[CXT5047_MODELS] = { 1562 [CXT5047_LAPTOP] = "laptop", 1563 [CXT5047_LAPTOP_HP] = "laptop-hp", 1564 [CXT5047_LAPTOP_EAPD] = "laptop-eapd", 1565 #ifdef CONFIG_SND_DEBUG 1566 [CXT5047_TEST] = "test", 1567 #endif 1568 [CXT5047_AUTO] = "auto", 1569 }; 1570 1571 static const struct snd_pci_quirk cxt5047_cfg_tbl[] = { 1572 SND_PCI_QUIRK(0x103c, 0x30a5, "HP DV5200T/DV8000T", CXT5047_LAPTOP_HP), 1573 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP DV Series", 1574 CXT5047_LAPTOP), 1575 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba P100", CXT5047_LAPTOP_EAPD), 1576 {} 1577 }; 1578 1579 static int patch_cxt5047(struct hda_codec *codec) 1580 { 1581 struct conexant_spec *spec; 1582 int board_config; 1583 1584 board_config = snd_hda_check_board_config(codec, CXT5047_MODELS, 1585 cxt5047_models, 1586 cxt5047_cfg_tbl); 1587 if (board_config < 0) 1588 board_config = CXT5047_AUTO; /* model=auto as default */ 1589 if (board_config == CXT5047_AUTO) 1590 return patch_conexant_auto(codec); 1591 1592 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1593 if (!spec) 1594 return -ENOMEM; 1595 codec->spec = spec; 1596 codec->pin_amp_workaround = 1; 1597 1598 spec->multiout.max_channels = 2; 1599 spec->multiout.num_dacs = ARRAY_SIZE(cxt5047_dac_nids); 1600 spec->multiout.dac_nids = cxt5047_dac_nids; 1601 spec->multiout.dig_out_nid = CXT5047_SPDIF_OUT; 1602 spec->num_adc_nids = 1; 1603 spec->adc_nids = cxt5047_adc_nids; 1604 spec->capsrc_nids = cxt5047_capsrc_nids; 1605 spec->num_mixers = 1; 1606 spec->mixers[0] = cxt5047_base_mixers; 1607 spec->num_init_verbs = 1; 1608 spec->init_verbs[0] = cxt5047_init_verbs; 1609 spec->spdif_route = 0; 1610 spec->num_channel_mode = ARRAY_SIZE(cxt5047_modes), 1611 spec->channel_mode = cxt5047_modes, 1612 1613 codec->patch_ops = conexant_patch_ops; 1614 1615 switch (board_config) { 1616 case CXT5047_LAPTOP: 1617 spec->num_mixers = 2; 1618 spec->mixers[1] = cxt5047_hp_spk_mixers; 1619 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event; 1620 break; 1621 case CXT5047_LAPTOP_HP: 1622 spec->num_mixers = 2; 1623 spec->mixers[1] = cxt5047_hp_only_mixers; 1624 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event; 1625 codec->patch_ops.init = cxt5047_hp_init; 1626 break; 1627 case CXT5047_LAPTOP_EAPD: 1628 spec->input_mux = &cxt5047_toshiba_capture_source; 1629 spec->num_mixers = 2; 1630 spec->mixers[1] = cxt5047_hp_spk_mixers; 1631 spec->num_init_verbs = 2; 1632 spec->init_verbs[1] = cxt5047_toshiba_init_verbs; 1633 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event; 1634 break; 1635 #ifdef CONFIG_SND_DEBUG 1636 case CXT5047_TEST: 1637 spec->input_mux = &cxt5047_test_capture_source; 1638 spec->mixers[0] = cxt5047_test_mixer; 1639 spec->init_verbs[0] = cxt5047_test_init_verbs; 1640 codec->patch_ops.unsol_event = cxt5047_hp_unsol_event; 1641 #endif 1642 } 1643 spec->vmaster_nid = 0x13; 1644 1645 switch (codec->subsystem_id >> 16) { 1646 case 0x103c: 1647 /* HP laptops have really bad sound over 0 dB on NID 0x10. 1648 * Fix max PCM level to 0 dB (originally it has 0x1e steps 1649 * with 0 dB offset 0x17) 1650 */ 1651 snd_hda_override_amp_caps(codec, 0x10, HDA_INPUT, 1652 (0x17 << AC_AMPCAP_OFFSET_SHIFT) | 1653 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | 1654 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) | 1655 (1 << AC_AMPCAP_MUTE_SHIFT)); 1656 break; 1657 } 1658 1659 return 0; 1660 } 1661 1662 /* Conexant 5051 specific */ 1663 static const hda_nid_t cxt5051_dac_nids[1] = { 0x10 }; 1664 static const hda_nid_t cxt5051_adc_nids[2] = { 0x14, 0x15 }; 1665 1666 static const struct hda_channel_mode cxt5051_modes[1] = { 1667 { 2, NULL }, 1668 }; 1669 1670 static void cxt5051_update_speaker(struct hda_codec *codec) 1671 { 1672 struct conexant_spec *spec = codec->spec; 1673 unsigned int pinctl; 1674 /* headphone pin */ 1675 pinctl = (spec->hp_present && spec->cur_eapd) ? PIN_HP : 0; 1676 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 1677 pinctl); 1678 /* speaker pin */ 1679 pinctl = (!spec->hp_present && spec->cur_eapd) ? PIN_OUT : 0; 1680 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 1681 pinctl); 1682 /* on ideapad there is an aditional speaker (subwoofer) to mute */ 1683 if (spec->ideapad) 1684 snd_hda_codec_write(codec, 0x1b, 0, 1685 AC_VERB_SET_PIN_WIDGET_CONTROL, 1686 pinctl); 1687 } 1688 1689 /* turn on/off EAPD (+ mute HP) as a master switch */ 1690 static int cxt5051_hp_master_sw_put(struct snd_kcontrol *kcontrol, 1691 struct snd_ctl_elem_value *ucontrol) 1692 { 1693 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1694 1695 if (!cxt_eapd_put(kcontrol, ucontrol)) 1696 return 0; 1697 cxt5051_update_speaker(codec); 1698 return 1; 1699 } 1700 1701 /* toggle input of built-in and mic jack appropriately */ 1702 static void cxt5051_portb_automic(struct hda_codec *codec) 1703 { 1704 struct conexant_spec *spec = codec->spec; 1705 unsigned int present; 1706 1707 if (!(spec->auto_mic & AUTO_MIC_PORTB)) 1708 return; 1709 present = snd_hda_jack_detect(codec, 0x17); 1710 snd_hda_codec_write(codec, 0x14, 0, 1711 AC_VERB_SET_CONNECT_SEL, 1712 present ? 0x01 : 0x00); 1713 } 1714 1715 /* switch the current ADC according to the jack state */ 1716 static void cxt5051_portc_automic(struct hda_codec *codec) 1717 { 1718 struct conexant_spec *spec = codec->spec; 1719 unsigned int present; 1720 hda_nid_t new_adc; 1721 1722 if (!(spec->auto_mic & AUTO_MIC_PORTC)) 1723 return; 1724 present = snd_hda_jack_detect(codec, 0x18); 1725 if (present) 1726 spec->cur_adc_idx = 1; 1727 else 1728 spec->cur_adc_idx = 0; 1729 new_adc = spec->adc_nids[spec->cur_adc_idx]; 1730 if (spec->cur_adc && spec->cur_adc != new_adc) { 1731 /* stream is running, let's swap the current ADC */ 1732 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1); 1733 spec->cur_adc = new_adc; 1734 snd_hda_codec_setup_stream(codec, new_adc, 1735 spec->cur_adc_stream_tag, 0, 1736 spec->cur_adc_format); 1737 } 1738 } 1739 1740 /* mute internal speaker if HP is plugged */ 1741 static void cxt5051_hp_automute(struct hda_codec *codec) 1742 { 1743 struct conexant_spec *spec = codec->spec; 1744 1745 spec->hp_present = snd_hda_jack_detect(codec, 0x16); 1746 cxt5051_update_speaker(codec); 1747 } 1748 1749 /* unsolicited event for HP jack sensing */ 1750 static void cxt5051_hp_unsol_event(struct hda_codec *codec, 1751 unsigned int res) 1752 { 1753 int nid = (res & AC_UNSOL_RES_SUBTAG) >> 20; 1754 switch (res >> 26) { 1755 case CONEXANT_HP_EVENT: 1756 cxt5051_hp_automute(codec); 1757 break; 1758 case CXT5051_PORTB_EVENT: 1759 cxt5051_portb_automic(codec); 1760 break; 1761 case CXT5051_PORTC_EVENT: 1762 cxt5051_portc_automic(codec); 1763 break; 1764 } 1765 snd_hda_input_jack_report(codec, nid); 1766 } 1767 1768 static const struct snd_kcontrol_new cxt5051_playback_mixers[] = { 1769 HDA_CODEC_VOLUME("Master Playback Volume", 0x10, 0x00, HDA_OUTPUT), 1770 { 1771 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1772 .name = "Master Playback Switch", 1773 .info = cxt_eapd_info, 1774 .get = cxt_eapd_get, 1775 .put = cxt5051_hp_master_sw_put, 1776 .private_value = 0x1a, 1777 }, 1778 {} 1779 }; 1780 1781 static const struct snd_kcontrol_new cxt5051_capture_mixers[] = { 1782 HDA_CODEC_VOLUME("Internal Mic Volume", 0x14, 0x00, HDA_INPUT), 1783 HDA_CODEC_MUTE("Internal Mic Switch", 0x14, 0x00, HDA_INPUT), 1784 HDA_CODEC_VOLUME("Mic Volume", 0x14, 0x01, HDA_INPUT), 1785 HDA_CODEC_MUTE("Mic Switch", 0x14, 0x01, HDA_INPUT), 1786 HDA_CODEC_VOLUME("Docking Mic Volume", 0x15, 0x00, HDA_INPUT), 1787 HDA_CODEC_MUTE("Docking Mic Switch", 0x15, 0x00, HDA_INPUT), 1788 {} 1789 }; 1790 1791 static const struct snd_kcontrol_new cxt5051_hp_mixers[] = { 1792 HDA_CODEC_VOLUME("Internal Mic Volume", 0x14, 0x00, HDA_INPUT), 1793 HDA_CODEC_MUTE("Internal Mic Switch", 0x14, 0x00, HDA_INPUT), 1794 HDA_CODEC_VOLUME("Mic Volume", 0x15, 0x00, HDA_INPUT), 1795 HDA_CODEC_MUTE("Mic Switch", 0x15, 0x00, HDA_INPUT), 1796 {} 1797 }; 1798 1799 static const struct snd_kcontrol_new cxt5051_hp_dv6736_mixers[] = { 1800 HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x00, HDA_INPUT), 1801 HDA_CODEC_MUTE("Capture Switch", 0x14, 0x00, HDA_INPUT), 1802 {} 1803 }; 1804 1805 static const struct snd_kcontrol_new cxt5051_f700_mixers[] = { 1806 HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x01, HDA_INPUT), 1807 HDA_CODEC_MUTE("Capture Switch", 0x14, 0x01, HDA_INPUT), 1808 {} 1809 }; 1810 1811 static const struct snd_kcontrol_new cxt5051_toshiba_mixers[] = { 1812 HDA_CODEC_VOLUME("Internal Mic Volume", 0x14, 0x00, HDA_INPUT), 1813 HDA_CODEC_MUTE("Internal Mic Switch", 0x14, 0x00, HDA_INPUT), 1814 HDA_CODEC_VOLUME("Mic Volume", 0x14, 0x01, HDA_INPUT), 1815 HDA_CODEC_MUTE("Mic Switch", 0x14, 0x01, HDA_INPUT), 1816 {} 1817 }; 1818 1819 static const struct hda_verb cxt5051_init_verbs[] = { 1820 /* Line in, Mic */ 1821 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03}, 1822 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1823 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03}, 1824 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1825 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 1826 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03}, 1827 /* SPK */ 1828 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1829 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00}, 1830 /* HP, Amp */ 1831 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1832 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, 1833 /* DAC1 */ 1834 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1835 /* Record selector: Internal mic */ 1836 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x44}, 1837 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1) | 0x44}, 1838 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x44}, 1839 /* SPDIF route: PCM */ 1840 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1841 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x0}, 1842 /* EAPD */ 1843 {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */ 1844 {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT}, 1845 { } /* end */ 1846 }; 1847 1848 static const struct hda_verb cxt5051_hp_dv6736_init_verbs[] = { 1849 /* Line in, Mic */ 1850 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03}, 1851 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1852 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0}, 1853 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0}, 1854 /* SPK */ 1855 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1856 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00}, 1857 /* HP, Amp */ 1858 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1859 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, 1860 /* DAC1 */ 1861 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1862 /* Record selector: Internal mic */ 1863 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1) | 0x44}, 1864 {0x14, AC_VERB_SET_CONNECT_SEL, 0x1}, 1865 /* SPDIF route: PCM */ 1866 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x0}, 1867 /* EAPD */ 1868 {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */ 1869 {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT}, 1870 { } /* end */ 1871 }; 1872 1873 static const struct hda_verb cxt5051_f700_init_verbs[] = { 1874 /* Line in, Mic */ 1875 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x03}, 1876 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 1877 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0}, 1878 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0}, 1879 /* SPK */ 1880 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1881 {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00}, 1882 /* HP, Amp */ 1883 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 1884 {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, 1885 /* DAC1 */ 1886 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 1887 /* Record selector: Internal mic */ 1888 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1) | 0x44}, 1889 {0x14, AC_VERB_SET_CONNECT_SEL, 0x1}, 1890 /* SPDIF route: PCM */ 1891 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x0}, 1892 /* EAPD */ 1893 {0x1a, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */ 1894 {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|CONEXANT_HP_EVENT}, 1895 { } /* end */ 1896 }; 1897 1898 static void cxt5051_init_mic_port(struct hda_codec *codec, hda_nid_t nid, 1899 unsigned int event) 1900 { 1901 snd_hda_codec_write(codec, nid, 0, 1902 AC_VERB_SET_UNSOLICITED_ENABLE, 1903 AC_USRSP_EN | event); 1904 snd_hda_input_jack_add(codec, nid, SND_JACK_MICROPHONE, NULL); 1905 snd_hda_input_jack_report(codec, nid); 1906 } 1907 1908 static const struct hda_verb cxt5051_ideapad_init_verbs[] = { 1909 /* Subwoofer */ 1910 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 1911 {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, 1912 { } /* end */ 1913 }; 1914 1915 /* initialize jack-sensing, too */ 1916 static int cxt5051_init(struct hda_codec *codec) 1917 { 1918 struct conexant_spec *spec = codec->spec; 1919 1920 conexant_init(codec); 1921 conexant_init_jacks(codec); 1922 1923 if (spec->auto_mic & AUTO_MIC_PORTB) 1924 cxt5051_init_mic_port(codec, 0x17, CXT5051_PORTB_EVENT); 1925 if (spec->auto_mic & AUTO_MIC_PORTC) 1926 cxt5051_init_mic_port(codec, 0x18, CXT5051_PORTC_EVENT); 1927 1928 if (codec->patch_ops.unsol_event) { 1929 cxt5051_hp_automute(codec); 1930 cxt5051_portb_automic(codec); 1931 cxt5051_portc_automic(codec); 1932 } 1933 return 0; 1934 } 1935 1936 1937 enum { 1938 CXT5051_LAPTOP, /* Laptops w/ EAPD support */ 1939 CXT5051_HP, /* no docking */ 1940 CXT5051_HP_DV6736, /* HP without mic switch */ 1941 CXT5051_F700, /* HP Compaq Presario F700 */ 1942 CXT5051_TOSHIBA, /* Toshiba M300 & co */ 1943 CXT5051_IDEAPAD, /* Lenovo IdeaPad Y430 */ 1944 CXT5051_AUTO, /* auto-parser */ 1945 CXT5051_MODELS 1946 }; 1947 1948 static const char *const cxt5051_models[CXT5051_MODELS] = { 1949 [CXT5051_LAPTOP] = "laptop", 1950 [CXT5051_HP] = "hp", 1951 [CXT5051_HP_DV6736] = "hp-dv6736", 1952 [CXT5051_F700] = "hp-700", 1953 [CXT5051_TOSHIBA] = "toshiba", 1954 [CXT5051_IDEAPAD] = "ideapad", 1955 [CXT5051_AUTO] = "auto", 1956 }; 1957 1958 static const struct snd_pci_quirk cxt5051_cfg_tbl[] = { 1959 SND_PCI_QUIRK(0x103c, 0x30cf, "HP DV6736", CXT5051_HP_DV6736), 1960 SND_PCI_QUIRK(0x103c, 0x360b, "Compaq Presario CQ60", CXT5051_HP), 1961 SND_PCI_QUIRK(0x103c, 0x30ea, "Compaq Presario F700", CXT5051_F700), 1962 SND_PCI_QUIRK(0x1179, 0xff50, "Toshiba M30x", CXT5051_TOSHIBA), 1963 SND_PCI_QUIRK(0x14f1, 0x0101, "Conexant Reference board", 1964 CXT5051_LAPTOP), 1965 SND_PCI_QUIRK(0x14f1, 0x5051, "HP Spartan 1.1", CXT5051_HP), 1966 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo IdeaPad", CXT5051_IDEAPAD), 1967 {} 1968 }; 1969 1970 static int patch_cxt5051(struct hda_codec *codec) 1971 { 1972 struct conexant_spec *spec; 1973 int board_config; 1974 1975 board_config = snd_hda_check_board_config(codec, CXT5051_MODELS, 1976 cxt5051_models, 1977 cxt5051_cfg_tbl); 1978 if (board_config < 0) 1979 board_config = CXT5051_AUTO; /* model=auto as default */ 1980 if (board_config == CXT5051_AUTO) 1981 return patch_conexant_auto(codec); 1982 1983 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1984 if (!spec) 1985 return -ENOMEM; 1986 codec->spec = spec; 1987 codec->pin_amp_workaround = 1; 1988 1989 codec->patch_ops = conexant_patch_ops; 1990 codec->patch_ops.init = cxt5051_init; 1991 1992 spec->multiout.max_channels = 2; 1993 spec->multiout.num_dacs = ARRAY_SIZE(cxt5051_dac_nids); 1994 spec->multiout.dac_nids = cxt5051_dac_nids; 1995 spec->multiout.dig_out_nid = CXT5051_SPDIF_OUT; 1996 spec->num_adc_nids = 1; /* not 2; via auto-mic switch */ 1997 spec->adc_nids = cxt5051_adc_nids; 1998 spec->num_mixers = 2; 1999 spec->mixers[0] = cxt5051_capture_mixers; 2000 spec->mixers[1] = cxt5051_playback_mixers; 2001 spec->num_init_verbs = 1; 2002 spec->init_verbs[0] = cxt5051_init_verbs; 2003 spec->spdif_route = 0; 2004 spec->num_channel_mode = ARRAY_SIZE(cxt5051_modes); 2005 spec->channel_mode = cxt5051_modes; 2006 spec->cur_adc = 0; 2007 spec->cur_adc_idx = 0; 2008 2009 set_beep_amp(spec, 0x13, 0, HDA_OUTPUT); 2010 2011 codec->patch_ops.unsol_event = cxt5051_hp_unsol_event; 2012 2013 spec->auto_mic = AUTO_MIC_PORTB | AUTO_MIC_PORTC; 2014 switch (board_config) { 2015 case CXT5051_HP: 2016 spec->mixers[0] = cxt5051_hp_mixers; 2017 break; 2018 case CXT5051_HP_DV6736: 2019 spec->init_verbs[0] = cxt5051_hp_dv6736_init_verbs; 2020 spec->mixers[0] = cxt5051_hp_dv6736_mixers; 2021 spec->auto_mic = 0; 2022 break; 2023 case CXT5051_F700: 2024 spec->init_verbs[0] = cxt5051_f700_init_verbs; 2025 spec->mixers[0] = cxt5051_f700_mixers; 2026 spec->auto_mic = 0; 2027 break; 2028 case CXT5051_TOSHIBA: 2029 spec->mixers[0] = cxt5051_toshiba_mixers; 2030 spec->auto_mic = AUTO_MIC_PORTB; 2031 break; 2032 case CXT5051_IDEAPAD: 2033 spec->init_verbs[spec->num_init_verbs++] = 2034 cxt5051_ideapad_init_verbs; 2035 spec->ideapad = 1; 2036 break; 2037 } 2038 2039 if (spec->beep_amp) 2040 snd_hda_attach_beep_device(codec, spec->beep_amp); 2041 2042 return 0; 2043 } 2044 2045 /* Conexant 5066 specific */ 2046 2047 static const hda_nid_t cxt5066_dac_nids[1] = { 0x10 }; 2048 static const hda_nid_t cxt5066_adc_nids[3] = { 0x14, 0x15, 0x16 }; 2049 static const hda_nid_t cxt5066_capsrc_nids[1] = { 0x17 }; 2050 static const hda_nid_t cxt5066_digout_pin_nids[2] = { 0x20, 0x22 }; 2051 2052 /* OLPC's microphone port is DC coupled for use with external sensors, 2053 * therefore we use a 50% mic bias in order to center the input signal with 2054 * the DC input range of the codec. */ 2055 #define CXT5066_OLPC_EXT_MIC_BIAS PIN_VREF50 2056 2057 static const struct hda_channel_mode cxt5066_modes[1] = { 2058 { 2, NULL }, 2059 }; 2060 2061 #define HP_PRESENT_PORT_A (1 << 0) 2062 #define HP_PRESENT_PORT_D (1 << 1) 2063 #define hp_port_a_present(spec) ((spec)->hp_present & HP_PRESENT_PORT_A) 2064 #define hp_port_d_present(spec) ((spec)->hp_present & HP_PRESENT_PORT_D) 2065 2066 static void cxt5066_update_speaker(struct hda_codec *codec) 2067 { 2068 struct conexant_spec *spec = codec->spec; 2069 unsigned int pinctl; 2070 2071 snd_printdd("CXT5066: update speaker, hp_present=%d, cur_eapd=%d\n", 2072 spec->hp_present, spec->cur_eapd); 2073 2074 /* Port A (HP) */ 2075 pinctl = (hp_port_a_present(spec) && spec->cur_eapd) ? PIN_HP : 0; 2076 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 2077 pinctl); 2078 2079 /* Port D (HP/LO) */ 2080 pinctl = spec->cur_eapd ? spec->port_d_mode : 0; 2081 if (spec->dell_automute || spec->thinkpad) { 2082 /* Mute if Port A is connected */ 2083 if (hp_port_a_present(spec)) 2084 pinctl = 0; 2085 } else { 2086 /* Thinkpad/Dell doesn't give pin-D status */ 2087 if (!hp_port_d_present(spec)) 2088 pinctl = 0; 2089 } 2090 snd_hda_codec_write(codec, 0x1c, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 2091 pinctl); 2092 2093 /* CLASS_D AMP */ 2094 pinctl = (!spec->hp_present && spec->cur_eapd) ? PIN_OUT : 0; 2095 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 2096 pinctl); 2097 } 2098 2099 /* turn on/off EAPD (+ mute HP) as a master switch */ 2100 static int cxt5066_hp_master_sw_put(struct snd_kcontrol *kcontrol, 2101 struct snd_ctl_elem_value *ucontrol) 2102 { 2103 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2104 2105 if (!cxt_eapd_put(kcontrol, ucontrol)) 2106 return 0; 2107 2108 cxt5066_update_speaker(codec); 2109 return 1; 2110 } 2111 2112 static const struct hda_input_mux cxt5066_olpc_dc_bias = { 2113 .num_items = 3, 2114 .items = { 2115 { "Off", PIN_IN }, 2116 { "50%", PIN_VREF50 }, 2117 { "80%", PIN_VREF80 }, 2118 }, 2119 }; 2120 2121 static int cxt5066_set_olpc_dc_bias(struct hda_codec *codec) 2122 { 2123 struct conexant_spec *spec = codec->spec; 2124 /* Even though port F is the DC input, the bias is controlled on port B. 2125 * we also leave that port as an active input (but unselected) in DC mode 2126 * just in case that is necessary to make the bias setting take effect. */ 2127 return snd_hda_codec_write_cache(codec, 0x1a, 0, 2128 AC_VERB_SET_PIN_WIDGET_CONTROL, 2129 cxt5066_olpc_dc_bias.items[spec->dc_input_bias].index); 2130 } 2131 2132 /* OLPC defers mic widget control until when capture is started because the 2133 * microphone LED comes on as soon as these settings are put in place. if we 2134 * did this before recording, it would give the false indication that recording 2135 * is happening when it is not. */ 2136 static void cxt5066_olpc_select_mic(struct hda_codec *codec) 2137 { 2138 struct conexant_spec *spec = codec->spec; 2139 if (!spec->recording) 2140 return; 2141 2142 if (spec->dc_enable) { 2143 /* in DC mode we ignore presence detection and just use the jack 2144 * through our special DC port */ 2145 const struct hda_verb enable_dc_mode[] = { 2146 /* disble internal mic, port C */ 2147 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2148 2149 /* enable DC capture, port F */ 2150 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2151 {}, 2152 }; 2153 2154 snd_hda_sequence_write(codec, enable_dc_mode); 2155 /* port B input disabled (and bias set) through the following call */ 2156 cxt5066_set_olpc_dc_bias(codec); 2157 return; 2158 } 2159 2160 /* disable DC (port F) */ 2161 snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 0); 2162 2163 /* external mic, port B */ 2164 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 2165 spec->ext_mic_present ? CXT5066_OLPC_EXT_MIC_BIAS : 0); 2166 2167 /* internal mic, port C */ 2168 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 2169 spec->ext_mic_present ? 0 : PIN_VREF80); 2170 } 2171 2172 /* toggle input of built-in and mic jack appropriately */ 2173 static void cxt5066_olpc_automic(struct hda_codec *codec) 2174 { 2175 struct conexant_spec *spec = codec->spec; 2176 unsigned int present; 2177 2178 if (spec->dc_enable) /* don't do presence detection in DC mode */ 2179 return; 2180 2181 present = snd_hda_codec_read(codec, 0x1a, 0, 2182 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000; 2183 if (present) 2184 snd_printdd("CXT5066: external microphone detected\n"); 2185 else 2186 snd_printdd("CXT5066: external microphone absent\n"); 2187 2188 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_CONNECT_SEL, 2189 present ? 0 : 1); 2190 spec->ext_mic_present = !!present; 2191 2192 cxt5066_olpc_select_mic(codec); 2193 } 2194 2195 /* toggle input of built-in digital mic and mic jack appropriately */ 2196 static void cxt5066_vostro_automic(struct hda_codec *codec) 2197 { 2198 unsigned int present; 2199 2200 struct hda_verb ext_mic_present[] = { 2201 /* enable external mic, port B */ 2202 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2203 2204 /* switch to external mic input */ 2205 {0x17, AC_VERB_SET_CONNECT_SEL, 0}, 2206 {0x14, AC_VERB_SET_CONNECT_SEL, 0}, 2207 2208 /* disable internal digital mic */ 2209 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2210 {} 2211 }; 2212 static const struct hda_verb ext_mic_absent[] = { 2213 /* enable internal mic, port C */ 2214 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2215 2216 /* switch to internal mic input */ 2217 {0x14, AC_VERB_SET_CONNECT_SEL, 2}, 2218 2219 /* disable external mic, port B */ 2220 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2221 {} 2222 }; 2223 2224 present = snd_hda_jack_detect(codec, 0x1a); 2225 if (present) { 2226 snd_printdd("CXT5066: external microphone detected\n"); 2227 snd_hda_sequence_write(codec, ext_mic_present); 2228 } else { 2229 snd_printdd("CXT5066: external microphone absent\n"); 2230 snd_hda_sequence_write(codec, ext_mic_absent); 2231 } 2232 } 2233 2234 /* toggle input of built-in digital mic and mic jack appropriately */ 2235 static void cxt5066_ideapad_automic(struct hda_codec *codec) 2236 { 2237 unsigned int present; 2238 2239 struct hda_verb ext_mic_present[] = { 2240 {0x14, AC_VERB_SET_CONNECT_SEL, 0}, 2241 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2242 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2243 {} 2244 }; 2245 static const struct hda_verb ext_mic_absent[] = { 2246 {0x14, AC_VERB_SET_CONNECT_SEL, 2}, 2247 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2248 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2249 {} 2250 }; 2251 2252 present = snd_hda_jack_detect(codec, 0x1b); 2253 if (present) { 2254 snd_printdd("CXT5066: external microphone detected\n"); 2255 snd_hda_sequence_write(codec, ext_mic_present); 2256 } else { 2257 snd_printdd("CXT5066: external microphone absent\n"); 2258 snd_hda_sequence_write(codec, ext_mic_absent); 2259 } 2260 } 2261 2262 2263 /* toggle input of built-in digital mic and mic jack appropriately */ 2264 static void cxt5066_asus_automic(struct hda_codec *codec) 2265 { 2266 unsigned int present; 2267 2268 present = snd_hda_jack_detect(codec, 0x1b); 2269 snd_printdd("CXT5066: external microphone present=%d\n", present); 2270 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_CONNECT_SEL, 2271 present ? 1 : 0); 2272 } 2273 2274 2275 /* toggle input of built-in digital mic and mic jack appropriately */ 2276 static void cxt5066_hp_laptop_automic(struct hda_codec *codec) 2277 { 2278 unsigned int present; 2279 2280 present = snd_hda_jack_detect(codec, 0x1b); 2281 snd_printdd("CXT5066: external microphone present=%d\n", present); 2282 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_CONNECT_SEL, 2283 present ? 1 : 3); 2284 } 2285 2286 2287 /* toggle input of built-in digital mic and mic jack appropriately 2288 order is: external mic -> dock mic -> interal mic */ 2289 static void cxt5066_thinkpad_automic(struct hda_codec *codec) 2290 { 2291 unsigned int ext_present, dock_present; 2292 2293 static const struct hda_verb ext_mic_present[] = { 2294 {0x14, AC_VERB_SET_CONNECT_SEL, 0}, 2295 {0x17, AC_VERB_SET_CONNECT_SEL, 1}, 2296 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2297 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2298 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2299 {} 2300 }; 2301 static const struct hda_verb dock_mic_present[] = { 2302 {0x14, AC_VERB_SET_CONNECT_SEL, 0}, 2303 {0x17, AC_VERB_SET_CONNECT_SEL, 0}, 2304 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2305 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2306 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2307 {} 2308 }; 2309 static const struct hda_verb ext_mic_absent[] = { 2310 {0x14, AC_VERB_SET_CONNECT_SEL, 2}, 2311 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2312 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2313 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2314 {} 2315 }; 2316 2317 ext_present = snd_hda_jack_detect(codec, 0x1b); 2318 dock_present = snd_hda_jack_detect(codec, 0x1a); 2319 if (ext_present) { 2320 snd_printdd("CXT5066: external microphone detected\n"); 2321 snd_hda_sequence_write(codec, ext_mic_present); 2322 } else if (dock_present) { 2323 snd_printdd("CXT5066: dock microphone detected\n"); 2324 snd_hda_sequence_write(codec, dock_mic_present); 2325 } else { 2326 snd_printdd("CXT5066: external microphone absent\n"); 2327 snd_hda_sequence_write(codec, ext_mic_absent); 2328 } 2329 } 2330 2331 /* mute internal speaker if HP is plugged */ 2332 static void cxt5066_hp_automute(struct hda_codec *codec) 2333 { 2334 struct conexant_spec *spec = codec->spec; 2335 unsigned int portA, portD; 2336 2337 /* Port A */ 2338 portA = snd_hda_jack_detect(codec, 0x19); 2339 2340 /* Port D */ 2341 portD = snd_hda_jack_detect(codec, 0x1c); 2342 2343 spec->hp_present = portA ? HP_PRESENT_PORT_A : 0; 2344 spec->hp_present |= portD ? HP_PRESENT_PORT_D : 0; 2345 snd_printdd("CXT5066: hp automute portA=%x portD=%x present=%d\n", 2346 portA, portD, spec->hp_present); 2347 cxt5066_update_speaker(codec); 2348 } 2349 2350 /* Dispatch the right mic autoswitch function */ 2351 static void cxt5066_automic(struct hda_codec *codec) 2352 { 2353 struct conexant_spec *spec = codec->spec; 2354 2355 if (spec->dell_vostro) 2356 cxt5066_vostro_automic(codec); 2357 else if (spec->ideapad) 2358 cxt5066_ideapad_automic(codec); 2359 else if (spec->thinkpad) 2360 cxt5066_thinkpad_automic(codec); 2361 else if (spec->hp_laptop) 2362 cxt5066_hp_laptop_automic(codec); 2363 else if (spec->asus) 2364 cxt5066_asus_automic(codec); 2365 } 2366 2367 /* unsolicited event for jack sensing */ 2368 static void cxt5066_olpc_unsol_event(struct hda_codec *codec, unsigned int res) 2369 { 2370 struct conexant_spec *spec = codec->spec; 2371 snd_printdd("CXT5066: unsol event %x (%x)\n", res, res >> 26); 2372 switch (res >> 26) { 2373 case CONEXANT_HP_EVENT: 2374 cxt5066_hp_automute(codec); 2375 break; 2376 case CONEXANT_MIC_EVENT: 2377 /* ignore mic events in DC mode; we're always using the jack */ 2378 if (!spec->dc_enable) 2379 cxt5066_olpc_automic(codec); 2380 break; 2381 } 2382 } 2383 2384 /* unsolicited event for jack sensing */ 2385 static void cxt5066_unsol_event(struct hda_codec *codec, unsigned int res) 2386 { 2387 snd_printdd("CXT5066: unsol event %x (%x)\n", res, res >> 26); 2388 switch (res >> 26) { 2389 case CONEXANT_HP_EVENT: 2390 cxt5066_hp_automute(codec); 2391 break; 2392 case CONEXANT_MIC_EVENT: 2393 cxt5066_automic(codec); 2394 break; 2395 } 2396 } 2397 2398 2399 static const struct hda_input_mux cxt5066_analog_mic_boost = { 2400 .num_items = 5, 2401 .items = { 2402 { "0dB", 0 }, 2403 { "10dB", 1 }, 2404 { "20dB", 2 }, 2405 { "30dB", 3 }, 2406 { "40dB", 4 }, 2407 }, 2408 }; 2409 2410 static void cxt5066_set_mic_boost(struct hda_codec *codec) 2411 { 2412 struct conexant_spec *spec = codec->spec; 2413 snd_hda_codec_write_cache(codec, 0x17, 0, 2414 AC_VERB_SET_AMP_GAIN_MUTE, 2415 AC_AMP_SET_RIGHT | AC_AMP_SET_LEFT | AC_AMP_SET_OUTPUT | 2416 cxt5066_analog_mic_boost.items[spec->mic_boost].index); 2417 if (spec->ideapad || spec->thinkpad) { 2418 /* adjust the internal mic as well...it is not through 0x17 */ 2419 snd_hda_codec_write_cache(codec, 0x23, 0, 2420 AC_VERB_SET_AMP_GAIN_MUTE, 2421 AC_AMP_SET_RIGHT | AC_AMP_SET_LEFT | AC_AMP_SET_INPUT | 2422 cxt5066_analog_mic_boost. 2423 items[spec->mic_boost].index); 2424 } 2425 } 2426 2427 static int cxt5066_mic_boost_mux_enum_info(struct snd_kcontrol *kcontrol, 2428 struct snd_ctl_elem_info *uinfo) 2429 { 2430 return snd_hda_input_mux_info(&cxt5066_analog_mic_boost, uinfo); 2431 } 2432 2433 static int cxt5066_mic_boost_mux_enum_get(struct snd_kcontrol *kcontrol, 2434 struct snd_ctl_elem_value *ucontrol) 2435 { 2436 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2437 struct conexant_spec *spec = codec->spec; 2438 ucontrol->value.enumerated.item[0] = spec->mic_boost; 2439 return 0; 2440 } 2441 2442 static int cxt5066_mic_boost_mux_enum_put(struct snd_kcontrol *kcontrol, 2443 struct snd_ctl_elem_value *ucontrol) 2444 { 2445 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2446 struct conexant_spec *spec = codec->spec; 2447 const struct hda_input_mux *imux = &cxt5066_analog_mic_boost; 2448 unsigned int idx; 2449 idx = ucontrol->value.enumerated.item[0]; 2450 if (idx >= imux->num_items) 2451 idx = imux->num_items - 1; 2452 2453 spec->mic_boost = idx; 2454 if (!spec->dc_enable) 2455 cxt5066_set_mic_boost(codec); 2456 return 1; 2457 } 2458 2459 static void cxt5066_enable_dc(struct hda_codec *codec) 2460 { 2461 const struct hda_verb enable_dc_mode[] = { 2462 /* disable gain */ 2463 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2464 2465 /* switch to DC input */ 2466 {0x17, AC_VERB_SET_CONNECT_SEL, 3}, 2467 {} 2468 }; 2469 2470 /* configure as input source */ 2471 snd_hda_sequence_write(codec, enable_dc_mode); 2472 cxt5066_olpc_select_mic(codec); /* also sets configured bias */ 2473 } 2474 2475 static void cxt5066_disable_dc(struct hda_codec *codec) 2476 { 2477 /* reconfigure input source */ 2478 cxt5066_set_mic_boost(codec); 2479 /* automic also selects the right mic if we're recording */ 2480 cxt5066_olpc_automic(codec); 2481 } 2482 2483 static int cxt5066_olpc_dc_get(struct snd_kcontrol *kcontrol, 2484 struct snd_ctl_elem_value *ucontrol) 2485 { 2486 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2487 struct conexant_spec *spec = codec->spec; 2488 ucontrol->value.integer.value[0] = spec->dc_enable; 2489 return 0; 2490 } 2491 2492 static int cxt5066_olpc_dc_put(struct snd_kcontrol *kcontrol, 2493 struct snd_ctl_elem_value *ucontrol) 2494 { 2495 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2496 struct conexant_spec *spec = codec->spec; 2497 int dc_enable = !!ucontrol->value.integer.value[0]; 2498 2499 if (dc_enable == spec->dc_enable) 2500 return 0; 2501 2502 spec->dc_enable = dc_enable; 2503 if (dc_enable) 2504 cxt5066_enable_dc(codec); 2505 else 2506 cxt5066_disable_dc(codec); 2507 2508 return 1; 2509 } 2510 2511 static int cxt5066_olpc_dc_bias_enum_info(struct snd_kcontrol *kcontrol, 2512 struct snd_ctl_elem_info *uinfo) 2513 { 2514 return snd_hda_input_mux_info(&cxt5066_olpc_dc_bias, uinfo); 2515 } 2516 2517 static int cxt5066_olpc_dc_bias_enum_get(struct snd_kcontrol *kcontrol, 2518 struct snd_ctl_elem_value *ucontrol) 2519 { 2520 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2521 struct conexant_spec *spec = codec->spec; 2522 ucontrol->value.enumerated.item[0] = spec->dc_input_bias; 2523 return 0; 2524 } 2525 2526 static int cxt5066_olpc_dc_bias_enum_put(struct snd_kcontrol *kcontrol, 2527 struct snd_ctl_elem_value *ucontrol) 2528 { 2529 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2530 struct conexant_spec *spec = codec->spec; 2531 const struct hda_input_mux *imux = &cxt5066_analog_mic_boost; 2532 unsigned int idx; 2533 2534 idx = ucontrol->value.enumerated.item[0]; 2535 if (idx >= imux->num_items) 2536 idx = imux->num_items - 1; 2537 2538 spec->dc_input_bias = idx; 2539 if (spec->dc_enable) 2540 cxt5066_set_olpc_dc_bias(codec); 2541 return 1; 2542 } 2543 2544 static void cxt5066_olpc_capture_prepare(struct hda_codec *codec) 2545 { 2546 struct conexant_spec *spec = codec->spec; 2547 /* mark as recording and configure the microphone widget so that the 2548 * recording LED comes on. */ 2549 spec->recording = 1; 2550 cxt5066_olpc_select_mic(codec); 2551 } 2552 2553 static void cxt5066_olpc_capture_cleanup(struct hda_codec *codec) 2554 { 2555 struct conexant_spec *spec = codec->spec; 2556 const struct hda_verb disable_mics[] = { 2557 /* disable external mic, port B */ 2558 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2559 2560 /* disble internal mic, port C */ 2561 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2562 2563 /* disable DC capture, port F */ 2564 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2565 {}, 2566 }; 2567 2568 snd_hda_sequence_write(codec, disable_mics); 2569 spec->recording = 0; 2570 } 2571 2572 static void conexant_check_dig_outs(struct hda_codec *codec, 2573 const hda_nid_t *dig_pins, 2574 int num_pins) 2575 { 2576 struct conexant_spec *spec = codec->spec; 2577 hda_nid_t *nid_loc = &spec->multiout.dig_out_nid; 2578 int i; 2579 2580 for (i = 0; i < num_pins; i++, dig_pins++) { 2581 unsigned int cfg = snd_hda_codec_get_pincfg(codec, *dig_pins); 2582 if (get_defcfg_connect(cfg) == AC_JACK_PORT_NONE) 2583 continue; 2584 if (snd_hda_get_connections(codec, *dig_pins, nid_loc, 1) != 1) 2585 continue; 2586 if (spec->slave_dig_outs[0]) 2587 nid_loc++; 2588 else 2589 nid_loc = spec->slave_dig_outs; 2590 } 2591 } 2592 2593 static const struct hda_input_mux cxt5066_capture_source = { 2594 .num_items = 4, 2595 .items = { 2596 { "Mic B", 0 }, 2597 { "Mic C", 1 }, 2598 { "Mic E", 2 }, 2599 { "Mic F", 3 }, 2600 }, 2601 }; 2602 2603 static const struct hda_bind_ctls cxt5066_bind_capture_vol_others = { 2604 .ops = &snd_hda_bind_vol, 2605 .values = { 2606 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_INPUT), 2607 HDA_COMPOSE_AMP_VAL(0x14, 3, 2, HDA_INPUT), 2608 0 2609 }, 2610 }; 2611 2612 static const struct hda_bind_ctls cxt5066_bind_capture_sw_others = { 2613 .ops = &snd_hda_bind_sw, 2614 .values = { 2615 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_INPUT), 2616 HDA_COMPOSE_AMP_VAL(0x14, 3, 2, HDA_INPUT), 2617 0 2618 }, 2619 }; 2620 2621 static const struct snd_kcontrol_new cxt5066_mixer_master[] = { 2622 HDA_CODEC_VOLUME("Master Playback Volume", 0x10, 0x00, HDA_OUTPUT), 2623 {} 2624 }; 2625 2626 static const struct snd_kcontrol_new cxt5066_mixer_master_olpc[] = { 2627 { 2628 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2629 .name = "Master Playback Volume", 2630 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 2631 SNDRV_CTL_ELEM_ACCESS_TLV_READ | 2632 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, 2633 .subdevice = HDA_SUBDEV_AMP_FLAG, 2634 .info = snd_hda_mixer_amp_volume_info, 2635 .get = snd_hda_mixer_amp_volume_get, 2636 .put = snd_hda_mixer_amp_volume_put, 2637 .tlv = { .c = snd_hda_mixer_amp_tlv }, 2638 /* offset by 28 volume steps to limit minimum gain to -46dB */ 2639 .private_value = 2640 HDA_COMPOSE_AMP_VAL_OFS(0x10, 3, 0, HDA_OUTPUT, 28), 2641 }, 2642 {} 2643 }; 2644 2645 static const struct snd_kcontrol_new cxt5066_mixer_olpc_dc[] = { 2646 { 2647 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2648 .name = "DC Mode Enable Switch", 2649 .info = snd_ctl_boolean_mono_info, 2650 .get = cxt5066_olpc_dc_get, 2651 .put = cxt5066_olpc_dc_put, 2652 }, 2653 { 2654 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2655 .name = "DC Input Bias Enum", 2656 .info = cxt5066_olpc_dc_bias_enum_info, 2657 .get = cxt5066_olpc_dc_bias_enum_get, 2658 .put = cxt5066_olpc_dc_bias_enum_put, 2659 }, 2660 {} 2661 }; 2662 2663 static const struct snd_kcontrol_new cxt5066_mixers[] = { 2664 { 2665 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2666 .name = "Master Playback Switch", 2667 .info = cxt_eapd_info, 2668 .get = cxt_eapd_get, 2669 .put = cxt5066_hp_master_sw_put, 2670 .private_value = 0x1d, 2671 }, 2672 2673 { 2674 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2675 .name = "Analog Mic Boost Capture Enum", 2676 .info = cxt5066_mic_boost_mux_enum_info, 2677 .get = cxt5066_mic_boost_mux_enum_get, 2678 .put = cxt5066_mic_boost_mux_enum_put, 2679 }, 2680 2681 HDA_BIND_VOL("Capture Volume", &cxt5066_bind_capture_vol_others), 2682 HDA_BIND_SW("Capture Switch", &cxt5066_bind_capture_sw_others), 2683 {} 2684 }; 2685 2686 static const struct snd_kcontrol_new cxt5066_vostro_mixers[] = { 2687 { 2688 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2689 .name = "Internal Mic Boost Capture Enum", 2690 .info = cxt5066_mic_boost_mux_enum_info, 2691 .get = cxt5066_mic_boost_mux_enum_get, 2692 .put = cxt5066_mic_boost_mux_enum_put, 2693 .private_value = 0x23 | 0x100, 2694 }, 2695 {} 2696 }; 2697 2698 static const struct hda_verb cxt5066_init_verbs[] = { 2699 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Port B */ 2700 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Port C */ 2701 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Port F */ 2702 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Port E */ 2703 2704 /* Speakers */ 2705 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2706 {0x1f, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ 2707 2708 /* HP, Amp */ 2709 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2710 {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ 2711 2712 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2713 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ 2714 2715 /* DAC1 */ 2716 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2717 2718 /* Node 14 connections: 0x17 0x18 0x23 0x24 0x27 */ 2719 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x50}, 2720 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2721 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2) | 0x50}, 2722 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2723 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 2724 2725 /* no digital microphone support yet */ 2726 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2727 2728 /* Audio input selector */ 2729 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x3}, 2730 2731 /* SPDIF route: PCM */ 2732 {0x20, AC_VERB_SET_CONNECT_SEL, 0x0}, 2733 {0x22, AC_VERB_SET_CONNECT_SEL, 0x0}, 2734 2735 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2736 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2737 2738 /* EAPD */ 2739 {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */ 2740 2741 /* not handling these yet */ 2742 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, 0}, 2743 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, 0}, 2744 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, 0}, 2745 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, 0}, 2746 {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE, 0}, 2747 {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, 0}, 2748 {0x20, AC_VERB_SET_UNSOLICITED_ENABLE, 0}, 2749 {0x22, AC_VERB_SET_UNSOLICITED_ENABLE, 0}, 2750 { } /* end */ 2751 }; 2752 2753 static const struct hda_verb cxt5066_init_verbs_olpc[] = { 2754 /* Port A: headphones */ 2755 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2756 {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ 2757 2758 /* Port B: external microphone */ 2759 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2760 2761 /* Port C: internal microphone */ 2762 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2763 2764 /* Port D: unused */ 2765 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2766 2767 /* Port E: unused, but has primary EAPD */ 2768 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2769 {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */ 2770 2771 /* Port F: external DC input through microphone port */ 2772 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2773 2774 /* Port G: internal speakers */ 2775 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2776 {0x1f, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ 2777 2778 /* DAC1 */ 2779 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2780 2781 /* DAC2: unused */ 2782 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2783 2784 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x50}, 2785 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2786 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2787 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2788 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2789 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2790 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2791 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2792 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2793 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2794 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2795 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2796 2797 /* Disable digital microphone port */ 2798 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2799 2800 /* Audio input selectors */ 2801 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x3}, 2802 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 2803 2804 /* Disable SPDIF */ 2805 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2806 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2807 2808 /* enable unsolicited events for Port A and B */ 2809 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT}, 2810 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT}, 2811 { } /* end */ 2812 }; 2813 2814 static const struct hda_verb cxt5066_init_verbs_vostro[] = { 2815 /* Port A: headphones */ 2816 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2817 {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ 2818 2819 /* Port B: external microphone */ 2820 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2821 2822 /* Port C: unused */ 2823 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2824 2825 /* Port D: unused */ 2826 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2827 2828 /* Port E: unused, but has primary EAPD */ 2829 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2830 {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */ 2831 2832 /* Port F: unused */ 2833 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2834 2835 /* Port G: internal speakers */ 2836 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2837 {0x1f, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ 2838 2839 /* DAC1 */ 2840 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2841 2842 /* DAC2: unused */ 2843 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2844 2845 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2846 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2847 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2848 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2849 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2850 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2851 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2852 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2853 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2854 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2855 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2856 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2857 2858 /* Digital microphone port */ 2859 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2860 2861 /* Audio input selectors */ 2862 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x3}, 2863 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 2864 2865 /* Disable SPDIF */ 2866 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2867 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2868 2869 /* enable unsolicited events for Port A and B */ 2870 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT}, 2871 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT}, 2872 { } /* end */ 2873 }; 2874 2875 static const struct hda_verb cxt5066_init_verbs_ideapad[] = { 2876 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Port B */ 2877 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, /* Port C */ 2878 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Port F */ 2879 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Port E */ 2880 2881 /* Speakers */ 2882 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2883 {0x1f, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ 2884 2885 /* HP, Amp */ 2886 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2887 {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ 2888 2889 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2890 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ 2891 2892 /* DAC1 */ 2893 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2894 2895 /* Node 14 connections: 0x17 0x18 0x23 0x24 0x27 */ 2896 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x50}, 2897 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2898 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2) | 0x50}, 2899 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2900 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 2901 {0x14, AC_VERB_SET_CONNECT_SEL, 2}, /* default to internal mic */ 2902 2903 /* Audio input selector */ 2904 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x2}, 2905 {0x17, AC_VERB_SET_CONNECT_SEL, 1}, /* route ext mic */ 2906 2907 /* SPDIF route: PCM */ 2908 {0x20, AC_VERB_SET_CONNECT_SEL, 0x0}, 2909 {0x22, AC_VERB_SET_CONNECT_SEL, 0x0}, 2910 2911 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2912 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2913 2914 /* internal microphone */ 2915 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* enable internal mic */ 2916 2917 /* EAPD */ 2918 {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */ 2919 2920 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT}, 2921 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT}, 2922 { } /* end */ 2923 }; 2924 2925 static const struct hda_verb cxt5066_init_verbs_thinkpad[] = { 2926 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Port F */ 2927 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* Port E */ 2928 2929 /* Port G: internal speakers */ 2930 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2931 {0x1f, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ 2932 2933 /* Port A: HP, Amp */ 2934 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2935 {0x19, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ 2936 2937 /* Port B: Mic Dock */ 2938 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2939 2940 /* Port C: Mic */ 2941 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2942 2943 /* Port D: HP Dock, Amp */ 2944 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0}, 2945 {0x1c, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC1 */ 2946 2947 /* DAC1 */ 2948 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2949 2950 /* Node 14 connections: 0x17 0x18 0x23 0x24 0x27 */ 2951 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) | 0x50}, 2952 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2953 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2) | 0x50}, 2954 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2955 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 2956 {0x14, AC_VERB_SET_CONNECT_SEL, 2}, /* default to internal mic */ 2957 2958 /* Audio input selector */ 2959 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x2}, 2960 {0x17, AC_VERB_SET_CONNECT_SEL, 1}, /* route ext mic */ 2961 2962 /* SPDIF route: PCM */ 2963 {0x20, AC_VERB_SET_CONNECT_SEL, 0x0}, 2964 {0x22, AC_VERB_SET_CONNECT_SEL, 0x0}, 2965 2966 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2967 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2968 2969 /* internal microphone */ 2970 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* enable internal mic */ 2971 2972 /* EAPD */ 2973 {0x1d, AC_VERB_SET_EAPD_BTLENABLE, 0x2}, /* default on */ 2974 2975 /* enable unsolicited events for Port A, B, C and D */ 2976 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT}, 2977 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT}, 2978 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT}, 2979 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT}, 2980 { } /* end */ 2981 }; 2982 2983 static const struct hda_verb cxt5066_init_verbs_portd_lo[] = { 2984 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2985 { } /* end */ 2986 }; 2987 2988 2989 static const struct hda_verb cxt5066_init_verbs_hp_laptop[] = { 2990 {0x14, AC_VERB_SET_CONNECT_SEL, 0x0}, 2991 {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT}, 2992 {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT}, 2993 { } /* end */ 2994 }; 2995 2996 /* initialize jack-sensing, too */ 2997 static int cxt5066_init(struct hda_codec *codec) 2998 { 2999 snd_printdd("CXT5066: init\n"); 3000 conexant_init(codec); 3001 if (codec->patch_ops.unsol_event) { 3002 cxt5066_hp_automute(codec); 3003 cxt5066_automic(codec); 3004 } 3005 cxt5066_set_mic_boost(codec); 3006 return 0; 3007 } 3008 3009 static int cxt5066_olpc_init(struct hda_codec *codec) 3010 { 3011 struct conexant_spec *spec = codec->spec; 3012 snd_printdd("CXT5066: init\n"); 3013 conexant_init(codec); 3014 cxt5066_hp_automute(codec); 3015 if (!spec->dc_enable) { 3016 cxt5066_set_mic_boost(codec); 3017 cxt5066_olpc_automic(codec); 3018 } else { 3019 cxt5066_enable_dc(codec); 3020 } 3021 return 0; 3022 } 3023 3024 enum { 3025 CXT5066_LAPTOP, /* Laptops w/ EAPD support */ 3026 CXT5066_DELL_LAPTOP, /* Dell Laptop */ 3027 CXT5066_OLPC_XO_1_5, /* OLPC XO 1.5 */ 3028 CXT5066_DELL_VOSTRO, /* Dell Vostro 1015i */ 3029 CXT5066_IDEAPAD, /* Lenovo IdeaPad U150 */ 3030 CXT5066_THINKPAD, /* Lenovo ThinkPad T410s, others? */ 3031 CXT5066_ASUS, /* Asus K52JU, Lenovo G560 - Int mic at 0x1a and Ext mic at 0x1b */ 3032 CXT5066_HP_LAPTOP, /* HP Laptop */ 3033 CXT5066_AUTO, /* BIOS auto-parser */ 3034 CXT5066_MODELS 3035 }; 3036 3037 static const char * const cxt5066_models[CXT5066_MODELS] = { 3038 [CXT5066_LAPTOP] = "laptop", 3039 [CXT5066_DELL_LAPTOP] = "dell-laptop", 3040 [CXT5066_OLPC_XO_1_5] = "olpc-xo-1_5", 3041 [CXT5066_DELL_VOSTRO] = "dell-vostro", 3042 [CXT5066_IDEAPAD] = "ideapad", 3043 [CXT5066_THINKPAD] = "thinkpad", 3044 [CXT5066_ASUS] = "asus", 3045 [CXT5066_HP_LAPTOP] = "hp-laptop", 3046 [CXT5066_AUTO] = "auto", 3047 }; 3048 3049 static const struct snd_pci_quirk cxt5066_cfg_tbl[] = { 3050 SND_PCI_QUIRK(0x1025, 0x054c, "Acer Aspire 3830TG", CXT5066_AUTO), 3051 SND_PCI_QUIRK_MASK(0x1025, 0xff00, 0x0400, "Acer", CXT5066_IDEAPAD), 3052 SND_PCI_QUIRK(0x1028, 0x02d8, "Dell Vostro", CXT5066_DELL_VOSTRO), 3053 SND_PCI_QUIRK(0x1028, 0x02f5, "Dell Vostro 320", CXT5066_IDEAPAD), 3054 SND_PCI_QUIRK(0x1028, 0x0401, "Dell Vostro 1014", CXT5066_DELL_VOSTRO), 3055 SND_PCI_QUIRK(0x1028, 0x0402, "Dell Vostro", CXT5066_DELL_VOSTRO), 3056 SND_PCI_QUIRK(0x1028, 0x0408, "Dell Inspiron One 19T", CXT5066_IDEAPAD), 3057 SND_PCI_QUIRK(0x1028, 0x050f, "Dell Inspiron", CXT5066_IDEAPAD), 3058 SND_PCI_QUIRK(0x1028, 0x0510, "Dell Vostro", CXT5066_IDEAPAD), 3059 SND_PCI_QUIRK(0x103c, 0x360b, "HP G60", CXT5066_HP_LAPTOP), 3060 SND_PCI_QUIRK(0x1043, 0x13f3, "Asus A52J", CXT5066_ASUS), 3061 SND_PCI_QUIRK(0x1043, 0x1643, "Asus K52JU", CXT5066_ASUS), 3062 SND_PCI_QUIRK(0x1043, 0x1993, "Asus U50F", CXT5066_ASUS), 3063 SND_PCI_QUIRK(0x1179, 0xff1e, "Toshiba Satellite C650D", CXT5066_IDEAPAD), 3064 SND_PCI_QUIRK(0x1179, 0xff50, "Toshiba Satellite P500-PSPGSC-01800T", CXT5066_OLPC_XO_1_5), 3065 SND_PCI_QUIRK(0x14f1, 0x0101, "Conexant Reference board", 3066 CXT5066_LAPTOP), 3067 SND_PCI_QUIRK(0x152d, 0x0833, "OLPC XO-1.5", CXT5066_OLPC_XO_1_5), 3068 SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo T400s", CXT5066_THINKPAD), 3069 SND_PCI_QUIRK(0x17aa, 0x21c5, "Thinkpad Edge 13", CXT5066_THINKPAD), 3070 SND_PCI_QUIRK(0x17aa, 0x21c6, "Thinkpad Edge 13", CXT5066_ASUS), 3071 SND_PCI_QUIRK(0x17aa, 0x215e, "Lenovo Thinkpad", CXT5066_THINKPAD), 3072 SND_PCI_QUIRK(0x17aa, 0x21cf, "Lenovo T520 & W520", CXT5066_AUTO), 3073 SND_PCI_QUIRK(0x17aa, 0x21da, "Lenovo X220", CXT5066_THINKPAD), 3074 SND_PCI_QUIRK(0x17aa, 0x21db, "Lenovo X220-tablet", CXT5066_THINKPAD), 3075 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo U350", CXT5066_ASUS), 3076 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo G560", CXT5066_ASUS), 3077 SND_PCI_QUIRK(0x17aa, 0x3938, "Lenovo G565", CXT5066_AUTO), 3078 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", CXT5066_IDEAPAD), /* Fallback for Lenovos without dock mic */ 3079 SND_PCI_QUIRK(0x1b0a, 0x2092, "CyberpowerPC Gamer Xplorer N57001", CXT5066_AUTO), 3080 {} 3081 }; 3082 3083 static int patch_cxt5066(struct hda_codec *codec) 3084 { 3085 struct conexant_spec *spec; 3086 int board_config; 3087 3088 board_config = snd_hda_check_board_config(codec, CXT5066_MODELS, 3089 cxt5066_models, cxt5066_cfg_tbl); 3090 if (board_config < 0) 3091 board_config = CXT5066_AUTO; /* model=auto as default */ 3092 if (board_config == CXT5066_AUTO) 3093 return patch_conexant_auto(codec); 3094 3095 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3096 if (!spec) 3097 return -ENOMEM; 3098 codec->spec = spec; 3099 3100 codec->patch_ops = conexant_patch_ops; 3101 codec->patch_ops.init = conexant_init; 3102 3103 spec->dell_automute = 0; 3104 spec->multiout.max_channels = 2; 3105 spec->multiout.num_dacs = ARRAY_SIZE(cxt5066_dac_nids); 3106 spec->multiout.dac_nids = cxt5066_dac_nids; 3107 conexant_check_dig_outs(codec, cxt5066_digout_pin_nids, 3108 ARRAY_SIZE(cxt5066_digout_pin_nids)); 3109 spec->num_adc_nids = 1; 3110 spec->adc_nids = cxt5066_adc_nids; 3111 spec->capsrc_nids = cxt5066_capsrc_nids; 3112 spec->input_mux = &cxt5066_capture_source; 3113 3114 spec->port_d_mode = PIN_HP; 3115 3116 spec->num_init_verbs = 1; 3117 spec->init_verbs[0] = cxt5066_init_verbs; 3118 spec->num_channel_mode = ARRAY_SIZE(cxt5066_modes); 3119 spec->channel_mode = cxt5066_modes; 3120 spec->cur_adc = 0; 3121 spec->cur_adc_idx = 0; 3122 3123 set_beep_amp(spec, 0x13, 0, HDA_OUTPUT); 3124 3125 switch (board_config) { 3126 default: 3127 case CXT5066_LAPTOP: 3128 spec->mixers[spec->num_mixers++] = cxt5066_mixer_master; 3129 spec->mixers[spec->num_mixers++] = cxt5066_mixers; 3130 break; 3131 case CXT5066_DELL_LAPTOP: 3132 spec->mixers[spec->num_mixers++] = cxt5066_mixer_master; 3133 spec->mixers[spec->num_mixers++] = cxt5066_mixers; 3134 3135 spec->port_d_mode = PIN_OUT; 3136 spec->init_verbs[spec->num_init_verbs] = cxt5066_init_verbs_portd_lo; 3137 spec->num_init_verbs++; 3138 spec->dell_automute = 1; 3139 break; 3140 case CXT5066_ASUS: 3141 case CXT5066_HP_LAPTOP: 3142 codec->patch_ops.init = cxt5066_init; 3143 codec->patch_ops.unsol_event = cxt5066_unsol_event; 3144 spec->init_verbs[spec->num_init_verbs] = 3145 cxt5066_init_verbs_hp_laptop; 3146 spec->num_init_verbs++; 3147 spec->hp_laptop = board_config == CXT5066_HP_LAPTOP; 3148 spec->asus = board_config == CXT5066_ASUS; 3149 spec->mixers[spec->num_mixers++] = cxt5066_mixer_master; 3150 spec->mixers[spec->num_mixers++] = cxt5066_mixers; 3151 /* no S/PDIF out */ 3152 if (board_config == CXT5066_HP_LAPTOP) 3153 spec->multiout.dig_out_nid = 0; 3154 /* input source automatically selected */ 3155 spec->input_mux = NULL; 3156 spec->port_d_mode = 0; 3157 spec->mic_boost = 3; /* default 30dB gain */ 3158 break; 3159 3160 case CXT5066_OLPC_XO_1_5: 3161 codec->patch_ops.init = cxt5066_olpc_init; 3162 codec->patch_ops.unsol_event = cxt5066_olpc_unsol_event; 3163 spec->init_verbs[0] = cxt5066_init_verbs_olpc; 3164 spec->mixers[spec->num_mixers++] = cxt5066_mixer_master_olpc; 3165 spec->mixers[spec->num_mixers++] = cxt5066_mixer_olpc_dc; 3166 spec->mixers[spec->num_mixers++] = cxt5066_mixers; 3167 spec->port_d_mode = 0; 3168 spec->mic_boost = 3; /* default 30dB gain */ 3169 3170 /* no S/PDIF out */ 3171 spec->multiout.dig_out_nid = 0; 3172 3173 /* input source automatically selected */ 3174 spec->input_mux = NULL; 3175 3176 /* our capture hooks which allow us to turn on the microphone LED 3177 * at the right time */ 3178 spec->capture_prepare = cxt5066_olpc_capture_prepare; 3179 spec->capture_cleanup = cxt5066_olpc_capture_cleanup; 3180 break; 3181 case CXT5066_DELL_VOSTRO: 3182 codec->patch_ops.init = cxt5066_init; 3183 codec->patch_ops.unsol_event = cxt5066_unsol_event; 3184 spec->init_verbs[0] = cxt5066_init_verbs_vostro; 3185 spec->mixers[spec->num_mixers++] = cxt5066_mixer_master_olpc; 3186 spec->mixers[spec->num_mixers++] = cxt5066_mixers; 3187 spec->mixers[spec->num_mixers++] = cxt5066_vostro_mixers; 3188 spec->port_d_mode = 0; 3189 spec->dell_vostro = 1; 3190 spec->mic_boost = 3; /* default 30dB gain */ 3191 3192 /* no S/PDIF out */ 3193 spec->multiout.dig_out_nid = 0; 3194 3195 /* input source automatically selected */ 3196 spec->input_mux = NULL; 3197 break; 3198 case CXT5066_IDEAPAD: 3199 codec->patch_ops.init = cxt5066_init; 3200 codec->patch_ops.unsol_event = cxt5066_unsol_event; 3201 spec->mixers[spec->num_mixers++] = cxt5066_mixer_master; 3202 spec->mixers[spec->num_mixers++] = cxt5066_mixers; 3203 spec->init_verbs[0] = cxt5066_init_verbs_ideapad; 3204 spec->port_d_mode = 0; 3205 spec->ideapad = 1; 3206 spec->mic_boost = 2; /* default 20dB gain */ 3207 3208 /* no S/PDIF out */ 3209 spec->multiout.dig_out_nid = 0; 3210 3211 /* input source automatically selected */ 3212 spec->input_mux = NULL; 3213 break; 3214 case CXT5066_THINKPAD: 3215 codec->patch_ops.init = cxt5066_init; 3216 codec->patch_ops.unsol_event = cxt5066_unsol_event; 3217 spec->mixers[spec->num_mixers++] = cxt5066_mixer_master; 3218 spec->mixers[spec->num_mixers++] = cxt5066_mixers; 3219 spec->init_verbs[0] = cxt5066_init_verbs_thinkpad; 3220 spec->thinkpad = 1; 3221 spec->port_d_mode = PIN_OUT; 3222 spec->mic_boost = 2; /* default 20dB gain */ 3223 3224 /* no S/PDIF out */ 3225 spec->multiout.dig_out_nid = 0; 3226 3227 /* input source automatically selected */ 3228 spec->input_mux = NULL; 3229 break; 3230 } 3231 3232 if (spec->beep_amp) 3233 snd_hda_attach_beep_device(codec, spec->beep_amp); 3234 3235 return 0; 3236 } 3237 3238 /* 3239 * Automatic parser for CX20641 & co 3240 */ 3241 3242 static int cx_auto_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 3243 struct hda_codec *codec, 3244 unsigned int stream_tag, 3245 unsigned int format, 3246 struct snd_pcm_substream *substream) 3247 { 3248 struct conexant_spec *spec = codec->spec; 3249 hda_nid_t adc = spec->imux_info[spec->cur_mux[0]].adc; 3250 if (spec->adc_switching) { 3251 spec->cur_adc = adc; 3252 spec->cur_adc_stream_tag = stream_tag; 3253 spec->cur_adc_format = format; 3254 } 3255 snd_hda_codec_setup_stream(codec, adc, stream_tag, 0, format); 3256 return 0; 3257 } 3258 3259 static int cx_auto_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 3260 struct hda_codec *codec, 3261 struct snd_pcm_substream *substream) 3262 { 3263 struct conexant_spec *spec = codec->spec; 3264 snd_hda_codec_cleanup_stream(codec, spec->cur_adc); 3265 spec->cur_adc = 0; 3266 return 0; 3267 } 3268 3269 static const struct hda_pcm_stream cx_auto_pcm_analog_capture = { 3270 .substreams = 1, 3271 .channels_min = 2, 3272 .channels_max = 2, 3273 .nid = 0, /* fill later */ 3274 .ops = { 3275 .prepare = cx_auto_capture_pcm_prepare, 3276 .cleanup = cx_auto_capture_pcm_cleanup 3277 }, 3278 }; 3279 3280 static const hda_nid_t cx_auto_adc_nids[] = { 0x14 }; 3281 3282 #define get_connection_index(codec, mux, nid)\ 3283 snd_hda_get_conn_index(codec, mux, nid, 0) 3284 3285 /* get an unassigned DAC from the given list. 3286 * Return the nid if found and reduce the DAC list, or return zero if 3287 * not found 3288 */ 3289 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t pin, 3290 hda_nid_t *dacs, int *num_dacs) 3291 { 3292 int i, nums = *num_dacs; 3293 hda_nid_t ret = 0; 3294 3295 for (i = 0; i < nums; i++) { 3296 if (get_connection_index(codec, pin, dacs[i]) >= 0) { 3297 ret = dacs[i]; 3298 break; 3299 } 3300 } 3301 if (!ret) 3302 return 0; 3303 if (--nums > 0) 3304 memmove(dacs, dacs + 1, nums * sizeof(hda_nid_t)); 3305 *num_dacs = nums; 3306 return ret; 3307 } 3308 3309 #define MAX_AUTO_DACS 5 3310 3311 #define DAC_SLAVE_FLAG 0x8000 /* filled dac is a slave */ 3312 3313 /* fill analog DAC list from the widget tree */ 3314 static int fill_cx_auto_dacs(struct hda_codec *codec, hda_nid_t *dacs) 3315 { 3316 hda_nid_t nid, end_nid; 3317 int nums = 0; 3318 3319 end_nid = codec->start_nid + codec->num_nodes; 3320 for (nid = codec->start_nid; nid < end_nid; nid++) { 3321 unsigned int wcaps = get_wcaps(codec, nid); 3322 unsigned int type = get_wcaps_type(wcaps); 3323 if (type == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL)) { 3324 dacs[nums++] = nid; 3325 if (nums >= MAX_AUTO_DACS) 3326 break; 3327 } 3328 } 3329 return nums; 3330 } 3331 3332 /* fill pin_dac_pair list from the pin and dac list */ 3333 static int fill_dacs_for_pins(struct hda_codec *codec, hda_nid_t *pins, 3334 int num_pins, hda_nid_t *dacs, int *rest, 3335 struct pin_dac_pair *filled, int nums, 3336 int type) 3337 { 3338 int i, start = nums; 3339 3340 for (i = 0; i < num_pins; i++, nums++) { 3341 filled[nums].pin = pins[i]; 3342 filled[nums].type = type; 3343 filled[nums].dac = get_unassigned_dac(codec, pins[i], dacs, rest); 3344 if (filled[nums].dac) 3345 continue; 3346 if (filled[start].dac && get_connection_index(codec, pins[i], filled[start].dac) >= 0) { 3347 filled[nums].dac = filled[start].dac | DAC_SLAVE_FLAG; 3348 continue; 3349 } 3350 if (filled[0].dac && get_connection_index(codec, pins[i], filled[0].dac) >= 0) { 3351 filled[nums].dac = filled[0].dac | DAC_SLAVE_FLAG; 3352 continue; 3353 } 3354 snd_printdd("Failed to find a DAC for pin 0x%x", pins[i]); 3355 } 3356 return nums; 3357 } 3358 3359 /* parse analog output paths */ 3360 static void cx_auto_parse_output(struct hda_codec *codec) 3361 { 3362 struct conexant_spec *spec = codec->spec; 3363 struct auto_pin_cfg *cfg = &spec->autocfg; 3364 hda_nid_t dacs[MAX_AUTO_DACS]; 3365 int i, j, nums, rest; 3366 3367 rest = fill_cx_auto_dacs(codec, dacs); 3368 /* parse all analog output pins */ 3369 nums = fill_dacs_for_pins(codec, cfg->line_out_pins, cfg->line_outs, 3370 dacs, &rest, spec->dac_info, 0, 3371 AUTO_PIN_LINE_OUT); 3372 nums = fill_dacs_for_pins(codec, cfg->hp_pins, cfg->hp_outs, 3373 dacs, &rest, spec->dac_info, nums, 3374 AUTO_PIN_HP_OUT); 3375 nums = fill_dacs_for_pins(codec, cfg->speaker_pins, cfg->speaker_outs, 3376 dacs, &rest, spec->dac_info, nums, 3377 AUTO_PIN_SPEAKER_OUT); 3378 spec->dac_info_filled = nums; 3379 /* fill multiout struct */ 3380 for (i = 0; i < nums; i++) { 3381 hda_nid_t dac = spec->dac_info[i].dac; 3382 if (!dac || (dac & DAC_SLAVE_FLAG)) 3383 continue; 3384 switch (spec->dac_info[i].type) { 3385 case AUTO_PIN_LINE_OUT: 3386 spec->private_dac_nids[spec->multiout.num_dacs] = dac; 3387 spec->multiout.num_dacs++; 3388 break; 3389 case AUTO_PIN_HP_OUT: 3390 case AUTO_PIN_SPEAKER_OUT: 3391 if (!spec->multiout.hp_nid) { 3392 spec->multiout.hp_nid = dac; 3393 break; 3394 } 3395 for (j = 0; j < ARRAY_SIZE(spec->multiout.extra_out_nid); j++) 3396 if (!spec->multiout.extra_out_nid[j]) { 3397 spec->multiout.extra_out_nid[j] = dac; 3398 break; 3399 } 3400 break; 3401 } 3402 } 3403 spec->multiout.dac_nids = spec->private_dac_nids; 3404 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 3405 3406 for (i = 0; i < cfg->hp_outs; i++) { 3407 if (is_jack_detectable(codec, cfg->hp_pins[i])) { 3408 spec->auto_mute = 1; 3409 break; 3410 } 3411 } 3412 if (spec->auto_mute && 3413 cfg->line_out_pins[0] && 3414 cfg->line_out_type != AUTO_PIN_SPEAKER_OUT && 3415 cfg->line_out_pins[0] != cfg->hp_pins[0] && 3416 cfg->line_out_pins[0] != cfg->speaker_pins[0]) { 3417 for (i = 0; i < cfg->line_outs; i++) { 3418 if (is_jack_detectable(codec, cfg->line_out_pins[i])) { 3419 spec->detect_line = 1; 3420 break; 3421 } 3422 } 3423 spec->automute_lines = spec->detect_line; 3424 } 3425 3426 spec->vmaster_nid = spec->private_dac_nids[0]; 3427 } 3428 3429 static void cx_auto_turn_eapd(struct hda_codec *codec, int num_pins, 3430 hda_nid_t *pins, bool on); 3431 3432 static void do_automute(struct hda_codec *codec, int num_pins, 3433 hda_nid_t *pins, bool on) 3434 { 3435 struct conexant_spec *spec = codec->spec; 3436 int i; 3437 for (i = 0; i < num_pins; i++) 3438 snd_hda_codec_write(codec, pins[i], 0, 3439 AC_VERB_SET_PIN_WIDGET_CONTROL, 3440 on ? PIN_OUT : 0); 3441 if (spec->pin_eapd_ctrls) 3442 cx_auto_turn_eapd(codec, num_pins, pins, on); 3443 } 3444 3445 static int detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins) 3446 { 3447 int i, present = 0; 3448 3449 for (i = 0; i < num_pins; i++) { 3450 hda_nid_t nid = pins[i]; 3451 if (!nid || !is_jack_detectable(codec, nid)) 3452 break; 3453 snd_hda_input_jack_report(codec, nid); 3454 present |= snd_hda_jack_detect(codec, nid); 3455 } 3456 return present; 3457 } 3458 3459 /* auto-mute/unmute speaker and line outs according to headphone jack */ 3460 static void cx_auto_update_speakers(struct hda_codec *codec) 3461 { 3462 struct conexant_spec *spec = codec->spec; 3463 struct auto_pin_cfg *cfg = &spec->autocfg; 3464 int on = 1; 3465 3466 /* turn on HP EAPD when HP jacks are present */ 3467 if (spec->pin_eapd_ctrls) { 3468 if (spec->auto_mute) 3469 on = spec->hp_present; 3470 cx_auto_turn_eapd(codec, cfg->hp_outs, cfg->hp_pins, on); 3471 } 3472 3473 /* mute speakers in auto-mode if HP or LO jacks are plugged */ 3474 if (spec->auto_mute) 3475 on = !(spec->hp_present || 3476 (spec->detect_line && spec->line_present)); 3477 do_automute(codec, cfg->speaker_outs, cfg->speaker_pins, on); 3478 3479 /* toggle line-out mutes if needed, too */ 3480 /* if LO is a copy of either HP or Speaker, don't need to handle it */ 3481 if (cfg->line_out_pins[0] == cfg->hp_pins[0] || 3482 cfg->line_out_pins[0] == cfg->speaker_pins[0]) 3483 return; 3484 if (spec->auto_mute) { 3485 /* mute LO in auto-mode when HP jack is present */ 3486 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT || 3487 spec->automute_lines) 3488 on = !spec->hp_present; 3489 else 3490 on = 1; 3491 } 3492 do_automute(codec, cfg->line_outs, cfg->line_out_pins, on); 3493 } 3494 3495 static void cx_auto_hp_automute(struct hda_codec *codec) 3496 { 3497 struct conexant_spec *spec = codec->spec; 3498 struct auto_pin_cfg *cfg = &spec->autocfg; 3499 3500 if (!spec->auto_mute) 3501 return; 3502 spec->hp_present = detect_jacks(codec, cfg->hp_outs, cfg->hp_pins); 3503 cx_auto_update_speakers(codec); 3504 } 3505 3506 static void cx_auto_line_automute(struct hda_codec *codec) 3507 { 3508 struct conexant_spec *spec = codec->spec; 3509 struct auto_pin_cfg *cfg = &spec->autocfg; 3510 3511 if (!spec->auto_mute || !spec->detect_line) 3512 return; 3513 spec->line_present = detect_jacks(codec, cfg->line_outs, 3514 cfg->line_out_pins); 3515 cx_auto_update_speakers(codec); 3516 } 3517 3518 static int cx_automute_mode_info(struct snd_kcontrol *kcontrol, 3519 struct snd_ctl_elem_info *uinfo) 3520 { 3521 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3522 struct conexant_spec *spec = codec->spec; 3523 static const char * const texts2[] = { 3524 "Disabled", "Enabled" 3525 }; 3526 static const char * const texts3[] = { 3527 "Disabled", "Speaker Only", "Line-Out+Speaker" 3528 }; 3529 const char * const *texts; 3530 3531 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3532 uinfo->count = 1; 3533 if (spec->automute_hp_lo) { 3534 uinfo->value.enumerated.items = 3; 3535 texts = texts3; 3536 } else { 3537 uinfo->value.enumerated.items = 2; 3538 texts = texts2; 3539 } 3540 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items) 3541 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1; 3542 strcpy(uinfo->value.enumerated.name, 3543 texts[uinfo->value.enumerated.item]); 3544 return 0; 3545 } 3546 3547 static int cx_automute_mode_get(struct snd_kcontrol *kcontrol, 3548 struct snd_ctl_elem_value *ucontrol) 3549 { 3550 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3551 struct conexant_spec *spec = codec->spec; 3552 unsigned int val; 3553 if (!spec->auto_mute) 3554 val = 0; 3555 else if (!spec->automute_lines) 3556 val = 1; 3557 else 3558 val = 2; 3559 ucontrol->value.enumerated.item[0] = val; 3560 return 0; 3561 } 3562 3563 static int cx_automute_mode_put(struct snd_kcontrol *kcontrol, 3564 struct snd_ctl_elem_value *ucontrol) 3565 { 3566 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3567 struct conexant_spec *spec = codec->spec; 3568 3569 switch (ucontrol->value.enumerated.item[0]) { 3570 case 0: 3571 if (!spec->auto_mute) 3572 return 0; 3573 spec->auto_mute = 0; 3574 break; 3575 case 1: 3576 if (spec->auto_mute && !spec->automute_lines) 3577 return 0; 3578 spec->auto_mute = 1; 3579 spec->automute_lines = 0; 3580 break; 3581 case 2: 3582 if (!spec->automute_hp_lo) 3583 return -EINVAL; 3584 if (spec->auto_mute && spec->automute_lines) 3585 return 0; 3586 spec->auto_mute = 1; 3587 spec->automute_lines = 1; 3588 break; 3589 default: 3590 return -EINVAL; 3591 } 3592 cx_auto_update_speakers(codec); 3593 return 1; 3594 } 3595 3596 static const struct snd_kcontrol_new cx_automute_mode_enum[] = { 3597 { 3598 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3599 .name = "Auto-Mute Mode", 3600 .info = cx_automute_mode_info, 3601 .get = cx_automute_mode_get, 3602 .put = cx_automute_mode_put, 3603 }, 3604 { } 3605 }; 3606 3607 static int cx_auto_mux_enum_info(struct snd_kcontrol *kcontrol, 3608 struct snd_ctl_elem_info *uinfo) 3609 { 3610 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3611 struct conexant_spec *spec = codec->spec; 3612 3613 return snd_hda_input_mux_info(&spec->private_imux, uinfo); 3614 } 3615 3616 static int cx_auto_mux_enum_get(struct snd_kcontrol *kcontrol, 3617 struct snd_ctl_elem_value *ucontrol) 3618 { 3619 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3620 struct conexant_spec *spec = codec->spec; 3621 3622 ucontrol->value.enumerated.item[0] = spec->cur_mux[0]; 3623 return 0; 3624 } 3625 3626 /* look for the route the given pin from mux and return the index; 3627 * if do_select is set, actually select the route. 3628 */ 3629 static int __select_input_connection(struct hda_codec *codec, hda_nid_t mux, 3630 hda_nid_t pin, hda_nid_t *srcp, 3631 bool do_select, int depth) 3632 { 3633 hda_nid_t conn[HDA_MAX_NUM_INPUTS]; 3634 int i, nums; 3635 3636 switch (get_wcaps_type(get_wcaps(codec, mux))) { 3637 case AC_WID_AUD_IN: 3638 case AC_WID_AUD_SEL: 3639 case AC_WID_AUD_MIX: 3640 break; 3641 default: 3642 return -1; 3643 } 3644 3645 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn)); 3646 for (i = 0; i < nums; i++) 3647 if (conn[i] == pin) { 3648 if (do_select) 3649 snd_hda_codec_write(codec, mux, 0, 3650 AC_VERB_SET_CONNECT_SEL, i); 3651 if (srcp) 3652 *srcp = mux; 3653 return i; 3654 } 3655 depth++; 3656 if (depth == 2) 3657 return -1; 3658 for (i = 0; i < nums; i++) { 3659 int ret = __select_input_connection(codec, conn[i], pin, srcp, 3660 do_select, depth); 3661 if (ret >= 0) { 3662 if (do_select) 3663 snd_hda_codec_write(codec, mux, 0, 3664 AC_VERB_SET_CONNECT_SEL, i); 3665 return i; 3666 } 3667 } 3668 return -1; 3669 } 3670 3671 static void select_input_connection(struct hda_codec *codec, hda_nid_t mux, 3672 hda_nid_t pin) 3673 { 3674 __select_input_connection(codec, mux, pin, NULL, true, 0); 3675 } 3676 3677 static int get_input_connection(struct hda_codec *codec, hda_nid_t mux, 3678 hda_nid_t pin) 3679 { 3680 return __select_input_connection(codec, mux, pin, NULL, false, 0); 3681 } 3682 3683 static int cx_auto_mux_enum_update(struct hda_codec *codec, 3684 const struct hda_input_mux *imux, 3685 unsigned int idx) 3686 { 3687 struct conexant_spec *spec = codec->spec; 3688 hda_nid_t adc; 3689 int changed = 1; 3690 3691 if (!imux->num_items) 3692 return 0; 3693 if (idx >= imux->num_items) 3694 idx = imux->num_items - 1; 3695 if (spec->cur_mux[0] == idx) 3696 changed = 0; 3697 adc = spec->imux_info[idx].adc; 3698 select_input_connection(codec, spec->imux_info[idx].adc, 3699 spec->imux_info[idx].pin); 3700 if (spec->cur_adc && spec->cur_adc != adc) { 3701 /* stream is running, let's swap the current ADC */ 3702 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1); 3703 spec->cur_adc = adc; 3704 snd_hda_codec_setup_stream(codec, adc, 3705 spec->cur_adc_stream_tag, 0, 3706 spec->cur_adc_format); 3707 } 3708 spec->cur_mux[0] = idx; 3709 return changed; 3710 } 3711 3712 static int cx_auto_mux_enum_put(struct snd_kcontrol *kcontrol, 3713 struct snd_ctl_elem_value *ucontrol) 3714 { 3715 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3716 struct conexant_spec *spec = codec->spec; 3717 3718 return cx_auto_mux_enum_update(codec, &spec->private_imux, 3719 ucontrol->value.enumerated.item[0]); 3720 } 3721 3722 static const struct snd_kcontrol_new cx_auto_capture_mixers[] = { 3723 { 3724 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3725 .name = "Capture Source", 3726 .info = cx_auto_mux_enum_info, 3727 .get = cx_auto_mux_enum_get, 3728 .put = cx_auto_mux_enum_put 3729 }, 3730 {} 3731 }; 3732 3733 static bool select_automic(struct hda_codec *codec, int idx, bool detect) 3734 { 3735 struct conexant_spec *spec = codec->spec; 3736 if (idx < 0) 3737 return false; 3738 if (detect && !snd_hda_jack_detect(codec, spec->imux_info[idx].pin)) 3739 return false; 3740 cx_auto_mux_enum_update(codec, &spec->private_imux, idx); 3741 return true; 3742 } 3743 3744 /* automatic switch internal and external mic */ 3745 static void cx_auto_automic(struct hda_codec *codec) 3746 { 3747 struct conexant_spec *spec = codec->spec; 3748 3749 if (!spec->auto_mic) 3750 return; 3751 if (!select_automic(codec, spec->auto_mic_ext, true)) 3752 if (!select_automic(codec, spec->auto_mic_dock, true)) 3753 select_automic(codec, spec->auto_mic_int, false); 3754 } 3755 3756 static void cx_auto_unsol_event(struct hda_codec *codec, unsigned int res) 3757 { 3758 int nid = (res & AC_UNSOL_RES_SUBTAG) >> 20; 3759 switch (res >> 26) { 3760 case CONEXANT_HP_EVENT: 3761 cx_auto_hp_automute(codec); 3762 break; 3763 case CONEXANT_LINE_EVENT: 3764 cx_auto_line_automute(codec); 3765 break; 3766 case CONEXANT_MIC_EVENT: 3767 cx_auto_automic(codec); 3768 snd_hda_input_jack_report(codec, nid); 3769 break; 3770 } 3771 } 3772 3773 /* check whether the pin config is suitable for auto-mic switching; 3774 * auto-mic is enabled only when one int-mic and one ext- and/or 3775 * one dock-mic exist 3776 */ 3777 static void cx_auto_check_auto_mic(struct hda_codec *codec) 3778 { 3779 struct conexant_spec *spec = codec->spec; 3780 int pset[INPUT_PIN_ATTR_NORMAL + 1]; 3781 int i; 3782 3783 for (i = 0; i < ARRAY_SIZE(pset); i++) 3784 pset[i] = -1; 3785 for (i = 0; i < spec->private_imux.num_items; i++) { 3786 hda_nid_t pin = spec->imux_info[i].pin; 3787 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, pin); 3788 int type, attr; 3789 attr = snd_hda_get_input_pin_attr(def_conf); 3790 if (attr == INPUT_PIN_ATTR_UNUSED) 3791 return; /* invalid entry */ 3792 if (attr > INPUT_PIN_ATTR_NORMAL) 3793 attr = INPUT_PIN_ATTR_NORMAL; 3794 if (attr != INPUT_PIN_ATTR_INT && 3795 !is_jack_detectable(codec, pin)) 3796 return; /* non-detectable pin */ 3797 type = get_defcfg_device(def_conf); 3798 if (type != AC_JACK_MIC_IN && 3799 (attr != INPUT_PIN_ATTR_DOCK || type != AC_JACK_LINE_IN)) 3800 return; /* no valid input type */ 3801 if (pset[attr] >= 0) 3802 return; /* already occupied */ 3803 pset[attr] = i; 3804 } 3805 if (pset[INPUT_PIN_ATTR_INT] < 0 || 3806 (pset[INPUT_PIN_ATTR_NORMAL] < 0 && pset[INPUT_PIN_ATTR_DOCK])) 3807 return; /* no input to switch*/ 3808 spec->auto_mic = 1; 3809 spec->auto_mic_ext = pset[INPUT_PIN_ATTR_NORMAL]; 3810 spec->auto_mic_dock = pset[INPUT_PIN_ATTR_DOCK]; 3811 spec->auto_mic_int = pset[INPUT_PIN_ATTR_INT]; 3812 } 3813 3814 static void cx_auto_parse_input(struct hda_codec *codec) 3815 { 3816 struct conexant_spec *spec = codec->spec; 3817 struct auto_pin_cfg *cfg = &spec->autocfg; 3818 struct hda_input_mux *imux; 3819 int i, j; 3820 3821 imux = &spec->private_imux; 3822 for (i = 0; i < cfg->num_inputs; i++) { 3823 for (j = 0; j < spec->num_adc_nids; j++) { 3824 hda_nid_t adc = spec->adc_nids[j]; 3825 int idx = get_input_connection(codec, adc, 3826 cfg->inputs[i].pin); 3827 if (idx >= 0) { 3828 const char *label; 3829 label = hda_get_autocfg_input_label(codec, cfg, i); 3830 spec->imux_info[imux->num_items].index = i; 3831 spec->imux_info[imux->num_items].boost = 0; 3832 spec->imux_info[imux->num_items].adc = adc; 3833 spec->imux_info[imux->num_items].pin = 3834 cfg->inputs[i].pin; 3835 snd_hda_add_imux_item(imux, label, idx, NULL); 3836 break; 3837 } 3838 } 3839 } 3840 if (imux->num_items >= 2 && cfg->num_inputs == imux->num_items) 3841 cx_auto_check_auto_mic(codec); 3842 if (imux->num_items > 1) { 3843 for (i = 1; i < imux->num_items; i++) { 3844 if (spec->imux_info[i].adc != spec->imux_info[0].adc) { 3845 spec->adc_switching = 1; 3846 break; 3847 } 3848 } 3849 } 3850 } 3851 3852 /* get digital-input audio widget corresponding to the given pin */ 3853 static hda_nid_t cx_auto_get_dig_in(struct hda_codec *codec, hda_nid_t pin) 3854 { 3855 hda_nid_t nid, end_nid; 3856 3857 end_nid = codec->start_nid + codec->num_nodes; 3858 for (nid = codec->start_nid; nid < end_nid; nid++) { 3859 unsigned int wcaps = get_wcaps(codec, nid); 3860 unsigned int type = get_wcaps_type(wcaps); 3861 if (type == AC_WID_AUD_IN && (wcaps & AC_WCAP_DIGITAL)) { 3862 if (get_connection_index(codec, nid, pin) >= 0) 3863 return nid; 3864 } 3865 } 3866 return 0; 3867 } 3868 3869 static void cx_auto_parse_digital(struct hda_codec *codec) 3870 { 3871 struct conexant_spec *spec = codec->spec; 3872 struct auto_pin_cfg *cfg = &spec->autocfg; 3873 hda_nid_t nid; 3874 3875 if (cfg->dig_outs && 3876 snd_hda_get_connections(codec, cfg->dig_out_pins[0], &nid, 1) == 1) 3877 spec->multiout.dig_out_nid = nid; 3878 if (cfg->dig_in_pin) 3879 spec->dig_in_nid = cx_auto_get_dig_in(codec, cfg->dig_in_pin); 3880 } 3881 3882 #ifdef CONFIG_SND_HDA_INPUT_BEEP 3883 static void cx_auto_parse_beep(struct hda_codec *codec) 3884 { 3885 struct conexant_spec *spec = codec->spec; 3886 hda_nid_t nid, end_nid; 3887 3888 end_nid = codec->start_nid + codec->num_nodes; 3889 for (nid = codec->start_nid; nid < end_nid; nid++) 3890 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_BEEP) { 3891 set_beep_amp(spec, nid, 0, HDA_OUTPUT); 3892 break; 3893 } 3894 } 3895 #else 3896 #define cx_auto_parse_beep(codec) 3897 #endif 3898 3899 /* parse EAPDs */ 3900 static void cx_auto_parse_eapd(struct hda_codec *codec) 3901 { 3902 struct conexant_spec *spec = codec->spec; 3903 hda_nid_t nid, end_nid; 3904 3905 end_nid = codec->start_nid + codec->num_nodes; 3906 for (nid = codec->start_nid; nid < end_nid; nid++) { 3907 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN) 3908 continue; 3909 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)) 3910 continue; 3911 spec->eapds[spec->num_eapds++] = nid; 3912 if (spec->num_eapds >= ARRAY_SIZE(spec->eapds)) 3913 break; 3914 } 3915 3916 /* NOTE: below is a wild guess; if we have more than two EAPDs, 3917 * it's a new chip, where EAPDs are supposed to be associated to 3918 * pins, and we can control EAPD per pin. 3919 * OTOH, if only one or two EAPDs are found, it's an old chip, 3920 * thus it might control over all pins. 3921 */ 3922 spec->pin_eapd_ctrls = spec->num_eapds > 2; 3923 } 3924 3925 static int cx_auto_parse_auto_config(struct hda_codec *codec) 3926 { 3927 struct conexant_spec *spec = codec->spec; 3928 int err; 3929 3930 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 3931 if (err < 0) 3932 return err; 3933 3934 cx_auto_parse_output(codec); 3935 cx_auto_parse_input(codec); 3936 cx_auto_parse_digital(codec); 3937 cx_auto_parse_beep(codec); 3938 cx_auto_parse_eapd(codec); 3939 return 0; 3940 } 3941 3942 static void cx_auto_turn_eapd(struct hda_codec *codec, int num_pins, 3943 hda_nid_t *pins, bool on) 3944 { 3945 int i; 3946 for (i = 0; i < num_pins; i++) { 3947 if (snd_hda_query_pin_caps(codec, pins[i]) & AC_PINCAP_EAPD) 3948 snd_hda_codec_write(codec, pins[i], 0, 3949 AC_VERB_SET_EAPD_BTLENABLE, 3950 on ? 0x02 : 0); 3951 } 3952 } 3953 3954 static void select_connection(struct hda_codec *codec, hda_nid_t pin, 3955 hda_nid_t src) 3956 { 3957 int idx = get_connection_index(codec, pin, src); 3958 if (idx >= 0) 3959 snd_hda_codec_write(codec, pin, 0, 3960 AC_VERB_SET_CONNECT_SEL, idx); 3961 } 3962 3963 static void mute_outputs(struct hda_codec *codec, int num_nids, 3964 const hda_nid_t *nids) 3965 { 3966 int i, val; 3967 3968 for (i = 0; i < num_nids; i++) { 3969 hda_nid_t nid = nids[i]; 3970 if (!(get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)) 3971 continue; 3972 if (query_amp_caps(codec, nid, HDA_OUTPUT) & AC_AMPCAP_MUTE) 3973 val = AMP_OUT_MUTE; 3974 else 3975 val = AMP_OUT_ZERO; 3976 snd_hda_codec_write(codec, nid, 0, 3977 AC_VERB_SET_AMP_GAIN_MUTE, val); 3978 } 3979 } 3980 3981 static void enable_unsol_pins(struct hda_codec *codec, int num_pins, 3982 hda_nid_t *pins, unsigned int tag) 3983 { 3984 int i; 3985 for (i = 0; i < num_pins; i++) 3986 snd_hda_codec_write(codec, pins[i], 0, 3987 AC_VERB_SET_UNSOLICITED_ENABLE, 3988 AC_USRSP_EN | tag); 3989 } 3990 3991 static void cx_auto_init_output(struct hda_codec *codec) 3992 { 3993 struct conexant_spec *spec = codec->spec; 3994 struct auto_pin_cfg *cfg = &spec->autocfg; 3995 hda_nid_t nid; 3996 int i; 3997 3998 mute_outputs(codec, spec->multiout.num_dacs, spec->multiout.dac_nids); 3999 for (i = 0; i < cfg->hp_outs; i++) 4000 snd_hda_codec_write(codec, cfg->hp_pins[i], 0, 4001 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP); 4002 mute_outputs(codec, cfg->hp_outs, cfg->hp_pins); 4003 mute_outputs(codec, cfg->line_outs, cfg->line_out_pins); 4004 mute_outputs(codec, cfg->speaker_outs, cfg->speaker_pins); 4005 for (i = 0; i < spec->dac_info_filled; i++) { 4006 nid = spec->dac_info[i].dac; 4007 if (!nid) 4008 nid = spec->multiout.dac_nids[0]; 4009 else if (nid & DAC_SLAVE_FLAG) 4010 nid &= ~DAC_SLAVE_FLAG; 4011 select_connection(codec, spec->dac_info[i].pin, nid); 4012 } 4013 if (spec->auto_mute) { 4014 enable_unsol_pins(codec, cfg->hp_outs, cfg->hp_pins, 4015 CONEXANT_HP_EVENT); 4016 spec->hp_present = detect_jacks(codec, cfg->hp_outs, 4017 cfg->hp_pins); 4018 if (spec->detect_line) { 4019 enable_unsol_pins(codec, cfg->line_outs, 4020 cfg->line_out_pins, 4021 CONEXANT_LINE_EVENT); 4022 spec->line_present = 4023 detect_jacks(codec, cfg->line_outs, 4024 cfg->line_out_pins); 4025 } 4026 } 4027 cx_auto_update_speakers(codec); 4028 /* turn on all EAPDs if no individual EAPD control is available */ 4029 if (!spec->pin_eapd_ctrls) 4030 cx_auto_turn_eapd(codec, spec->num_eapds, spec->eapds, true); 4031 } 4032 4033 static void cx_auto_init_input(struct hda_codec *codec) 4034 { 4035 struct conexant_spec *spec = codec->spec; 4036 struct auto_pin_cfg *cfg = &spec->autocfg; 4037 int i, val; 4038 4039 for (i = 0; i < spec->num_adc_nids; i++) { 4040 hda_nid_t nid = spec->adc_nids[i]; 4041 if (!(get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) 4042 continue; 4043 if (query_amp_caps(codec, nid, HDA_INPUT) & AC_AMPCAP_MUTE) 4044 val = AMP_IN_MUTE(0); 4045 else 4046 val = AMP_IN_UNMUTE(0); 4047 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 4048 val); 4049 } 4050 4051 for (i = 0; i < cfg->num_inputs; i++) { 4052 unsigned int type; 4053 if (cfg->inputs[i].type == AUTO_PIN_MIC) 4054 type = PIN_VREF80; 4055 else 4056 type = PIN_IN; 4057 snd_hda_codec_write(codec, cfg->inputs[i].pin, 0, 4058 AC_VERB_SET_PIN_WIDGET_CONTROL, type); 4059 } 4060 4061 if (spec->auto_mic) { 4062 if (spec->auto_mic_ext >= 0) { 4063 snd_hda_codec_write(codec, 4064 cfg->inputs[spec->auto_mic_ext].pin, 0, 4065 AC_VERB_SET_UNSOLICITED_ENABLE, 4066 AC_USRSP_EN | CONEXANT_MIC_EVENT); 4067 } 4068 if (spec->auto_mic_dock >= 0) { 4069 snd_hda_codec_write(codec, 4070 cfg->inputs[spec->auto_mic_dock].pin, 0, 4071 AC_VERB_SET_UNSOLICITED_ENABLE, 4072 AC_USRSP_EN | CONEXANT_MIC_EVENT); 4073 } 4074 cx_auto_automic(codec); 4075 } else { 4076 select_input_connection(codec, spec->imux_info[0].adc, 4077 spec->imux_info[0].pin); 4078 } 4079 } 4080 4081 static void cx_auto_init_digital(struct hda_codec *codec) 4082 { 4083 struct conexant_spec *spec = codec->spec; 4084 struct auto_pin_cfg *cfg = &spec->autocfg; 4085 4086 if (spec->multiout.dig_out_nid) 4087 snd_hda_codec_write(codec, cfg->dig_out_pins[0], 0, 4088 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 4089 if (spec->dig_in_nid) 4090 snd_hda_codec_write(codec, cfg->dig_in_pin, 0, 4091 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN); 4092 } 4093 4094 static int cx_auto_init(struct hda_codec *codec) 4095 { 4096 /*snd_hda_sequence_write(codec, cx_auto_init_verbs);*/ 4097 cx_auto_init_output(codec); 4098 cx_auto_init_input(codec); 4099 cx_auto_init_digital(codec); 4100 return 0; 4101 } 4102 4103 static int cx_auto_add_volume_idx(struct hda_codec *codec, const char *basename, 4104 const char *dir, int cidx, 4105 hda_nid_t nid, int hda_dir, int amp_idx) 4106 { 4107 static char name[32]; 4108 static struct snd_kcontrol_new knew[] = { 4109 HDA_CODEC_VOLUME(name, 0, 0, 0), 4110 HDA_CODEC_MUTE(name, 0, 0, 0), 4111 }; 4112 static const char * const sfx[2] = { "Volume", "Switch" }; 4113 int i, err; 4114 4115 for (i = 0; i < 2; i++) { 4116 struct snd_kcontrol *kctl; 4117 knew[i].private_value = HDA_COMPOSE_AMP_VAL(nid, 3, amp_idx, 4118 hda_dir); 4119 knew[i].subdevice = HDA_SUBDEV_AMP_FLAG; 4120 knew[i].index = cidx; 4121 snprintf(name, sizeof(name), "%s%s %s", basename, dir, sfx[i]); 4122 kctl = snd_ctl_new1(&knew[i], codec); 4123 if (!kctl) 4124 return -ENOMEM; 4125 err = snd_hda_ctl_add(codec, nid, kctl); 4126 if (err < 0) 4127 return err; 4128 if (!(query_amp_caps(codec, nid, hda_dir) & AC_AMPCAP_MUTE)) 4129 break; 4130 } 4131 return 0; 4132 } 4133 4134 #define cx_auto_add_volume(codec, str, dir, cidx, nid, hda_dir) \ 4135 cx_auto_add_volume_idx(codec, str, dir, cidx, nid, hda_dir, 0) 4136 4137 #define cx_auto_add_pb_volume(codec, nid, str, idx) \ 4138 cx_auto_add_volume(codec, str, " Playback", idx, nid, HDA_OUTPUT) 4139 4140 static int try_add_pb_volume(struct hda_codec *codec, hda_nid_t dac, 4141 hda_nid_t pin, const char *name, int idx) 4142 { 4143 unsigned int caps; 4144 if (dac && !(dac & DAC_SLAVE_FLAG)) { 4145 caps = query_amp_caps(codec, dac, HDA_OUTPUT); 4146 if (caps & AC_AMPCAP_NUM_STEPS) 4147 return cx_auto_add_pb_volume(codec, dac, name, idx); 4148 } 4149 caps = query_amp_caps(codec, pin, HDA_OUTPUT); 4150 if (caps & AC_AMPCAP_NUM_STEPS) 4151 return cx_auto_add_pb_volume(codec, pin, name, idx); 4152 return 0; 4153 } 4154 4155 static int cx_auto_build_output_controls(struct hda_codec *codec) 4156 { 4157 struct conexant_spec *spec = codec->spec; 4158 int i, err; 4159 int num_line = 0, num_hp = 0, num_spk = 0; 4160 static const char * const texts[3] = { "Front", "Surround", "CLFE" }; 4161 4162 if (spec->dac_info_filled == 1) 4163 return try_add_pb_volume(codec, spec->dac_info[0].dac, 4164 spec->dac_info[0].pin, 4165 "Master", 0); 4166 4167 for (i = 0; i < spec->dac_info_filled; i++) { 4168 const char *label; 4169 int idx, type; 4170 hda_nid_t dac = spec->dac_info[i].dac; 4171 type = spec->dac_info[i].type; 4172 if (type == AUTO_PIN_LINE_OUT) 4173 type = spec->autocfg.line_out_type; 4174 switch (type) { 4175 case AUTO_PIN_LINE_OUT: 4176 default: 4177 label = texts[num_line++]; 4178 idx = 0; 4179 break; 4180 case AUTO_PIN_HP_OUT: 4181 label = "Headphone"; 4182 idx = num_hp++; 4183 break; 4184 case AUTO_PIN_SPEAKER_OUT: 4185 label = "Speaker"; 4186 idx = num_spk++; 4187 break; 4188 } 4189 err = try_add_pb_volume(codec, dac, 4190 spec->dac_info[i].pin, 4191 label, idx); 4192 if (err < 0) 4193 return err; 4194 } 4195 4196 if (spec->auto_mute) { 4197 err = snd_hda_add_new_ctls(codec, cx_automute_mode_enum); 4198 if (err < 0) 4199 return err; 4200 } 4201 4202 return 0; 4203 } 4204 4205 static int cx_auto_add_capture_volume(struct hda_codec *codec, hda_nid_t nid, 4206 const char *label, const char *pfx, 4207 int cidx) 4208 { 4209 struct conexant_spec *spec = codec->spec; 4210 int i; 4211 4212 for (i = 0; i < spec->num_adc_nids; i++) { 4213 hda_nid_t adc_nid = spec->adc_nids[i]; 4214 int idx = get_input_connection(codec, adc_nid, nid); 4215 if (idx < 0) 4216 continue; 4217 if (spec->single_adc_amp) 4218 idx = 0; 4219 return cx_auto_add_volume_idx(codec, label, pfx, 4220 cidx, adc_nid, HDA_INPUT, idx); 4221 } 4222 return 0; 4223 } 4224 4225 static int cx_auto_add_boost_volume(struct hda_codec *codec, int idx, 4226 const char *label, int cidx) 4227 { 4228 struct conexant_spec *spec = codec->spec; 4229 hda_nid_t mux, nid; 4230 int i, con; 4231 4232 nid = spec->imux_info[idx].pin; 4233 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) 4234 return cx_auto_add_volume(codec, label, " Boost", cidx, 4235 nid, HDA_INPUT); 4236 con = __select_input_connection(codec, spec->imux_info[idx].adc, nid, 4237 &mux, false, 0); 4238 if (con < 0) 4239 return 0; 4240 for (i = 0; i < idx; i++) { 4241 if (spec->imux_info[i].boost == mux) 4242 return 0; /* already present */ 4243 } 4244 4245 if (get_wcaps(codec, mux) & AC_WCAP_OUT_AMP) { 4246 spec->imux_info[idx].boost = mux; 4247 return cx_auto_add_volume(codec, label, " Boost", 0, 4248 mux, HDA_OUTPUT); 4249 } 4250 return 0; 4251 } 4252 4253 static int cx_auto_build_input_controls(struct hda_codec *codec) 4254 { 4255 struct conexant_spec *spec = codec->spec; 4256 struct hda_input_mux *imux = &spec->private_imux; 4257 const char *prev_label; 4258 int input_conn[HDA_MAX_NUM_INPUTS]; 4259 int i, j, err, cidx; 4260 int multi_connection; 4261 4262 if (!imux->num_items) 4263 return 0; 4264 4265 multi_connection = 0; 4266 for (i = 0; i < imux->num_items; i++) { 4267 cidx = get_input_connection(codec, spec->imux_info[i].adc, 4268 spec->imux_info[i].pin); 4269 if (cidx < 0) 4270 continue; 4271 input_conn[i] = spec->imux_info[i].adc; 4272 if (!spec->single_adc_amp) 4273 input_conn[i] |= cidx << 8; 4274 if (i > 0 && input_conn[i] != input_conn[0]) 4275 multi_connection = 1; 4276 } 4277 4278 prev_label = NULL; 4279 cidx = 0; 4280 for (i = 0; i < imux->num_items; i++) { 4281 hda_nid_t nid = spec->imux_info[i].pin; 4282 const char *label; 4283 4284 label = hda_get_autocfg_input_label(codec, &spec->autocfg, 4285 spec->imux_info[i].index); 4286 if (label == prev_label) 4287 cidx++; 4288 else 4289 cidx = 0; 4290 prev_label = label; 4291 4292 err = cx_auto_add_boost_volume(codec, i, label, cidx); 4293 if (err < 0) 4294 return err; 4295 4296 if (!multi_connection) { 4297 if (i > 0) 4298 continue; 4299 err = cx_auto_add_capture_volume(codec, nid, 4300 "Capture", "", cidx); 4301 } else { 4302 bool dup_found = false; 4303 for (j = 0; j < i; j++) { 4304 if (input_conn[j] == input_conn[i]) { 4305 dup_found = true; 4306 break; 4307 } 4308 } 4309 if (dup_found) 4310 continue; 4311 err = cx_auto_add_capture_volume(codec, nid, 4312 label, " Capture", cidx); 4313 } 4314 if (err < 0) 4315 return err; 4316 } 4317 4318 if (spec->private_imux.num_items > 1 && !spec->auto_mic) { 4319 err = snd_hda_add_new_ctls(codec, cx_auto_capture_mixers); 4320 if (err < 0) 4321 return err; 4322 } 4323 4324 return 0; 4325 } 4326 4327 static int cx_auto_build_controls(struct hda_codec *codec) 4328 { 4329 int err; 4330 4331 err = cx_auto_build_output_controls(codec); 4332 if (err < 0) 4333 return err; 4334 err = cx_auto_build_input_controls(codec); 4335 if (err < 0) 4336 return err; 4337 return conexant_build_controls(codec); 4338 } 4339 4340 static int cx_auto_search_adcs(struct hda_codec *codec) 4341 { 4342 struct conexant_spec *spec = codec->spec; 4343 hda_nid_t nid, end_nid; 4344 4345 end_nid = codec->start_nid + codec->num_nodes; 4346 for (nid = codec->start_nid; nid < end_nid; nid++) { 4347 unsigned int caps = get_wcaps(codec, nid); 4348 if (get_wcaps_type(caps) != AC_WID_AUD_IN) 4349 continue; 4350 if (caps & AC_WCAP_DIGITAL) 4351 continue; 4352 if (snd_BUG_ON(spec->num_adc_nids >= 4353 ARRAY_SIZE(spec->private_adc_nids))) 4354 break; 4355 spec->private_adc_nids[spec->num_adc_nids++] = nid; 4356 } 4357 spec->adc_nids = spec->private_adc_nids; 4358 return 0; 4359 } 4360 4361 4362 static const struct hda_codec_ops cx_auto_patch_ops = { 4363 .build_controls = cx_auto_build_controls, 4364 .build_pcms = conexant_build_pcms, 4365 .init = cx_auto_init, 4366 .free = conexant_free, 4367 .unsol_event = cx_auto_unsol_event, 4368 #ifdef CONFIG_SND_HDA_POWER_SAVE 4369 .suspend = conexant_suspend, 4370 #endif 4371 .reboot_notify = snd_hda_shutup_pins, 4372 }; 4373 4374 /* 4375 * pin fix-up 4376 */ 4377 struct cxt_pincfg { 4378 hda_nid_t nid; 4379 u32 val; 4380 }; 4381 4382 static void apply_pincfg(struct hda_codec *codec, const struct cxt_pincfg *cfg) 4383 { 4384 for (; cfg->nid; cfg++) 4385 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val); 4386 4387 } 4388 4389 static void apply_pin_fixup(struct hda_codec *codec, 4390 const struct snd_pci_quirk *quirk, 4391 const struct cxt_pincfg **table) 4392 { 4393 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk); 4394 if (quirk) { 4395 snd_printdd(KERN_INFO "hda_codec: applying pincfg for %s\n", 4396 quirk->name); 4397 apply_pincfg(codec, table[quirk->value]); 4398 } 4399 } 4400 4401 enum { 4402 CXT_PINCFG_LENOVO_X200, 4403 }; 4404 4405 static const struct cxt_pincfg cxt_pincfg_lenovo_x200[] = { 4406 { 0x16, 0x042140ff }, /* HP (seq# overridden) */ 4407 { 0x17, 0x21a11000 }, /* dock-mic */ 4408 { 0x19, 0x2121103f }, /* dock-HP */ 4409 {} 4410 }; 4411 4412 static const struct cxt_pincfg *cxt_pincfg_tbl[] = { 4413 [CXT_PINCFG_LENOVO_X200] = cxt_pincfg_lenovo_x200, 4414 }; 4415 4416 static const struct snd_pci_quirk cxt_fixups[] = { 4417 SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo X200", CXT_PINCFG_LENOVO_X200), 4418 {} 4419 }; 4420 4421 static int patch_conexant_auto(struct hda_codec *codec) 4422 { 4423 struct conexant_spec *spec; 4424 int err; 4425 4426 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 4427 codec->chip_name); 4428 4429 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 4430 if (!spec) 4431 return -ENOMEM; 4432 codec->spec = spec; 4433 codec->pin_amp_workaround = 1; 4434 4435 switch (codec->vendor_id) { 4436 case 0x14f15045: 4437 spec->single_adc_amp = 1; 4438 break; 4439 } 4440 4441 apply_pin_fixup(codec, cxt_fixups, cxt_pincfg_tbl); 4442 4443 err = cx_auto_search_adcs(codec); 4444 if (err < 0) 4445 return err; 4446 err = cx_auto_parse_auto_config(codec); 4447 if (err < 0) { 4448 kfree(codec->spec); 4449 codec->spec = NULL; 4450 return err; 4451 } 4452 spec->capture_stream = &cx_auto_pcm_analog_capture; 4453 codec->patch_ops = cx_auto_patch_ops; 4454 if (spec->beep_amp) 4455 snd_hda_attach_beep_device(codec, spec->beep_amp); 4456 return 0; 4457 } 4458 4459 /* 4460 */ 4461 4462 static const struct hda_codec_preset snd_hda_preset_conexant[] = { 4463 { .id = 0x14f15045, .name = "CX20549 (Venice)", 4464 .patch = patch_cxt5045 }, 4465 { .id = 0x14f15047, .name = "CX20551 (Waikiki)", 4466 .patch = patch_cxt5047 }, 4467 { .id = 0x14f15051, .name = "CX20561 (Hermosa)", 4468 .patch = patch_cxt5051 }, 4469 { .id = 0x14f15066, .name = "CX20582 (Pebble)", 4470 .patch = patch_cxt5066 }, 4471 { .id = 0x14f15067, .name = "CX20583 (Pebble HSF)", 4472 .patch = patch_cxt5066 }, 4473 { .id = 0x14f15068, .name = "CX20584", 4474 .patch = patch_cxt5066 }, 4475 { .id = 0x14f15069, .name = "CX20585", 4476 .patch = patch_cxt5066 }, 4477 { .id = 0x14f1506c, .name = "CX20588", 4478 .patch = patch_cxt5066 }, 4479 { .id = 0x14f1506e, .name = "CX20590", 4480 .patch = patch_cxt5066 }, 4481 { .id = 0x14f15097, .name = "CX20631", 4482 .patch = patch_conexant_auto }, 4483 { .id = 0x14f15098, .name = "CX20632", 4484 .patch = patch_conexant_auto }, 4485 { .id = 0x14f150a1, .name = "CX20641", 4486 .patch = patch_conexant_auto }, 4487 { .id = 0x14f150a2, .name = "CX20642", 4488 .patch = patch_conexant_auto }, 4489 { .id = 0x14f150ab, .name = "CX20651", 4490 .patch = patch_conexant_auto }, 4491 { .id = 0x14f150ac, .name = "CX20652", 4492 .patch = patch_conexant_auto }, 4493 { .id = 0x14f150b8, .name = "CX20664", 4494 .patch = patch_conexant_auto }, 4495 { .id = 0x14f150b9, .name = "CX20665", 4496 .patch = patch_conexant_auto }, 4497 {} /* terminator */ 4498 }; 4499 4500 MODULE_ALIAS("snd-hda-codec-id:14f15045"); 4501 MODULE_ALIAS("snd-hda-codec-id:14f15047"); 4502 MODULE_ALIAS("snd-hda-codec-id:14f15051"); 4503 MODULE_ALIAS("snd-hda-codec-id:14f15066"); 4504 MODULE_ALIAS("snd-hda-codec-id:14f15067"); 4505 MODULE_ALIAS("snd-hda-codec-id:14f15068"); 4506 MODULE_ALIAS("snd-hda-codec-id:14f15069"); 4507 MODULE_ALIAS("snd-hda-codec-id:14f1506c"); 4508 MODULE_ALIAS("snd-hda-codec-id:14f1506e"); 4509 MODULE_ALIAS("snd-hda-codec-id:14f15097"); 4510 MODULE_ALIAS("snd-hda-codec-id:14f15098"); 4511 MODULE_ALIAS("snd-hda-codec-id:14f150a1"); 4512 MODULE_ALIAS("snd-hda-codec-id:14f150a2"); 4513 MODULE_ALIAS("snd-hda-codec-id:14f150ab"); 4514 MODULE_ALIAS("snd-hda-codec-id:14f150ac"); 4515 MODULE_ALIAS("snd-hda-codec-id:14f150b8"); 4516 MODULE_ALIAS("snd-hda-codec-id:14f150b9"); 4517 4518 MODULE_LICENSE("GPL"); 4519 MODULE_DESCRIPTION("Conexant HD-audio codec"); 4520 4521 static struct hda_codec_preset_list conexant_list = { 4522 .preset = snd_hda_preset_conexant, 4523 .owner = THIS_MODULE, 4524 }; 4525 4526 static int __init patch_conexant_init(void) 4527 { 4528 return snd_hda_add_codec_preset(&conexant_list); 4529 } 4530 4531 static void __exit patch_conexant_exit(void) 4532 { 4533 snd_hda_delete_codec_preset(&conexant_list); 4534 } 4535 4536 module_init(patch_conexant_init) 4537 module_exit(patch_conexant_exit) 4538