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