1 /* 2 * HD audio interface patch for AD1882, AD1884, AD1981HD, AD1983, AD1984, 3 * AD1986A, AD1988 4 * 5 * Copyright (c) 2005-2007 Takashi Iwai <tiwai@suse.de> 6 * 7 * This driver is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This driver is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22 #include <linux/init.h> 23 #include <linux/delay.h> 24 #include <linux/slab.h> 25 #include <linux/pci.h> 26 27 #include <sound/core.h> 28 #include "hda_codec.h" 29 #include "hda_local.h" 30 #include "hda_beep.h" 31 32 struct ad198x_spec { 33 struct snd_kcontrol_new *mixers[5]; 34 int num_mixers; 35 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */ 36 const struct hda_verb *init_verbs[5]; /* initialization verbs 37 * don't forget NULL termination! 38 */ 39 unsigned int num_init_verbs; 40 41 /* playback */ 42 struct hda_multi_out multiout; /* playback set-up 43 * max_channels, dacs must be set 44 * dig_out_nid and hp_nid are optional 45 */ 46 unsigned int cur_eapd; 47 unsigned int need_dac_fix; 48 49 /* capture */ 50 unsigned int num_adc_nids; 51 hda_nid_t *adc_nids; 52 hda_nid_t dig_in_nid; /* digital-in NID; optional */ 53 54 /* capture source */ 55 const struct hda_input_mux *input_mux; 56 hda_nid_t *capsrc_nids; 57 unsigned int cur_mux[3]; 58 59 /* channel model */ 60 const struct hda_channel_mode *channel_mode; 61 int num_channel_mode; 62 63 /* PCM information */ 64 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */ 65 66 unsigned int spdif_route; 67 68 /* dynamic controls, init_verbs and input_mux */ 69 struct auto_pin_cfg autocfg; 70 struct snd_array kctls; 71 struct hda_input_mux private_imux; 72 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; 73 74 unsigned int jack_present :1; 75 unsigned int inv_jack_detect:1; /* inverted jack-detection */ 76 unsigned int inv_eapd:1; /* inverted EAPD implementation */ 77 78 #ifdef CONFIG_SND_HDA_POWER_SAVE 79 struct hda_loopback_check loopback; 80 #endif 81 /* for virtual master */ 82 hda_nid_t vmaster_nid; 83 const char **slave_vols; 84 const char **slave_sws; 85 }; 86 87 /* 88 * input MUX handling (common part) 89 */ 90 static int ad198x_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 91 { 92 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 93 struct ad198x_spec *spec = codec->spec; 94 95 return snd_hda_input_mux_info(spec->input_mux, uinfo); 96 } 97 98 static int ad198x_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 99 { 100 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 101 struct ad198x_spec *spec = codec->spec; 102 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 103 104 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 105 return 0; 106 } 107 108 static int ad198x_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 109 { 110 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 111 struct ad198x_spec *spec = codec->spec; 112 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 113 114 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, 115 spec->capsrc_nids[adc_idx], 116 &spec->cur_mux[adc_idx]); 117 } 118 119 /* 120 * initialization (common callbacks) 121 */ 122 static int ad198x_init(struct hda_codec *codec) 123 { 124 struct ad198x_spec *spec = codec->spec; 125 int i; 126 127 for (i = 0; i < spec->num_init_verbs; i++) 128 snd_hda_sequence_write(codec, spec->init_verbs[i]); 129 return 0; 130 } 131 132 static const char *ad_slave_vols[] = { 133 "Front Playback Volume", 134 "Surround Playback Volume", 135 "Center Playback Volume", 136 "LFE Playback Volume", 137 "Side Playback Volume", 138 "Headphone Playback Volume", 139 "Mono Playback Volume", 140 "Speaker Playback Volume", 141 "IEC958 Playback Volume", 142 NULL 143 }; 144 145 static const char *ad_slave_sws[] = { 146 "Front Playback Switch", 147 "Surround Playback Switch", 148 "Center Playback Switch", 149 "LFE Playback Switch", 150 "Side Playback Switch", 151 "Headphone Playback Switch", 152 "Mono Playback Switch", 153 "Speaker Playback Switch", 154 "IEC958 Playback Switch", 155 NULL 156 }; 157 158 static void ad198x_free_kctls(struct hda_codec *codec); 159 160 #ifdef CONFIG_SND_HDA_INPUT_BEEP 161 /* additional beep mixers; the actual parameters are overwritten at build */ 162 static struct snd_kcontrol_new ad_beep_mixer[] = { 163 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_OUTPUT), 164 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_OUTPUT), 165 { } /* end */ 166 }; 167 168 #define set_beep_amp(spec, nid, idx, dir) \ 169 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir)) /* mono */ 170 #else 171 #define set_beep_amp(spec, nid, idx, dir) /* NOP */ 172 #endif 173 174 static int ad198x_build_controls(struct hda_codec *codec) 175 { 176 struct ad198x_spec *spec = codec->spec; 177 unsigned int i; 178 int err; 179 180 for (i = 0; i < spec->num_mixers; i++) { 181 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 182 if (err < 0) 183 return err; 184 } 185 if (spec->multiout.dig_out_nid) { 186 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid); 187 if (err < 0) 188 return err; 189 err = snd_hda_create_spdif_share_sw(codec, 190 &spec->multiout); 191 if (err < 0) 192 return err; 193 spec->multiout.share_spdif = 1; 194 } 195 if (spec->dig_in_nid) { 196 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 197 if (err < 0) 198 return err; 199 } 200 201 /* create beep controls if needed */ 202 #ifdef CONFIG_SND_HDA_INPUT_BEEP 203 if (spec->beep_amp) { 204 struct snd_kcontrol_new *knew; 205 for (knew = ad_beep_mixer; knew->name; knew++) { 206 struct snd_kcontrol *kctl; 207 kctl = snd_ctl_new1(knew, codec); 208 if (!kctl) 209 return -ENOMEM; 210 kctl->private_value = spec->beep_amp; 211 err = snd_hda_ctl_add(codec, 212 get_amp_nid_(spec->beep_amp), 213 kctl); 214 if (err < 0) 215 return err; 216 } 217 } 218 #endif 219 220 /* if we have no master control, let's create it */ 221 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { 222 unsigned int vmaster_tlv[4]; 223 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid, 224 HDA_OUTPUT, vmaster_tlv); 225 err = snd_hda_add_vmaster(codec, "Master Playback Volume", 226 vmaster_tlv, 227 (spec->slave_vols ? 228 spec->slave_vols : ad_slave_vols)); 229 if (err < 0) 230 return err; 231 } 232 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { 233 err = snd_hda_add_vmaster(codec, "Master Playback Switch", 234 NULL, 235 (spec->slave_sws ? 236 spec->slave_sws : ad_slave_sws)); 237 if (err < 0) 238 return err; 239 } 240 241 ad198x_free_kctls(codec); /* no longer needed */ 242 return 0; 243 } 244 245 #ifdef CONFIG_SND_HDA_POWER_SAVE 246 static int ad198x_check_power_status(struct hda_codec *codec, hda_nid_t nid) 247 { 248 struct ad198x_spec *spec = codec->spec; 249 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid); 250 } 251 #endif 252 253 /* 254 * Analog playback callbacks 255 */ 256 static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo, 257 struct hda_codec *codec, 258 struct snd_pcm_substream *substream) 259 { 260 struct ad198x_spec *spec = codec->spec; 261 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 262 hinfo); 263 } 264 265 static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 266 struct hda_codec *codec, 267 unsigned int stream_tag, 268 unsigned int format, 269 struct snd_pcm_substream *substream) 270 { 271 struct ad198x_spec *spec = codec->spec; 272 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, 273 format, substream); 274 } 275 276 static int ad198x_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 277 struct hda_codec *codec, 278 struct snd_pcm_substream *substream) 279 { 280 struct ad198x_spec *spec = codec->spec; 281 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 282 } 283 284 /* 285 * Digital out 286 */ 287 static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 288 struct hda_codec *codec, 289 struct snd_pcm_substream *substream) 290 { 291 struct ad198x_spec *spec = codec->spec; 292 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 293 } 294 295 static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 296 struct hda_codec *codec, 297 struct snd_pcm_substream *substream) 298 { 299 struct ad198x_spec *spec = codec->spec; 300 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 301 } 302 303 static int ad198x_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 304 struct hda_codec *codec, 305 unsigned int stream_tag, 306 unsigned int format, 307 struct snd_pcm_substream *substream) 308 { 309 struct ad198x_spec *spec = codec->spec; 310 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag, 311 format, substream); 312 } 313 314 static int ad198x_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 315 struct hda_codec *codec, 316 struct snd_pcm_substream *substream) 317 { 318 struct ad198x_spec *spec = codec->spec; 319 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout); 320 } 321 322 /* 323 * Analog capture 324 */ 325 static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 326 struct hda_codec *codec, 327 unsigned int stream_tag, 328 unsigned int format, 329 struct snd_pcm_substream *substream) 330 { 331 struct ad198x_spec *spec = codec->spec; 332 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 333 stream_tag, 0, format); 334 return 0; 335 } 336 337 static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 338 struct hda_codec *codec, 339 struct snd_pcm_substream *substream) 340 { 341 struct ad198x_spec *spec = codec->spec; 342 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]); 343 return 0; 344 } 345 346 347 /* 348 */ 349 static struct hda_pcm_stream ad198x_pcm_analog_playback = { 350 .substreams = 1, 351 .channels_min = 2, 352 .channels_max = 6, /* changed later */ 353 .nid = 0, /* fill later */ 354 .ops = { 355 .open = ad198x_playback_pcm_open, 356 .prepare = ad198x_playback_pcm_prepare, 357 .cleanup = ad198x_playback_pcm_cleanup 358 }, 359 }; 360 361 static struct hda_pcm_stream ad198x_pcm_analog_capture = { 362 .substreams = 1, 363 .channels_min = 2, 364 .channels_max = 2, 365 .nid = 0, /* fill later */ 366 .ops = { 367 .prepare = ad198x_capture_pcm_prepare, 368 .cleanup = ad198x_capture_pcm_cleanup 369 }, 370 }; 371 372 static struct hda_pcm_stream ad198x_pcm_digital_playback = { 373 .substreams = 1, 374 .channels_min = 2, 375 .channels_max = 2, 376 .nid = 0, /* fill later */ 377 .ops = { 378 .open = ad198x_dig_playback_pcm_open, 379 .close = ad198x_dig_playback_pcm_close, 380 .prepare = ad198x_dig_playback_pcm_prepare, 381 .cleanup = ad198x_dig_playback_pcm_cleanup 382 }, 383 }; 384 385 static struct hda_pcm_stream ad198x_pcm_digital_capture = { 386 .substreams = 1, 387 .channels_min = 2, 388 .channels_max = 2, 389 /* NID is set in alc_build_pcms */ 390 }; 391 392 static int ad198x_build_pcms(struct hda_codec *codec) 393 { 394 struct ad198x_spec *spec = codec->spec; 395 struct hda_pcm *info = spec->pcm_rec; 396 397 codec->num_pcms = 1; 398 codec->pcm_info = info; 399 400 info->name = "AD198x Analog"; 401 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_analog_playback; 402 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels; 403 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0]; 404 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture; 405 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids; 406 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 407 408 if (spec->multiout.dig_out_nid) { 409 info++; 410 codec->num_pcms++; 411 info->name = "AD198x Digital"; 412 info->pcm_type = HDA_PCM_TYPE_SPDIF; 413 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback; 414 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; 415 if (spec->dig_in_nid) { 416 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture; 417 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; 418 } 419 } 420 421 return 0; 422 } 423 424 static void ad198x_free_kctls(struct hda_codec *codec) 425 { 426 struct ad198x_spec *spec = codec->spec; 427 428 if (spec->kctls.list) { 429 struct snd_kcontrol_new *kctl = spec->kctls.list; 430 int i; 431 for (i = 0; i < spec->kctls.used; i++) 432 kfree(kctl[i].name); 433 } 434 snd_array_free(&spec->kctls); 435 } 436 437 static void ad198x_free(struct hda_codec *codec) 438 { 439 struct ad198x_spec *spec = codec->spec; 440 441 if (!spec) 442 return; 443 444 ad198x_free_kctls(codec); 445 kfree(spec); 446 snd_hda_detach_beep_device(codec); 447 } 448 449 static struct hda_codec_ops ad198x_patch_ops = { 450 .build_controls = ad198x_build_controls, 451 .build_pcms = ad198x_build_pcms, 452 .init = ad198x_init, 453 .free = ad198x_free, 454 #ifdef CONFIG_SND_HDA_POWER_SAVE 455 .check_power_status = ad198x_check_power_status, 456 #endif 457 }; 458 459 460 /* 461 * EAPD control 462 * the private value = nid 463 */ 464 #define ad198x_eapd_info snd_ctl_boolean_mono_info 465 466 static int ad198x_eapd_get(struct snd_kcontrol *kcontrol, 467 struct snd_ctl_elem_value *ucontrol) 468 { 469 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 470 struct ad198x_spec *spec = codec->spec; 471 if (spec->inv_eapd) 472 ucontrol->value.integer.value[0] = ! spec->cur_eapd; 473 else 474 ucontrol->value.integer.value[0] = spec->cur_eapd; 475 return 0; 476 } 477 478 static int ad198x_eapd_put(struct snd_kcontrol *kcontrol, 479 struct snd_ctl_elem_value *ucontrol) 480 { 481 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 482 struct ad198x_spec *spec = codec->spec; 483 hda_nid_t nid = kcontrol->private_value & 0xff; 484 unsigned int eapd; 485 eapd = !!ucontrol->value.integer.value[0]; 486 if (spec->inv_eapd) 487 eapd = !eapd; 488 if (eapd == spec->cur_eapd) 489 return 0; 490 spec->cur_eapd = eapd; 491 snd_hda_codec_write_cache(codec, nid, 492 0, AC_VERB_SET_EAPD_BTLENABLE, 493 eapd ? 0x02 : 0x00); 494 return 1; 495 } 496 497 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol, 498 struct snd_ctl_elem_info *uinfo); 499 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol, 500 struct snd_ctl_elem_value *ucontrol); 501 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol, 502 struct snd_ctl_elem_value *ucontrol); 503 504 505 /* 506 * AD1986A specific 507 */ 508 509 #define AD1986A_SPDIF_OUT 0x02 510 #define AD1986A_FRONT_DAC 0x03 511 #define AD1986A_SURR_DAC 0x04 512 #define AD1986A_CLFE_DAC 0x05 513 #define AD1986A_ADC 0x06 514 515 static hda_nid_t ad1986a_dac_nids[3] = { 516 AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC 517 }; 518 static hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC }; 519 static hda_nid_t ad1986a_capsrc_nids[1] = { 0x12 }; 520 521 static struct hda_input_mux ad1986a_capture_source = { 522 .num_items = 7, 523 .items = { 524 { "Mic", 0x0 }, 525 { "CD", 0x1 }, 526 { "Aux", 0x3 }, 527 { "Line", 0x4 }, 528 { "Mix", 0x5 }, 529 { "Mono", 0x6 }, 530 { "Phone", 0x7 }, 531 }, 532 }; 533 534 535 static struct hda_bind_ctls ad1986a_bind_pcm_vol = { 536 .ops = &snd_hda_bind_vol, 537 .values = { 538 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT), 539 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT), 540 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT), 541 0 542 }, 543 }; 544 545 static struct hda_bind_ctls ad1986a_bind_pcm_sw = { 546 .ops = &snd_hda_bind_sw, 547 .values = { 548 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT), 549 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT), 550 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT), 551 0 552 }, 553 }; 554 555 /* 556 * mixers 557 */ 558 static struct snd_kcontrol_new ad1986a_mixers[] = { 559 /* 560 * bind volumes/mutes of 3 DACs as a single PCM control for simplicity 561 */ 562 HDA_BIND_VOL("PCM Playback Volume", &ad1986a_bind_pcm_vol), 563 HDA_BIND_SW("PCM Playback Switch", &ad1986a_bind_pcm_sw), 564 HDA_CODEC_VOLUME("Front Playback Volume", 0x1b, 0x0, HDA_OUTPUT), 565 HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 566 HDA_CODEC_VOLUME("Surround Playback Volume", 0x1c, 0x0, HDA_OUTPUT), 567 HDA_CODEC_MUTE("Surround Playback Switch", 0x1c, 0x0, HDA_OUTPUT), 568 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x1d, 1, 0x0, HDA_OUTPUT), 569 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x1d, 2, 0x0, HDA_OUTPUT), 570 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x1d, 1, 0x0, HDA_OUTPUT), 571 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x1d, 2, 0x0, HDA_OUTPUT), 572 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT), 573 HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT), 574 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT), 575 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT), 576 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT), 577 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT), 578 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT), 579 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT), 580 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT), 581 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT), 582 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT), 583 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT), 584 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), 585 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT), 586 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT), 587 { 588 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 589 .name = "Capture Source", 590 .info = ad198x_mux_enum_info, 591 .get = ad198x_mux_enum_get, 592 .put = ad198x_mux_enum_put, 593 }, 594 HDA_CODEC_MUTE("Stereo Downmix Switch", 0x09, 0x0, HDA_OUTPUT), 595 { } /* end */ 596 }; 597 598 /* additional mixers for 3stack mode */ 599 static struct snd_kcontrol_new ad1986a_3st_mixers[] = { 600 { 601 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 602 .name = "Channel Mode", 603 .info = ad198x_ch_mode_info, 604 .get = ad198x_ch_mode_get, 605 .put = ad198x_ch_mode_put, 606 }, 607 { } /* end */ 608 }; 609 610 /* laptop model - 2ch only */ 611 static hda_nid_t ad1986a_laptop_dac_nids[1] = { AD1986A_FRONT_DAC }; 612 613 /* master controls both pins 0x1a and 0x1b */ 614 static struct hda_bind_ctls ad1986a_laptop_master_vol = { 615 .ops = &snd_hda_bind_vol, 616 .values = { 617 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT), 618 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 619 0, 620 }, 621 }; 622 623 static struct hda_bind_ctls ad1986a_laptop_master_sw = { 624 .ops = &snd_hda_bind_sw, 625 .values = { 626 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT), 627 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 628 0, 629 }, 630 }; 631 632 static struct snd_kcontrol_new ad1986a_laptop_mixers[] = { 633 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT), 634 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT), 635 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol), 636 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw), 637 HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT), 638 HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT), 639 HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT), 640 HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT), 641 HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT), 642 HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT), 643 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT), 644 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT), 645 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT), 646 /* 647 HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT), 648 HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */ 649 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT), 650 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT), 651 { 652 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 653 .name = "Capture Source", 654 .info = ad198x_mux_enum_info, 655 .get = ad198x_mux_enum_get, 656 .put = ad198x_mux_enum_put, 657 }, 658 { } /* end */ 659 }; 660 661 /* laptop-eapd model - 2ch only */ 662 663 static struct hda_input_mux ad1986a_laptop_eapd_capture_source = { 664 .num_items = 3, 665 .items = { 666 { "Mic", 0x0 }, 667 { "Internal Mic", 0x4 }, 668 { "Mix", 0x5 }, 669 }, 670 }; 671 672 static struct hda_input_mux ad1986a_automic_capture_source = { 673 .num_items = 2, 674 .items = { 675 { "Mic", 0x0 }, 676 { "Mix", 0x5 }, 677 }, 678 }; 679 680 static struct snd_kcontrol_new ad1986a_laptop_master_mixers[] = { 681 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol), 682 HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw), 683 { } /* end */ 684 }; 685 686 static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = { 687 HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT), 688 HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT), 689 HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT), 690 HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT), 691 HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT), 692 HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT), 693 HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT), 694 { 695 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 696 .name = "Capture Source", 697 .info = ad198x_mux_enum_info, 698 .get = ad198x_mux_enum_get, 699 .put = ad198x_mux_enum_put, 700 }, 701 { 702 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 703 .name = "External Amplifier", 704 .info = ad198x_eapd_info, 705 .get = ad198x_eapd_get, 706 .put = ad198x_eapd_put, 707 .private_value = 0x1b, /* port-D */ 708 }, 709 { } /* end */ 710 }; 711 712 static struct snd_kcontrol_new ad1986a_laptop_intmic_mixers[] = { 713 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0, HDA_OUTPUT), 714 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0, HDA_OUTPUT), 715 { } /* end */ 716 }; 717 718 /* re-connect the mic boost input according to the jack sensing */ 719 static void ad1986a_automic(struct hda_codec *codec) 720 { 721 unsigned int present; 722 present = snd_hda_jack_detect(codec, 0x1f); 723 /* 0 = 0x1f, 2 = 0x1d, 4 = mixed */ 724 snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_CONNECT_SEL, 725 present ? 0 : 2); 726 } 727 728 #define AD1986A_MIC_EVENT 0x36 729 730 static void ad1986a_automic_unsol_event(struct hda_codec *codec, 731 unsigned int res) 732 { 733 if ((res >> 26) != AD1986A_MIC_EVENT) 734 return; 735 ad1986a_automic(codec); 736 } 737 738 static int ad1986a_automic_init(struct hda_codec *codec) 739 { 740 ad198x_init(codec); 741 ad1986a_automic(codec); 742 return 0; 743 } 744 745 /* laptop-automute - 2ch only */ 746 747 static void ad1986a_update_hp(struct hda_codec *codec) 748 { 749 struct ad198x_spec *spec = codec->spec; 750 unsigned int mute; 751 752 if (spec->jack_present) 753 mute = HDA_AMP_MUTE; /* mute internal speaker */ 754 else 755 /* unmute internal speaker if necessary */ 756 mute = snd_hda_codec_amp_read(codec, 0x1a, 0, HDA_OUTPUT, 0); 757 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0, 758 HDA_AMP_MUTE, mute); 759 } 760 761 static void ad1986a_hp_automute(struct hda_codec *codec) 762 { 763 struct ad198x_spec *spec = codec->spec; 764 765 spec->jack_present = snd_hda_jack_detect(codec, 0x1a); 766 if (spec->inv_jack_detect) 767 spec->jack_present = !spec->jack_present; 768 ad1986a_update_hp(codec); 769 } 770 771 #define AD1986A_HP_EVENT 0x37 772 773 static void ad1986a_hp_unsol_event(struct hda_codec *codec, unsigned int res) 774 { 775 if ((res >> 26) != AD1986A_HP_EVENT) 776 return; 777 ad1986a_hp_automute(codec); 778 } 779 780 static int ad1986a_hp_init(struct hda_codec *codec) 781 { 782 ad198x_init(codec); 783 ad1986a_hp_automute(codec); 784 return 0; 785 } 786 787 /* bind hp and internal speaker mute (with plug check) */ 788 static int ad1986a_hp_master_sw_put(struct snd_kcontrol *kcontrol, 789 struct snd_ctl_elem_value *ucontrol) 790 { 791 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 792 long *valp = ucontrol->value.integer.value; 793 int change; 794 795 change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0, 796 HDA_AMP_MUTE, 797 valp[0] ? 0 : HDA_AMP_MUTE); 798 change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0, 799 HDA_AMP_MUTE, 800 valp[1] ? 0 : HDA_AMP_MUTE); 801 if (change) 802 ad1986a_update_hp(codec); 803 return change; 804 } 805 806 static struct snd_kcontrol_new ad1986a_automute_master_mixers[] = { 807 HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol), 808 { 809 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 810 .name = "Master Playback Switch", 811 .info = snd_hda_mixer_amp_switch_info, 812 .get = snd_hda_mixer_amp_switch_get, 813 .put = ad1986a_hp_master_sw_put, 814 .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT), 815 }, 816 { } /* end */ 817 }; 818 819 820 /* 821 * initialization verbs 822 */ 823 static struct hda_verb ad1986a_init_verbs[] = { 824 /* Front, Surround, CLFE DAC; mute as default */ 825 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 826 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 827 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 828 /* Downmix - off */ 829 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 830 /* HP, Line-Out, Surround, CLFE selectors */ 831 {0x0a, AC_VERB_SET_CONNECT_SEL, 0x0}, 832 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, 833 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, 834 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0}, 835 /* Mono selector */ 836 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x0}, 837 /* Mic selector: Mic 1/2 pin */ 838 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0}, 839 /* Line-in selector: Line-in */ 840 {0x10, AC_VERB_SET_CONNECT_SEL, 0x0}, 841 /* Mic 1/2 swap */ 842 {0x11, AC_VERB_SET_CONNECT_SEL, 0x0}, 843 /* Record selector: mic */ 844 {0x12, AC_VERB_SET_CONNECT_SEL, 0x0}, 845 /* Mic, Phone, CD, Aux, Line-In amp; mute as default */ 846 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 847 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 848 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 849 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 850 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 851 /* PC beep */ 852 {0x18, AC_VERB_SET_CONNECT_SEL, 0x0}, 853 /* HP, Line-Out, Surround, CLFE, Mono pins; mute as default */ 854 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 855 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 856 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 857 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 858 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 859 /* HP Pin */ 860 {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 861 /* Front, Surround, CLFE Pins */ 862 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 863 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 864 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 865 /* Mono Pin */ 866 {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 867 /* Mic Pin */ 868 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 869 /* Line, Aux, CD, Beep-In Pin */ 870 {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 871 {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 872 {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 873 {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 874 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 875 { } /* end */ 876 }; 877 878 static struct hda_verb ad1986a_ch2_init[] = { 879 /* Surround out -> Line In */ 880 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 881 /* Line-in selectors */ 882 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x1 }, 883 /* CLFE -> Mic in */ 884 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 885 /* Mic selector, mix C/LFE (backmic) and Mic (frontmic) */ 886 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 }, 887 { } /* end */ 888 }; 889 890 static struct hda_verb ad1986a_ch4_init[] = { 891 /* Surround out -> Surround */ 892 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 893 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 }, 894 /* CLFE -> Mic in */ 895 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 896 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 }, 897 { } /* end */ 898 }; 899 900 static struct hda_verb ad1986a_ch6_init[] = { 901 /* Surround out -> Surround out */ 902 { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 903 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 }, 904 /* CLFE -> CLFE */ 905 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 906 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x0 }, 907 { } /* end */ 908 }; 909 910 static struct hda_channel_mode ad1986a_modes[3] = { 911 { 2, ad1986a_ch2_init }, 912 { 4, ad1986a_ch4_init }, 913 { 6, ad1986a_ch6_init }, 914 }; 915 916 /* eapd initialization */ 917 static struct hda_verb ad1986a_eapd_init_verbs[] = { 918 {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, 919 {} 920 }; 921 922 static struct hda_verb ad1986a_automic_verbs[] = { 923 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 924 {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 925 /*{0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},*/ 926 {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0}, 927 {0x1f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_MIC_EVENT}, 928 {} 929 }; 930 931 /* Ultra initialization */ 932 static struct hda_verb ad1986a_ultra_init[] = { 933 /* eapd initialization */ 934 { 0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, 935 /* CLFE -> Mic in */ 936 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2 }, 937 { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 938 { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 }, 939 { } /* end */ 940 }; 941 942 /* pin sensing on HP jack */ 943 static struct hda_verb ad1986a_hp_init_verbs[] = { 944 {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_HP_EVENT}, 945 {} 946 }; 947 948 static void ad1986a_samsung_p50_unsol_event(struct hda_codec *codec, 949 unsigned int res) 950 { 951 switch (res >> 26) { 952 case AD1986A_HP_EVENT: 953 ad1986a_hp_automute(codec); 954 break; 955 case AD1986A_MIC_EVENT: 956 ad1986a_automic(codec); 957 break; 958 } 959 } 960 961 static int ad1986a_samsung_p50_init(struct hda_codec *codec) 962 { 963 ad198x_init(codec); 964 ad1986a_hp_automute(codec); 965 ad1986a_automic(codec); 966 return 0; 967 } 968 969 970 /* models */ 971 enum { 972 AD1986A_6STACK, 973 AD1986A_3STACK, 974 AD1986A_LAPTOP, 975 AD1986A_LAPTOP_EAPD, 976 AD1986A_LAPTOP_AUTOMUTE, 977 AD1986A_ULTRA, 978 AD1986A_SAMSUNG, 979 AD1986A_SAMSUNG_P50, 980 AD1986A_MODELS 981 }; 982 983 static const char *ad1986a_models[AD1986A_MODELS] = { 984 [AD1986A_6STACK] = "6stack", 985 [AD1986A_3STACK] = "3stack", 986 [AD1986A_LAPTOP] = "laptop", 987 [AD1986A_LAPTOP_EAPD] = "laptop-eapd", 988 [AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute", 989 [AD1986A_ULTRA] = "ultra", 990 [AD1986A_SAMSUNG] = "samsung", 991 [AD1986A_SAMSUNG_P50] = "samsung-p50", 992 }; 993 994 static struct snd_pci_quirk ad1986a_cfg_tbl[] = { 995 SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_LAPTOP_EAPD), 996 SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9", AD1986A_LAPTOP_EAPD), 997 SND_PCI_QUIRK(0x1043, 0x11f7, "ASUS U5A", AD1986A_LAPTOP_EAPD), 998 SND_PCI_QUIRK(0x1043, 0x1213, "ASUS A6J", AD1986A_LAPTOP_EAPD), 999 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS U5F", AD1986A_LAPTOP_EAPD), 1000 SND_PCI_QUIRK(0x1043, 0x1297, "ASUS Z62F", AD1986A_LAPTOP_EAPD), 1001 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS V1j", AD1986A_LAPTOP_EAPD), 1002 SND_PCI_QUIRK(0x1043, 0x1302, "ASUS W3j", AD1986A_LAPTOP_EAPD), 1003 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS VX1", AD1986A_LAPTOP), 1004 SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8J", AD1986A_3STACK), 1005 SND_PCI_QUIRK(0x1043, 0x817f, "ASUS P5", AD1986A_3STACK), 1006 SND_PCI_QUIRK(0x1043, 0x818f, "ASUS P5", AD1986A_LAPTOP), 1007 SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS P5", AD1986A_3STACK), 1008 SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK), 1009 SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK), 1010 SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK), 1011 SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba", AD1986A_LAPTOP_EAPD), 1012 SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK), 1013 SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP), 1014 SND_PCI_QUIRK(0x144d, 0xc024, "Samsung P50", AD1986A_SAMSUNG_P50), 1015 SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA), 1016 SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc000, "Samsung", AD1986A_SAMSUNG), 1017 SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK), 1018 SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_LAPTOP), 1019 SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK), 1020 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_LAPTOP_AUTOMUTE), 1021 SND_PCI_QUIRK(0x17c0, 0x2017, "Samsung M50", AD1986A_LAPTOP), 1022 {} 1023 }; 1024 1025 #ifdef CONFIG_SND_HDA_POWER_SAVE 1026 static struct hda_amp_list ad1986a_loopbacks[] = { 1027 { 0x13, HDA_OUTPUT, 0 }, /* Mic */ 1028 { 0x14, HDA_OUTPUT, 0 }, /* Phone */ 1029 { 0x15, HDA_OUTPUT, 0 }, /* CD */ 1030 { 0x16, HDA_OUTPUT, 0 }, /* Aux */ 1031 { 0x17, HDA_OUTPUT, 0 }, /* Line */ 1032 { } /* end */ 1033 }; 1034 #endif 1035 1036 static int is_jack_available(struct hda_codec *codec, hda_nid_t nid) 1037 { 1038 unsigned int conf = snd_hda_codec_get_pincfg(codec, nid); 1039 return get_defcfg_connect(conf) != AC_JACK_PORT_NONE; 1040 } 1041 1042 static int patch_ad1986a(struct hda_codec *codec) 1043 { 1044 struct ad198x_spec *spec; 1045 int err, board_config; 1046 1047 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1048 if (spec == NULL) 1049 return -ENOMEM; 1050 1051 codec->spec = spec; 1052 1053 err = snd_hda_attach_beep_device(codec, 0x19); 1054 if (err < 0) { 1055 ad198x_free(codec); 1056 return err; 1057 } 1058 set_beep_amp(spec, 0x18, 0, HDA_OUTPUT); 1059 1060 spec->multiout.max_channels = 6; 1061 spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids); 1062 spec->multiout.dac_nids = ad1986a_dac_nids; 1063 spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT; 1064 spec->num_adc_nids = 1; 1065 spec->adc_nids = ad1986a_adc_nids; 1066 spec->capsrc_nids = ad1986a_capsrc_nids; 1067 spec->input_mux = &ad1986a_capture_source; 1068 spec->num_mixers = 1; 1069 spec->mixers[0] = ad1986a_mixers; 1070 spec->num_init_verbs = 1; 1071 spec->init_verbs[0] = ad1986a_init_verbs; 1072 #ifdef CONFIG_SND_HDA_POWER_SAVE 1073 spec->loopback.amplist = ad1986a_loopbacks; 1074 #endif 1075 spec->vmaster_nid = 0x1b; 1076 spec->inv_eapd = 1; /* AD1986A has the inverted EAPD implementation */ 1077 1078 codec->patch_ops = ad198x_patch_ops; 1079 1080 /* override some parameters */ 1081 board_config = snd_hda_check_board_config(codec, AD1986A_MODELS, 1082 ad1986a_models, 1083 ad1986a_cfg_tbl); 1084 switch (board_config) { 1085 case AD1986A_3STACK: 1086 spec->num_mixers = 2; 1087 spec->mixers[1] = ad1986a_3st_mixers; 1088 spec->num_init_verbs = 2; 1089 spec->init_verbs[1] = ad1986a_ch2_init; 1090 spec->channel_mode = ad1986a_modes; 1091 spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes); 1092 spec->need_dac_fix = 1; 1093 spec->multiout.max_channels = 2; 1094 spec->multiout.num_dacs = 1; 1095 break; 1096 case AD1986A_LAPTOP: 1097 spec->mixers[0] = ad1986a_laptop_mixers; 1098 spec->multiout.max_channels = 2; 1099 spec->multiout.num_dacs = 1; 1100 spec->multiout.dac_nids = ad1986a_laptop_dac_nids; 1101 break; 1102 case AD1986A_LAPTOP_EAPD: 1103 spec->num_mixers = 3; 1104 spec->mixers[0] = ad1986a_laptop_master_mixers; 1105 spec->mixers[1] = ad1986a_laptop_eapd_mixers; 1106 spec->mixers[2] = ad1986a_laptop_intmic_mixers; 1107 spec->num_init_verbs = 2; 1108 spec->init_verbs[1] = ad1986a_eapd_init_verbs; 1109 spec->multiout.max_channels = 2; 1110 spec->multiout.num_dacs = 1; 1111 spec->multiout.dac_nids = ad1986a_laptop_dac_nids; 1112 if (!is_jack_available(codec, 0x25)) 1113 spec->multiout.dig_out_nid = 0; 1114 spec->input_mux = &ad1986a_laptop_eapd_capture_source; 1115 break; 1116 case AD1986A_SAMSUNG: 1117 spec->num_mixers = 2; 1118 spec->mixers[0] = ad1986a_laptop_master_mixers; 1119 spec->mixers[1] = ad1986a_laptop_eapd_mixers; 1120 spec->num_init_verbs = 3; 1121 spec->init_verbs[1] = ad1986a_eapd_init_verbs; 1122 spec->init_verbs[2] = ad1986a_automic_verbs; 1123 spec->multiout.max_channels = 2; 1124 spec->multiout.num_dacs = 1; 1125 spec->multiout.dac_nids = ad1986a_laptop_dac_nids; 1126 if (!is_jack_available(codec, 0x25)) 1127 spec->multiout.dig_out_nid = 0; 1128 spec->input_mux = &ad1986a_automic_capture_source; 1129 codec->patch_ops.unsol_event = ad1986a_automic_unsol_event; 1130 codec->patch_ops.init = ad1986a_automic_init; 1131 break; 1132 case AD1986A_SAMSUNG_P50: 1133 spec->num_mixers = 2; 1134 spec->mixers[0] = ad1986a_automute_master_mixers; 1135 spec->mixers[1] = ad1986a_laptop_eapd_mixers; 1136 spec->num_init_verbs = 4; 1137 spec->init_verbs[1] = ad1986a_eapd_init_verbs; 1138 spec->init_verbs[2] = ad1986a_automic_verbs; 1139 spec->init_verbs[3] = ad1986a_hp_init_verbs; 1140 spec->multiout.max_channels = 2; 1141 spec->multiout.num_dacs = 1; 1142 spec->multiout.dac_nids = ad1986a_laptop_dac_nids; 1143 if (!is_jack_available(codec, 0x25)) 1144 spec->multiout.dig_out_nid = 0; 1145 spec->input_mux = &ad1986a_automic_capture_source; 1146 codec->patch_ops.unsol_event = ad1986a_samsung_p50_unsol_event; 1147 codec->patch_ops.init = ad1986a_samsung_p50_init; 1148 break; 1149 case AD1986A_LAPTOP_AUTOMUTE: 1150 spec->num_mixers = 3; 1151 spec->mixers[0] = ad1986a_automute_master_mixers; 1152 spec->mixers[1] = ad1986a_laptop_eapd_mixers; 1153 spec->mixers[2] = ad1986a_laptop_intmic_mixers; 1154 spec->num_init_verbs = 3; 1155 spec->init_verbs[1] = ad1986a_eapd_init_verbs; 1156 spec->init_verbs[2] = ad1986a_hp_init_verbs; 1157 spec->multiout.max_channels = 2; 1158 spec->multiout.num_dacs = 1; 1159 spec->multiout.dac_nids = ad1986a_laptop_dac_nids; 1160 if (!is_jack_available(codec, 0x25)) 1161 spec->multiout.dig_out_nid = 0; 1162 spec->input_mux = &ad1986a_laptop_eapd_capture_source; 1163 codec->patch_ops.unsol_event = ad1986a_hp_unsol_event; 1164 codec->patch_ops.init = ad1986a_hp_init; 1165 /* Lenovo N100 seems to report the reversed bit 1166 * for HP jack-sensing 1167 */ 1168 spec->inv_jack_detect = 1; 1169 break; 1170 case AD1986A_ULTRA: 1171 spec->mixers[0] = ad1986a_laptop_eapd_mixers; 1172 spec->num_init_verbs = 2; 1173 spec->init_verbs[1] = ad1986a_ultra_init; 1174 spec->multiout.max_channels = 2; 1175 spec->multiout.num_dacs = 1; 1176 spec->multiout.dac_nids = ad1986a_laptop_dac_nids; 1177 spec->multiout.dig_out_nid = 0; 1178 break; 1179 } 1180 1181 /* AD1986A has a hardware problem that it can't share a stream 1182 * with multiple output pins. The copy of front to surrounds 1183 * causes noisy or silent outputs at a certain timing, e.g. 1184 * changing the volume. 1185 * So, let's disable the shared stream. 1186 */ 1187 spec->multiout.no_share_stream = 1; 1188 1189 codec->no_trigger_sense = 1; 1190 1191 return 0; 1192 } 1193 1194 /* 1195 * AD1983 specific 1196 */ 1197 1198 #define AD1983_SPDIF_OUT 0x02 1199 #define AD1983_DAC 0x03 1200 #define AD1983_ADC 0x04 1201 1202 static hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC }; 1203 static hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC }; 1204 static hda_nid_t ad1983_capsrc_nids[1] = { 0x15 }; 1205 1206 static struct hda_input_mux ad1983_capture_source = { 1207 .num_items = 4, 1208 .items = { 1209 { "Mic", 0x0 }, 1210 { "Line", 0x1 }, 1211 { "Mix", 0x2 }, 1212 { "Mix Mono", 0x3 }, 1213 }, 1214 }; 1215 1216 /* 1217 * SPDIF playback route 1218 */ 1219 static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 1220 { 1221 static char *texts[] = { "PCM", "ADC" }; 1222 1223 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1224 uinfo->count = 1; 1225 uinfo->value.enumerated.items = 2; 1226 if (uinfo->value.enumerated.item > 1) 1227 uinfo->value.enumerated.item = 1; 1228 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 1229 return 0; 1230 } 1231 1232 static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1233 { 1234 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1235 struct ad198x_spec *spec = codec->spec; 1236 1237 ucontrol->value.enumerated.item[0] = spec->spdif_route; 1238 return 0; 1239 } 1240 1241 static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 1242 { 1243 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1244 struct ad198x_spec *spec = codec->spec; 1245 1246 if (ucontrol->value.enumerated.item[0] > 1) 1247 return -EINVAL; 1248 if (spec->spdif_route != ucontrol->value.enumerated.item[0]) { 1249 spec->spdif_route = ucontrol->value.enumerated.item[0]; 1250 snd_hda_codec_write_cache(codec, spec->multiout.dig_out_nid, 0, 1251 AC_VERB_SET_CONNECT_SEL, 1252 spec->spdif_route); 1253 return 1; 1254 } 1255 return 0; 1256 } 1257 1258 static struct snd_kcontrol_new ad1983_mixers[] = { 1259 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT), 1260 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT), 1261 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT), 1262 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT), 1263 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT), 1264 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT), 1265 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT), 1266 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT), 1267 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT), 1268 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT), 1269 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT), 1270 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT), 1271 HDA_CODEC_VOLUME("Mic Boost", 0x0c, 0x0, HDA_OUTPUT), 1272 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT), 1273 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT), 1274 { 1275 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1276 .name = "Capture Source", 1277 .info = ad198x_mux_enum_info, 1278 .get = ad198x_mux_enum_get, 1279 .put = ad198x_mux_enum_put, 1280 }, 1281 { 1282 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1283 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 1284 .info = ad1983_spdif_route_info, 1285 .get = ad1983_spdif_route_get, 1286 .put = ad1983_spdif_route_put, 1287 }, 1288 { } /* end */ 1289 }; 1290 1291 static struct hda_verb ad1983_init_verbs[] = { 1292 /* Front, HP, Mono; mute as default */ 1293 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1294 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1295 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1296 /* Beep, PCM, Mic, Line-In: mute */ 1297 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1298 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1299 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1300 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1301 /* Front, HP selectors; from Mix */ 1302 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01}, 1303 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01}, 1304 /* Mono selector; from Mix */ 1305 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03}, 1306 /* Mic selector; Mic */ 1307 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, 1308 /* Line-in selector: Line-in */ 1309 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0}, 1310 /* Mic boost: 0dB */ 1311 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 1312 /* Record selector: mic */ 1313 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0}, 1314 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1315 /* SPDIF route: PCM */ 1316 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, 1317 /* Front Pin */ 1318 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 1319 /* HP Pin */ 1320 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 1321 /* Mono Pin */ 1322 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 1323 /* Mic Pin */ 1324 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 1325 /* Line Pin */ 1326 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 1327 { } /* end */ 1328 }; 1329 1330 #ifdef CONFIG_SND_HDA_POWER_SAVE 1331 static struct hda_amp_list ad1983_loopbacks[] = { 1332 { 0x12, HDA_OUTPUT, 0 }, /* Mic */ 1333 { 0x13, HDA_OUTPUT, 0 }, /* Line */ 1334 { } /* end */ 1335 }; 1336 #endif 1337 1338 static int patch_ad1983(struct hda_codec *codec) 1339 { 1340 struct ad198x_spec *spec; 1341 int err; 1342 1343 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1344 if (spec == NULL) 1345 return -ENOMEM; 1346 1347 codec->spec = spec; 1348 1349 err = snd_hda_attach_beep_device(codec, 0x10); 1350 if (err < 0) { 1351 ad198x_free(codec); 1352 return err; 1353 } 1354 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT); 1355 1356 spec->multiout.max_channels = 2; 1357 spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids); 1358 spec->multiout.dac_nids = ad1983_dac_nids; 1359 spec->multiout.dig_out_nid = AD1983_SPDIF_OUT; 1360 spec->num_adc_nids = 1; 1361 spec->adc_nids = ad1983_adc_nids; 1362 spec->capsrc_nids = ad1983_capsrc_nids; 1363 spec->input_mux = &ad1983_capture_source; 1364 spec->num_mixers = 1; 1365 spec->mixers[0] = ad1983_mixers; 1366 spec->num_init_verbs = 1; 1367 spec->init_verbs[0] = ad1983_init_verbs; 1368 spec->spdif_route = 0; 1369 #ifdef CONFIG_SND_HDA_POWER_SAVE 1370 spec->loopback.amplist = ad1983_loopbacks; 1371 #endif 1372 spec->vmaster_nid = 0x05; 1373 1374 codec->patch_ops = ad198x_patch_ops; 1375 1376 codec->no_trigger_sense = 1; 1377 1378 return 0; 1379 } 1380 1381 1382 /* 1383 * AD1981 HD specific 1384 */ 1385 1386 #define AD1981_SPDIF_OUT 0x02 1387 #define AD1981_DAC 0x03 1388 #define AD1981_ADC 0x04 1389 1390 static hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC }; 1391 static hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC }; 1392 static hda_nid_t ad1981_capsrc_nids[1] = { 0x15 }; 1393 1394 /* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */ 1395 static struct hda_input_mux ad1981_capture_source = { 1396 .num_items = 7, 1397 .items = { 1398 { "Front Mic", 0x0 }, 1399 { "Line", 0x1 }, 1400 { "Mix", 0x2 }, 1401 { "Mix Mono", 0x3 }, 1402 { "CD", 0x4 }, 1403 { "Mic", 0x6 }, 1404 { "Aux", 0x7 }, 1405 }, 1406 }; 1407 1408 static struct snd_kcontrol_new ad1981_mixers[] = { 1409 HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT), 1410 HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT), 1411 HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT), 1412 HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT), 1413 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT), 1414 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT), 1415 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT), 1416 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT), 1417 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT), 1418 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT), 1419 HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT), 1420 HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT), 1421 HDA_CODEC_VOLUME("Aux Playback Volume", 0x1b, 0x0, HDA_OUTPUT), 1422 HDA_CODEC_MUTE("Aux Playback Switch", 0x1b, 0x0, HDA_OUTPUT), 1423 HDA_CODEC_VOLUME("Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT), 1424 HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT), 1425 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT), 1426 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT), 1427 HDA_CODEC_VOLUME("Front Mic Boost", 0x08, 0x0, HDA_INPUT), 1428 HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x0, HDA_INPUT), 1429 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT), 1430 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT), 1431 { 1432 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1433 .name = "Capture Source", 1434 .info = ad198x_mux_enum_info, 1435 .get = ad198x_mux_enum_get, 1436 .put = ad198x_mux_enum_put, 1437 }, 1438 /* identical with AD1983 */ 1439 { 1440 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1441 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 1442 .info = ad1983_spdif_route_info, 1443 .get = ad1983_spdif_route_get, 1444 .put = ad1983_spdif_route_put, 1445 }, 1446 { } /* end */ 1447 }; 1448 1449 static struct hda_verb ad1981_init_verbs[] = { 1450 /* Front, HP, Mono; mute as default */ 1451 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1452 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1453 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1454 /* Beep, PCM, Front Mic, Line, Rear Mic, Aux, CD-In: mute */ 1455 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1456 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1457 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1458 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1459 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1460 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1461 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1462 /* Front, HP selectors; from Mix */ 1463 {0x05, AC_VERB_SET_CONNECT_SEL, 0x01}, 1464 {0x06, AC_VERB_SET_CONNECT_SEL, 0x01}, 1465 /* Mono selector; from Mix */ 1466 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03}, 1467 /* Mic Mixer; select Front Mic */ 1468 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 1469 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1470 /* Mic boost: 0dB */ 1471 {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1472 {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 1473 /* Record selector: Front mic */ 1474 {0x15, AC_VERB_SET_CONNECT_SEL, 0x0}, 1475 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1476 /* SPDIF route: PCM */ 1477 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, 1478 /* Front Pin */ 1479 {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 1480 /* HP Pin */ 1481 {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, 1482 /* Mono Pin */ 1483 {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 }, 1484 /* Front & Rear Mic Pins */ 1485 {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 1486 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 }, 1487 /* Line Pin */ 1488 {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 }, 1489 /* Digital Beep */ 1490 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00}, 1491 /* Line-Out as Input: disabled */ 1492 {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1493 { } /* end */ 1494 }; 1495 1496 #ifdef CONFIG_SND_HDA_POWER_SAVE 1497 static struct hda_amp_list ad1981_loopbacks[] = { 1498 { 0x12, HDA_OUTPUT, 0 }, /* Front Mic */ 1499 { 0x13, HDA_OUTPUT, 0 }, /* Line */ 1500 { 0x1b, HDA_OUTPUT, 0 }, /* Aux */ 1501 { 0x1c, HDA_OUTPUT, 0 }, /* Mic */ 1502 { 0x1d, HDA_OUTPUT, 0 }, /* CD */ 1503 { } /* end */ 1504 }; 1505 #endif 1506 1507 /* 1508 * Patch for HP nx6320 1509 * 1510 * nx6320 uses EAPD in the reverse way - EAPD-on means the internal 1511 * speaker output enabled _and_ mute-LED off. 1512 */ 1513 1514 #define AD1981_HP_EVENT 0x37 1515 #define AD1981_MIC_EVENT 0x38 1516 1517 static struct hda_verb ad1981_hp_init_verbs[] = { 1518 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */ 1519 /* pin sensing on HP and Mic jacks */ 1520 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT}, 1521 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT}, 1522 {} 1523 }; 1524 1525 /* turn on/off EAPD (+ mute HP) as a master switch */ 1526 static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol, 1527 struct snd_ctl_elem_value *ucontrol) 1528 { 1529 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1530 struct ad198x_spec *spec = codec->spec; 1531 1532 if (! ad198x_eapd_put(kcontrol, ucontrol)) 1533 return 0; 1534 /* change speaker pin appropriately */ 1535 snd_hda_codec_write(codec, 0x05, 0, 1536 AC_VERB_SET_PIN_WIDGET_CONTROL, 1537 spec->cur_eapd ? PIN_OUT : 0); 1538 /* toggle HP mute appropriately */ 1539 snd_hda_codec_amp_stereo(codec, 0x06, HDA_OUTPUT, 0, 1540 HDA_AMP_MUTE, 1541 spec->cur_eapd ? 0 : HDA_AMP_MUTE); 1542 return 1; 1543 } 1544 1545 /* bind volumes of both NID 0x05 and 0x06 */ 1546 static struct hda_bind_ctls ad1981_hp_bind_master_vol = { 1547 .ops = &snd_hda_bind_vol, 1548 .values = { 1549 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT), 1550 HDA_COMPOSE_AMP_VAL(0x06, 3, 0, HDA_OUTPUT), 1551 0 1552 }, 1553 }; 1554 1555 /* mute internal speaker if HP is plugged */ 1556 static void ad1981_hp_automute(struct hda_codec *codec) 1557 { 1558 unsigned int present; 1559 1560 present = snd_hda_jack_detect(codec, 0x06); 1561 snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0, 1562 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 1563 } 1564 1565 /* toggle input of built-in and mic jack appropriately */ 1566 static void ad1981_hp_automic(struct hda_codec *codec) 1567 { 1568 static struct hda_verb mic_jack_on[] = { 1569 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1570 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 1571 {} 1572 }; 1573 static struct hda_verb mic_jack_off[] = { 1574 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080}, 1575 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 1576 {} 1577 }; 1578 unsigned int present; 1579 1580 present = snd_hda_jack_detect(codec, 0x08); 1581 if (present) 1582 snd_hda_sequence_write(codec, mic_jack_on); 1583 else 1584 snd_hda_sequence_write(codec, mic_jack_off); 1585 } 1586 1587 /* unsolicited event for HP jack sensing */ 1588 static void ad1981_hp_unsol_event(struct hda_codec *codec, 1589 unsigned int res) 1590 { 1591 res >>= 26; 1592 switch (res) { 1593 case AD1981_HP_EVENT: 1594 ad1981_hp_automute(codec); 1595 break; 1596 case AD1981_MIC_EVENT: 1597 ad1981_hp_automic(codec); 1598 break; 1599 } 1600 } 1601 1602 static struct hda_input_mux ad1981_hp_capture_source = { 1603 .num_items = 3, 1604 .items = { 1605 { "Mic", 0x0 }, 1606 { "Docking-Station", 0x1 }, 1607 { "Mix", 0x2 }, 1608 }, 1609 }; 1610 1611 static struct snd_kcontrol_new ad1981_hp_mixers[] = { 1612 HDA_BIND_VOL("Master Playback Volume", &ad1981_hp_bind_master_vol), 1613 { 1614 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1615 .name = "Master Playback Switch", 1616 .info = ad198x_eapd_info, 1617 .get = ad198x_eapd_get, 1618 .put = ad1981_hp_master_sw_put, 1619 .private_value = 0x05, 1620 }, 1621 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT), 1622 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT), 1623 #if 0 1624 /* FIXME: analog mic/line loopback doesn't work with my tests... 1625 * (although recording is OK) 1626 */ 1627 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT), 1628 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT), 1629 HDA_CODEC_VOLUME("Docking-Station Playback Volume", 0x13, 0x0, HDA_OUTPUT), 1630 HDA_CODEC_MUTE("Docking-Station Playback Switch", 0x13, 0x0, HDA_OUTPUT), 1631 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT), 1632 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT), 1633 /* FIXME: does this laptop have analog CD connection? */ 1634 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT), 1635 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT), 1636 #endif 1637 HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT), 1638 HDA_CODEC_VOLUME("Internal Mic Boost", 0x18, 0x0, HDA_INPUT), 1639 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT), 1640 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT), 1641 { 1642 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1643 .name = "Capture Source", 1644 .info = ad198x_mux_enum_info, 1645 .get = ad198x_mux_enum_get, 1646 .put = ad198x_mux_enum_put, 1647 }, 1648 { } /* end */ 1649 }; 1650 1651 /* initialize jack-sensing, too */ 1652 static int ad1981_hp_init(struct hda_codec *codec) 1653 { 1654 ad198x_init(codec); 1655 ad1981_hp_automute(codec); 1656 ad1981_hp_automic(codec); 1657 return 0; 1658 } 1659 1660 /* configuration for Toshiba Laptops */ 1661 static struct hda_verb ad1981_toshiba_init_verbs[] = { 1662 {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x01 }, /* default on */ 1663 /* pin sensing on HP and Mic jacks */ 1664 {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT}, 1665 {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT}, 1666 {} 1667 }; 1668 1669 static struct snd_kcontrol_new ad1981_toshiba_mixers[] = { 1670 HDA_CODEC_VOLUME("Amp Volume", 0x1a, 0x0, HDA_OUTPUT), 1671 HDA_CODEC_MUTE("Amp Switch", 0x1a, 0x0, HDA_OUTPUT), 1672 { } 1673 }; 1674 1675 /* configuration for Lenovo Thinkpad T60 */ 1676 static struct snd_kcontrol_new ad1981_thinkpad_mixers[] = { 1677 HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT), 1678 HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT), 1679 HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT), 1680 HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT), 1681 HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT), 1682 HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT), 1683 HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT), 1684 HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT), 1685 HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT), 1686 HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT), 1687 HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT), 1688 { 1689 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1690 .name = "Capture Source", 1691 .info = ad198x_mux_enum_info, 1692 .get = ad198x_mux_enum_get, 1693 .put = ad198x_mux_enum_put, 1694 }, 1695 /* identical with AD1983 */ 1696 { 1697 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1698 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 1699 .info = ad1983_spdif_route_info, 1700 .get = ad1983_spdif_route_get, 1701 .put = ad1983_spdif_route_put, 1702 }, 1703 { } /* end */ 1704 }; 1705 1706 static struct hda_input_mux ad1981_thinkpad_capture_source = { 1707 .num_items = 3, 1708 .items = { 1709 { "Mic", 0x0 }, 1710 { "Mix", 0x2 }, 1711 { "CD", 0x4 }, 1712 }, 1713 }; 1714 1715 /* models */ 1716 enum { 1717 AD1981_BASIC, 1718 AD1981_HP, 1719 AD1981_THINKPAD, 1720 AD1981_TOSHIBA, 1721 AD1981_MODELS 1722 }; 1723 1724 static const char *ad1981_models[AD1981_MODELS] = { 1725 [AD1981_HP] = "hp", 1726 [AD1981_THINKPAD] = "thinkpad", 1727 [AD1981_BASIC] = "basic", 1728 [AD1981_TOSHIBA] = "toshiba" 1729 }; 1730 1731 static struct snd_pci_quirk ad1981_cfg_tbl[] = { 1732 SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD), 1733 SND_PCI_QUIRK(0x1014, 0x05b7, "Lenovo Z60m", AD1981_THINKPAD), 1734 /* All HP models */ 1735 SND_PCI_QUIRK_VENDOR(0x103c, "HP nx", AD1981_HP), 1736 SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA), 1737 /* Lenovo Thinkpad T60/X60/Z6xx */ 1738 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1981_THINKPAD), 1739 /* HP nx6320 (reversed SSID, H/W bug) */ 1740 SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP), 1741 {} 1742 }; 1743 1744 static int patch_ad1981(struct hda_codec *codec) 1745 { 1746 struct ad198x_spec *spec; 1747 int err, board_config; 1748 1749 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1750 if (spec == NULL) 1751 return -ENOMEM; 1752 1753 codec->spec = spec; 1754 1755 err = snd_hda_attach_beep_device(codec, 0x10); 1756 if (err < 0) { 1757 ad198x_free(codec); 1758 return err; 1759 } 1760 set_beep_amp(spec, 0x0d, 0, HDA_OUTPUT); 1761 1762 spec->multiout.max_channels = 2; 1763 spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids); 1764 spec->multiout.dac_nids = ad1981_dac_nids; 1765 spec->multiout.dig_out_nid = AD1981_SPDIF_OUT; 1766 spec->num_adc_nids = 1; 1767 spec->adc_nids = ad1981_adc_nids; 1768 spec->capsrc_nids = ad1981_capsrc_nids; 1769 spec->input_mux = &ad1981_capture_source; 1770 spec->num_mixers = 1; 1771 spec->mixers[0] = ad1981_mixers; 1772 spec->num_init_verbs = 1; 1773 spec->init_verbs[0] = ad1981_init_verbs; 1774 spec->spdif_route = 0; 1775 #ifdef CONFIG_SND_HDA_POWER_SAVE 1776 spec->loopback.amplist = ad1981_loopbacks; 1777 #endif 1778 spec->vmaster_nid = 0x05; 1779 1780 codec->patch_ops = ad198x_patch_ops; 1781 1782 /* override some parameters */ 1783 board_config = snd_hda_check_board_config(codec, AD1981_MODELS, 1784 ad1981_models, 1785 ad1981_cfg_tbl); 1786 switch (board_config) { 1787 case AD1981_HP: 1788 spec->mixers[0] = ad1981_hp_mixers; 1789 spec->num_init_verbs = 2; 1790 spec->init_verbs[1] = ad1981_hp_init_verbs; 1791 spec->multiout.dig_out_nid = 0; 1792 spec->input_mux = &ad1981_hp_capture_source; 1793 1794 codec->patch_ops.init = ad1981_hp_init; 1795 codec->patch_ops.unsol_event = ad1981_hp_unsol_event; 1796 /* set the upper-limit for mixer amp to 0dB for avoiding the 1797 * possible damage by overloading 1798 */ 1799 snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT, 1800 (0x17 << AC_AMPCAP_OFFSET_SHIFT) | 1801 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | 1802 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) | 1803 (1 << AC_AMPCAP_MUTE_SHIFT)); 1804 break; 1805 case AD1981_THINKPAD: 1806 spec->mixers[0] = ad1981_thinkpad_mixers; 1807 spec->input_mux = &ad1981_thinkpad_capture_source; 1808 break; 1809 case AD1981_TOSHIBA: 1810 spec->mixers[0] = ad1981_hp_mixers; 1811 spec->mixers[1] = ad1981_toshiba_mixers; 1812 spec->num_init_verbs = 2; 1813 spec->init_verbs[1] = ad1981_toshiba_init_verbs; 1814 spec->multiout.dig_out_nid = 0; 1815 spec->input_mux = &ad1981_hp_capture_source; 1816 codec->patch_ops.init = ad1981_hp_init; 1817 codec->patch_ops.unsol_event = ad1981_hp_unsol_event; 1818 break; 1819 } 1820 1821 codec->no_trigger_sense = 1; 1822 1823 return 0; 1824 } 1825 1826 1827 /* 1828 * AD1988 1829 * 1830 * Output pins and routes 1831 * 1832 * Pin Mix Sel DAC (*) 1833 * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06 1834 * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06 1835 * port-C 0x15 (mute) <- 0x2c <- 0x31 <- 05/0a 1836 * port-D 0x12 (mute/hp) <- 0x29 <- 04 1837 * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a 1838 * port-F 0x16 (mute) <- 0x2a <- 06 1839 * port-G 0x24 (mute) <- 0x27 <- 05 1840 * port-H 0x25 (mute) <- 0x28 <- 0a 1841 * mono 0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06 1842 * 1843 * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah 1844 * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug. 1845 * 1846 * Input pins and routes 1847 * 1848 * pin boost mix input # / adc input # 1849 * port-A 0x11 -> 0x38 -> mix 2, ADC 0 1850 * port-B 0x14 -> 0x39 -> mix 0, ADC 1 1851 * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2 1852 * port-D 0x12 -> 0x3d -> mix 3, ADC 8 1853 * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4 1854 * port-F 0x16 -> 0x3b -> mix 5, ADC 3 1855 * port-G 0x24 -> N/A -> 33:1 - mix 1, 34:1 - mix 4, ADC 6 1856 * port-H 0x25 -> N/A -> 33:2 - mix 1, 34:2 - mix 4, ADC 7 1857 * 1858 * 1859 * DAC assignment 1860 * 6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03 1861 * 3stack - front/surr/CLFE/opt DACs - 04/05/0a/03 1862 * 1863 * Inputs of Analog Mix (0x20) 1864 * 0:Port-B (front mic) 1865 * 1:Port-C/G/H (line-in) 1866 * 2:Port-A 1867 * 3:Port-D (line-in/2) 1868 * 4:Port-E/G/H (mic-in) 1869 * 5:Port-F (mic2-in) 1870 * 6:CD 1871 * 7:Beep 1872 * 1873 * ADC selection 1874 * 0:Port-A 1875 * 1:Port-B (front mic-in) 1876 * 2:Port-C (line-in) 1877 * 3:Port-F (mic2-in) 1878 * 4:Port-E (mic-in) 1879 * 5:CD 1880 * 6:Port-G 1881 * 7:Port-H 1882 * 8:Port-D (line-in/2) 1883 * 9:Mix 1884 * 1885 * Proposed pin assignments by the datasheet 1886 * 1887 * 6-stack 1888 * Port-A front headphone 1889 * B front mic-in 1890 * C rear line-in 1891 * D rear front-out 1892 * E rear mic-in 1893 * F rear surround 1894 * G rear CLFE 1895 * H rear side 1896 * 1897 * 3-stack 1898 * Port-A front headphone 1899 * B front mic 1900 * C rear line-in/surround 1901 * D rear front-out 1902 * E rear mic-in/CLFE 1903 * 1904 * laptop 1905 * Port-A headphone 1906 * B mic-in 1907 * C docking station 1908 * D internal speaker (with EAPD) 1909 * E/F quad mic array 1910 */ 1911 1912 1913 /* models */ 1914 enum { 1915 AD1988_6STACK, 1916 AD1988_6STACK_DIG, 1917 AD1988_3STACK, 1918 AD1988_3STACK_DIG, 1919 AD1988_LAPTOP, 1920 AD1988_LAPTOP_DIG, 1921 AD1988_AUTO, 1922 AD1988_MODEL_LAST, 1923 }; 1924 1925 /* reivision id to check workarounds */ 1926 #define AD1988A_REV2 0x100200 1927 1928 #define is_rev2(codec) \ 1929 ((codec)->vendor_id == 0x11d41988 && \ 1930 (codec)->revision_id == AD1988A_REV2) 1931 1932 /* 1933 * mixers 1934 */ 1935 1936 static hda_nid_t ad1988_6stack_dac_nids[4] = { 1937 0x04, 0x06, 0x05, 0x0a 1938 }; 1939 1940 static hda_nid_t ad1988_3stack_dac_nids[3] = { 1941 0x04, 0x05, 0x0a 1942 }; 1943 1944 /* for AD1988A revision-2, DAC2-4 are swapped */ 1945 static hda_nid_t ad1988_6stack_dac_nids_rev2[4] = { 1946 0x04, 0x05, 0x0a, 0x06 1947 }; 1948 1949 static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = { 1950 0x04, 0x0a, 0x06 1951 }; 1952 1953 static hda_nid_t ad1988_adc_nids[3] = { 1954 0x08, 0x09, 0x0f 1955 }; 1956 1957 static hda_nid_t ad1988_capsrc_nids[3] = { 1958 0x0c, 0x0d, 0x0e 1959 }; 1960 1961 #define AD1988_SPDIF_OUT 0x02 1962 #define AD1988_SPDIF_OUT_HDMI 0x0b 1963 #define AD1988_SPDIF_IN 0x07 1964 1965 static hda_nid_t ad1989b_slave_dig_outs[] = { 1966 AD1988_SPDIF_OUT, AD1988_SPDIF_OUT_HDMI, 0 1967 }; 1968 1969 static struct hda_input_mux ad1988_6stack_capture_source = { 1970 .num_items = 5, 1971 .items = { 1972 { "Front Mic", 0x1 }, /* port-B */ 1973 { "Line", 0x2 }, /* port-C */ 1974 { "Mic", 0x4 }, /* port-E */ 1975 { "CD", 0x5 }, 1976 { "Mix", 0x9 }, 1977 }, 1978 }; 1979 1980 static struct hda_input_mux ad1988_laptop_capture_source = { 1981 .num_items = 3, 1982 .items = { 1983 { "Mic/Line", 0x1 }, /* port-B */ 1984 { "CD", 0x5 }, 1985 { "Mix", 0x9 }, 1986 }, 1987 }; 1988 1989 /* 1990 */ 1991 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol, 1992 struct snd_ctl_elem_info *uinfo) 1993 { 1994 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 1995 struct ad198x_spec *spec = codec->spec; 1996 return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode, 1997 spec->num_channel_mode); 1998 } 1999 2000 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol, 2001 struct snd_ctl_elem_value *ucontrol) 2002 { 2003 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2004 struct ad198x_spec *spec = codec->spec; 2005 return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode, 2006 spec->num_channel_mode, spec->multiout.max_channels); 2007 } 2008 2009 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol, 2010 struct snd_ctl_elem_value *ucontrol) 2011 { 2012 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2013 struct ad198x_spec *spec = codec->spec; 2014 int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode, 2015 spec->num_channel_mode, 2016 &spec->multiout.max_channels); 2017 if (err >= 0 && spec->need_dac_fix) 2018 spec->multiout.num_dacs = spec->multiout.max_channels / 2; 2019 return err; 2020 } 2021 2022 /* 6-stack mode */ 2023 static struct snd_kcontrol_new ad1988_6stack_mixers1[] = { 2024 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT), 2025 HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT), 2026 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT), 2027 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT), 2028 HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT), 2029 { } /* end */ 2030 }; 2031 2032 static struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = { 2033 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT), 2034 HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT), 2035 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT), 2036 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT), 2037 HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT), 2038 { } /* end */ 2039 }; 2040 2041 static struct snd_kcontrol_new ad1988_6stack_mixers2[] = { 2042 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT), 2043 HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT), 2044 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT), 2045 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT), 2046 HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT), 2047 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT), 2048 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT), 2049 2050 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT), 2051 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT), 2052 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT), 2053 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT), 2054 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT), 2055 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT), 2056 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT), 2057 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT), 2058 2059 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT), 2060 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT), 2061 2062 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT), 2063 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT), 2064 2065 { } /* end */ 2066 }; 2067 2068 /* 3-stack mode */ 2069 static struct snd_kcontrol_new ad1988_3stack_mixers1[] = { 2070 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT), 2071 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT), 2072 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT), 2073 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT), 2074 { } /* end */ 2075 }; 2076 2077 static struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = { 2078 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT), 2079 HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT), 2080 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT), 2081 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT), 2082 { } /* end */ 2083 }; 2084 2085 static struct snd_kcontrol_new ad1988_3stack_mixers2[] = { 2086 HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT), 2087 HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT), 2088 HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT), 2089 HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT), 2090 HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT), 2091 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT), 2092 2093 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT), 2094 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT), 2095 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT), 2096 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT), 2097 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT), 2098 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT), 2099 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT), 2100 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT), 2101 2102 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT), 2103 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT), 2104 2105 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT), 2106 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT), 2107 { 2108 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2109 .name = "Channel Mode", 2110 .info = ad198x_ch_mode_info, 2111 .get = ad198x_ch_mode_get, 2112 .put = ad198x_ch_mode_put, 2113 }, 2114 2115 { } /* end */ 2116 }; 2117 2118 /* laptop mode */ 2119 static struct snd_kcontrol_new ad1988_laptop_mixers[] = { 2120 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT), 2121 HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT), 2122 HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT), 2123 2124 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT), 2125 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT), 2126 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT), 2127 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT), 2128 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT), 2129 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT), 2130 2131 HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT), 2132 HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT), 2133 2134 HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT), 2135 2136 { 2137 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2138 .name = "External Amplifier", 2139 .info = ad198x_eapd_info, 2140 .get = ad198x_eapd_get, 2141 .put = ad198x_eapd_put, 2142 .private_value = 0x12, /* port-D */ 2143 }, 2144 2145 { } /* end */ 2146 }; 2147 2148 /* capture */ 2149 static struct snd_kcontrol_new ad1988_capture_mixers[] = { 2150 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 2151 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 2152 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT), 2153 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT), 2154 HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT), 2155 HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT), 2156 { 2157 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2158 /* The multiple "Capture Source" controls confuse alsamixer 2159 * So call somewhat different.. 2160 */ 2161 /* .name = "Capture Source", */ 2162 .name = "Input Source", 2163 .count = 3, 2164 .info = ad198x_mux_enum_info, 2165 .get = ad198x_mux_enum_get, 2166 .put = ad198x_mux_enum_put, 2167 }, 2168 { } /* end */ 2169 }; 2170 2171 static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol, 2172 struct snd_ctl_elem_info *uinfo) 2173 { 2174 static char *texts[] = { 2175 "PCM", "ADC1", "ADC2", "ADC3" 2176 }; 2177 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2178 uinfo->count = 1; 2179 uinfo->value.enumerated.items = 4; 2180 if (uinfo->value.enumerated.item >= 4) 2181 uinfo->value.enumerated.item = 3; 2182 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 2183 return 0; 2184 } 2185 2186 static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol, 2187 struct snd_ctl_elem_value *ucontrol) 2188 { 2189 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2190 unsigned int sel; 2191 2192 sel = snd_hda_codec_read(codec, 0x1d, 0, AC_VERB_GET_AMP_GAIN_MUTE, 2193 AC_AMP_GET_INPUT); 2194 if (!(sel & 0x80)) 2195 ucontrol->value.enumerated.item[0] = 0; 2196 else { 2197 sel = snd_hda_codec_read(codec, 0x0b, 0, 2198 AC_VERB_GET_CONNECT_SEL, 0); 2199 if (sel < 3) 2200 sel++; 2201 else 2202 sel = 0; 2203 ucontrol->value.enumerated.item[0] = sel; 2204 } 2205 return 0; 2206 } 2207 2208 static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol, 2209 struct snd_ctl_elem_value *ucontrol) 2210 { 2211 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2212 unsigned int val, sel; 2213 int change; 2214 2215 val = ucontrol->value.enumerated.item[0]; 2216 if (val > 3) 2217 return -EINVAL; 2218 if (!val) { 2219 sel = snd_hda_codec_read(codec, 0x1d, 0, 2220 AC_VERB_GET_AMP_GAIN_MUTE, 2221 AC_AMP_GET_INPUT); 2222 change = sel & 0x80; 2223 if (change) { 2224 snd_hda_codec_write_cache(codec, 0x1d, 0, 2225 AC_VERB_SET_AMP_GAIN_MUTE, 2226 AMP_IN_UNMUTE(0)); 2227 snd_hda_codec_write_cache(codec, 0x1d, 0, 2228 AC_VERB_SET_AMP_GAIN_MUTE, 2229 AMP_IN_MUTE(1)); 2230 } 2231 } else { 2232 sel = snd_hda_codec_read(codec, 0x1d, 0, 2233 AC_VERB_GET_AMP_GAIN_MUTE, 2234 AC_AMP_GET_INPUT | 0x01); 2235 change = sel & 0x80; 2236 if (change) { 2237 snd_hda_codec_write_cache(codec, 0x1d, 0, 2238 AC_VERB_SET_AMP_GAIN_MUTE, 2239 AMP_IN_MUTE(0)); 2240 snd_hda_codec_write_cache(codec, 0x1d, 0, 2241 AC_VERB_SET_AMP_GAIN_MUTE, 2242 AMP_IN_UNMUTE(1)); 2243 } 2244 sel = snd_hda_codec_read(codec, 0x0b, 0, 2245 AC_VERB_GET_CONNECT_SEL, 0) + 1; 2246 change |= sel != val; 2247 if (change) 2248 snd_hda_codec_write_cache(codec, 0x0b, 0, 2249 AC_VERB_SET_CONNECT_SEL, 2250 val - 1); 2251 } 2252 return change; 2253 } 2254 2255 static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = { 2256 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT), 2257 { 2258 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2259 .name = "IEC958 Playback Source", 2260 .info = ad1988_spdif_playback_source_info, 2261 .get = ad1988_spdif_playback_source_get, 2262 .put = ad1988_spdif_playback_source_put, 2263 }, 2264 { } /* end */ 2265 }; 2266 2267 static struct snd_kcontrol_new ad1988_spdif_in_mixers[] = { 2268 HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT), 2269 { } /* end */ 2270 }; 2271 2272 static struct snd_kcontrol_new ad1989_spdif_out_mixers[] = { 2273 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT), 2274 HDA_CODEC_VOLUME("HDMI Playback Volume", 0x1d, 0x0, HDA_OUTPUT), 2275 { } /* end */ 2276 }; 2277 2278 /* 2279 * initialization verbs 2280 */ 2281 2282 /* 2283 * for 6-stack (+dig) 2284 */ 2285 static struct hda_verb ad1988_6stack_init_verbs[] = { 2286 /* Front, Surround, CLFE, side DAC; unmute as default */ 2287 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2288 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2289 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2290 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2291 /* Port-A front headphon path */ 2292 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */ 2293 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2294 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2295 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2296 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2297 /* Port-D line-out path */ 2298 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2299 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2300 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2301 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2302 /* Port-F surround path */ 2303 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2304 {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2305 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2306 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2307 /* Port-G CLFE path */ 2308 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2309 {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2310 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2311 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2312 /* Port-H side path */ 2313 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2314 {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2315 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2316 {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2317 /* Mono out path */ 2318 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */ 2319 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2320 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2321 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2322 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */ 2323 /* Port-B front mic-in path */ 2324 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2325 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2326 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2327 /* Port-C line-in path */ 2328 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2329 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2330 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2331 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0}, 2332 /* Port-E mic-in path */ 2333 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2334 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2335 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2336 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0}, 2337 /* Analog CD Input */ 2338 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 2339 /* Analog Mix output amp */ 2340 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */ 2341 2342 { } 2343 }; 2344 2345 static struct hda_verb ad1988_capture_init_verbs[] = { 2346 /* mute analog mix */ 2347 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2348 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2349 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2350 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2351 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 2352 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 2353 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 2354 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2355 /* select ADCs - front-mic */ 2356 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1}, 2357 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1}, 2358 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1}, 2359 2360 { } 2361 }; 2362 2363 static struct hda_verb ad1988_spdif_init_verbs[] = { 2364 /* SPDIF out sel */ 2365 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */ 2366 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */ 2367 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 2368 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2369 /* SPDIF out pin */ 2370 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */ 2371 2372 { } 2373 }; 2374 2375 /* AD1989 has no ADC -> SPDIF route */ 2376 static struct hda_verb ad1989_spdif_init_verbs[] = { 2377 /* SPDIF-1 out pin */ 2378 {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 2379 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */ 2380 /* SPDIF-2/HDMI out pin */ 2381 {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 2382 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */ 2383 { } 2384 }; 2385 2386 /* 2387 * verbs for 3stack (+dig) 2388 */ 2389 static struct hda_verb ad1988_3stack_ch2_init[] = { 2390 /* set port-C to line-in */ 2391 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 2392 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, 2393 /* set port-E to mic-in */ 2394 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 2395 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, 2396 { } /* end */ 2397 }; 2398 2399 static struct hda_verb ad1988_3stack_ch6_init[] = { 2400 /* set port-C to surround out */ 2401 { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 2402 { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 2403 /* set port-E to CLFE out */ 2404 { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, 2405 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 2406 { } /* end */ 2407 }; 2408 2409 static struct hda_channel_mode ad1988_3stack_modes[2] = { 2410 { 2, ad1988_3stack_ch2_init }, 2411 { 6, ad1988_3stack_ch6_init }, 2412 }; 2413 2414 static struct hda_verb ad1988_3stack_init_verbs[] = { 2415 /* Front, Surround, CLFE, side DAC; unmute as default */ 2416 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2417 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2418 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2419 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2420 /* Port-A front headphon path */ 2421 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */ 2422 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2423 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2424 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2425 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2426 /* Port-D line-out path */ 2427 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2428 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2429 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2430 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2431 /* Mono out path */ 2432 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */ 2433 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2434 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2435 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2436 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */ 2437 /* Port-B front mic-in path */ 2438 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2439 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2440 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2441 /* Port-C line-in/surround path - 6ch mode as default */ 2442 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2443 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2444 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2445 {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */ 2446 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0}, 2447 /* Port-E mic-in/CLFE path - 6ch mode as default */ 2448 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2449 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2450 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2451 {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */ 2452 {0x34, AC_VERB_SET_CONNECT_SEL, 0x0}, 2453 /* mute analog mix */ 2454 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2455 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2456 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2457 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2458 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 2459 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 2460 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 2461 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2462 /* select ADCs - front-mic */ 2463 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1}, 2464 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1}, 2465 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1}, 2466 /* Analog Mix output amp */ 2467 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */ 2468 { } 2469 }; 2470 2471 /* 2472 * verbs for laptop mode (+dig) 2473 */ 2474 static struct hda_verb ad1988_laptop_hp_on[] = { 2475 /* unmute port-A and mute port-D */ 2476 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 2477 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 2478 { } /* end */ 2479 }; 2480 static struct hda_verb ad1988_laptop_hp_off[] = { 2481 /* mute port-A and unmute port-D */ 2482 { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 2483 { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, 2484 { } /* end */ 2485 }; 2486 2487 #define AD1988_HP_EVENT 0x01 2488 2489 static struct hda_verb ad1988_laptop_init_verbs[] = { 2490 /* Front, Surround, CLFE, side DAC; unmute as default */ 2491 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2492 {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2493 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2494 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2495 /* Port-A front headphon path */ 2496 {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */ 2497 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2498 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2499 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2500 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 2501 /* unsolicited event for pin-sense */ 2502 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT }, 2503 /* Port-D line-out path + EAPD */ 2504 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2505 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2506 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2507 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2508 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */ 2509 /* Mono out path */ 2510 {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */ 2511 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2512 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2513 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2514 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */ 2515 /* Port-B mic-in path */ 2516 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 2517 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 2518 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2519 /* Port-C docking station - try to output */ 2520 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 2521 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 2522 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 2523 {0x33, AC_VERB_SET_CONNECT_SEL, 0x0}, 2524 /* mute analog mix */ 2525 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 2526 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 2527 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 2528 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 2529 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 2530 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 2531 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 2532 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 2533 /* select ADCs - mic */ 2534 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1}, 2535 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1}, 2536 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1}, 2537 /* Analog Mix output amp */ 2538 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */ 2539 { } 2540 }; 2541 2542 static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res) 2543 { 2544 if ((res >> 26) != AD1988_HP_EVENT) 2545 return; 2546 if (snd_hda_jack_detect(codec, 0x11)) 2547 snd_hda_sequence_write(codec, ad1988_laptop_hp_on); 2548 else 2549 snd_hda_sequence_write(codec, ad1988_laptop_hp_off); 2550 } 2551 2552 #ifdef CONFIG_SND_HDA_POWER_SAVE 2553 static struct hda_amp_list ad1988_loopbacks[] = { 2554 { 0x20, HDA_INPUT, 0 }, /* Front Mic */ 2555 { 0x20, HDA_INPUT, 1 }, /* Line */ 2556 { 0x20, HDA_INPUT, 4 }, /* Mic */ 2557 { 0x20, HDA_INPUT, 6 }, /* CD */ 2558 { } /* end */ 2559 }; 2560 #endif 2561 2562 /* 2563 * Automatic parse of I/O pins from the BIOS configuration 2564 */ 2565 2566 enum { 2567 AD_CTL_WIDGET_VOL, 2568 AD_CTL_WIDGET_MUTE, 2569 AD_CTL_BIND_MUTE, 2570 }; 2571 static struct snd_kcontrol_new ad1988_control_templates[] = { 2572 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 2573 HDA_CODEC_MUTE(NULL, 0, 0, 0), 2574 HDA_BIND_MUTE(NULL, 0, 0, 0), 2575 }; 2576 2577 /* add dynamic controls */ 2578 static int add_control(struct ad198x_spec *spec, int type, const char *name, 2579 unsigned long val) 2580 { 2581 struct snd_kcontrol_new *knew; 2582 2583 snd_array_init(&spec->kctls, sizeof(*knew), 32); 2584 knew = snd_array_new(&spec->kctls); 2585 if (!knew) 2586 return -ENOMEM; 2587 *knew = ad1988_control_templates[type]; 2588 knew->name = kstrdup(name, GFP_KERNEL); 2589 if (! knew->name) 2590 return -ENOMEM; 2591 if (get_amp_nid_(val)) 2592 knew->subdevice = HDA_SUBDEV_NID_FLAG | get_amp_nid_(val); 2593 knew->private_value = val; 2594 return 0; 2595 } 2596 2597 #define AD1988_PIN_CD_NID 0x18 2598 #define AD1988_PIN_BEEP_NID 0x10 2599 2600 static hda_nid_t ad1988_mixer_nids[8] = { 2601 /* A B C D E F G H */ 2602 0x22, 0x2b, 0x2c, 0x29, 0x26, 0x2a, 0x27, 0x28 2603 }; 2604 2605 static inline hda_nid_t ad1988_idx_to_dac(struct hda_codec *codec, int idx) 2606 { 2607 static hda_nid_t idx_to_dac[8] = { 2608 /* A B C D E F G H */ 2609 0x04, 0x06, 0x05, 0x04, 0x0a, 0x06, 0x05, 0x0a 2610 }; 2611 static hda_nid_t idx_to_dac_rev2[8] = { 2612 /* A B C D E F G H */ 2613 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06 2614 }; 2615 if (is_rev2(codec)) 2616 return idx_to_dac_rev2[idx]; 2617 else 2618 return idx_to_dac[idx]; 2619 } 2620 2621 static hda_nid_t ad1988_boost_nids[8] = { 2622 0x38, 0x39, 0x3a, 0x3d, 0x3c, 0x3b, 0, 0 2623 }; 2624 2625 static int ad1988_pin_idx(hda_nid_t nid) 2626 { 2627 static hda_nid_t ad1988_io_pins[8] = { 2628 0x11, 0x14, 0x15, 0x12, 0x17, 0x16, 0x24, 0x25 2629 }; 2630 int i; 2631 for (i = 0; i < ARRAY_SIZE(ad1988_io_pins); i++) 2632 if (ad1988_io_pins[i] == nid) 2633 return i; 2634 return 0; /* should be -1 */ 2635 } 2636 2637 static int ad1988_pin_to_loopback_idx(hda_nid_t nid) 2638 { 2639 static int loopback_idx[8] = { 2640 2, 0, 1, 3, 4, 5, 1, 4 2641 }; 2642 switch (nid) { 2643 case AD1988_PIN_CD_NID: 2644 return 6; 2645 default: 2646 return loopback_idx[ad1988_pin_idx(nid)]; 2647 } 2648 } 2649 2650 static int ad1988_pin_to_adc_idx(hda_nid_t nid) 2651 { 2652 static int adc_idx[8] = { 2653 0, 1, 2, 8, 4, 3, 6, 7 2654 }; 2655 switch (nid) { 2656 case AD1988_PIN_CD_NID: 2657 return 5; 2658 default: 2659 return adc_idx[ad1988_pin_idx(nid)]; 2660 } 2661 } 2662 2663 /* fill in the dac_nids table from the parsed pin configuration */ 2664 static int ad1988_auto_fill_dac_nids(struct hda_codec *codec, 2665 const struct auto_pin_cfg *cfg) 2666 { 2667 struct ad198x_spec *spec = codec->spec; 2668 int i, idx; 2669 2670 spec->multiout.dac_nids = spec->private_dac_nids; 2671 2672 /* check the pins hardwired to audio widget */ 2673 for (i = 0; i < cfg->line_outs; i++) { 2674 idx = ad1988_pin_idx(cfg->line_out_pins[i]); 2675 spec->multiout.dac_nids[i] = ad1988_idx_to_dac(codec, idx); 2676 } 2677 spec->multiout.num_dacs = cfg->line_outs; 2678 return 0; 2679 } 2680 2681 /* add playback controls from the parsed DAC table */ 2682 static int ad1988_auto_create_multi_out_ctls(struct ad198x_spec *spec, 2683 const struct auto_pin_cfg *cfg) 2684 { 2685 char name[32]; 2686 static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" }; 2687 hda_nid_t nid; 2688 int i, err; 2689 2690 for (i = 0; i < cfg->line_outs; i++) { 2691 hda_nid_t dac = spec->multiout.dac_nids[i]; 2692 if (! dac) 2693 continue; 2694 nid = ad1988_mixer_nids[ad1988_pin_idx(cfg->line_out_pins[i])]; 2695 if (i == 2) { 2696 /* Center/LFE */ 2697 err = add_control(spec, AD_CTL_WIDGET_VOL, 2698 "Center Playback Volume", 2699 HDA_COMPOSE_AMP_VAL(dac, 1, 0, HDA_OUTPUT)); 2700 if (err < 0) 2701 return err; 2702 err = add_control(spec, AD_CTL_WIDGET_VOL, 2703 "LFE Playback Volume", 2704 HDA_COMPOSE_AMP_VAL(dac, 2, 0, HDA_OUTPUT)); 2705 if (err < 0) 2706 return err; 2707 err = add_control(spec, AD_CTL_BIND_MUTE, 2708 "Center Playback Switch", 2709 HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT)); 2710 if (err < 0) 2711 return err; 2712 err = add_control(spec, AD_CTL_BIND_MUTE, 2713 "LFE Playback Switch", 2714 HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT)); 2715 if (err < 0) 2716 return err; 2717 } else { 2718 sprintf(name, "%s Playback Volume", chname[i]); 2719 err = add_control(spec, AD_CTL_WIDGET_VOL, name, 2720 HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT)); 2721 if (err < 0) 2722 return err; 2723 sprintf(name, "%s Playback Switch", chname[i]); 2724 err = add_control(spec, AD_CTL_BIND_MUTE, name, 2725 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT)); 2726 if (err < 0) 2727 return err; 2728 } 2729 } 2730 return 0; 2731 } 2732 2733 /* add playback controls for speaker and HP outputs */ 2734 static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin, 2735 const char *pfx) 2736 { 2737 struct ad198x_spec *spec = codec->spec; 2738 hda_nid_t nid; 2739 int i, idx, err; 2740 char name[32]; 2741 2742 if (! pin) 2743 return 0; 2744 2745 idx = ad1988_pin_idx(pin); 2746 nid = ad1988_idx_to_dac(codec, idx); 2747 /* check whether the corresponding DAC was already taken */ 2748 for (i = 0; i < spec->autocfg.line_outs; i++) { 2749 hda_nid_t pin = spec->autocfg.line_out_pins[i]; 2750 hda_nid_t dac = ad1988_idx_to_dac(codec, ad1988_pin_idx(pin)); 2751 if (dac == nid) 2752 break; 2753 } 2754 if (i >= spec->autocfg.line_outs) { 2755 /* specify the DAC as the extra output */ 2756 if (!spec->multiout.hp_nid) 2757 spec->multiout.hp_nid = nid; 2758 else 2759 spec->multiout.extra_out_nid[0] = nid; 2760 /* control HP volume/switch on the output mixer amp */ 2761 sprintf(name, "%s Playback Volume", pfx); 2762 err = add_control(spec, AD_CTL_WIDGET_VOL, name, 2763 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 2764 if (err < 0) 2765 return err; 2766 } 2767 nid = ad1988_mixer_nids[idx]; 2768 sprintf(name, "%s Playback Switch", pfx); 2769 if ((err = add_control(spec, AD_CTL_BIND_MUTE, name, 2770 HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0) 2771 return err; 2772 return 0; 2773 } 2774 2775 /* create input playback/capture controls for the given pin */ 2776 static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin, 2777 const char *ctlname, int boost) 2778 { 2779 char name[32]; 2780 int err, idx; 2781 2782 sprintf(name, "%s Playback Volume", ctlname); 2783 idx = ad1988_pin_to_loopback_idx(pin); 2784 if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name, 2785 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0) 2786 return err; 2787 sprintf(name, "%s Playback Switch", ctlname); 2788 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, name, 2789 HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0) 2790 return err; 2791 if (boost) { 2792 hda_nid_t bnid; 2793 idx = ad1988_pin_idx(pin); 2794 bnid = ad1988_boost_nids[idx]; 2795 if (bnid) { 2796 sprintf(name, "%s Boost", ctlname); 2797 return add_control(spec, AD_CTL_WIDGET_VOL, name, 2798 HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT)); 2799 2800 } 2801 } 2802 return 0; 2803 } 2804 2805 /* create playback/capture controls for input pins */ 2806 static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec, 2807 const struct auto_pin_cfg *cfg) 2808 { 2809 struct hda_input_mux *imux = &spec->private_imux; 2810 int i, err; 2811 2812 for (i = 0; i < AUTO_PIN_LAST; i++) { 2813 err = new_analog_input(spec, cfg->input_pins[i], 2814 auto_pin_cfg_labels[i], 2815 i <= AUTO_PIN_FRONT_MIC); 2816 if (err < 0) 2817 return err; 2818 imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; 2819 imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]); 2820 imux->num_items++; 2821 } 2822 imux->items[imux->num_items].label = "Mix"; 2823 imux->items[imux->num_items].index = 9; 2824 imux->num_items++; 2825 2826 if ((err = add_control(spec, AD_CTL_WIDGET_VOL, 2827 "Analog Mix Playback Volume", 2828 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0) 2829 return err; 2830 if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, 2831 "Analog Mix Playback Switch", 2832 HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0) 2833 return err; 2834 2835 return 0; 2836 } 2837 2838 static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec, 2839 hda_nid_t nid, int pin_type, 2840 int dac_idx) 2841 { 2842 /* set as output */ 2843 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type); 2844 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 2845 switch (nid) { 2846 case 0x11: /* port-A - DAC 04 */ 2847 snd_hda_codec_write(codec, 0x37, 0, AC_VERB_SET_CONNECT_SEL, 0x01); 2848 break; 2849 case 0x14: /* port-B - DAC 06 */ 2850 snd_hda_codec_write(codec, 0x30, 0, AC_VERB_SET_CONNECT_SEL, 0x02); 2851 break; 2852 case 0x15: /* port-C - DAC 05 */ 2853 snd_hda_codec_write(codec, 0x31, 0, AC_VERB_SET_CONNECT_SEL, 0x00); 2854 break; 2855 case 0x17: /* port-E - DAC 0a */ 2856 snd_hda_codec_write(codec, 0x32, 0, AC_VERB_SET_CONNECT_SEL, 0x01); 2857 break; 2858 case 0x13: /* mono - DAC 04 */ 2859 snd_hda_codec_write(codec, 0x36, 0, AC_VERB_SET_CONNECT_SEL, 0x01); 2860 break; 2861 } 2862 } 2863 2864 static void ad1988_auto_init_multi_out(struct hda_codec *codec) 2865 { 2866 struct ad198x_spec *spec = codec->spec; 2867 int i; 2868 2869 for (i = 0; i < spec->autocfg.line_outs; i++) { 2870 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 2871 ad1988_auto_set_output_and_unmute(codec, nid, PIN_OUT, i); 2872 } 2873 } 2874 2875 static void ad1988_auto_init_extra_out(struct hda_codec *codec) 2876 { 2877 struct ad198x_spec *spec = codec->spec; 2878 hda_nid_t pin; 2879 2880 pin = spec->autocfg.speaker_pins[0]; 2881 if (pin) /* connect to front */ 2882 ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0); 2883 pin = spec->autocfg.hp_pins[0]; 2884 if (pin) /* connect to front */ 2885 ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0); 2886 } 2887 2888 static void ad1988_auto_init_analog_input(struct hda_codec *codec) 2889 { 2890 struct ad198x_spec *spec = codec->spec; 2891 int i, idx; 2892 2893 for (i = 0; i < AUTO_PIN_LAST; i++) { 2894 hda_nid_t nid = spec->autocfg.input_pins[i]; 2895 if (! nid) 2896 continue; 2897 switch (nid) { 2898 case 0x15: /* port-C */ 2899 snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0); 2900 break; 2901 case 0x17: /* port-E */ 2902 snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0); 2903 break; 2904 } 2905 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, 2906 i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN); 2907 if (nid != AD1988_PIN_CD_NID) 2908 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, 2909 AMP_OUT_MUTE); 2910 idx = ad1988_pin_idx(nid); 2911 if (ad1988_boost_nids[idx]) 2912 snd_hda_codec_write(codec, ad1988_boost_nids[idx], 0, 2913 AC_VERB_SET_AMP_GAIN_MUTE, 2914 AMP_OUT_ZERO); 2915 } 2916 } 2917 2918 /* parse the BIOS configuration and set up the alc_spec */ 2919 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */ 2920 static int ad1988_parse_auto_config(struct hda_codec *codec) 2921 { 2922 struct ad198x_spec *spec = codec->spec; 2923 int err; 2924 2925 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0) 2926 return err; 2927 if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0) 2928 return err; 2929 if (! spec->autocfg.line_outs) 2930 return 0; /* can't find valid BIOS pin config */ 2931 if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 || 2932 (err = ad1988_auto_create_extra_out(codec, 2933 spec->autocfg.speaker_pins[0], 2934 "Speaker")) < 0 || 2935 (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0], 2936 "Headphone")) < 0 || 2937 (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0) 2938 return err; 2939 2940 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 2941 2942 if (spec->autocfg.dig_outs) 2943 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT; 2944 if (spec->autocfg.dig_in_pin) 2945 spec->dig_in_nid = AD1988_SPDIF_IN; 2946 2947 if (spec->kctls.list) 2948 spec->mixers[spec->num_mixers++] = spec->kctls.list; 2949 2950 spec->init_verbs[spec->num_init_verbs++] = ad1988_6stack_init_verbs; 2951 2952 spec->input_mux = &spec->private_imux; 2953 2954 return 1; 2955 } 2956 2957 /* init callback for auto-configuration model -- overriding the default init */ 2958 static int ad1988_auto_init(struct hda_codec *codec) 2959 { 2960 ad198x_init(codec); 2961 ad1988_auto_init_multi_out(codec); 2962 ad1988_auto_init_extra_out(codec); 2963 ad1988_auto_init_analog_input(codec); 2964 return 0; 2965 } 2966 2967 2968 /* 2969 */ 2970 2971 static const char *ad1988_models[AD1988_MODEL_LAST] = { 2972 [AD1988_6STACK] = "6stack", 2973 [AD1988_6STACK_DIG] = "6stack-dig", 2974 [AD1988_3STACK] = "3stack", 2975 [AD1988_3STACK_DIG] = "3stack-dig", 2976 [AD1988_LAPTOP] = "laptop", 2977 [AD1988_LAPTOP_DIG] = "laptop-dig", 2978 [AD1988_AUTO] = "auto", 2979 }; 2980 2981 static struct snd_pci_quirk ad1988_cfg_tbl[] = { 2982 SND_PCI_QUIRK(0x1043, 0x81ec, "Asus P5B-DLX", AD1988_6STACK_DIG), 2983 SND_PCI_QUIRK(0x1043, 0x81f6, "Asus M2N-SLI", AD1988_6STACK_DIG), 2984 SND_PCI_QUIRK(0x1043, 0x8277, "Asus P5K-E/WIFI-AP", AD1988_6STACK_DIG), 2985 SND_PCI_QUIRK(0x1043, 0x8311, "Asus P5Q-Premium/Pro", AD1988_6STACK_DIG), 2986 {} 2987 }; 2988 2989 static int patch_ad1988(struct hda_codec *codec) 2990 { 2991 struct ad198x_spec *spec; 2992 int err, board_config; 2993 2994 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 2995 if (spec == NULL) 2996 return -ENOMEM; 2997 2998 codec->spec = spec; 2999 3000 if (is_rev2(codec)) 3001 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n"); 3002 3003 board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST, 3004 ad1988_models, ad1988_cfg_tbl); 3005 if (board_config < 0) { 3006 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 3007 codec->chip_name); 3008 board_config = AD1988_AUTO; 3009 } 3010 3011 if (board_config == AD1988_AUTO) { 3012 /* automatic parse from the BIOS config */ 3013 err = ad1988_parse_auto_config(codec); 3014 if (err < 0) { 3015 ad198x_free(codec); 3016 return err; 3017 } else if (! err) { 3018 printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS. Using 6-stack mode...\n"); 3019 board_config = AD1988_6STACK; 3020 } 3021 } 3022 3023 err = snd_hda_attach_beep_device(codec, 0x10); 3024 if (err < 0) { 3025 ad198x_free(codec); 3026 return err; 3027 } 3028 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT); 3029 3030 switch (board_config) { 3031 case AD1988_6STACK: 3032 case AD1988_6STACK_DIG: 3033 spec->multiout.max_channels = 8; 3034 spec->multiout.num_dacs = 4; 3035 if (is_rev2(codec)) 3036 spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2; 3037 else 3038 spec->multiout.dac_nids = ad1988_6stack_dac_nids; 3039 spec->input_mux = &ad1988_6stack_capture_source; 3040 spec->num_mixers = 2; 3041 if (is_rev2(codec)) 3042 spec->mixers[0] = ad1988_6stack_mixers1_rev2; 3043 else 3044 spec->mixers[0] = ad1988_6stack_mixers1; 3045 spec->mixers[1] = ad1988_6stack_mixers2; 3046 spec->num_init_verbs = 1; 3047 spec->init_verbs[0] = ad1988_6stack_init_verbs; 3048 if (board_config == AD1988_6STACK_DIG) { 3049 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT; 3050 spec->dig_in_nid = AD1988_SPDIF_IN; 3051 } 3052 break; 3053 case AD1988_3STACK: 3054 case AD1988_3STACK_DIG: 3055 spec->multiout.max_channels = 6; 3056 spec->multiout.num_dacs = 3; 3057 if (is_rev2(codec)) 3058 spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2; 3059 else 3060 spec->multiout.dac_nids = ad1988_3stack_dac_nids; 3061 spec->input_mux = &ad1988_6stack_capture_source; 3062 spec->channel_mode = ad1988_3stack_modes; 3063 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes); 3064 spec->num_mixers = 2; 3065 if (is_rev2(codec)) 3066 spec->mixers[0] = ad1988_3stack_mixers1_rev2; 3067 else 3068 spec->mixers[0] = ad1988_3stack_mixers1; 3069 spec->mixers[1] = ad1988_3stack_mixers2; 3070 spec->num_init_verbs = 1; 3071 spec->init_verbs[0] = ad1988_3stack_init_verbs; 3072 if (board_config == AD1988_3STACK_DIG) 3073 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT; 3074 break; 3075 case AD1988_LAPTOP: 3076 case AD1988_LAPTOP_DIG: 3077 spec->multiout.max_channels = 2; 3078 spec->multiout.num_dacs = 1; 3079 spec->multiout.dac_nids = ad1988_3stack_dac_nids; 3080 spec->input_mux = &ad1988_laptop_capture_source; 3081 spec->num_mixers = 1; 3082 spec->mixers[0] = ad1988_laptop_mixers; 3083 spec->inv_eapd = 1; /* inverted EAPD */ 3084 spec->num_init_verbs = 1; 3085 spec->init_verbs[0] = ad1988_laptop_init_verbs; 3086 if (board_config == AD1988_LAPTOP_DIG) 3087 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT; 3088 break; 3089 } 3090 3091 spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids); 3092 spec->adc_nids = ad1988_adc_nids; 3093 spec->capsrc_nids = ad1988_capsrc_nids; 3094 spec->mixers[spec->num_mixers++] = ad1988_capture_mixers; 3095 spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs; 3096 if (spec->multiout.dig_out_nid) { 3097 if (codec->vendor_id >= 0x11d4989a) { 3098 spec->mixers[spec->num_mixers++] = 3099 ad1989_spdif_out_mixers; 3100 spec->init_verbs[spec->num_init_verbs++] = 3101 ad1989_spdif_init_verbs; 3102 codec->slave_dig_outs = ad1989b_slave_dig_outs; 3103 } else { 3104 spec->mixers[spec->num_mixers++] = 3105 ad1988_spdif_out_mixers; 3106 spec->init_verbs[spec->num_init_verbs++] = 3107 ad1988_spdif_init_verbs; 3108 } 3109 } 3110 if (spec->dig_in_nid && codec->vendor_id < 0x11d4989a) 3111 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers; 3112 3113 codec->patch_ops = ad198x_patch_ops; 3114 switch (board_config) { 3115 case AD1988_AUTO: 3116 codec->patch_ops.init = ad1988_auto_init; 3117 break; 3118 case AD1988_LAPTOP: 3119 case AD1988_LAPTOP_DIG: 3120 codec->patch_ops.unsol_event = ad1988_laptop_unsol_event; 3121 break; 3122 } 3123 #ifdef CONFIG_SND_HDA_POWER_SAVE 3124 spec->loopback.amplist = ad1988_loopbacks; 3125 #endif 3126 spec->vmaster_nid = 0x04; 3127 3128 codec->no_trigger_sense = 1; 3129 3130 return 0; 3131 } 3132 3133 3134 /* 3135 * AD1884 / AD1984 3136 * 3137 * port-B - front line/mic-in 3138 * port-E - aux in/out 3139 * port-F - aux in/out 3140 * port-C - rear line/mic-in 3141 * port-D - rear line/hp-out 3142 * port-A - front line/hp-out 3143 * 3144 * AD1984 = AD1884 + two digital mic-ins 3145 * 3146 * FIXME: 3147 * For simplicity, we share the single DAC for both HP and line-outs 3148 * right now. The inidividual playbacks could be easily implemented, 3149 * but no build-up framework is given, so far. 3150 */ 3151 3152 static hda_nid_t ad1884_dac_nids[1] = { 3153 0x04, 3154 }; 3155 3156 static hda_nid_t ad1884_adc_nids[2] = { 3157 0x08, 0x09, 3158 }; 3159 3160 static hda_nid_t ad1884_capsrc_nids[2] = { 3161 0x0c, 0x0d, 3162 }; 3163 3164 #define AD1884_SPDIF_OUT 0x02 3165 3166 static struct hda_input_mux ad1884_capture_source = { 3167 .num_items = 4, 3168 .items = { 3169 { "Front Mic", 0x0 }, 3170 { "Mic", 0x1 }, 3171 { "CD", 0x2 }, 3172 { "Mix", 0x3 }, 3173 }, 3174 }; 3175 3176 static struct snd_kcontrol_new ad1884_base_mixers[] = { 3177 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT), 3178 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */ 3179 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT), 3180 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT), 3181 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT), 3182 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT), 3183 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT), 3184 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT), 3185 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT), 3186 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT), 3187 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT), 3188 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT), 3189 HDA_CODEC_VOLUME("Mic Boost", 0x15, 0x0, HDA_INPUT), 3190 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT), 3191 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 3192 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 3193 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT), 3194 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT), 3195 { 3196 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3197 /* The multiple "Capture Source" controls confuse alsamixer 3198 * So call somewhat different.. 3199 */ 3200 /* .name = "Capture Source", */ 3201 .name = "Input Source", 3202 .count = 2, 3203 .info = ad198x_mux_enum_info, 3204 .get = ad198x_mux_enum_get, 3205 .put = ad198x_mux_enum_put, 3206 }, 3207 /* SPDIF controls */ 3208 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT), 3209 { 3210 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3211 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 3212 /* identical with ad1983 */ 3213 .info = ad1983_spdif_route_info, 3214 .get = ad1983_spdif_route_get, 3215 .put = ad1983_spdif_route_put, 3216 }, 3217 { } /* end */ 3218 }; 3219 3220 static struct snd_kcontrol_new ad1984_dmic_mixers[] = { 3221 HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x05, 0x0, HDA_INPUT), 3222 HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x05, 0x0, HDA_INPUT), 3223 HDA_CODEC_VOLUME_IDX("Digital Mic Capture Volume", 1, 0x06, 0x0, 3224 HDA_INPUT), 3225 HDA_CODEC_MUTE_IDX("Digital Mic Capture Switch", 1, 0x06, 0x0, 3226 HDA_INPUT), 3227 { } /* end */ 3228 }; 3229 3230 /* 3231 * initialization verbs 3232 */ 3233 static struct hda_verb ad1884_init_verbs[] = { 3234 /* DACs; mute as default */ 3235 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3236 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3237 /* Port-A (HP) mixer */ 3238 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3239 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3240 /* Port-A pin */ 3241 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3242 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3243 /* HP selector - select DAC2 */ 3244 {0x22, AC_VERB_SET_CONNECT_SEL, 0x1}, 3245 /* Port-D (Line-out) mixer */ 3246 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3247 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3248 /* Port-D pin */ 3249 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3250 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3251 /* Mono-out mixer */ 3252 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3253 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3254 /* Mono-out pin */ 3255 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3256 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3257 /* Mono selector */ 3258 {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1}, 3259 /* Port-B (front mic) pin */ 3260 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3261 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3262 /* Port-C (rear mic) pin */ 3263 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3264 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3265 /* Analog mixer; mute as default */ 3266 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3267 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3268 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 3269 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 3270 /* Analog Mix output amp */ 3271 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */ 3272 /* SPDIF output selector */ 3273 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */ 3274 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */ 3275 { } /* end */ 3276 }; 3277 3278 #ifdef CONFIG_SND_HDA_POWER_SAVE 3279 static struct hda_amp_list ad1884_loopbacks[] = { 3280 { 0x20, HDA_INPUT, 0 }, /* Front Mic */ 3281 { 0x20, HDA_INPUT, 1 }, /* Mic */ 3282 { 0x20, HDA_INPUT, 2 }, /* CD */ 3283 { 0x20, HDA_INPUT, 4 }, /* Docking */ 3284 { } /* end */ 3285 }; 3286 #endif 3287 3288 static const char *ad1884_slave_vols[] = { 3289 "PCM Playback Volume", 3290 "Mic Playback Volume", 3291 "Mono Playback Volume", 3292 "Front Mic Playback Volume", 3293 "Mic Playback Volume", 3294 "CD Playback Volume", 3295 "Internal Mic Playback Volume", 3296 "Docking Mic Playback Volume", 3297 /* "Beep Playback Volume", */ 3298 "IEC958 Playback Volume", 3299 NULL 3300 }; 3301 3302 static int patch_ad1884(struct hda_codec *codec) 3303 { 3304 struct ad198x_spec *spec; 3305 int err; 3306 3307 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3308 if (spec == NULL) 3309 return -ENOMEM; 3310 3311 codec->spec = spec; 3312 3313 err = snd_hda_attach_beep_device(codec, 0x10); 3314 if (err < 0) { 3315 ad198x_free(codec); 3316 return err; 3317 } 3318 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT); 3319 3320 spec->multiout.max_channels = 2; 3321 spec->multiout.num_dacs = ARRAY_SIZE(ad1884_dac_nids); 3322 spec->multiout.dac_nids = ad1884_dac_nids; 3323 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT; 3324 spec->num_adc_nids = ARRAY_SIZE(ad1884_adc_nids); 3325 spec->adc_nids = ad1884_adc_nids; 3326 spec->capsrc_nids = ad1884_capsrc_nids; 3327 spec->input_mux = &ad1884_capture_source; 3328 spec->num_mixers = 1; 3329 spec->mixers[0] = ad1884_base_mixers; 3330 spec->num_init_verbs = 1; 3331 spec->init_verbs[0] = ad1884_init_verbs; 3332 spec->spdif_route = 0; 3333 #ifdef CONFIG_SND_HDA_POWER_SAVE 3334 spec->loopback.amplist = ad1884_loopbacks; 3335 #endif 3336 spec->vmaster_nid = 0x04; 3337 /* we need to cover all playback volumes */ 3338 spec->slave_vols = ad1884_slave_vols; 3339 3340 codec->patch_ops = ad198x_patch_ops; 3341 3342 codec->no_trigger_sense = 1; 3343 3344 return 0; 3345 } 3346 3347 /* 3348 * Lenovo Thinkpad T61/X61 3349 */ 3350 static struct hda_input_mux ad1984_thinkpad_capture_source = { 3351 .num_items = 4, 3352 .items = { 3353 { "Mic", 0x0 }, 3354 { "Internal Mic", 0x1 }, 3355 { "Mix", 0x3 }, 3356 { "Docking-Station", 0x4 }, 3357 }, 3358 }; 3359 3360 3361 /* 3362 * Dell Precision T3400 3363 */ 3364 static struct hda_input_mux ad1984_dell_desktop_capture_source = { 3365 .num_items = 3, 3366 .items = { 3367 { "Front Mic", 0x0 }, 3368 { "Line-In", 0x1 }, 3369 { "Mix", 0x3 }, 3370 }, 3371 }; 3372 3373 3374 static struct snd_kcontrol_new ad1984_thinkpad_mixers[] = { 3375 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT), 3376 /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */ 3377 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT), 3378 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT), 3379 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT), 3380 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT), 3381 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT), 3382 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT), 3383 HDA_CODEC_VOLUME("Docking Mic Playback Volume", 0x20, 0x04, HDA_INPUT), 3384 HDA_CODEC_MUTE("Docking Mic Playback Switch", 0x20, 0x04, HDA_INPUT), 3385 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT), 3386 HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT), 3387 HDA_CODEC_VOLUME("Docking Mic Boost", 0x25, 0x0, HDA_OUTPUT), 3388 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 3389 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 3390 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT), 3391 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT), 3392 { 3393 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3394 /* The multiple "Capture Source" controls confuse alsamixer 3395 * So call somewhat different.. 3396 */ 3397 /* .name = "Capture Source", */ 3398 .name = "Input Source", 3399 .count = 2, 3400 .info = ad198x_mux_enum_info, 3401 .get = ad198x_mux_enum_get, 3402 .put = ad198x_mux_enum_put, 3403 }, 3404 /* SPDIF controls */ 3405 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT), 3406 { 3407 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3408 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 3409 /* identical with ad1983 */ 3410 .info = ad1983_spdif_route_info, 3411 .get = ad1983_spdif_route_get, 3412 .put = ad1983_spdif_route_put, 3413 }, 3414 { } /* end */ 3415 }; 3416 3417 /* additional verbs */ 3418 static struct hda_verb ad1984_thinkpad_init_verbs[] = { 3419 /* Port-E (docking station mic) pin */ 3420 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3421 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3422 /* docking mic boost */ 3423 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 3424 /* Analog mixer - docking mic; mute as default */ 3425 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 3426 /* enable EAPD bit */ 3427 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 3428 { } /* end */ 3429 }; 3430 3431 /* 3432 * Dell Precision T3400 3433 */ 3434 static struct snd_kcontrol_new ad1984_dell_desktop_mixers[] = { 3435 HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT), 3436 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT), 3437 HDA_CODEC_MUTE("Speaker Playback Switch", 0x12, 0x0, HDA_OUTPUT), 3438 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT), 3439 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT), 3440 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT), 3441 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT), 3442 HDA_CODEC_VOLUME("Line-In Playback Volume", 0x20, 0x01, HDA_INPUT), 3443 HDA_CODEC_MUTE("Line-In Playback Switch", 0x20, 0x01, HDA_INPUT), 3444 HDA_CODEC_VOLUME("Line-In Boost", 0x15, 0x0, HDA_INPUT), 3445 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT), 3446 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 3447 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 3448 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT), 3449 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT), 3450 { 3451 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3452 /* The multiple "Capture Source" controls confuse alsamixer 3453 * So call somewhat different.. 3454 */ 3455 /* .name = "Capture Source", */ 3456 .name = "Input Source", 3457 .count = 2, 3458 .info = ad198x_mux_enum_info, 3459 .get = ad198x_mux_enum_get, 3460 .put = ad198x_mux_enum_put, 3461 }, 3462 { } /* end */ 3463 }; 3464 3465 /* Digial MIC ADC NID 0x05 + 0x06 */ 3466 static int ad1984_pcm_dmic_prepare(struct hda_pcm_stream *hinfo, 3467 struct hda_codec *codec, 3468 unsigned int stream_tag, 3469 unsigned int format, 3470 struct snd_pcm_substream *substream) 3471 { 3472 snd_hda_codec_setup_stream(codec, 0x05 + substream->number, 3473 stream_tag, 0, format); 3474 return 0; 3475 } 3476 3477 static int ad1984_pcm_dmic_cleanup(struct hda_pcm_stream *hinfo, 3478 struct hda_codec *codec, 3479 struct snd_pcm_substream *substream) 3480 { 3481 snd_hda_codec_cleanup_stream(codec, 0x05 + substream->number); 3482 return 0; 3483 } 3484 3485 static struct hda_pcm_stream ad1984_pcm_dmic_capture = { 3486 .substreams = 2, 3487 .channels_min = 2, 3488 .channels_max = 2, 3489 .nid = 0x05, 3490 .ops = { 3491 .prepare = ad1984_pcm_dmic_prepare, 3492 .cleanup = ad1984_pcm_dmic_cleanup 3493 }, 3494 }; 3495 3496 static int ad1984_build_pcms(struct hda_codec *codec) 3497 { 3498 struct ad198x_spec *spec = codec->spec; 3499 struct hda_pcm *info; 3500 int err; 3501 3502 err = ad198x_build_pcms(codec); 3503 if (err < 0) 3504 return err; 3505 3506 info = spec->pcm_rec + codec->num_pcms; 3507 codec->num_pcms++; 3508 info->name = "AD1984 Digital Mic"; 3509 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad1984_pcm_dmic_capture; 3510 return 0; 3511 } 3512 3513 /* models */ 3514 enum { 3515 AD1984_BASIC, 3516 AD1984_THINKPAD, 3517 AD1984_DELL_DESKTOP, 3518 AD1984_MODELS 3519 }; 3520 3521 static const char *ad1984_models[AD1984_MODELS] = { 3522 [AD1984_BASIC] = "basic", 3523 [AD1984_THINKPAD] = "thinkpad", 3524 [AD1984_DELL_DESKTOP] = "dell_desktop", 3525 }; 3526 3527 static struct snd_pci_quirk ad1984_cfg_tbl[] = { 3528 /* Lenovo Thinkpad T61/X61 */ 3529 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1984_THINKPAD), 3530 SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP), 3531 {} 3532 }; 3533 3534 static int patch_ad1984(struct hda_codec *codec) 3535 { 3536 struct ad198x_spec *spec; 3537 int board_config, err; 3538 3539 err = patch_ad1884(codec); 3540 if (err < 0) 3541 return err; 3542 spec = codec->spec; 3543 board_config = snd_hda_check_board_config(codec, AD1984_MODELS, 3544 ad1984_models, ad1984_cfg_tbl); 3545 switch (board_config) { 3546 case AD1984_BASIC: 3547 /* additional digital mics */ 3548 spec->mixers[spec->num_mixers++] = ad1984_dmic_mixers; 3549 codec->patch_ops.build_pcms = ad1984_build_pcms; 3550 break; 3551 case AD1984_THINKPAD: 3552 spec->multiout.dig_out_nid = AD1884_SPDIF_OUT; 3553 spec->input_mux = &ad1984_thinkpad_capture_source; 3554 spec->mixers[0] = ad1984_thinkpad_mixers; 3555 spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs; 3556 break; 3557 case AD1984_DELL_DESKTOP: 3558 spec->multiout.dig_out_nid = 0; 3559 spec->input_mux = &ad1984_dell_desktop_capture_source; 3560 spec->mixers[0] = ad1984_dell_desktop_mixers; 3561 break; 3562 } 3563 return 0; 3564 } 3565 3566 3567 /* 3568 * AD1883 / AD1884A / AD1984A / AD1984B 3569 * 3570 * port-B (0x14) - front mic-in 3571 * port-E (0x1c) - rear mic-in 3572 * port-F (0x16) - CD / ext out 3573 * port-C (0x15) - rear line-in 3574 * port-D (0x12) - rear line-out 3575 * port-A (0x11) - front hp-out 3576 * 3577 * AD1984A = AD1884A + digital-mic 3578 * AD1883 = equivalent with AD1984A 3579 * AD1984B = AD1984A + extra SPDIF-out 3580 * 3581 * FIXME: 3582 * We share the single DAC for both HP and line-outs (see AD1884/1984). 3583 */ 3584 3585 static hda_nid_t ad1884a_dac_nids[1] = { 3586 0x03, 3587 }; 3588 3589 #define ad1884a_adc_nids ad1884_adc_nids 3590 #define ad1884a_capsrc_nids ad1884_capsrc_nids 3591 3592 #define AD1884A_SPDIF_OUT 0x02 3593 3594 static struct hda_input_mux ad1884a_capture_source = { 3595 .num_items = 5, 3596 .items = { 3597 { "Front Mic", 0x0 }, 3598 { "Mic", 0x4 }, 3599 { "Line", 0x1 }, 3600 { "CD", 0x2 }, 3601 { "Mix", 0x3 }, 3602 }, 3603 }; 3604 3605 static struct snd_kcontrol_new ad1884a_base_mixers[] = { 3606 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT), 3607 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT), 3608 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT), 3609 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT), 3610 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT), 3611 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT), 3612 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT), 3613 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT), 3614 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT), 3615 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT), 3616 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT), 3617 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT), 3618 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT), 3619 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT), 3620 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT), 3621 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT), 3622 HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT), 3623 HDA_CODEC_VOLUME("Line Boost", 0x15, 0x0, HDA_INPUT), 3624 HDA_CODEC_VOLUME("Mic Boost", 0x25, 0x0, HDA_OUTPUT), 3625 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 3626 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 3627 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT), 3628 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT), 3629 { 3630 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3631 /* The multiple "Capture Source" controls confuse alsamixer 3632 * So call somewhat different.. 3633 */ 3634 /* .name = "Capture Source", */ 3635 .name = "Input Source", 3636 .count = 2, 3637 .info = ad198x_mux_enum_info, 3638 .get = ad198x_mux_enum_get, 3639 .put = ad198x_mux_enum_put, 3640 }, 3641 /* SPDIF controls */ 3642 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT), 3643 { 3644 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3645 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 3646 /* identical with ad1983 */ 3647 .info = ad1983_spdif_route_info, 3648 .get = ad1983_spdif_route_get, 3649 .put = ad1983_spdif_route_put, 3650 }, 3651 { } /* end */ 3652 }; 3653 3654 /* 3655 * initialization verbs 3656 */ 3657 static struct hda_verb ad1884a_init_verbs[] = { 3658 /* DACs; unmute as default */ 3659 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */ 3660 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */ 3661 /* Port-A (HP) mixer - route only from analog mixer */ 3662 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3663 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3664 /* Port-A pin */ 3665 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3666 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3667 /* Port-D (Line-out) mixer - route only from analog mixer */ 3668 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3669 {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3670 /* Port-D pin */ 3671 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3672 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3673 /* Mono-out mixer - route only from analog mixer */ 3674 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3675 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3676 /* Mono-out pin */ 3677 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3678 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3679 /* Port-B (front mic) pin */ 3680 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3681 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3682 /* Port-C (rear line-in) pin */ 3683 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3684 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 3685 /* Port-E (rear mic) pin */ 3686 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3687 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3688 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* no boost */ 3689 /* Port-F (CD) pin */ 3690 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3691 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3692 /* Analog mixer; mute as default */ 3693 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3694 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3695 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 3696 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 3697 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)}, /* aux */ 3698 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 3699 /* Analog Mix output amp */ 3700 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3701 /* capture sources */ 3702 {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, 3703 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3704 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0}, 3705 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3706 /* SPDIF output amp */ 3707 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */ 3708 { } /* end */ 3709 }; 3710 3711 #ifdef CONFIG_SND_HDA_POWER_SAVE 3712 static struct hda_amp_list ad1884a_loopbacks[] = { 3713 { 0x20, HDA_INPUT, 0 }, /* Front Mic */ 3714 { 0x20, HDA_INPUT, 1 }, /* Mic */ 3715 { 0x20, HDA_INPUT, 2 }, /* CD */ 3716 { 0x20, HDA_INPUT, 4 }, /* Docking */ 3717 { } /* end */ 3718 }; 3719 #endif 3720 3721 /* 3722 * Laptop model 3723 * 3724 * Port A: Headphone jack 3725 * Port B: MIC jack 3726 * Port C: Internal MIC 3727 * Port D: Dock Line Out (if enabled) 3728 * Port E: Dock Line In (if enabled) 3729 * Port F: Internal speakers 3730 */ 3731 3732 static int ad1884a_mobile_master_sw_put(struct snd_kcontrol *kcontrol, 3733 struct snd_ctl_elem_value *ucontrol) 3734 { 3735 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3736 int ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 3737 int mute = (!ucontrol->value.integer.value[0] && 3738 !ucontrol->value.integer.value[1]); 3739 /* toggle GPIO1 according to the mute state */ 3740 snd_hda_codec_write_cache(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 3741 mute ? 0x02 : 0x0); 3742 return ret; 3743 } 3744 3745 static struct snd_kcontrol_new ad1884a_laptop_mixers[] = { 3746 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT), 3747 { 3748 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3749 .name = "Master Playback Switch", 3750 .info = snd_hda_mixer_amp_switch_info, 3751 .get = snd_hda_mixer_amp_switch_get, 3752 .put = ad1884a_mobile_master_sw_put, 3753 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT), 3754 }, 3755 HDA_CODEC_MUTE("Dock Playback Switch", 0x12, 0x0, HDA_OUTPUT), 3756 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT), 3757 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT), 3758 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT), 3759 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT), 3760 HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x20, 0x01, HDA_INPUT), 3761 HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT), 3762 HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x20, 0x04, HDA_INPUT), 3763 HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x20, 0x04, HDA_INPUT), 3764 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT), 3765 HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT), 3766 HDA_CODEC_VOLUME("Dock Mic Boost", 0x25, 0x0, HDA_OUTPUT), 3767 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 3768 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 3769 { } /* end */ 3770 }; 3771 3772 static struct snd_kcontrol_new ad1884a_mobile_mixers[] = { 3773 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT), 3774 /*HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),*/ 3775 { 3776 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3777 .name = "Master Playback Switch", 3778 .info = snd_hda_mixer_amp_switch_info, 3779 .get = snd_hda_mixer_amp_switch_get, 3780 .put = ad1884a_mobile_master_sw_put, 3781 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT), 3782 }, 3783 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT), 3784 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT), 3785 HDA_CODEC_VOLUME("Mic Capture Volume", 0x14, 0x0, HDA_INPUT), 3786 HDA_CODEC_VOLUME("Internal Mic Capture Volume", 0x15, 0x0, HDA_INPUT), 3787 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 3788 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 3789 { } /* end */ 3790 }; 3791 3792 /* mute internal speaker if HP is plugged */ 3793 static void ad1884a_hp_automute(struct hda_codec *codec) 3794 { 3795 unsigned int present; 3796 3797 present = snd_hda_jack_detect(codec, 0x11); 3798 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 3799 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 3800 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE, 3801 present ? 0x00 : 0x02); 3802 } 3803 3804 /* switch to external mic if plugged */ 3805 static void ad1884a_hp_automic(struct hda_codec *codec) 3806 { 3807 unsigned int present; 3808 3809 present = snd_hda_jack_detect(codec, 0x14); 3810 snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL, 3811 present ? 0 : 1); 3812 } 3813 3814 #define AD1884A_HP_EVENT 0x37 3815 #define AD1884A_MIC_EVENT 0x36 3816 3817 /* unsolicited event for HP jack sensing */ 3818 static void ad1884a_hp_unsol_event(struct hda_codec *codec, unsigned int res) 3819 { 3820 switch (res >> 26) { 3821 case AD1884A_HP_EVENT: 3822 ad1884a_hp_automute(codec); 3823 break; 3824 case AD1884A_MIC_EVENT: 3825 ad1884a_hp_automic(codec); 3826 break; 3827 } 3828 } 3829 3830 /* initialize jack-sensing, too */ 3831 static int ad1884a_hp_init(struct hda_codec *codec) 3832 { 3833 ad198x_init(codec); 3834 ad1884a_hp_automute(codec); 3835 ad1884a_hp_automic(codec); 3836 return 0; 3837 } 3838 3839 /* mute internal speaker if HP or docking HP is plugged */ 3840 static void ad1884a_laptop_automute(struct hda_codec *codec) 3841 { 3842 unsigned int present; 3843 3844 present = snd_hda_jack_detect(codec, 0x11); 3845 if (!present) 3846 present = snd_hda_jack_detect(codec, 0x12); 3847 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0, 3848 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 3849 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_EAPD_BTLENABLE, 3850 present ? 0x00 : 0x02); 3851 } 3852 3853 /* switch to external mic if plugged */ 3854 static void ad1884a_laptop_automic(struct hda_codec *codec) 3855 { 3856 unsigned int idx; 3857 3858 if (snd_hda_jack_detect(codec, 0x14)) 3859 idx = 0; 3860 else if (snd_hda_jack_detect(codec, 0x1c)) 3861 idx = 4; 3862 else 3863 idx = 1; 3864 snd_hda_codec_write(codec, 0x0c, 0, AC_VERB_SET_CONNECT_SEL, idx); 3865 } 3866 3867 /* unsolicited event for HP jack sensing */ 3868 static void ad1884a_laptop_unsol_event(struct hda_codec *codec, 3869 unsigned int res) 3870 { 3871 switch (res >> 26) { 3872 case AD1884A_HP_EVENT: 3873 ad1884a_laptop_automute(codec); 3874 break; 3875 case AD1884A_MIC_EVENT: 3876 ad1884a_laptop_automic(codec); 3877 break; 3878 } 3879 } 3880 3881 /* initialize jack-sensing, too */ 3882 static int ad1884a_laptop_init(struct hda_codec *codec) 3883 { 3884 ad198x_init(codec); 3885 ad1884a_laptop_automute(codec); 3886 ad1884a_laptop_automic(codec); 3887 return 0; 3888 } 3889 3890 /* additional verbs for laptop model */ 3891 static struct hda_verb ad1884a_laptop_verbs[] = { 3892 /* Port-A (HP) pin - always unmuted */ 3893 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3894 /* Port-F (int speaker) mixer - route only from analog mixer */ 3895 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3896 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3897 /* Port-F (int speaker) pin */ 3898 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3899 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3900 /* required for compaq 6530s/6531s speaker output */ 3901 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 3902 /* Port-C pin - internal mic-in */ 3903 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3904 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */ 3905 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */ 3906 /* Port-D (docking line-out) pin - default unmuted */ 3907 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3908 /* analog mix */ 3909 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 3910 /* unsolicited event for pin-sense */ 3911 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT}, 3912 {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT}, 3913 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT}, 3914 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT}, 3915 /* allow to touch GPIO1 (for mute control) */ 3916 {0x01, AC_VERB_SET_GPIO_MASK, 0x02}, 3917 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02}, 3918 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */ 3919 { } /* end */ 3920 }; 3921 3922 static struct hda_verb ad1884a_mobile_verbs[] = { 3923 /* DACs; unmute as default */ 3924 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */ 3925 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */ 3926 /* Port-A (HP) mixer - route only from analog mixer */ 3927 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3928 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3929 /* Port-A pin */ 3930 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3931 /* Port-A (HP) pin - always unmuted */ 3932 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3933 /* Port-B (mic jack) pin */ 3934 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3935 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */ 3936 /* Port-C (int mic) pin */ 3937 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 3938 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x7002}, /* raise mic as default */ 3939 /* Port-F (int speaker) mixer - route only from analog mixer */ 3940 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3941 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 3942 /* Port-F pin */ 3943 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 3944 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3945 /* Analog mixer; mute as default */ 3946 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 3947 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 3948 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 3949 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 3950 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 3951 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 3952 /* Analog Mix output amp */ 3953 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3954 /* capture sources */ 3955 /* {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, */ /* set via unsol */ 3956 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3957 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0}, 3958 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 3959 /* unsolicited event for pin-sense */ 3960 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT}, 3961 {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT}, 3962 /* allow to touch GPIO1 (for mute control) */ 3963 {0x01, AC_VERB_SET_GPIO_MASK, 0x02}, 3964 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02}, 3965 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */ 3966 { } /* end */ 3967 }; 3968 3969 /* 3970 * Thinkpad X300 3971 * 0x11 - HP 3972 * 0x12 - speaker 3973 * 0x14 - mic-in 3974 * 0x17 - built-in mic 3975 */ 3976 3977 static struct hda_verb ad1984a_thinkpad_verbs[] = { 3978 /* HP unmute */ 3979 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 3980 /* analog mix */ 3981 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 3982 /* turn on EAPD */ 3983 {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 3984 /* unsolicited event for pin-sense */ 3985 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT}, 3986 /* internal mic - dmic */ 3987 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 3988 /* set magic COEFs for dmic */ 3989 {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7}, 3990 {0x01, AC_VERB_SET_PROC_COEF, 0x08}, 3991 { } /* end */ 3992 }; 3993 3994 static struct snd_kcontrol_new ad1984a_thinkpad_mixers[] = { 3995 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT), 3996 HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT), 3997 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT), 3998 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT), 3999 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT), 4000 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT), 4001 HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT), 4002 HDA_CODEC_VOLUME("Internal Mic Boost", 0x17, 0x0, HDA_INPUT), 4003 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 4004 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 4005 { 4006 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4007 .name = "Capture Source", 4008 .info = ad198x_mux_enum_info, 4009 .get = ad198x_mux_enum_get, 4010 .put = ad198x_mux_enum_put, 4011 }, 4012 { } /* end */ 4013 }; 4014 4015 static struct hda_input_mux ad1984a_thinkpad_capture_source = { 4016 .num_items = 3, 4017 .items = { 4018 { "Mic", 0x0 }, 4019 { "Internal Mic", 0x5 }, 4020 { "Mix", 0x3 }, 4021 }, 4022 }; 4023 4024 /* mute internal speaker if HP is plugged */ 4025 static void ad1984a_thinkpad_automute(struct hda_codec *codec) 4026 { 4027 unsigned int present; 4028 4029 present = snd_hda_jack_detect(codec, 0x11); 4030 snd_hda_codec_amp_stereo(codec, 0x12, HDA_OUTPUT, 0, 4031 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0); 4032 } 4033 4034 /* unsolicited event for HP jack sensing */ 4035 static void ad1984a_thinkpad_unsol_event(struct hda_codec *codec, 4036 unsigned int res) 4037 { 4038 if ((res >> 26) != AD1884A_HP_EVENT) 4039 return; 4040 ad1984a_thinkpad_automute(codec); 4041 } 4042 4043 /* initialize jack-sensing, too */ 4044 static int ad1984a_thinkpad_init(struct hda_codec *codec) 4045 { 4046 ad198x_init(codec); 4047 ad1984a_thinkpad_automute(codec); 4048 return 0; 4049 } 4050 4051 /* 4052 * HP Touchsmart 4053 * port-A (0x11) - front hp-out 4054 * port-B (0x14) - unused 4055 * port-C (0x15) - unused 4056 * port-D (0x12) - rear line out 4057 * port-E (0x1c) - front mic-in 4058 * port-F (0x16) - Internal speakers 4059 * digital-mic (0x17) - Internal mic 4060 */ 4061 4062 static struct hda_verb ad1984a_touchsmart_verbs[] = { 4063 /* DACs; unmute as default */ 4064 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */ 4065 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x27}, /* 0dB */ 4066 /* Port-A (HP) mixer - route only from analog mixer */ 4067 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4068 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 4069 /* Port-A pin */ 4070 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4071 /* Port-A (HP) pin - always unmuted */ 4072 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4073 /* Port-E (int speaker) mixer - route only from analog mixer */ 4074 {0x25, AC_VERB_SET_AMP_GAIN_MUTE, 0x03}, 4075 /* Port-E pin */ 4076 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4077 {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, 4078 {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4079 /* Port-F (int speaker) mixer - route only from analog mixer */ 4080 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4081 {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 4082 /* Port-F pin */ 4083 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4084 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4085 /* Analog mixer; mute as default */ 4086 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4087 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4088 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4089 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4090 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4091 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 4092 /* Analog Mix output amp */ 4093 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4094 /* capture sources */ 4095 /* {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0}, */ /* set via unsol */ 4096 {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4097 {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0}, 4098 {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4099 /* unsolicited event for pin-sense */ 4100 {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_HP_EVENT}, 4101 {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1884A_MIC_EVENT}, 4102 /* allow to touch GPIO1 (for mute control) */ 4103 {0x01, AC_VERB_SET_GPIO_MASK, 0x02}, 4104 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02}, 4105 {0x01, AC_VERB_SET_GPIO_DATA, 0x02}, /* first muted */ 4106 /* internal mic - dmic */ 4107 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4108 /* set magic COEFs for dmic */ 4109 {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7}, 4110 {0x01, AC_VERB_SET_PROC_COEF, 0x08}, 4111 { } /* end */ 4112 }; 4113 4114 static struct snd_kcontrol_new ad1984a_touchsmart_mixers[] = { 4115 HDA_CODEC_VOLUME("Master Playback Volume", 0x21, 0x0, HDA_OUTPUT), 4116 /* HDA_CODEC_MUTE("Master Playback Switch", 0x21, 0x0, HDA_OUTPUT),*/ 4117 { 4118 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4119 .name = "Master Playback Switch", 4120 .info = snd_hda_mixer_amp_switch_info, 4121 .get = snd_hda_mixer_amp_switch_get, 4122 .put = ad1884a_mobile_master_sw_put, 4123 .private_value = HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT), 4124 }, 4125 HDA_CODEC_VOLUME("PCM Playback Volume", 0x20, 0x5, HDA_INPUT), 4126 HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT), 4127 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 4128 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 4129 HDA_CODEC_VOLUME("Mic Boost", 0x25, 0x0, HDA_OUTPUT), 4130 HDA_CODEC_VOLUME("Internal Mic Boost", 0x17, 0x0, HDA_INPUT), 4131 { } /* end */ 4132 }; 4133 4134 /* switch to external mic if plugged */ 4135 static void ad1984a_touchsmart_automic(struct hda_codec *codec) 4136 { 4137 if (snd_hda_jack_detect(codec, 0x1c)) 4138 snd_hda_codec_write(codec, 0x0c, 0, 4139 AC_VERB_SET_CONNECT_SEL, 0x4); 4140 else 4141 snd_hda_codec_write(codec, 0x0c, 0, 4142 AC_VERB_SET_CONNECT_SEL, 0x5); 4143 } 4144 4145 4146 /* unsolicited event for HP jack sensing */ 4147 static void ad1984a_touchsmart_unsol_event(struct hda_codec *codec, 4148 unsigned int res) 4149 { 4150 switch (res >> 26) { 4151 case AD1884A_HP_EVENT: 4152 ad1884a_hp_automute(codec); 4153 break; 4154 case AD1884A_MIC_EVENT: 4155 ad1984a_touchsmart_automic(codec); 4156 break; 4157 } 4158 } 4159 4160 /* initialize jack-sensing, too */ 4161 static int ad1984a_touchsmart_init(struct hda_codec *codec) 4162 { 4163 ad198x_init(codec); 4164 ad1884a_hp_automute(codec); 4165 ad1984a_touchsmart_automic(codec); 4166 return 0; 4167 } 4168 4169 4170 /* 4171 */ 4172 4173 enum { 4174 AD1884A_DESKTOP, 4175 AD1884A_LAPTOP, 4176 AD1884A_MOBILE, 4177 AD1884A_THINKPAD, 4178 AD1984A_TOUCHSMART, 4179 AD1884A_MODELS 4180 }; 4181 4182 static const char *ad1884a_models[AD1884A_MODELS] = { 4183 [AD1884A_DESKTOP] = "desktop", 4184 [AD1884A_LAPTOP] = "laptop", 4185 [AD1884A_MOBILE] = "mobile", 4186 [AD1884A_THINKPAD] = "thinkpad", 4187 [AD1984A_TOUCHSMART] = "touchsmart", 4188 }; 4189 4190 static struct snd_pci_quirk ad1884a_cfg_tbl[] = { 4191 SND_PCI_QUIRK(0x103c, 0x3030, "HP", AD1884A_MOBILE), 4192 SND_PCI_QUIRK(0x103c, 0x3037, "HP 2230s", AD1884A_LAPTOP), 4193 SND_PCI_QUIRK(0x103c, 0x3056, "HP", AD1884A_MOBILE), 4194 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x3070, "HP", AD1884A_MOBILE), 4195 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30d0, "HP laptop", AD1884A_LAPTOP), 4196 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x30e0, "HP laptop", AD1884A_LAPTOP), 4197 SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3600, "HP laptop", AD1884A_LAPTOP), 4198 SND_PCI_QUIRK_MASK(0x103c, 0xfff0, 0x7010, "HP laptop", AD1884A_MOBILE), 4199 SND_PCI_QUIRK(0x17aa, 0x20ac, "Thinkpad X300", AD1884A_THINKPAD), 4200 SND_PCI_QUIRK(0x103c, 0x2a82, "Touchsmart", AD1984A_TOUCHSMART), 4201 {} 4202 }; 4203 4204 static int patch_ad1884a(struct hda_codec *codec) 4205 { 4206 struct ad198x_spec *spec; 4207 int err, board_config; 4208 4209 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 4210 if (spec == NULL) 4211 return -ENOMEM; 4212 4213 codec->spec = spec; 4214 4215 err = snd_hda_attach_beep_device(codec, 0x10); 4216 if (err < 0) { 4217 ad198x_free(codec); 4218 return err; 4219 } 4220 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT); 4221 4222 spec->multiout.max_channels = 2; 4223 spec->multiout.num_dacs = ARRAY_SIZE(ad1884a_dac_nids); 4224 spec->multiout.dac_nids = ad1884a_dac_nids; 4225 spec->multiout.dig_out_nid = AD1884A_SPDIF_OUT; 4226 spec->num_adc_nids = ARRAY_SIZE(ad1884a_adc_nids); 4227 spec->adc_nids = ad1884a_adc_nids; 4228 spec->capsrc_nids = ad1884a_capsrc_nids; 4229 spec->input_mux = &ad1884a_capture_source; 4230 spec->num_mixers = 1; 4231 spec->mixers[0] = ad1884a_base_mixers; 4232 spec->num_init_verbs = 1; 4233 spec->init_verbs[0] = ad1884a_init_verbs; 4234 spec->spdif_route = 0; 4235 #ifdef CONFIG_SND_HDA_POWER_SAVE 4236 spec->loopback.amplist = ad1884a_loopbacks; 4237 #endif 4238 codec->patch_ops = ad198x_patch_ops; 4239 4240 /* override some parameters */ 4241 board_config = snd_hda_check_board_config(codec, AD1884A_MODELS, 4242 ad1884a_models, 4243 ad1884a_cfg_tbl); 4244 switch (board_config) { 4245 case AD1884A_LAPTOP: 4246 spec->mixers[0] = ad1884a_laptop_mixers; 4247 spec->init_verbs[spec->num_init_verbs++] = ad1884a_laptop_verbs; 4248 spec->multiout.dig_out_nid = 0; 4249 codec->patch_ops.unsol_event = ad1884a_laptop_unsol_event; 4250 codec->patch_ops.init = ad1884a_laptop_init; 4251 /* set the upper-limit for mixer amp to 0dB for avoiding the 4252 * possible damage by overloading 4253 */ 4254 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT, 4255 (0x17 << AC_AMPCAP_OFFSET_SHIFT) | 4256 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | 4257 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) | 4258 (1 << AC_AMPCAP_MUTE_SHIFT)); 4259 break; 4260 case AD1884A_MOBILE: 4261 spec->mixers[0] = ad1884a_mobile_mixers; 4262 spec->init_verbs[0] = ad1884a_mobile_verbs; 4263 spec->multiout.dig_out_nid = 0; 4264 codec->patch_ops.unsol_event = ad1884a_hp_unsol_event; 4265 codec->patch_ops.init = ad1884a_hp_init; 4266 /* set the upper-limit for mixer amp to 0dB for avoiding the 4267 * possible damage by overloading 4268 */ 4269 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT, 4270 (0x17 << AC_AMPCAP_OFFSET_SHIFT) | 4271 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | 4272 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) | 4273 (1 << AC_AMPCAP_MUTE_SHIFT)); 4274 break; 4275 case AD1884A_THINKPAD: 4276 spec->mixers[0] = ad1984a_thinkpad_mixers; 4277 spec->init_verbs[spec->num_init_verbs++] = 4278 ad1984a_thinkpad_verbs; 4279 spec->multiout.dig_out_nid = 0; 4280 spec->input_mux = &ad1984a_thinkpad_capture_source; 4281 codec->patch_ops.unsol_event = ad1984a_thinkpad_unsol_event; 4282 codec->patch_ops.init = ad1984a_thinkpad_init; 4283 break; 4284 case AD1984A_TOUCHSMART: 4285 spec->mixers[0] = ad1984a_touchsmart_mixers; 4286 spec->init_verbs[0] = ad1984a_touchsmart_verbs; 4287 spec->multiout.dig_out_nid = 0; 4288 codec->patch_ops.unsol_event = ad1984a_touchsmart_unsol_event; 4289 codec->patch_ops.init = ad1984a_touchsmart_init; 4290 /* set the upper-limit for mixer amp to 0dB for avoiding the 4291 * possible damage by overloading 4292 */ 4293 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT, 4294 (0x17 << AC_AMPCAP_OFFSET_SHIFT) | 4295 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | 4296 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) | 4297 (1 << AC_AMPCAP_MUTE_SHIFT)); 4298 break; 4299 } 4300 4301 codec->no_trigger_sense = 1; 4302 4303 return 0; 4304 } 4305 4306 4307 /* 4308 * AD1882 / AD1882A 4309 * 4310 * port-A - front hp-out 4311 * port-B - front mic-in 4312 * port-C - rear line-in, shared surr-out (3stack) 4313 * port-D - rear line-out 4314 * port-E - rear mic-in, shared clfe-out (3stack) 4315 * port-F - rear surr-out (6stack) 4316 * port-G - rear clfe-out (6stack) 4317 */ 4318 4319 static hda_nid_t ad1882_dac_nids[3] = { 4320 0x04, 0x03, 0x05 4321 }; 4322 4323 static hda_nid_t ad1882_adc_nids[2] = { 4324 0x08, 0x09, 4325 }; 4326 4327 static hda_nid_t ad1882_capsrc_nids[2] = { 4328 0x0c, 0x0d, 4329 }; 4330 4331 #define AD1882_SPDIF_OUT 0x02 4332 4333 /* list: 0x11, 0x39, 0x3a, 0x18, 0x3c, 0x3b, 0x12, 0x20 */ 4334 static struct hda_input_mux ad1882_capture_source = { 4335 .num_items = 5, 4336 .items = { 4337 { "Front Mic", 0x1 }, 4338 { "Mic", 0x4 }, 4339 { "Line", 0x2 }, 4340 { "CD", 0x3 }, 4341 { "Mix", 0x7 }, 4342 }, 4343 }; 4344 4345 /* list: 0x11, 0x39, 0x3a, 0x3c, 0x18, 0x1f, 0x12, 0x20 */ 4346 static struct hda_input_mux ad1882a_capture_source = { 4347 .num_items = 5, 4348 .items = { 4349 { "Front Mic", 0x1 }, 4350 { "Mic", 0x4}, 4351 { "Line", 0x2 }, 4352 { "Digital Mic", 0x06 }, 4353 { "Mix", 0x7 }, 4354 }, 4355 }; 4356 4357 static struct snd_kcontrol_new ad1882_base_mixers[] = { 4358 HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT), 4359 HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT), 4360 HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT), 4361 HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT), 4362 HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT), 4363 HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT), 4364 HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT), 4365 HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT), 4366 4367 HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT), 4368 HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT), 4369 HDA_CODEC_VOLUME("Line-In Boost", 0x3a, 0x0, HDA_OUTPUT), 4370 HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT), 4371 HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT), 4372 HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT), 4373 HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT), 4374 { 4375 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4376 /* The multiple "Capture Source" controls confuse alsamixer 4377 * So call somewhat different.. 4378 */ 4379 /* .name = "Capture Source", */ 4380 .name = "Input Source", 4381 .count = 2, 4382 .info = ad198x_mux_enum_info, 4383 .get = ad198x_mux_enum_get, 4384 .put = ad198x_mux_enum_put, 4385 }, 4386 /* SPDIF controls */ 4387 HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT), 4388 { 4389 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4390 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source", 4391 /* identical with ad1983 */ 4392 .info = ad1983_spdif_route_info, 4393 .get = ad1983_spdif_route_get, 4394 .put = ad1983_spdif_route_put, 4395 }, 4396 { } /* end */ 4397 }; 4398 4399 static struct snd_kcontrol_new ad1882_loopback_mixers[] = { 4400 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT), 4401 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT), 4402 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT), 4403 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT), 4404 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x04, HDA_INPUT), 4405 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x04, HDA_INPUT), 4406 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT), 4407 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT), 4408 { } /* end */ 4409 }; 4410 4411 static struct snd_kcontrol_new ad1882a_loopback_mixers[] = { 4412 HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT), 4413 HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT), 4414 HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x04, HDA_INPUT), 4415 HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT), 4416 HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x01, HDA_INPUT), 4417 HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT), 4418 HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT), 4419 HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT), 4420 HDA_CODEC_VOLUME("Digital Mic Boost", 0x1f, 0x0, HDA_INPUT), 4421 { } /* end */ 4422 }; 4423 4424 static struct snd_kcontrol_new ad1882_3stack_mixers[] = { 4425 HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT), 4426 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x17, 1, 0x0, HDA_OUTPUT), 4427 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x17, 2, 0x0, HDA_OUTPUT), 4428 { 4429 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4430 .name = "Channel Mode", 4431 .info = ad198x_ch_mode_info, 4432 .get = ad198x_ch_mode_get, 4433 .put = ad198x_ch_mode_put, 4434 }, 4435 { } /* end */ 4436 }; 4437 4438 static struct snd_kcontrol_new ad1882_6stack_mixers[] = { 4439 HDA_CODEC_MUTE("Surround Playback Switch", 0x16, 0x0, HDA_OUTPUT), 4440 HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x24, 1, 0x0, HDA_OUTPUT), 4441 HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x24, 2, 0x0, HDA_OUTPUT), 4442 { } /* end */ 4443 }; 4444 4445 static struct hda_verb ad1882_ch2_init[] = { 4446 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4447 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4448 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4449 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4450 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4451 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4452 { } /* end */ 4453 }; 4454 4455 static struct hda_verb ad1882_ch4_init[] = { 4456 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4457 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4458 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 4459 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4460 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4461 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4462 { } /* end */ 4463 }; 4464 4465 static struct hda_verb ad1882_ch6_init[] = { 4466 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4467 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4468 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 4469 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4470 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4471 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 4472 { } /* end */ 4473 }; 4474 4475 static struct hda_channel_mode ad1882_modes[3] = { 4476 { 2, ad1882_ch2_init }, 4477 { 4, ad1882_ch4_init }, 4478 { 6, ad1882_ch6_init }, 4479 }; 4480 4481 /* 4482 * initialization verbs 4483 */ 4484 static struct hda_verb ad1882_init_verbs[] = { 4485 /* DACs; mute as default */ 4486 {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4487 {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4488 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, 4489 /* Port-A (HP) mixer */ 4490 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4491 {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 4492 /* Port-A pin */ 4493 {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4494 {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4495 /* HP selector - select DAC2 */ 4496 {0x37, AC_VERB_SET_CONNECT_SEL, 0x1}, 4497 /* Port-D (Line-out) mixer */ 4498 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4499 {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 4500 /* Port-D pin */ 4501 {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4502 {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4503 /* Mono-out mixer */ 4504 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 4505 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)}, 4506 /* Mono-out pin */ 4507 {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, 4508 {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4509 /* Port-B (front mic) pin */ 4510 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4511 {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4512 {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */ 4513 /* Port-C (line-in) pin */ 4514 {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, 4515 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4516 {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */ 4517 /* Port-C mixer - mute as input */ 4518 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4519 {0x2c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4520 /* Port-E (mic-in) pin */ 4521 {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, 4522 {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4523 {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, /* boost */ 4524 /* Port-E mixer - mute as input */ 4525 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4526 {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4527 /* Port-F (surround) */ 4528 {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4529 {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4530 /* Port-G (CLFE) */ 4531 {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 4532 {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, 4533 /* Analog mixer; mute as default */ 4534 /* list: 0x39, 0x3a, 0x11, 0x12, 0x3c, 0x3b, 0x18, 0x1a */ 4535 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, 4536 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, 4537 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, 4538 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, 4539 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, 4540 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, 4541 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, 4542 {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, 4543 /* Analog Mix output amp */ 4544 {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */ 4545 /* SPDIF output selector */ 4546 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */ 4547 {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */ 4548 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */ 4549 { } /* end */ 4550 }; 4551 4552 #ifdef CONFIG_SND_HDA_POWER_SAVE 4553 static struct hda_amp_list ad1882_loopbacks[] = { 4554 { 0x20, HDA_INPUT, 0 }, /* Front Mic */ 4555 { 0x20, HDA_INPUT, 1 }, /* Mic */ 4556 { 0x20, HDA_INPUT, 4 }, /* Line */ 4557 { 0x20, HDA_INPUT, 6 }, /* CD */ 4558 { } /* end */ 4559 }; 4560 #endif 4561 4562 /* models */ 4563 enum { 4564 AD1882_3STACK, 4565 AD1882_6STACK, 4566 AD1882_MODELS 4567 }; 4568 4569 static const char *ad1882_models[AD1986A_MODELS] = { 4570 [AD1882_3STACK] = "3stack", 4571 [AD1882_6STACK] = "6stack", 4572 }; 4573 4574 4575 static int patch_ad1882(struct hda_codec *codec) 4576 { 4577 struct ad198x_spec *spec; 4578 int err, board_config; 4579 4580 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 4581 if (spec == NULL) 4582 return -ENOMEM; 4583 4584 codec->spec = spec; 4585 4586 err = snd_hda_attach_beep_device(codec, 0x10); 4587 if (err < 0) { 4588 ad198x_free(codec); 4589 return err; 4590 } 4591 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT); 4592 4593 spec->multiout.max_channels = 6; 4594 spec->multiout.num_dacs = 3; 4595 spec->multiout.dac_nids = ad1882_dac_nids; 4596 spec->multiout.dig_out_nid = AD1882_SPDIF_OUT; 4597 spec->num_adc_nids = ARRAY_SIZE(ad1882_adc_nids); 4598 spec->adc_nids = ad1882_adc_nids; 4599 spec->capsrc_nids = ad1882_capsrc_nids; 4600 if (codec->vendor_id == 0x11d41882) 4601 spec->input_mux = &ad1882_capture_source; 4602 else 4603 spec->input_mux = &ad1882a_capture_source; 4604 spec->num_mixers = 2; 4605 spec->mixers[0] = ad1882_base_mixers; 4606 if (codec->vendor_id == 0x11d41882) 4607 spec->mixers[1] = ad1882_loopback_mixers; 4608 else 4609 spec->mixers[1] = ad1882a_loopback_mixers; 4610 spec->num_init_verbs = 1; 4611 spec->init_verbs[0] = ad1882_init_verbs; 4612 spec->spdif_route = 0; 4613 #ifdef CONFIG_SND_HDA_POWER_SAVE 4614 spec->loopback.amplist = ad1882_loopbacks; 4615 #endif 4616 spec->vmaster_nid = 0x04; 4617 4618 codec->patch_ops = ad198x_patch_ops; 4619 4620 /* override some parameters */ 4621 board_config = snd_hda_check_board_config(codec, AD1882_MODELS, 4622 ad1882_models, NULL); 4623 switch (board_config) { 4624 default: 4625 case AD1882_3STACK: 4626 spec->num_mixers = 3; 4627 spec->mixers[2] = ad1882_3stack_mixers; 4628 spec->channel_mode = ad1882_modes; 4629 spec->num_channel_mode = ARRAY_SIZE(ad1882_modes); 4630 spec->need_dac_fix = 1; 4631 spec->multiout.max_channels = 2; 4632 spec->multiout.num_dacs = 1; 4633 break; 4634 case AD1882_6STACK: 4635 spec->num_mixers = 3; 4636 spec->mixers[2] = ad1882_6stack_mixers; 4637 break; 4638 } 4639 4640 codec->no_trigger_sense = 1; 4641 4642 return 0; 4643 } 4644 4645 4646 /* 4647 * patch entries 4648 */ 4649 static struct hda_codec_preset snd_hda_preset_analog[] = { 4650 { .id = 0x11d4184a, .name = "AD1884A", .patch = patch_ad1884a }, 4651 { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 }, 4652 { .id = 0x11d41883, .name = "AD1883", .patch = patch_ad1884a }, 4653 { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 }, 4654 { .id = 0x11d4194a, .name = "AD1984A", .patch = patch_ad1884a }, 4655 { .id = 0x11d4194b, .name = "AD1984B", .patch = patch_ad1884a }, 4656 { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 }, 4657 { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 }, 4658 { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1984 }, 4659 { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a }, 4660 { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 }, 4661 { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 }, 4662 { .id = 0x11d4882a, .name = "AD1882A", .patch = patch_ad1882 }, 4663 { .id = 0x11d4989a, .name = "AD1989A", .patch = patch_ad1988 }, 4664 { .id = 0x11d4989b, .name = "AD1989B", .patch = patch_ad1988 }, 4665 {} /* terminator */ 4666 }; 4667 4668 MODULE_ALIAS("snd-hda-codec-id:11d4*"); 4669 4670 MODULE_LICENSE("GPL"); 4671 MODULE_DESCRIPTION("Analog Devices HD-audio codec"); 4672 4673 static struct hda_codec_preset_list analog_list = { 4674 .preset = snd_hda_preset_analog, 4675 .owner = THIS_MODULE, 4676 }; 4677 4678 static int __init patch_analog_init(void) 4679 { 4680 return snd_hda_add_codec_preset(&analog_list); 4681 } 4682 4683 static void __exit patch_analog_exit(void) 4684 { 4685 snd_hda_delete_codec_preset(&analog_list); 4686 } 4687 4688 module_init(patch_analog_init) 4689 module_exit(patch_analog_exit) 4690