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/slab.h> 24#include <linux/module.h> 25 26#include <sound/core.h> 27#include "hda_codec.h" 28#include "hda_local.h" 29#include "hda_auto_parser.h" 30#include "hda_beep.h" 31#include "hda_jack.h" 32#include "hda_generic.h" 33 34 35struct ad198x_spec { 36 struct hda_gen_spec gen; 37 38 /* for auto parser */ 39 int smux_paths[4]; 40 unsigned int cur_smux; 41 hda_nid_t eapd_nid; 42 43 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */ 44}; 45 46 47#ifdef CONFIG_SND_HDA_INPUT_BEEP 48/* additional beep mixers; the actual parameters are overwritten at build */ 49static const struct snd_kcontrol_new ad_beep_mixer[] = { 50 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_OUTPUT), 51 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_OUTPUT), 52 { } /* end */ 53}; 54 55#define set_beep_amp(spec, nid, idx, dir) \ 56 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir)) /* mono */ 57#else 58#define set_beep_amp(spec, nid, idx, dir) /* NOP */ 59#endif 60 61#ifdef CONFIG_SND_HDA_INPUT_BEEP 62static int create_beep_ctls(struct hda_codec *codec) 63{ 64 struct ad198x_spec *spec = codec->spec; 65 const struct snd_kcontrol_new *knew; 66 67 if (!spec->beep_amp) 68 return 0; 69 70 for (knew = ad_beep_mixer ; knew->name; knew++) { 71 int err; 72 struct snd_kcontrol *kctl; 73 kctl = snd_ctl_new1(knew, codec); 74 if (!kctl) 75 return -ENOMEM; 76 kctl->private_value = spec->beep_amp; 77 err = snd_hda_ctl_add(codec, 0, kctl); 78 if (err < 0) 79 return err; 80 } 81 return 0; 82} 83#else 84#define create_beep_ctls(codec) 0 85#endif 86 87 88static void ad198x_power_eapd_write(struct hda_codec *codec, hda_nid_t front, 89 hda_nid_t hp) 90{ 91 if (snd_hda_query_pin_caps(codec, front) & AC_PINCAP_EAPD) 92 snd_hda_codec_write(codec, front, 0, AC_VERB_SET_EAPD_BTLENABLE, 93 !codec->inv_eapd ? 0x00 : 0x02); 94 if (snd_hda_query_pin_caps(codec, hp) & AC_PINCAP_EAPD) 95 snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_EAPD_BTLENABLE, 96 !codec->inv_eapd ? 0x00 : 0x02); 97} 98 99static void ad198x_power_eapd(struct hda_codec *codec) 100{ 101 /* We currently only handle front, HP */ 102 switch (codec->core.vendor_id) { 103 case 0x11d41882: 104 case 0x11d4882a: 105 case 0x11d41884: 106 case 0x11d41984: 107 case 0x11d41883: 108 case 0x11d4184a: 109 case 0x11d4194a: 110 case 0x11d4194b: 111 case 0x11d41988: 112 case 0x11d4198b: 113 case 0x11d4989a: 114 case 0x11d4989b: 115 ad198x_power_eapd_write(codec, 0x12, 0x11); 116 break; 117 case 0x11d41981: 118 case 0x11d41983: 119 ad198x_power_eapd_write(codec, 0x05, 0x06); 120 break; 121 case 0x11d41986: 122 ad198x_power_eapd_write(codec, 0x1b, 0x1a); 123 break; 124 } 125} 126 127static void ad198x_shutup(struct hda_codec *codec) 128{ 129 snd_hda_shutup_pins(codec); 130 ad198x_power_eapd(codec); 131} 132 133#ifdef CONFIG_PM 134static int ad198x_suspend(struct hda_codec *codec) 135{ 136 ad198x_shutup(codec); 137 return 0; 138} 139#endif 140 141/* follow EAPD via vmaster hook */ 142static void ad_vmaster_eapd_hook(void *private_data, int enabled) 143{ 144 struct hda_codec *codec = private_data; 145 struct ad198x_spec *spec = codec->spec; 146 147 if (!spec->eapd_nid) 148 return; 149 if (codec->inv_eapd) 150 enabled = !enabled; 151 snd_hda_codec_update_cache(codec, spec->eapd_nid, 0, 152 AC_VERB_SET_EAPD_BTLENABLE, 153 enabled ? 0x02 : 0x00); 154} 155 156/* 157 * Automatic parse of I/O pins from the BIOS configuration 158 */ 159 160static int ad198x_auto_build_controls(struct hda_codec *codec) 161{ 162 int err; 163 164 err = snd_hda_gen_build_controls(codec); 165 if (err < 0) 166 return err; 167 err = create_beep_ctls(codec); 168 if (err < 0) 169 return err; 170 return 0; 171} 172 173static const struct hda_codec_ops ad198x_auto_patch_ops = { 174 .build_controls = ad198x_auto_build_controls, 175 .build_pcms = snd_hda_gen_build_pcms, 176 .init = snd_hda_gen_init, 177 .free = snd_hda_gen_free, 178 .unsol_event = snd_hda_jack_unsol_event, 179#ifdef CONFIG_PM 180 .check_power_status = snd_hda_gen_check_power_status, 181 .suspend = ad198x_suspend, 182#endif 183 .reboot_notify = ad198x_shutup, 184}; 185 186 187static int ad198x_parse_auto_config(struct hda_codec *codec, bool indep_hp) 188{ 189 struct ad198x_spec *spec = codec->spec; 190 struct auto_pin_cfg *cfg = &spec->gen.autocfg; 191 int err; 192 193 codec->spdif_status_reset = 1; 194 codec->no_trigger_sense = 1; 195 codec->no_sticky_stream = 1; 196 197 spec->gen.indep_hp = indep_hp; 198 if (!spec->gen.add_stereo_mix_input) 199 spec->gen.add_stereo_mix_input = HDA_HINT_STEREO_MIX_AUTO; 200 201 err = snd_hda_parse_pin_defcfg(codec, cfg, NULL, 0); 202 if (err < 0) 203 return err; 204 err = snd_hda_gen_parse_auto_config(codec, cfg); 205 if (err < 0) 206 return err; 207 208 codec->patch_ops = ad198x_auto_patch_ops; 209 210 return 0; 211} 212 213/* 214 * AD1986A specific 215 */ 216 217static int alloc_ad_spec(struct hda_codec *codec) 218{ 219 struct ad198x_spec *spec; 220 221 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 222 if (!spec) 223 return -ENOMEM; 224 codec->spec = spec; 225 snd_hda_gen_spec_init(&spec->gen); 226 return 0; 227} 228 229/* 230 * AD1986A fixup codes 231 */ 232 233/* Lenovo N100 seems to report the reversed bit for HP jack-sensing */ 234static void ad_fixup_inv_jack_detect(struct hda_codec *codec, 235 const struct hda_fixup *fix, int action) 236{ 237 struct ad198x_spec *spec = codec->spec; 238 239 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 240 codec->inv_jack_detect = 1; 241 spec->gen.keep_eapd_on = 1; 242 spec->gen.vmaster_mute.hook = ad_vmaster_eapd_hook; 243 spec->eapd_nid = 0x1b; 244 } 245} 246 247/* Toshiba Satellite L40 implements EAPD in a standard way unlike others */ 248static void ad1986a_fixup_eapd(struct hda_codec *codec, 249 const struct hda_fixup *fix, int action) 250{ 251 struct ad198x_spec *spec = codec->spec; 252 253 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 254 codec->inv_eapd = 0; 255 spec->gen.keep_eapd_on = 1; 256 spec->eapd_nid = 0x1b; 257 } 258} 259 260/* enable stereo-mix input for avoiding regression on KDE (bko#88251) */ 261static void ad1986a_fixup_eapd_mix_in(struct hda_codec *codec, 262 const struct hda_fixup *fix, int action) 263{ 264 struct ad198x_spec *spec = codec->spec; 265 266 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 267 ad1986a_fixup_eapd(codec, fix, action); 268 spec->gen.add_stereo_mix_input = HDA_HINT_STEREO_MIX_ENABLE; 269 } 270} 271 272enum { 273 AD1986A_FIXUP_INV_JACK_DETECT, 274 AD1986A_FIXUP_ULTRA, 275 AD1986A_FIXUP_SAMSUNG, 276 AD1986A_FIXUP_3STACK, 277 AD1986A_FIXUP_LAPTOP, 278 AD1986A_FIXUP_LAPTOP_IMIC, 279 AD1986A_FIXUP_EAPD, 280 AD1986A_FIXUP_EAPD_MIX_IN, 281 AD1986A_FIXUP_EASYNOTE, 282}; 283 284static const struct hda_fixup ad1986a_fixups[] = { 285 [AD1986A_FIXUP_INV_JACK_DETECT] = { 286 .type = HDA_FIXUP_FUNC, 287 .v.func = ad_fixup_inv_jack_detect, 288 }, 289 [AD1986A_FIXUP_ULTRA] = { 290 .type = HDA_FIXUP_PINS, 291 .v.pins = (const struct hda_pintbl[]) { 292 { 0x1b, 0x90170110 }, /* speaker */ 293 { 0x1d, 0x90a7013e }, /* int mic */ 294 {} 295 }, 296 }, 297 [AD1986A_FIXUP_SAMSUNG] = { 298 .type = HDA_FIXUP_PINS, 299 .v.pins = (const struct hda_pintbl[]) { 300 { 0x1b, 0x90170110 }, /* speaker */ 301 { 0x1d, 0x90a7013e }, /* int mic */ 302 { 0x20, 0x411111f0 }, /* N/A */ 303 { 0x24, 0x411111f0 }, /* N/A */ 304 {} 305 }, 306 }, 307 [AD1986A_FIXUP_3STACK] = { 308 .type = HDA_FIXUP_PINS, 309 .v.pins = (const struct hda_pintbl[]) { 310 { 0x1a, 0x02214021 }, /* headphone */ 311 { 0x1b, 0x01014011 }, /* front */ 312 { 0x1c, 0x01813030 }, /* line-in */ 313 { 0x1d, 0x01a19020 }, /* rear mic */ 314 { 0x1e, 0x411111f0 }, /* N/A */ 315 { 0x1f, 0x02a190f0 }, /* mic */ 316 { 0x20, 0x411111f0 }, /* N/A */ 317 {} 318 }, 319 }, 320 [AD1986A_FIXUP_LAPTOP] = { 321 .type = HDA_FIXUP_PINS, 322 .v.pins = (const struct hda_pintbl[]) { 323 { 0x1a, 0x02214021 }, /* headphone */ 324 { 0x1b, 0x90170110 }, /* speaker */ 325 { 0x1c, 0x411111f0 }, /* N/A */ 326 { 0x1d, 0x411111f0 }, /* N/A */ 327 { 0x1e, 0x411111f0 }, /* N/A */ 328 { 0x1f, 0x02a191f0 }, /* mic */ 329 { 0x20, 0x411111f0 }, /* N/A */ 330 {} 331 }, 332 }, 333 [AD1986A_FIXUP_LAPTOP_IMIC] = { 334 .type = HDA_FIXUP_PINS, 335 .v.pins = (const struct hda_pintbl[]) { 336 { 0x1d, 0x90a7013e }, /* int mic */ 337 {} 338 }, 339 .chained_before = 1, 340 .chain_id = AD1986A_FIXUP_LAPTOP, 341 }, 342 [AD1986A_FIXUP_EAPD] = { 343 .type = HDA_FIXUP_FUNC, 344 .v.func = ad1986a_fixup_eapd, 345 }, 346 [AD1986A_FIXUP_EAPD_MIX_IN] = { 347 .type = HDA_FIXUP_FUNC, 348 .v.func = ad1986a_fixup_eapd_mix_in, 349 }, 350 [AD1986A_FIXUP_EASYNOTE] = { 351 .type = HDA_FIXUP_PINS, 352 .v.pins = (const struct hda_pintbl[]) { 353 { 0x1a, 0x0421402f }, /* headphone */ 354 { 0x1b, 0x90170110 }, /* speaker */ 355 { 0x1c, 0x411111f0 }, /* N/A */ 356 { 0x1d, 0x90a70130 }, /* int mic */ 357 { 0x1e, 0x411111f0 }, /* N/A */ 358 { 0x1f, 0x04a19040 }, /* mic */ 359 { 0x20, 0x411111f0 }, /* N/A */ 360 { 0x21, 0x411111f0 }, /* N/A */ 361 { 0x22, 0x411111f0 }, /* N/A */ 362 { 0x23, 0x411111f0 }, /* N/A */ 363 { 0x24, 0x411111f0 }, /* N/A */ 364 { 0x25, 0x411111f0 }, /* N/A */ 365 {} 366 }, 367 .chained = true, 368 .chain_id = AD1986A_FIXUP_EAPD_MIX_IN, 369 }, 370}; 371 372static const struct snd_pci_quirk ad1986a_fixup_tbl[] = { 373 SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_FIXUP_LAPTOP_IMIC), 374 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS Z99He", AD1986A_FIXUP_EAPD), 375 SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8JN", AD1986A_FIXUP_EAPD), 376 SND_PCI_QUIRK_MASK(0x1043, 0xff00, 0x8100, "ASUS P5", AD1986A_FIXUP_3STACK), 377 SND_PCI_QUIRK_MASK(0x1043, 0xff00, 0x8200, "ASUS M2", AD1986A_FIXUP_3STACK), 378 SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_FIXUP_3STACK), 379 SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba Satellite L40", AD1986A_FIXUP_EAPD), 380 SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_FIXUP_LAPTOP), 381 SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc000, "Samsung", AD1986A_FIXUP_SAMSUNG), 382 SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_FIXUP_ULTRA), 383 SND_PCI_QUIRK(0x1631, 0xc022, "PackardBell EasyNote MX65", AD1986A_FIXUP_EASYNOTE), 384 SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_FIXUP_INV_JACK_DETECT), 385 SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_FIXUP_3STACK), 386 SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_FIXUP_3STACK), 387 {} 388}; 389 390static const struct hda_model_fixup ad1986a_fixup_models[] = { 391 { .id = AD1986A_FIXUP_3STACK, .name = "3stack" }, 392 { .id = AD1986A_FIXUP_LAPTOP, .name = "laptop" }, 393 { .id = AD1986A_FIXUP_LAPTOP_IMIC, .name = "laptop-imic" }, 394 { .id = AD1986A_FIXUP_LAPTOP_IMIC, .name = "laptop-eapd" }, /* alias */ 395 { .id = AD1986A_FIXUP_EAPD, .name = "eapd" }, 396 {} 397}; 398 399/* 400 */ 401static int patch_ad1986a(struct hda_codec *codec) 402{ 403 int err; 404 struct ad198x_spec *spec; 405 static hda_nid_t preferred_pairs[] = { 406 0x1a, 0x03, 407 0x1b, 0x03, 408 0x1c, 0x04, 409 0x1d, 0x05, 410 0x1e, 0x03, 411 0 412 }; 413 414 err = alloc_ad_spec(codec); 415 if (err < 0) 416 return err; 417 spec = codec->spec; 418 419 /* AD1986A has the inverted EAPD implementation */ 420 codec->inv_eapd = 1; 421 422 spec->gen.mixer_nid = 0x07; 423 spec->gen.beep_nid = 0x19; 424 set_beep_amp(spec, 0x18, 0, HDA_OUTPUT); 425 426 /* AD1986A has a hardware problem that it can't share a stream 427 * with multiple output pins. The copy of front to surrounds 428 * causes noisy or silent outputs at a certain timing, e.g. 429 * changing the volume. 430 * So, let's disable the shared stream. 431 */ 432 spec->gen.multiout.no_share_stream = 1; 433 /* give fixed DAC/pin pairs */ 434 spec->gen.preferred_dacs = preferred_pairs; 435 436 /* AD1986A can't manage the dynamic pin on/off smoothly */ 437 spec->gen.auto_mute_via_amp = 1; 438 439 snd_hda_pick_fixup(codec, ad1986a_fixup_models, ad1986a_fixup_tbl, 440 ad1986a_fixups); 441 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 442 443 err = ad198x_parse_auto_config(codec, false); 444 if (err < 0) { 445 snd_hda_gen_free(codec); 446 return err; 447 } 448 449 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 450 451 return 0; 452} 453 454 455/* 456 * AD1983 specific 457 */ 458 459/* 460 * SPDIF mux control for AD1983 auto-parser 461 */ 462static int ad1983_auto_smux_enum_info(struct snd_kcontrol *kcontrol, 463 struct snd_ctl_elem_info *uinfo) 464{ 465 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 466 struct ad198x_spec *spec = codec->spec; 467 static const char * const texts2[] = { "PCM", "ADC" }; 468 static const char * const texts3[] = { "PCM", "ADC1", "ADC2" }; 469 hda_nid_t dig_out = spec->gen.multiout.dig_out_nid; 470 int num_conns = snd_hda_get_num_conns(codec, dig_out); 471 472 if (num_conns == 2) 473 return snd_hda_enum_helper_info(kcontrol, uinfo, 2, texts2); 474 else if (num_conns == 3) 475 return snd_hda_enum_helper_info(kcontrol, uinfo, 3, texts3); 476 else 477 return -EINVAL; 478} 479 480static int ad1983_auto_smux_enum_get(struct snd_kcontrol *kcontrol, 481 struct snd_ctl_elem_value *ucontrol) 482{ 483 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 484 struct ad198x_spec *spec = codec->spec; 485 486 ucontrol->value.enumerated.item[0] = spec->cur_smux; 487 return 0; 488} 489 490static int ad1983_auto_smux_enum_put(struct snd_kcontrol *kcontrol, 491 struct snd_ctl_elem_value *ucontrol) 492{ 493 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 494 struct ad198x_spec *spec = codec->spec; 495 unsigned int val = ucontrol->value.enumerated.item[0]; 496 hda_nid_t dig_out = spec->gen.multiout.dig_out_nid; 497 int num_conns = snd_hda_get_num_conns(codec, dig_out); 498 499 if (val >= num_conns) 500 return -EINVAL; 501 if (spec->cur_smux == val) 502 return 0; 503 spec->cur_smux = val; 504 snd_hda_codec_write_cache(codec, dig_out, 0, 505 AC_VERB_SET_CONNECT_SEL, val); 506 return 1; 507} 508 509static struct snd_kcontrol_new ad1983_auto_smux_mixer = { 510 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 511 .name = "IEC958 Playback Source", 512 .info = ad1983_auto_smux_enum_info, 513 .get = ad1983_auto_smux_enum_get, 514 .put = ad1983_auto_smux_enum_put, 515}; 516 517static int ad1983_add_spdif_mux_ctl(struct hda_codec *codec) 518{ 519 struct ad198x_spec *spec = codec->spec; 520 hda_nid_t dig_out = spec->gen.multiout.dig_out_nid; 521 int num_conns; 522 523 if (!dig_out) 524 return 0; 525 num_conns = snd_hda_get_num_conns(codec, dig_out); 526 if (num_conns != 2 && num_conns != 3) 527 return 0; 528 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &ad1983_auto_smux_mixer)) 529 return -ENOMEM; 530 return 0; 531} 532 533static int patch_ad1983(struct hda_codec *codec) 534{ 535 struct ad198x_spec *spec; 536 static hda_nid_t conn_0c[] = { 0x08 }; 537 static hda_nid_t conn_0d[] = { 0x09 }; 538 int err; 539 540 err = alloc_ad_spec(codec); 541 if (err < 0) 542 return err; 543 spec = codec->spec; 544 545 spec->gen.mixer_nid = 0x0e; 546 spec->gen.beep_nid = 0x10; 547 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT); 548 549 /* limit the loopback routes not to confuse the parser */ 550 snd_hda_override_conn_list(codec, 0x0c, ARRAY_SIZE(conn_0c), conn_0c); 551 snd_hda_override_conn_list(codec, 0x0d, ARRAY_SIZE(conn_0d), conn_0d); 552 553 err = ad198x_parse_auto_config(codec, false); 554 if (err < 0) 555 goto error; 556 err = ad1983_add_spdif_mux_ctl(codec); 557 if (err < 0) 558 goto error; 559 return 0; 560 561 error: 562 snd_hda_gen_free(codec); 563 return err; 564} 565 566 567/* 568 * AD1981 HD specific 569 */ 570 571static void ad1981_fixup_hp_eapd(struct hda_codec *codec, 572 const struct hda_fixup *fix, int action) 573{ 574 struct ad198x_spec *spec = codec->spec; 575 576 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 577 spec->gen.vmaster_mute.hook = ad_vmaster_eapd_hook; 578 spec->eapd_nid = 0x05; 579 } 580} 581 582/* set the upper-limit for mixer amp to 0dB for avoiding the possible 583 * damage by overloading 584 */ 585static void ad1981_fixup_amp_override(struct hda_codec *codec, 586 const struct hda_fixup *fix, int action) 587{ 588 if (action == HDA_FIXUP_ACT_PRE_PROBE) 589 snd_hda_override_amp_caps(codec, 0x11, HDA_INPUT, 590 (0x17 << AC_AMPCAP_OFFSET_SHIFT) | 591 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | 592 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) | 593 (1 << AC_AMPCAP_MUTE_SHIFT)); 594} 595 596enum { 597 AD1981_FIXUP_AMP_OVERRIDE, 598 AD1981_FIXUP_HP_EAPD, 599}; 600 601static const struct hda_fixup ad1981_fixups[] = { 602 [AD1981_FIXUP_AMP_OVERRIDE] = { 603 .type = HDA_FIXUP_FUNC, 604 .v.func = ad1981_fixup_amp_override, 605 }, 606 [AD1981_FIXUP_HP_EAPD] = { 607 .type = HDA_FIXUP_FUNC, 608 .v.func = ad1981_fixup_hp_eapd, 609 .chained = true, 610 .chain_id = AD1981_FIXUP_AMP_OVERRIDE, 611 }, 612}; 613 614static const struct snd_pci_quirk ad1981_fixup_tbl[] = { 615 SND_PCI_QUIRK_VENDOR(0x1014, "Lenovo", AD1981_FIXUP_AMP_OVERRIDE), 616 SND_PCI_QUIRK_VENDOR(0x103c, "HP", AD1981_FIXUP_HP_EAPD), 617 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", AD1981_FIXUP_AMP_OVERRIDE), 618 /* HP nx6320 (reversed SSID, H/W bug) */ 619 SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_FIXUP_HP_EAPD), 620 {} 621}; 622 623static int patch_ad1981(struct hda_codec *codec) 624{ 625 struct ad198x_spec *spec; 626 int err; 627 628 err = alloc_ad_spec(codec); 629 if (err < 0) 630 return -ENOMEM; 631 spec = codec->spec; 632 633 spec->gen.mixer_nid = 0x0e; 634 spec->gen.beep_nid = 0x10; 635 set_beep_amp(spec, 0x0d, 0, HDA_OUTPUT); 636 637 snd_hda_pick_fixup(codec, NULL, ad1981_fixup_tbl, ad1981_fixups); 638 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 639 640 err = ad198x_parse_auto_config(codec, false); 641 if (err < 0) 642 goto error; 643 err = ad1983_add_spdif_mux_ctl(codec); 644 if (err < 0) 645 goto error; 646 647 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 648 649 return 0; 650 651 error: 652 snd_hda_gen_free(codec); 653 return err; 654} 655 656 657/* 658 * AD1988 659 * 660 * Output pins and routes 661 * 662 * Pin Mix Sel DAC (*) 663 * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06 664 * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06 665 * port-C 0x15 (mute) <- 0x2c <- 0x31 <- 05/0a 666 * port-D 0x12 (mute/hp) <- 0x29 <- 04 667 * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a 668 * port-F 0x16 (mute) <- 0x2a <- 06 669 * port-G 0x24 (mute) <- 0x27 <- 05 670 * port-H 0x25 (mute) <- 0x28 <- 0a 671 * mono 0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06 672 * 673 * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah 674 * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug. 675 * 676 * Input pins and routes 677 * 678 * pin boost mix input # / adc input # 679 * port-A 0x11 -> 0x38 -> mix 2, ADC 0 680 * port-B 0x14 -> 0x39 -> mix 0, ADC 1 681 * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2 682 * port-D 0x12 -> 0x3d -> mix 3, ADC 8 683 * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4 684 * port-F 0x16 -> 0x3b -> mix 5, ADC 3 685 * port-G 0x24 -> N/A -> 33:1 - mix 1, 34:1 - mix 4, ADC 6 686 * port-H 0x25 -> N/A -> 33:2 - mix 1, 34:2 - mix 4, ADC 7 687 * 688 * 689 * DAC assignment 690 * 6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03 691 * 3stack - front/surr/CLFE/opt DACs - 04/05/0a/03 692 * 693 * Inputs of Analog Mix (0x20) 694 * 0:Port-B (front mic) 695 * 1:Port-C/G/H (line-in) 696 * 2:Port-A 697 * 3:Port-D (line-in/2) 698 * 4:Port-E/G/H (mic-in) 699 * 5:Port-F (mic2-in) 700 * 6:CD 701 * 7:Beep 702 * 703 * ADC selection 704 * 0:Port-A 705 * 1:Port-B (front mic-in) 706 * 2:Port-C (line-in) 707 * 3:Port-F (mic2-in) 708 * 4:Port-E (mic-in) 709 * 5:CD 710 * 6:Port-G 711 * 7:Port-H 712 * 8:Port-D (line-in/2) 713 * 9:Mix 714 * 715 * Proposed pin assignments by the datasheet 716 * 717 * 6-stack 718 * Port-A front headphone 719 * B front mic-in 720 * C rear line-in 721 * D rear front-out 722 * E rear mic-in 723 * F rear surround 724 * G rear CLFE 725 * H rear side 726 * 727 * 3-stack 728 * Port-A front headphone 729 * B front mic 730 * C rear line-in/surround 731 * D rear front-out 732 * E rear mic-in/CLFE 733 * 734 * laptop 735 * Port-A headphone 736 * B mic-in 737 * C docking station 738 * D internal speaker (with EAPD) 739 * E/F quad mic array 740 */ 741 742static int ad1988_auto_smux_enum_info(struct snd_kcontrol *kcontrol, 743 struct snd_ctl_elem_info *uinfo) 744{ 745 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 746 static const char * const texts[] = { 747 "PCM", "ADC1", "ADC2", "ADC3", 748 }; 749 int num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1; 750 if (num_conns > 4) 751 num_conns = 4; 752 return snd_hda_enum_helper_info(kcontrol, uinfo, num_conns, texts); 753} 754 755static int ad1988_auto_smux_enum_get(struct snd_kcontrol *kcontrol, 756 struct snd_ctl_elem_value *ucontrol) 757{ 758 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 759 struct ad198x_spec *spec = codec->spec; 760 761 ucontrol->value.enumerated.item[0] = spec->cur_smux; 762 return 0; 763} 764 765static int ad1988_auto_smux_enum_put(struct snd_kcontrol *kcontrol, 766 struct snd_ctl_elem_value *ucontrol) 767{ 768 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 769 struct ad198x_spec *spec = codec->spec; 770 unsigned int val = ucontrol->value.enumerated.item[0]; 771 struct nid_path *path; 772 int num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1; 773 774 if (val >= num_conns) 775 return -EINVAL; 776 if (spec->cur_smux == val) 777 return 0; 778 779 mutex_lock(&codec->control_mutex); 780 path = snd_hda_get_path_from_idx(codec, 781 spec->smux_paths[spec->cur_smux]); 782 if (path) 783 snd_hda_activate_path(codec, path, false, true); 784 path = snd_hda_get_path_from_idx(codec, spec->smux_paths[val]); 785 if (path) 786 snd_hda_activate_path(codec, path, true, true); 787 spec->cur_smux = val; 788 mutex_unlock(&codec->control_mutex); 789 return 1; 790} 791 792static struct snd_kcontrol_new ad1988_auto_smux_mixer = { 793 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 794 .name = "IEC958 Playback Source", 795 .info = ad1988_auto_smux_enum_info, 796 .get = ad1988_auto_smux_enum_get, 797 .put = ad1988_auto_smux_enum_put, 798}; 799 800static int ad1988_auto_init(struct hda_codec *codec) 801{ 802 struct ad198x_spec *spec = codec->spec; 803 int i, err; 804 805 err = snd_hda_gen_init(codec); 806 if (err < 0) 807 return err; 808 if (!spec->gen.autocfg.dig_outs) 809 return 0; 810 811 for (i = 0; i < 4; i++) { 812 struct nid_path *path; 813 path = snd_hda_get_path_from_idx(codec, spec->smux_paths[i]); 814 if (path) 815 snd_hda_activate_path(codec, path, path->active, false); 816 } 817 818 return 0; 819} 820 821static int ad1988_add_spdif_mux_ctl(struct hda_codec *codec) 822{ 823 struct ad198x_spec *spec = codec->spec; 824 int i, num_conns; 825 /* we create four static faked paths, since AD codecs have odd 826 * widget connections regarding the SPDIF out source 827 */ 828 static struct nid_path fake_paths[4] = { 829 { 830 .depth = 3, 831 .path = { 0x02, 0x1d, 0x1b }, 832 .idx = { 0, 0, 0 }, 833 .multi = { 0, 0, 0 }, 834 }, 835 { 836 .depth = 4, 837 .path = { 0x08, 0x0b, 0x1d, 0x1b }, 838 .idx = { 0, 0, 1, 0 }, 839 .multi = { 0, 1, 0, 0 }, 840 }, 841 { 842 .depth = 4, 843 .path = { 0x09, 0x0b, 0x1d, 0x1b }, 844 .idx = { 0, 1, 1, 0 }, 845 .multi = { 0, 1, 0, 0 }, 846 }, 847 { 848 .depth = 4, 849 .path = { 0x0f, 0x0b, 0x1d, 0x1b }, 850 .idx = { 0, 2, 1, 0 }, 851 .multi = { 0, 1, 0, 0 }, 852 }, 853 }; 854 855 /* SPDIF source mux appears to be present only on AD1988A */ 856 if (!spec->gen.autocfg.dig_outs || 857 get_wcaps_type(get_wcaps(codec, 0x1d)) != AC_WID_AUD_MIX) 858 return 0; 859 860 num_conns = snd_hda_get_num_conns(codec, 0x0b) + 1; 861 if (num_conns != 3 && num_conns != 4) 862 return 0; 863 864 for (i = 0; i < num_conns; i++) { 865 struct nid_path *path = snd_array_new(&spec->gen.paths); 866 if (!path) 867 return -ENOMEM; 868 *path = fake_paths[i]; 869 if (!i) 870 path->active = 1; 871 spec->smux_paths[i] = snd_hda_get_path_idx(codec, path); 872 } 873 874 if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &ad1988_auto_smux_mixer)) 875 return -ENOMEM; 876 877 codec->patch_ops.init = ad1988_auto_init; 878 879 return 0; 880} 881 882/* 883 */ 884 885enum { 886 AD1988_FIXUP_6STACK_DIG, 887}; 888 889static const struct hda_fixup ad1988_fixups[] = { 890 [AD1988_FIXUP_6STACK_DIG] = { 891 .type = HDA_FIXUP_PINS, 892 .v.pins = (const struct hda_pintbl[]) { 893 { 0x11, 0x02214130 }, /* front-hp */ 894 { 0x12, 0x01014010 }, /* line-out */ 895 { 0x14, 0x02a19122 }, /* front-mic */ 896 { 0x15, 0x01813021 }, /* line-in */ 897 { 0x16, 0x01011012 }, /* line-out */ 898 { 0x17, 0x01a19020 }, /* mic */ 899 { 0x1b, 0x0145f1f0 }, /* SPDIF */ 900 { 0x24, 0x01016011 }, /* line-out */ 901 { 0x25, 0x01012013 }, /* line-out */ 902 { } 903 } 904 }, 905}; 906 907static const struct hda_model_fixup ad1988_fixup_models[] = { 908 { .id = AD1988_FIXUP_6STACK_DIG, .name = "6stack-dig" }, 909 {} 910}; 911 912static int patch_ad1988(struct hda_codec *codec) 913{ 914 struct ad198x_spec *spec; 915 int err; 916 917 err = alloc_ad_spec(codec); 918 if (err < 0) 919 return err; 920 spec = codec->spec; 921 922 spec->gen.mixer_nid = 0x20; 923 spec->gen.mixer_merge_nid = 0x21; 924 spec->gen.beep_nid = 0x10; 925 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT); 926 927 snd_hda_pick_fixup(codec, ad1988_fixup_models, NULL, ad1988_fixups); 928 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 929 930 err = ad198x_parse_auto_config(codec, true); 931 if (err < 0) 932 goto error; 933 err = ad1988_add_spdif_mux_ctl(codec); 934 if (err < 0) 935 goto error; 936 937 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 938 939 return 0; 940 941 error: 942 snd_hda_gen_free(codec); 943 return err; 944} 945 946 947/* 948 * AD1884 / AD1984 949 * 950 * port-B - front line/mic-in 951 * port-E - aux in/out 952 * port-F - aux in/out 953 * port-C - rear line/mic-in 954 * port-D - rear line/hp-out 955 * port-A - front line/hp-out 956 * 957 * AD1984 = AD1884 + two digital mic-ins 958 * 959 * AD1883 / AD1884A / AD1984A / AD1984B 960 * 961 * port-B (0x14) - front mic-in 962 * port-E (0x1c) - rear mic-in 963 * port-F (0x16) - CD / ext out 964 * port-C (0x15) - rear line-in 965 * port-D (0x12) - rear line-out 966 * port-A (0x11) - front hp-out 967 * 968 * AD1984A = AD1884A + digital-mic 969 * AD1883 = equivalent with AD1984A 970 * AD1984B = AD1984A + extra SPDIF-out 971 */ 972 973/* set the upper-limit for mixer amp to 0dB for avoiding the possible 974 * damage by overloading 975 */ 976static void ad1884_fixup_amp_override(struct hda_codec *codec, 977 const struct hda_fixup *fix, int action) 978{ 979 if (action == HDA_FIXUP_ACT_PRE_PROBE) 980 snd_hda_override_amp_caps(codec, 0x20, HDA_INPUT, 981 (0x17 << AC_AMPCAP_OFFSET_SHIFT) | 982 (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | 983 (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) | 984 (1 << AC_AMPCAP_MUTE_SHIFT)); 985} 986 987/* toggle GPIO1 according to the mute state */ 988static void ad1884_vmaster_hp_gpio_hook(void *private_data, int enabled) 989{ 990 struct hda_codec *codec = private_data; 991 struct ad198x_spec *spec = codec->spec; 992 993 if (spec->eapd_nid) 994 ad_vmaster_eapd_hook(private_data, enabled); 995 snd_hda_codec_update_cache(codec, 0x01, 0, 996 AC_VERB_SET_GPIO_DATA, 997 enabled ? 0x00 : 0x02); 998} 999 1000static void ad1884_fixup_hp_eapd(struct hda_codec *codec, 1001 const struct hda_fixup *fix, int action) 1002{ 1003 struct ad198x_spec *spec = codec->spec; 1004 1005 switch (action) { 1006 case HDA_FIXUP_ACT_PRE_PROBE: 1007 spec->gen.vmaster_mute.hook = ad1884_vmaster_hp_gpio_hook; 1008 spec->gen.own_eapd_ctl = 1; 1009 snd_hda_codec_write_cache(codec, 0x01, 0, 1010 AC_VERB_SET_GPIO_MASK, 0x02); 1011 snd_hda_codec_write_cache(codec, 0x01, 0, 1012 AC_VERB_SET_GPIO_DIRECTION, 0x02); 1013 snd_hda_codec_write_cache(codec, 0x01, 0, 1014 AC_VERB_SET_GPIO_DATA, 0x02); 1015 break; 1016 case HDA_FIXUP_ACT_PROBE: 1017 if (spec->gen.autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT) 1018 spec->eapd_nid = spec->gen.autocfg.line_out_pins[0]; 1019 else 1020 spec->eapd_nid = spec->gen.autocfg.speaker_pins[0]; 1021 break; 1022 } 1023} 1024 1025static void ad1884_fixup_thinkpad(struct hda_codec *codec, 1026 const struct hda_fixup *fix, int action) 1027{ 1028 struct ad198x_spec *spec = codec->spec; 1029 1030 if (action == HDA_FIXUP_ACT_PRE_PROBE) { 1031 spec->gen.keep_eapd_on = 1; 1032 spec->gen.vmaster_mute.hook = ad_vmaster_eapd_hook; 1033 spec->eapd_nid = 0x12; 1034 /* Analog PC Beeper - allow firmware/ACPI beeps */ 1035 spec->beep_amp = HDA_COMPOSE_AMP_VAL(0x20, 3, 3, HDA_INPUT); 1036 spec->gen.beep_nid = 0; /* no digital beep */ 1037 } 1038} 1039 1040/* set magic COEFs for dmic */ 1041static const struct hda_verb ad1884_dmic_init_verbs[] = { 1042 {0x01, AC_VERB_SET_COEF_INDEX, 0x13f7}, 1043 {0x01, AC_VERB_SET_PROC_COEF, 0x08}, 1044 {} 1045}; 1046 1047enum { 1048 AD1884_FIXUP_AMP_OVERRIDE, 1049 AD1884_FIXUP_HP_EAPD, 1050 AD1884_FIXUP_DMIC_COEF, 1051 AD1884_FIXUP_THINKPAD, 1052 AD1884_FIXUP_HP_TOUCHSMART, 1053}; 1054 1055static const struct hda_fixup ad1884_fixups[] = { 1056 [AD1884_FIXUP_AMP_OVERRIDE] = { 1057 .type = HDA_FIXUP_FUNC, 1058 .v.func = ad1884_fixup_amp_override, 1059 }, 1060 [AD1884_FIXUP_HP_EAPD] = { 1061 .type = HDA_FIXUP_FUNC, 1062 .v.func = ad1884_fixup_hp_eapd, 1063 .chained = true, 1064 .chain_id = AD1884_FIXUP_AMP_OVERRIDE, 1065 }, 1066 [AD1884_FIXUP_DMIC_COEF] = { 1067 .type = HDA_FIXUP_VERBS, 1068 .v.verbs = ad1884_dmic_init_verbs, 1069 }, 1070 [AD1884_FIXUP_THINKPAD] = { 1071 .type = HDA_FIXUP_FUNC, 1072 .v.func = ad1884_fixup_thinkpad, 1073 .chained = true, 1074 .chain_id = AD1884_FIXUP_DMIC_COEF, 1075 }, 1076 [AD1884_FIXUP_HP_TOUCHSMART] = { 1077 .type = HDA_FIXUP_VERBS, 1078 .v.verbs = ad1884_dmic_init_verbs, 1079 .chained = true, 1080 .chain_id = AD1884_FIXUP_HP_EAPD, 1081 }, 1082}; 1083 1084static const struct snd_pci_quirk ad1884_fixup_tbl[] = { 1085 SND_PCI_QUIRK(0x103c, 0x2a82, "HP Touchsmart", AD1884_FIXUP_HP_TOUCHSMART), 1086 SND_PCI_QUIRK_VENDOR(0x103c, "HP", AD1884_FIXUP_HP_EAPD), 1087 SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1884_FIXUP_THINKPAD), 1088 {} 1089}; 1090 1091 1092static int patch_ad1884(struct hda_codec *codec) 1093{ 1094 struct ad198x_spec *spec; 1095 int err; 1096 1097 err = alloc_ad_spec(codec); 1098 if (err < 0) 1099 return err; 1100 spec = codec->spec; 1101 1102 spec->gen.mixer_nid = 0x20; 1103 spec->gen.mixer_merge_nid = 0x21; 1104 spec->gen.beep_nid = 0x10; 1105 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT); 1106 1107 snd_hda_pick_fixup(codec, NULL, ad1884_fixup_tbl, ad1884_fixups); 1108 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE); 1109 1110 err = ad198x_parse_auto_config(codec, true); 1111 if (err < 0) 1112 goto error; 1113 err = ad1983_add_spdif_mux_ctl(codec); 1114 if (err < 0) 1115 goto error; 1116 1117 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE); 1118 1119 return 0; 1120 1121 error: 1122 snd_hda_gen_free(codec); 1123 return err; 1124} 1125 1126/* 1127 * AD1882 / AD1882A 1128 * 1129 * port-A - front hp-out 1130 * port-B - front mic-in 1131 * port-C - rear line-in, shared surr-out (3stack) 1132 * port-D - rear line-out 1133 * port-E - rear mic-in, shared clfe-out (3stack) 1134 * port-F - rear surr-out (6stack) 1135 * port-G - rear clfe-out (6stack) 1136 */ 1137 1138static int patch_ad1882(struct hda_codec *codec) 1139{ 1140 struct ad198x_spec *spec; 1141 int err; 1142 1143 err = alloc_ad_spec(codec); 1144 if (err < 0) 1145 return err; 1146 spec = codec->spec; 1147 1148 spec->gen.mixer_nid = 0x20; 1149 spec->gen.mixer_merge_nid = 0x21; 1150 spec->gen.beep_nid = 0x10; 1151 set_beep_amp(spec, 0x10, 0, HDA_OUTPUT); 1152 err = ad198x_parse_auto_config(codec, true); 1153 if (err < 0) 1154 goto error; 1155 err = ad1988_add_spdif_mux_ctl(codec); 1156 if (err < 0) 1157 goto error; 1158 return 0; 1159 1160 error: 1161 snd_hda_gen_free(codec); 1162 return err; 1163} 1164 1165 1166/* 1167 * patch entries 1168 */ 1169static const struct hda_codec_preset snd_hda_preset_analog[] = { 1170 { .id = 0x11d4184a, .name = "AD1884A", .patch = patch_ad1884 }, 1171 { .id = 0x11d41882, .name = "AD1882", .patch = patch_ad1882 }, 1172 { .id = 0x11d41883, .name = "AD1883", .patch = patch_ad1884 }, 1173 { .id = 0x11d41884, .name = "AD1884", .patch = patch_ad1884 }, 1174 { .id = 0x11d4194a, .name = "AD1984A", .patch = patch_ad1884 }, 1175 { .id = 0x11d4194b, .name = "AD1984B", .patch = patch_ad1884 }, 1176 { .id = 0x11d41981, .name = "AD1981", .patch = patch_ad1981 }, 1177 { .id = 0x11d41983, .name = "AD1983", .patch = patch_ad1983 }, 1178 { .id = 0x11d41984, .name = "AD1984", .patch = patch_ad1884 }, 1179 { .id = 0x11d41986, .name = "AD1986A", .patch = patch_ad1986a }, 1180 { .id = 0x11d41988, .name = "AD1988", .patch = patch_ad1988 }, 1181 { .id = 0x11d4198b, .name = "AD1988B", .patch = patch_ad1988 }, 1182 { .id = 0x11d4882a, .name = "AD1882A", .patch = patch_ad1882 }, 1183 { .id = 0x11d4989a, .name = "AD1989A", .patch = patch_ad1988 }, 1184 { .id = 0x11d4989b, .name = "AD1989B", .patch = patch_ad1988 }, 1185 {} /* terminator */ 1186}; 1187 1188MODULE_ALIAS("snd-hda-codec-id:11d4*"); 1189 1190MODULE_LICENSE("GPL"); 1191MODULE_DESCRIPTION("Analog Devices HD-audio codec"); 1192 1193static struct hda_codec_driver analog_driver = { 1194 .preset = snd_hda_preset_analog, 1195}; 1196 1197module_hda_codec_driver(analog_driver); 1198